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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.69.2
+Version: 0.69.4
 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.4}/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.4}/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.4}/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.4}/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.4}/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.4}/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.4}/prediction_market_agent_tooling/markets/seer/data_models.py

@@ -163,13 +163,6 @@ class SeerMarketWithQuestions(SeerMarket):
     questions: list[SeerMarketQuestions]
 
 
-class RedeemParams(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    market: ChecksumAddress
-    outcome_indices: list[int] = Field(alias="outcomeIndexes")
-    amounts: list[OutcomeWei]
-
-
 class ExactInputSingleParams(BaseModel):
     # from https://gnosisscan.io/address/0xffb643e73f280b97809a8b41f7232ab401a04ee1#code
     model_config = ConfigDict(populate_by_name=True)

{prediction_market_agent_tooling-0.69.2 → prediction_market_agent_tooling-0.69.4}/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.4}/prediction_market_agent_tooling/markets/seer/seer.py

@@ -49,7 +49,6 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     SeerAgentResultMappingContract,
 )
 from prediction_market_agent_tooling.markets.seer.data_models import (
-    RedeemParams,
     SeerMarket,
     SeerMarketWithQuestions,
 )
@@ -83,6 +82,7 @@ from prediction_market_agent_tooling.tools.cow.cow_order import (
     OrderStatusError,
     get_orders_by_owner,
     get_trades_by_order_uid,
+    handle_allowance,
     swap_tokens_waiting,
     wait_for_order_completion,
 )
@@ -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()
@@ -273,6 +279,7 @@ class SeerAgentMarket(AgentMarket):
         """
         We filter the markets using previous trades by the user so that we don't have to process all Seer markets.
         """
+
         trades_by_user = get_seer_transactions(
             api_keys.bet_from_address, RPCConfig().CHAIN_ID
         )
@@ -293,10 +300,12 @@ class SeerAgentMarket(AgentMarket):
         return filtered_markets
 
     @staticmethod
-    def redeem_winnings(api_keys: APIKeys) -> None:
-        web3 = RPCConfig().get_web3()
+    def redeem_winnings(api_keys: APIKeys, web3: Web3 | None = None) -> None:
+        web3 = web3 or RPCConfig().get_web3()
         subgraph = SeerSubgraphHandler()
 
+        # ToDo - Find open positions by user directly
+
         closed_markets = subgraph.get_markets(
             filter_by=FilterBy.RESOLVED, sort_by=SortBy.NEWEST
         )
@@ -305,8 +314,8 @@ class SeerAgentMarket(AgentMarket):
         )
 
         market_balances = {
-            market.id: market.get_outcome_token_balances(
-                api_keys.bet_from_address, web3
+            market.id: list(
+                market.get_outcome_token_balances(api_keys.bet_from_address, web3)
             )
             for market in filtered_markets
         }
@@ -323,17 +332,15 @@ class SeerAgentMarket(AgentMarket):
             try:
                 # GnosisRouter needs approval to use our outcome tokens
                 for i, token in enumerate(market.wrapped_tokens):
-                    ContractERC20OnGnosisChain(
-                        address=Web3.to_checksum_address(token)
-                    ).approve(
-                        api_keys,
+                    handle_allowance(
+                        api_keys=api_keys,
+                        sell_token=Web3.to_checksum_address(token),
+                        amount_to_check_wei=market_balances[market.id][i].as_wei,
                         for_address=gnosis_router.address,
-                        amount_wei=market_balances[market.id][i].as_wei,
                         web3=web3,
                     )
 
                 # We can only ask for redeem of outcome tokens on correct outcomes
-                # TODO: Implement more complex use-cases: https://github.com/gnosis/prediction-market-agent-tooling/issues/850
                 amounts_to_redeem = [
                     (amount if numerator > 0 else OutcomeWei(0))
                     for amount, numerator in zip(
@@ -341,13 +348,13 @@ class SeerAgentMarket(AgentMarket):
                     )
                 ]
 
-                # Redeem!
-                params = RedeemParams(
+                gnosis_router.redeem_to_base(
+                    api_keys,
                     market=Web3.to_checksum_address(market.id),
-                    outcome_indices=list(range(len(market.payout_numerators))),
+                    outcome_indexes=list(range(len(market.payout_numerators))),
                     amounts=amounts_to_redeem,
+                    web3=web3,
                 )
-                gnosis_router.redeem_to_base(api_keys, params=params, web3=web3)
                 logger.info(f"Redeemed market {market.url}.")
             except Exception:
                 logger.exception(

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

@@ -8,13 +8,13 @@ from prediction_market_agent_tooling.gtypes import (
     ABI,
     ChecksumAddress,
     OutcomeStr,
+    OutcomeWei,
     TxReceipt,
     Wei,
     xDai,
 )
 from prediction_market_agent_tooling.markets.seer.data_models import (
     ExactInputSingleParams,
-    RedeemParams,
 )
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     CreateCategoricalMarketsParams,
@@ -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__)),
@@ -102,12 +102,18 @@ class GnosisRouter(ContractOnGnosisChain):
     def redeem_to_base(
         self,
         api_keys: APIKeys,
-        params: RedeemParams,
+        market: ChecksumAddress,
+        outcome_indexes: list[int],
+        amounts: list[OutcomeWei],
         web3: Web3 | None = None,
     ) -> TxReceipt:
-        params_dict = params.model_dump(by_alias=True)
         # We explicity set amounts since OutcomeWei gets serialized as dict
-        params_dict["amounts"] = [amount.value for amount in params.amounts]
+        params_dict = {
+            "market": market,
+            "outcomeIndexes": outcome_indexes,
+            "amounts": [amount.value for amount in amounts],
+        }
+
         receipt_tx = self.send(
             api_keys=api_keys,
             function_name="redeemToBase",
@@ -116,6 +122,22 @@ class GnosisRouter(ContractOnGnosisChain):
         )
         return receipt_tx
 
+    def split_from_base(
+        self,
+        api_keys: APIKeys,
+        market_id: ChecksumAddress,
+        amount_wei: Wei,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        """Splits using xDAI and receives outcome tokens"""
+        return self.send_with_value(
+            api_keys=api_keys,
+            function_name="splitFromBase",
+            amount_wei=amount_wei,
+            function_params=[market_id],
+            web3=web3,
+        )
+
     def split_position(
         self,
         api_keys: APIKeys,
@@ -135,7 +157,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 +187,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.4}/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(
@@ -431,6 +434,25 @@ class ContractWrapped1155BaseClass(ContractERC20BaseClass):
         )
     )
 
+    def factory(self, web3: Web3 | None = None) -> ChecksumAddress:
+        return Web3.to_checksum_address(self.call("factory", web3=web3))
+
+    def mint(
+        self,
+        api_keys: APIKeys,
+        to_address: ChecksumAddress,
+        amount: Wei,
+        tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        return self.send(
+            api_keys=api_keys,
+            function_name="mint",
+            function_params=[to_address, amount],
+            tx_params=tx_params,
+            web3=web3,
+        )
+
 
 class OwnableContract(ContractBaseClass):
     abi: ABI = abi_field_validator(
@@ -718,6 +740,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.4}/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.4}/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.4}/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.4}/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.4}/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.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.69.2"
+version = "0.69.4"
 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"]