prediction-market-agent-tooling 0.69.2__tar.gz → 0.69.3__tar.gz

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/PKG-INFO

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

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/deploy/agent.py

@@ -53,6 +53,7 @@ from prediction_market_agent_tooling.tools.tokens.main_token import (
 from prediction_market_agent_tooling.tools.utils import (
     DatetimeUTC,
     check_not_none,
+    retry_until_true,
     utcnow,
 )
 
@@ -645,8 +646,10 @@ class DeployableTraderAgent(DeployablePredictionAgent):
 
         total_amount = market.get_in_usd(market.get_tiny_bet_amount())
         existing_position = market.get_position(user_id=user_id)
+
         if existing_position and existing_position.total_amount_current > USD(0):
             total_amount += existing_position.total_amount_current
+
         return total_amount
 
     def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
@@ -703,8 +706,11 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                         )
                     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.
+                        # In this palce, we expect to have positions, so retry a few times if None are returned, which sometimes happens due to flaky subgraph.
                         current_position = check_not_none(
-                            market.get_position(
+                            retry_until_true(
+                                lambda x: x is not None and x.total_amount_ot > 0
+                            )(market.get_position)(
                                 market.get_user_id(api_keys=self.api_keys)
                             ),
                             "Should exists if we are going to sell outcomes.",

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -5,9 +5,7 @@ import numpy as np
 from scipy.optimize import minimize_scalar
 
 from prediction_market_agent_tooling.benchmark.utils import get_most_probable_outcome
-from prediction_market_agent_tooling.deploy.constants import (
-    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
-)
+from prediction_market_agent_tooling.deploy.constants import is_invalid_outcome
 from prediction_market_agent_tooling.gtypes import (
     USD,
     CollateralToken,
@@ -302,7 +300,7 @@ class CategoricalMaxAccuracyBettingStrategy(BettingStrategy):
     ) -> OutcomeStr:
         # We get the first direction which is != direction.
         other_direction = [i for i in outcomes if i.lower() != direction.lower()][0]
-        if INVALID_OUTCOME_LOWERCASE_IDENTIFIER in other_direction.lower():
+        if is_invalid_outcome(other_direction):
             raise ValueError("Invalid outcome found as opposite direction. Exitting.")
         return other_direction
 
@@ -459,7 +457,7 @@ class _BinaryKellyBettingStrategy(BettingStrategy):
         )
         # We get the first direction which is != direction.
         other_direction = [i for i in market.outcomes if i != direction][0]
-        if INVALID_OUTCOME_LOWERCASE_IDENTIFIER in other_direction.lower():
+        if is_invalid_outcome(other_direction):
             raise ValueError("Invalid outcome found as opposite direction. Exitting.")
 
         kelly_bet = self.get_kelly_bet(
@@ -484,11 +482,13 @@ class _BinaryKellyBettingStrategy(BettingStrategy):
         bet_outcome = direction if kelly_bet.direction else other_direction
 
         amounts = {
-            bet_outcome: BettingStrategy.cap_to_profitable_bet_amount(
-                market, market.get_token_in_usd(kelly_bet_size), bet_outcome
-            )
-            if kelly_bet_size > 0
-            else USD(0),
+            bet_outcome: (
+                BettingStrategy.cap_to_profitable_bet_amount(
+                    market, market.get_token_in_usd(kelly_bet_size), bet_outcome
+                )
+                if kelly_bet_size > 0
+                else USD(0)
+            ),
         }
         target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/deploy/constants.py

@@ -7,3 +7,7 @@ YES_OUTCOME_LOWERCASE_IDENTIFIER = "yes"
 NO_OUTCOME_LOWERCASE_IDENTIFIER = "no"
 UP_OUTCOME_LOWERCASE_IDENTIFIER = "up"
 DOWN_OUTCOME_LOWERCASE_IDENTIFIER = "down"
+
+
+def is_invalid_outcome(outcome: str) -> bool:
+    return INVALID_OUTCOME_LOWERCASE_IDENTIFIER in outcome.lower()

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/markets/agent_market.py

@@ -12,10 +12,10 @@ from prediction_market_agent_tooling.benchmark.utils import get_most_probable_ou
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.constants import (
     DOWN_OUTCOME_LOWERCASE_IDENTIFIER,
-    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
     NO_OUTCOME_LOWERCASE_IDENTIFIER,
     UP_OUTCOME_LOWERCASE_IDENTIFIER,
     YES_OUTCOME_LOWERCASE_IDENTIFIER,
+    is_invalid_outcome,
 )
 from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
@@ -212,7 +212,7 @@ class AgentMarket(BaseModel):
 
         if len(lowercase_outcomes) == 3:
             invalid_outcome = lowercase_outcomes[-1]
-            has_invalid = INVALID_OUTCOME_LOWERCASE_IDENTIFIER in invalid_outcome
+            has_invalid = is_invalid_outcome(invalid_outcome)
             return has_yes and has_no and has_invalid
 
         return has_yes and has_no
@@ -230,7 +230,7 @@ class AgentMarket(BaseModel):
 
         if len(lowercase_outcomes) == 3:
             invalid_outcome = lowercase_outcomes[-1]
-            has_invalid = INVALID_OUTCOME_LOWERCASE_IDENTIFIER in invalid_outcome
+            has_invalid = is_invalid_outcome(invalid_outcome)
             return has_up and has_down and has_invalid
 
         return has_up and has_down

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/markets/data_models.py

@@ -9,6 +9,7 @@ from prediction_market_agent_tooling.deploy.constants import (
     NO_OUTCOME_LOWERCASE_IDENTIFIER,
     UP_OUTCOME_LOWERCASE_IDENTIFIER,
     YES_OUTCOME_LOWERCASE_IDENTIFIER,
+    is_invalid_outcome,
 )
 from prediction_market_agent_tooling.gtypes import (
     USD,
@@ -224,10 +225,7 @@ class CategoricalProbabilisticAnswer(BaseModel):
             OutcomeStr(DOWN_OUTCOME_LOWERCASE_IDENTIFIER.upper())
         ] = answer.p_down
 
-        if (
-            market_outcomes
-            and INVALID_OUTCOME_LOWERCASE_IDENTIFIER in lowercase_market_outcomes
-        ):
+        if market_outcomes and any(is_invalid_outcome(o) for o in market_outcomes):
             probabilities[
                 OutcomeStr(INVALID_OUTCOME_LOWERCASE_IDENTIFIER.capitalize())
             ] = Probability(1 - answer.p_up - answer.p_down)

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -704,6 +704,26 @@ def omen_buy_outcome_tx(
     auto_deposit: bool,
     web3: Web3 | None = None,
     slippage: float = 0.01,
+) -> str:
+    return omen_buy_outcome_tx_no_retry(
+        api_keys=api_keys,
+        amount=amount,
+        market=market,
+        outcome=outcome,
+        auto_deposit=auto_deposit,
+        web3=web3,
+        slippage=slippage,
+    )
+
+
+def omen_buy_outcome_tx_no_retry(
+    api_keys: APIKeys,
+    amount: USD | CollateralToken,
+    market: OmenAgentMarket,
+    outcome: OutcomeStr,
+    auto_deposit: bool,
+    web3: Web3 | None = None,
+    slippage: float = 0.01,
 ) -> str:
     """
     Bets the given amount for the given outcome in the given market.

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/markets/seer/price_manager.py

@@ -2,9 +2,7 @@ from cachetools import TTLCache, cached
 from pydantic import BaseModel
 from web3 import Web3
 
-from prediction_market_agent_tooling.deploy.constants import (
-    INVALID_OUTCOME_LOWERCASE_IDENTIFIER,
-)
+from prediction_market_agent_tooling.deploy.constants import is_invalid_outcome
 from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     CollateralToken,
@@ -243,7 +241,7 @@ class PriceManager:
                     f"Outcome {outcome} not found in outcome_token_pool for market {self.seer_market.url}."
                 )
             if outcome not in probability_map:
-                if INVALID_OUTCOME_LOWERCASE_IDENTIFIER not in outcome.lower():
+                if not is_invalid_outcome(outcome):
                     raise PriceCalculationError(
                         f"Couldn't get probability for {outcome} for market {self.seer_market.url}."
                     )

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/markets/seer/seer.py

@@ -234,7 +234,9 @@ class SeerAgentMarket(AgentMarket):
     def get_tiny_bet_amount(self) -> CollateralToken:
         return self.get_in_token(SEER_TINY_BET_AMOUNT)
 
-    def get_position(self, user_id: str, web3: Web3 | None = None) -> ExistingPosition:
+    def get_position(
+        self, user_id: str, web3: Web3 | None = None
+    ) -> ExistingPosition | None:
         """
         Fetches position from the user in a given market.
         We ignore the INVALID balances since we are only interested in binary outcomes.
@@ -251,6 +253,10 @@ class SeerAgentMarket(AgentMarket):
 
             amounts_ot[outcome_str] = outcome_token_balance_wei.as_outcome_token
 
+        # Adhere to convenience from other markets, where we return None if user doesn't have any position.
+        if all(v == 0 for v in amounts_ot.values()):
+            return None
+
         amounts_current = {
             k: self.get_token_in_usd(self.get_sell_value_of_outcome_token(k, v))
             for k, v in amounts_ot.items()

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -88,7 +88,7 @@ class SeerMarketFactory(ContractOnGnosisChain):
 
 
 class GnosisRouter(ContractOnGnosisChain):
-    # https://gnosisscan.io/address/0x83183da839ce8228e31ae41222ead9edbb5cdcf1#code.
+    # https://gnosisscan.io/address/0xeC9048b59b3467415b1a38F63416407eA0c70fB8#code.
     abi: ABI = abi_field_validator(
         os.path.join(
             os.path.dirname(os.path.realpath(__file__)),
@@ -135,7 +135,6 @@ class GnosisRouter(ContractOnGnosisChain):
 
 
 class SwaprRouterContract(ContractOnGnosisChain):
-    # File content taken from https://github.com/protofire/omen-exchange/blob/master/app/src/abi/marketMaker.json.
     abi: ABI = abi_field_validator(
         os.path.join(
             os.path.dirname(os.path.realpath(__file__)),
@@ -166,4 +165,7 @@ class SwaprRouterContract(ContractOnGnosisChain):
             function_name="exactInputSingle",
             function_params=[tuple(dict(params).values())],
             web3=web3,
+            # Use higher gas limit for complex swap operations to avoid slow estimation
+            # Typical Swapr swaps use 150k-300k gas, we set conservative
+            default_gas=400_000,
         )

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/tools/contract.py

@@ -116,6 +116,7 @@ class ContractBaseClass(BaseModel):
         tx_params: t.Optional[TxParams] = None,
         timeout: int = 180,
         web3: Web3 | None = None,
+        default_gas: int | None = None,
     ) -> TxReceipt:
         """
         Used for changing a state (writing) to the contract.
@@ -132,6 +133,7 @@ class ContractBaseClass(BaseModel):
                 function_params=function_params,
                 tx_params=tx_params,
                 timeout=timeout,
+                default_gas=default_gas,
             )
         return send_function_on_contract_tx(
             web3=web3 or self.get_web3(),
@@ -142,6 +144,7 @@ class ContractBaseClass(BaseModel):
             function_params=function_params,
             tx_params=tx_params,
             timeout=timeout,
+            default_gas=default_gas,
         )
 
     def send_with_value(
@@ -718,6 +721,9 @@ class ConditionalTokenContract(ContractBaseClass):
             .events.PayoutRedemption()
             .process_receipt(receipt_tx)
         )
+        logger.info(
+            f"Receipt tx: `{receipt_tx}` Redeem event logs: `{redeem_event_logs}`"
+        )
         redeem_event = PayoutRedemptionEvent(**redeem_event_logs[0]["args"])
         return redeem_event
 

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -191,7 +191,7 @@ def handle_allowance(
 
 
 @postgres_rate_limited(
-    api_keys=APIKeys(), rate_id="swap_tokens_waiting", interval_seconds=60.0
+    api_keys=APIKeys(), rate_id="swap_tokens_waiting", interval_seconds=5.0
 )
 @tenacity.retry(
     reraise=True,

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/tools/cow/models.py

@@ -22,5 +22,6 @@ class Order(BaseModel):
 
 class RateLimit(SQLModel, table=True):
     __tablename__ = "rate_limit"
+    __table_args__ = {"extend_existing": True}
     id: str = Field(primary_key=True)
     last_called_at: DatetimeUTC = Field(default_factory=utcnow)

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/tools/cow/semaphore.py

@@ -18,7 +18,10 @@ FALLBACK_SQL_ENGINE = "sqlite:///rate_limit.db"
 
 
 def postgres_rate_limited(
-    api_keys: APIKeys, rate_id: str = "default", interval_seconds: float = 1.0
+    api_keys: APIKeys,
+    rate_id: str,
+    interval_seconds: float,
+    shared_db: bool = False,
 ) -> 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)
@@ -28,7 +31,7 @@ def postgres_rate_limited(
         def wrapper(*args: Any, **kwargs: Any) -> Any:
             sqlalchemy_db_url = (
                 api_keys.sqlalchemy_db_url.get_secret_value()
-                if api_keys.SQLALCHEMY_DB_URL
+                if shared_db
                 else FALLBACK_SQL_ENGINE
             )
 

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/tools/utils.py

@@ -1,8 +1,10 @@
+import functools
 import os
 import subprocess
+import time
 from datetime import datetime
 from math import prod
-from typing import Any, NoReturn, Optional, Type, TypeVar
+from typing import Any, Callable, NoReturn, Optional, Type, TypeVar, cast
 
 import httpx
 import pytz
@@ -56,6 +58,49 @@ def check_not_none(
     return value
 
 
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def retry_until_true(
+    condition: Callable[[Any], bool],
+    max_retries: int = 3,
+    delay: float = 1.0,
+) -> Callable[[F], F]:
+    """
+    Decorator that retries a function if the condition on its result evaluates to False.
+
+    Args:
+        condition: Function that takes the result and returns True if acceptable, False to retry
+        max_retries: Maximum number of retry attempts
+        delay: Delay between retries in seconds
+    """
+
+    def decorator(func: F) -> F:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            for attempt in range(1, max_retries + 1):
+                result = func(*args, **kwargs)
+
+                if condition(result):
+                    logger.info(f"Condition met for {func.__name__} on {attempt}.")
+                    return result
+
+                if attempt < max_retries:
+                    logger.debug(
+                        f"Retry {attempt + 1}/{max_retries} for {func.__name__}"
+                    )
+                    time.sleep(delay)
+                else:
+                    logger.warning(
+                        f"All {max_retries} retries exhausted for {func.__name__}"
+                    )
+                    return result
+
+        return cast(F, wrapper)
+
+    return decorator
+
+
 def should_not_happen(
     msg: str = "Should not happen.", exp: Type[ValueError] = ValueError
 ) -> NoReturn:

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/prediction_market_agent_tooling/tools/web3_utils.py

@@ -1,4 +1,5 @@
 import binascii
+import multiprocessing.context
 import secrets
 from typing import Any, Optional
 
@@ -7,12 +8,14 @@ import tenacity
 from eth_account import Account
 from eth_typing import URI
 from eth_utils.currency import MAX_WEI, MIN_WEI
+from joblib import Parallel, delayed
 from pydantic.types import SecretStr
 from safe_eth.eth import EthereumClient
 from safe_eth.eth.ethereum_client import TxSpeed
 from safe_eth.safe.safe import SafeV141
 from web3 import Web3
 from web3.constants import HASH_ZERO
+from web3.contract.contract import ContractFunction as Web3ContractFunction
 from web3.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt
 
 from prediction_market_agent_tooling.gtypes import (
@@ -76,7 +79,7 @@ def unwrap_generic_value(value: Any) -> Any:
 
 
 def parse_function_params(
-    params: Optional[list[Any] | tuple[Any] | dict[str, Any]]
+    params: Optional[list[Any] | tuple[Any] | dict[str, Any]],
 ) -> list[Any] | tuple[Any]:
     params = unwrap_generic_value(params)
     if params is None:
@@ -120,6 +123,7 @@ def prepare_tx(
     function_params: Optional[list[Any] | dict[str, Any]] = None,
     access_list: Optional[AccessList] = None,
     tx_params: Optional[TxParams] = None,
+    default_gas: int | None = None,
 ) -> TxParams:
     tx_params_new = _prepare_tx_params(web3, from_address, access_list, tx_params)
     contract = web3.eth.contract(address=contract_address, abi=contract_abi)
@@ -127,10 +131,37 @@ def prepare_tx(
     function_call = contract.functions[function_name](
         *parse_function_params(function_params)
     )
+    if default_gas is not None and "gas" not in tx_params_new:
+        tx_params_new["gas"] = estimate_gas_with_timeout(
+            function_call, default_gas=default_gas, tx_params=tx_params_new
+        )
     built_tx_params: TxParams = function_call.build_transaction(tx_params_new)
     return built_tx_params
 
 
+def estimate_gas_with_timeout(
+    function_call: Web3ContractFunction,
+    default_gas: int,
+    timeout: int = 15,
+    tx_params: Optional[TxParams] = None,
+) -> int:
+    """
+    Tries to estimate the gas, but default to the default value on timeout.
+    """
+    try:
+        # We need n_jobs=-1, otherwise timeouting isn't applied.
+        result: list[int] = Parallel(n_jobs=-1, backend="threading", timeout=timeout)(
+            delayed(function_call.estimate_gas)(tx_params) for _ in range(1)
+        )
+        estimated_gas = result[0]
+        return int(estimated_gas * 1.2)  # Add 20% buffer
+    except (TimeoutError, multiprocessing.context.TimeoutError):
+        logger.warning(
+            f"Gas estimation timed out after {timeout} seconds, using default: {default_gas}"
+        )
+        return default_gas
+
+
 def _prepare_tx_params(
     web3: Web3,
     from_address: ChecksumAddress | None,
@@ -182,6 +213,7 @@ def send_function_on_contract_tx(
     function_params: Optional[list[Any] | dict[str, Any]] = None,
     tx_params: Optional[TxParams] = None,
     timeout: int = 180,
+    default_gas: int | None = None,
 ) -> TxReceipt:
     public_key = private_key_to_public_key(from_private_key)
 
@@ -193,6 +225,7 @@ def send_function_on_contract_tx(
         function_name=function_name,
         function_params=function_params,
         tx_params=tx_params,
+        default_gas=default_gas,
     )
 
     receipt_tx = sign_send_and_get_receipt_tx(
@@ -221,6 +254,7 @@ def send_function_on_contract_tx_using_safe(
     function_params: Optional[list[Any] | dict[str, Any]] = None,
     tx_params: Optional[TxParams] = None,
     timeout: int = 180,
+    default_gas: int | None = None,
 ) -> TxReceipt:
     if not web3.provider.endpoint_uri:  # type: ignore
         raise EnvironmentError("RPC_URL not available in web3 object.")
@@ -261,6 +295,7 @@ def send_function_on_contract_tx_using_safe(
         function_params=function_params,
         access_list=access_list,
         tx_params=tx_params,
+        default_gas=default_gas,
     )
     safe_tx = s.build_multisig_tx(
         to=Web3.to_checksum_address(tx_params["to"]),

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.69.2"
+version = "0.69.3"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"
@@ -77,6 +77,8 @@ black = "^23.12.1"
 ape-foundry = "^0.8.2"
 eth-ape = "^0.8.34"
 diskcache = "^5.6.3"
+freezegun = "^1.5.5"
+pytest-line-profiler = "^0.2.1"
 
 [build-system]
 requires = ["poetry-core"]