prediction-market-agent-tooling 0.65.5__py3-none-any.whl → 0.69.17.dev1149__py3-none-any.whl

prediction_market_agent_tooling/tools/streamlit_utils.py

@@ -0,0 +1,188 @@
+import asyncio
+import os
+import typing as t
+
+import streamlit
+import streamlit as st
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.tools.caches.db_cache import DB_CACHE_LOG_PREFIX
+
+if t.TYPE_CHECKING:
+    from loguru import Message
+
+STREAMLIT_SINK_EXPLICIT_FLAG = "streamlit"
+
+
+def streamlit_asyncio_event_loop_hack() -> None:
+    """
+    This function is a hack to make Streamlit work with asyncio event loop.
+    See https://github.com/streamlit/streamlit/issues/744
+    """
+
+    def get_or_create_eventloop() -> asyncio.AbstractEventLoop:
+        try:
+            return asyncio.get_event_loop()
+        except RuntimeError as ex:
+            if "There is no current event loop in thread" in str(ex):
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                return asyncio.get_event_loop()
+            else:
+                raise ex
+
+    loop = get_or_create_eventloop()
+    asyncio.set_event_loop(loop)
+
+
+def check_required_api_keys(keys: APIKeys, required_keys: list[str]) -> None:
+    has_missing_keys = False
+    for key in required_keys:
+        if not getattr(keys, key):
+            st.error(f"Environment variable for key {key} has not been set.")
+            has_missing_keys = True
+    if has_missing_keys:
+        st.stop()
+
+
+def get_loguru_streamlit_sink(
+    explicit: bool,
+    expander_if_longer_than: int | None,
+    include_in_expander: int = 50,
+) -> t.Callable[["Message"], None]:
+    def loguru_streamlit_sink(log: "Message") -> None:
+        record = log.record
+        level = record["level"].name
+
+        message = streamlit_escape(record["message"])
+
+        # Ignore certain messages that aren't interesting for Streamlit user, but are in the production logs.
+        if any(x in message for x in [DB_CACHE_LOG_PREFIX]):
+            return
+
+        if explicit and not record["extra"].get(STREAMLIT_SINK_EXPLICIT_FLAG, False):
+            return
+
+        if level == "ERROR":
+            st_func = st.error
+            st_icon = "❌"
+
+        elif level == "WARNING":
+            st_func = st.warning
+            st_icon = "⚠️"
+
+        elif level == "SUCCESS":
+            st_func = st.success
+            st_icon = "✅"
+
+        elif level == "DEBUG":
+            st_func = None
+            st_icon = None
+
+        else:
+            st_func = st.info
+            st_icon = "ℹ️"
+
+        if st_func is None:
+            pass
+
+        elif (
+            expander_if_longer_than is not None
+            and len(message) > expander_if_longer_than
+        ):
+            with st.expander(
+                f"[Expand to see more] {message[:include_in_expander]}..."
+            ):
+                st_func(message, icon=st_icon)
+
+        else:
+            st_func(message, icon=st_icon)
+
+    return loguru_streamlit_sink
+
+
+@st.cache_resource
+def add_sink_to_logger(
+    explicit: bool = False, expander_if_longer_than: int | None = 500
+) -> None:
+    """
+    Adds streamlit as a sink to the loguru, so any loguru logs will be shown in the streamlit app.
+
+    Needs to be behind a cache decorator, so it only runs once per streamlit session (otherwise we would see duplicated messages).
+
+    If `explicit` is set to True, only logged messages with extra attribute `streamlit` will be shown in the streamlit app.
+    """
+    logger.add(
+        get_loguru_streamlit_sink(
+            explicit=explicit, expander_if_longer_than=expander_if_longer_than
+        )
+    )
+
+
+def streamlit_escape(message: str) -> str:
+    """
+    Escapes the string for streamlit writes.
+    """
+    # Replace escaped newlines with actual newlines.
+    message = message.replace("\\n", "\n")
+    # Fix malformed dollar signs in the messages.
+    message = message.replace("$", "\$")
+
+    return message
+
+
+def dict_to_point_list(d: dict[str, t.Any], indent: int = 0) -> str:
+    """
+    Helper method to convert nested dicts to a bullet point list.
+    """
+    lines = []
+    prefix = "  " * indent
+    for k, v in d.items():
+        if isinstance(v, dict):
+            lines.append(f"{prefix}- {k}:")
+            lines.append(dict_to_point_list(v, indent + 1))
+        elif isinstance(v, list):
+            lines.append(f"{prefix}- {k}:")
+            for idx, item in enumerate(v):
+                if isinstance(item, dict):
+                    lines.append(f"{prefix}  - item {idx}:")
+                    lines.append(dict_to_point_list(item, indent + 2))
+                else:
+                    lines.append(f"{prefix}  - item {idx}: {item}")
+        else:
+            lines.append(f"{prefix}- {k}: {v}")
+    return "\n".join(lines)
+
+
+def customize_index_html(head_content: str) -> None:
+    """
+    Unfortunatelly, Streamlit doesn't allow to update HTML content of the main index.html file, any component that allows passing of HTML will render it in iframe.
+    That's unusable for analytics tools like Posthog.
+
+    This is workaround that patches their index.html file directly in their package, found in https://stackoverflow.com/questions/70520191/how-to-add-the-google-analytics-tag-to-website-developed-with-streamlit/78992559#78992559.
+
+    There is also an issue that tracks this feature (open since 2023): https://github.com/streamlit/streamlit/issues/6140
+    """
+    streamlit_package_dir = os.path.dirname(streamlit.__file__)
+    index_path = os.path.join(streamlit_package_dir, "static", "index.html")
+
+    with open(index_path, "r") as f:
+        index_html = f.read()
+
+    if head_content not in index_html:
+        # Add the custom content to the head
+        index_html = index_html.replace("</head>", f"{head_content}</head>")
+
+        # Replace the <title> tag
+        index_html = index_html.replace(
+            "<title>Streamlit</title>", "<title>Savantly is cool</title>"
+        )
+
+        with open(index_path, "w") as f:
+            f.write(index_html)
+
+        logger.info("index.html injected with custom code.")
+
+    else:
+        logger.info("index.html injection skipped because it's already present.")

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -3,17 +3,28 @@ from web3 import Web3
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import USD, Wei
 from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.seer.seer_contracts import GnosisRouter
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractDepositableWrapperERC20BaseClass,
     ContractERC20BaseClass,
     ContractERC20OnGnosisChain,
     ContractERC4626BaseClass,
+    ContractWrapped1155BaseClass,
+    init_collateral_token_contract,
+    to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_sell_token_amount,
+    handle_allowance,
     swap_tokens_waiting,
 )
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
+from prediction_market_agent_tooling.tools.tokens.slippage import (
+    get_slippage_tolerance_per_token,
+)
 from prediction_market_agent_tooling.tools.tokens.usd import get_usd_in_token
 from prediction_market_agent_tooling.tools.utils import should_not_happen
 
@@ -46,6 +57,9 @@ def auto_deposit_collateral_token(
             collateral_token_contract, collateral_amount_wei, api_keys, web3
         )
 
+    elif isinstance(collateral_token_contract, ContractWrapped1155BaseClass):
+        mint_full_set(collateral_token_contract, collateral_amount_wei, api_keys, web3)
+
     elif isinstance(collateral_token_contract, ContractERC20BaseClass):
         auto_deposit_erc20(
             collateral_token_contract, collateral_amount_wei, api_keys, web3
@@ -156,10 +170,60 @@ def auto_deposit_erc20(
             raise ValueError(
                 "Not enough of the source token to sell to get the desired amount of the collateral token."
             )
+    slippage_tolerance = get_slippage_tolerance_per_token(
+        KEEPING_ERC20_TOKEN.address, collateral_token_contract.address
+    )
     swap_tokens_waiting(
         amount_wei=amount_to_sell_wei,
         sell_token=KEEPING_ERC20_TOKEN.address,
         buy_token=collateral_token_contract.address,
         api_keys=api_keys,
         web3=web3,
+        slippage_tolerance=slippage_tolerance,
+    )
+
+
+def mint_full_set(
+    collateral_token_contract: ContractERC20BaseClass,
+    collateral_amount_wei: Wei,
+    api_keys: APIKeys,
+    web3: Web3 | None,
+) -> None:
+    router = GnosisRouter()
+    # We need to fetch the parent's market collateral token, to split it and get the collateral token
+    # of the child market.
+    seer_subgraph_handler = SeerSubgraphHandler()
+    market = seer_subgraph_handler.get_market_by_wrapped_token(
+        tokens=[collateral_token_contract.address]
+    )
+    market_collateral_token = Web3.to_checksum_address(market.collateral_token)
+
+    balance_market_collateral = ContractERC20OnGnosisChain(
+        address=market_collateral_token
+    ).balanceOf(for_address=api_keys.bet_from_address, web3=web3)
+    if balance_market_collateral < collateral_amount_wei:
+        logger.debug(
+            f"Not enough collateral token in the market. Expected {collateral_amount_wei} but got {balance_market_collateral}. Auto-depositing market collateral."
+        )
+        market_collateral_token_contract = to_gnosis_chain_contract(
+            init_collateral_token_contract(market_collateral_token, web3=web3)
+        )
+        auto_deposit_collateral_token(
+            market_collateral_token_contract, collateral_amount_wei, api_keys, web3
+        )
+
+    handle_allowance(
+        api_keys=api_keys,
+        sell_token=market_collateral_token,
+        amount_to_check_wei=collateral_amount_wei,
+        for_address=router.address,
+        web3=web3,
+    )
+
+    router.split_position(
+        api_keys=api_keys,
+        collateral_token=market_collateral_token,
+        market_id=Web3.to_checksum_address(market.id),
+        amount=collateral_amount_wei,
+        web3=web3,
     )

prediction_market_agent_tooling/tools/tokens/auto_withdraw.py

@@ -9,6 +9,9 @@ from prediction_market_agent_tooling.tools.contract import (
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
+from prediction_market_agent_tooling.tools.tokens.slippage import (
+    get_slippage_tolerance_per_token,
+)
 from prediction_market_agent_tooling.tools.utils import should_not_happen
 
 
@@ -49,12 +52,17 @@ def auto_withdraw_collateral_token(
             f"Swapping {amount_wei.as_token} from {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
         )
         # Otherwise, DEX will handle the rest of token swaps.
+        slippage_tolerance = get_slippage_tolerance_per_token(
+            collateral_token_contract.address,
+            KEEPING_ERC20_TOKEN.address,
+        )
         swap_tokens_waiting(
             amount_wei=amount_wei,
             sell_token=collateral_token_contract.address,
             buy_token=KEEPING_ERC20_TOKEN.address,
             api_keys=api_keys,
             web3=web3,
+            slippage_tolerance=slippage_tolerance,
         )
     else:
         should_not_happen("Unsupported ERC20 contract type.")

prediction_market_agent_tooling/tools/tokens/slippage.py

@@ -0,0 +1,21 @@
+from prediction_market_agent_tooling.gtypes import ChecksumAddress
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    METRI_SUPER_GROUP_CONTRACT_ADDRESS,
+)
+
+DEFAULT_SLIPPAGE_TOLERANCE = 0.05
+
+SLIPPAGE_TOLERANCE_PER_TOKEN = {
+    METRI_SUPER_GROUP_CONTRACT_ADDRESS: 0.1,
+}
+
+
+def get_slippage_tolerance_per_token(
+    sell_token: ChecksumAddress,
+    buy_token: ChecksumAddress,
+    default_slippage: float = DEFAULT_SLIPPAGE_TOLERANCE,
+) -> float:
+    return max(
+        SLIPPAGE_TOLERANCE_PER_TOKEN.get(sell_token, default_slippage),
+        SLIPPAGE_TOLERANCE_PER_TOKEN.get(buy_token, default_slippage),
+    )

prediction_market_agent_tooling/tools/tokens/usd.py

@@ -10,6 +10,9 @@ from prediction_market_agent_tooling.markets.omen.omen_constants import (
     SDAI_CONTRACT_ADDRESS,
     WRAPPED_XDAI_CONTRACT_ADDRESS,
 )
+from prediction_market_agent_tooling.markets.polymarket.polymarket_contracts import (
+    USDCeContract,
+)
 from prediction_market_agent_tooling.tools.contract import ContractERC4626OnGnosisChain
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_buy_token_amount_else_raise,
@@ -39,8 +42,8 @@ def get_token_in_usd(amount: CollateralToken, token_address: ChecksumAddress) ->
 # A short cache to not spam CoW and prevent timeouts, but still have relatively fresh data.
 @cached(TTLCache(maxsize=100, ttl=5 * 60))
 def get_single_token_to_usd_rate(token_address: ChecksumAddress) -> USD:
-    # (w)xDai is a stable coin against USD, so use it to estimate USD worth.
-    if WRAPPED_XDAI_CONTRACT_ADDRESS == token_address:
+    # (w)xDai and USDC are stablecoins pegged to USD, so use it to estimate USD worth.
+    if token_address in [WRAPPED_XDAI_CONTRACT_ADDRESS, USDCeContract().address]:
         return USD(1.0)
     # sDai is ERC4626 with wxDai as asset, we can take the rate directly from there instead of calling CoW.
     if SDAI_CONTRACT_ADDRESS == token_address:

prediction_market_agent_tooling/tools/utils.py

@@ -1,14 +1,18 @@
+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
 import requests
 from pydantic import BaseModel, ValidationError
 from scipy.optimize import newton
 from scipy.stats import entropy
+from tenacity import RetryError
 
 from prediction_market_agent_tooling.gtypes import (
     CollateralToken,
@@ -54,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:
@@ -142,7 +189,9 @@ def get_current_git_url() -> str:
     return git.Repo(search_parent_directories=True).remotes.origin.url
 
 
-def response_to_json(response: requests.models.Response) -> dict[str, Any]:
+def response_to_json(
+    response: requests.models.Response | httpx.Response,
+) -> dict[str, Any]:
     response.raise_for_status()
     response_json: dict[str, Any] = response.json()
     return response_json
@@ -152,7 +201,7 @@ BaseModelT = TypeVar("BaseModelT", bound=BaseModel)
 
 
 def response_to_model(
-    response: requests.models.Response, model: Type[BaseModelT]
+    response: requests.models.Response | httpx.Response, model: Type[BaseModelT]
 ) -> BaseModelT:
     response_json = response_to_json(response)
     try:
@@ -230,3 +279,12 @@ def calculate_sell_amount_in_collateral(
 
     amount_to_sell = newton(f, 0)
     return CollateralToken(float(amount_to_sell) * 0.999999)  # Avoid rounding errors
+
+
+def extract_error_from_retry_error(e: BaseException | RetryError) -> BaseException:
+    if (
+        isinstance(e, RetryError)
+        and (exp_from_retry := e.last_attempt.exception()) is not None
+    ):
+        e = exp_from_retry
+    return e

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,22 @@ 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.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt
+from web3.contract.contract import ContractFunction as Web3ContractFunction
+from web3.types import (
+    AccessList,
+    AccessListEntry,
+    BlockIdentifier,
+    Nonce,
+    TxParams,
+    TxReceipt,
+)
 
 from prediction_market_agent_tooling.gtypes import (
     ABI,
@@ -67,17 +78,23 @@ def unwrap_generic_value(value: Any) -> Any:
         return value.value
     elif isinstance(value, list):
         return [unwrap_generic_value(v) for v in value]
+    elif isinstance(value, tuple):
+        return tuple(unwrap_generic_value(v) for v in value)
     elif isinstance(value, dict):
         return {k: unwrap_generic_value(v) for k, v in value.items()}
     return value
 
 
-def parse_function_params(params: Optional[list[Any] | dict[str, Any]]) -> list[Any]:
+def parse_function_params(
+    params: Optional[list[Any] | tuple[Any] | dict[str, Any]],
+) -> list[Any] | tuple[Any]:
     params = unwrap_generic_value(params)
     if params is None:
         return []
     if isinstance(params, list):
-        return params
+        return [unwrap_generic_value(i) for i in params]
+    if isinstance(params, tuple):
+        return tuple(unwrap_generic_value(i) for i in params)
     if isinstance(params, dict):
         return list(params.values())
     raise ValueError(f"Invalid type for function parameters: {type(params)}")
@@ -96,9 +113,12 @@ def call_function_on_contract(
     contract_abi: ABI,
     function_name: str,
     function_params: Optional[list[Any] | dict[str, Any]] = None,
+    block_identifier: Optional[BlockIdentifier] = None,
 ) -> Any:
     contract = web3.eth.contract(address=contract_address, abi=contract_abi)
-    output = contract.functions[function_name](*parse_function_params(function_params)).call()  # type: ignore # TODO: Fix Mypy, as this works just OK.
+    output = contract.functions[function_name](
+        *parse_function_params(function_params)
+    ).call(block_identifier=block_identifier)
     return output
 
 
@@ -111,14 +131,43 @@ 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)
-
     # Build the transaction.
-    function_call = contract.functions[function_name](*parse_function_params(function_params))  # type: ignore # TODO: Fix Mypy, as this works just OK.
-    tx_params_new = function_call.build_transaction(tx_params_new)
-    return tx_params_new
+    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(
@@ -172,6 +221,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)
 
@@ -183,6 +233,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(
@@ -211,6 +262,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.")
@@ -251,6 +303,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"]),
@@ -263,6 +316,7 @@ def send_function_on_contract_tx_using_safe(
     tx_hash, tx = safe_tx.execute(
         from_private_key.get_secret_value(),
         tx_nonce=eoa_nonce,
+        eip1559_speed=TxSpeed.FAST,
     )
     receipt_tx = web3.eth.wait_for_transaction_receipt(tx_hash, timeout=timeout)
     check_tx_receipt(receipt_tx)
@@ -280,7 +334,7 @@ def sign_send_and_get_receipt_tx(
         tx_params_new, private_key=from_private_key.get_secret_value()
     )
     # Send the signed transaction.
-    send_tx = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
+    send_tx = web3.eth.send_raw_transaction(signed_tx.raw_transaction)
     # And wait for the receipt.
     receipt_tx = web3.eth.wait_for_transaction_receipt(send_tx, timeout=timeout)
     # Verify it didn't fail.

{prediction_market_agent_tooling-0.65.5.dist-info → prediction_market_agent_tooling-0.69.17.dev1149.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: prediction-market-agent-tooling
-Version: 0.65.5
+Version: 0.69.17.dev1149
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
+License-File: LICENSE
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
 Classifier: Programming Language :: Python :: 3
@@ -14,11 +15,11 @@ 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.1)
 Requires-Dist: cron-validator (>=1.0.8,<2.0.0)
-Requires-Dist: eth-account (>=0.8.0,<0.12.0)
+Requires-Dist: eth-account (>=0.13.0,<0.14.0)
 Requires-Dist: eth-keys (>=0.6.1,<0.7.0)
-Requires-Dist: eth-typing (>=3.0.0,<4.0.0)
+Requires-Dist: eth-typing (>=5.0.0,<6.0.0)
 Requires-Dist: functions-framework (>=3.5.0,<4.0.0)
 Requires-Dist: google-api-python-client (==2.95.0) ; extra == "google"
 Requires-Dist: google-cloud-functions (>=1.16.0,<2.0.0)
@@ -41,14 +42,16 @@ Requires-Dist: prompt-toolkit (>=3.0.43,<4.0.0)
 Requires-Dist: proto-plus (>=1.0.0,<2.0.0)
 Requires-Dist: protobuf (>=5.0.0,<6.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
+Requires-Dist: py-clob-client (>=0.24.0,<0.25.0)
 Requires-Dist: pydantic (>=2.6.1,<3.0.0)
+Requires-Dist: pydantic-ai (>=1.0.3,<2.0.0)
 Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
 Requires-Dist: pymongo (>=4.8.0,<5.0.0)
 Requires-Dist: pytest-postgresql (>=6.1.1,<7.0.0)
 Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: python-json-logger (>=3.3.0,<4.0.0)
-Requires-Dist: safe-cli (>=1.0.0,<2.0.0)
-Requires-Dist: safe-eth-py (>=6.0.0b41,<7.0.0)
+Requires-Dist: safe-cli (>=1.5.0,<2.0.0)
+Requires-Dist: safe-eth-py (>=7.8.0,<8.0.0)
 Requires-Dist: scikit-learn (>=1.3.1,<2.0.0)
 Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
 Requires-Dist: streamlit (>=1.31.0,<2.0.0)
@@ -61,7 +64,7 @@ Requires-Dist: types-cachetools (>=5.5.0.20240820,<6.0.0.0)
 Requires-Dist: types-python-dateutil (>=2.9.0.20240906,<3.0.0.0)
 Requires-Dist: types-pytz (>=2024.1.0.20240203,<2025.0.0.0)
 Requires-Dist: types-requests (>=2.31.0.0,<3.0.0.0)
-Requires-Dist: web3 (>=6.15.1,<7.0.0)
+Requires-Dist: web3 (>=6,<8)
 Description-Content-Type: text/markdown
 
 # Prediction Market Agent Tooling
@@ -99,7 +102,8 @@ For example:
 ```python
 import prediction_market_agent_tooling.benchmark.benchmark as bm
 from prediction_market_agent_tooling.benchmark.agents import RandomAgent
-from prediction_market_agent_tooling.markets.markets import MarketType, get_binary_markets
+from prediction_market_agent_tooling.markets.market_type import MarketType
+from prediction_market_agent_tooling.markets.markets import get_binary_markets
 
 benchmarker = bm.Benchmarker(
     markets=get_binary_markets(limit=10, market_type=MarketType.MANIFOLD),