prediction-market-agent-tooling 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -2,7 +2,9 @@ import sys
 import typing as t
 from datetime import datetime
 
+import tenacity
 from eth_typing import ChecksumAddress
+from loguru import logger
 from subgrounds import FieldPath, Subgrounds
 
 from prediction_market_agent_tooling.gtypes import HexAddress, HexBytes, Wei, wei_type
@@ -39,6 +41,14 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
 
     def __init__(self) -> None:
         self.sg = Subgrounds()
+
+        # Patch the query_json method to retry on failure.
+        self.sg.query_json = tenacity.retry(
+            stop=tenacity.stop_after_attempt(3),
+            wait=tenacity.wait_fixed(1),
+            after=lambda x: logger.debug(f"query_json failed, {x.attempt_number=}."),
+        )(self.sg.query_json)
+
         # Load the subgraph
         self.trades_subgraph = self.sg.load_subgraph(self.OMEN_TRADES_SUBGRAPH)
         self.conditional_tokens_subgraph = self.sg.load_subgraph(
@@ -121,6 +131,8 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             markets_field.outcomes,
             markets_field.outcomeTokenAmounts,
             markets_field.outcomeTokenMarginalPrices,
+            markets_field.lastActiveDay,
+            markets_field.lastActiveHour,
             markets_field.fee,
             markets_field.answerFinalizedTimestamp,
             markets_field.resolutionTimestamp,
@@ -419,26 +431,30 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         items = self._parse_items_from_json(result)
         return [OmenUserPosition.model_validate(i) for i in items]
 
-    def get_bets(
+    def get_trades(
         self,
-        better_address: ChecksumAddress,
-        start_time: datetime,
+        better_address: ChecksumAddress | None = None,
+        start_time: datetime | None = None,
         end_time: t.Optional[datetime] = None,
-        market_id: t.Optional[str] = None,
+        market_id: t.Optional[ChecksumAddress] = None,
         filter_by_answer_finalized_not_null: bool = False,
+        type_: t.Literal["Buy", "Sell"] | None = None,
     ) -> list[OmenBet]:
         if not end_time:
             end_time = utcnow()
 
         trade = self.trades_subgraph.FpmmTrade
-        where_stms = [
-            trade.type == "Buy",
-            trade.creator == better_address.lower(),
-            trade.creationTimestamp >= to_int_timestamp(start_time),
-            trade.creationTimestamp <= to_int_timestamp(end_time),
-        ]
+        where_stms = []
+        if start_time:
+            where_stms.append(trade.creationTimestamp >= to_int_timestamp(start_time))
+        if end_time:
+            where_stms.append(trade.creationTimestamp <= to_int_timestamp(end_time))
+        if type_:
+            where_stms.append(trade.type == type_)
+        if better_address:
+            where_stms.append(trade.creator == better_address.lower())
         if market_id:
-            where_stms.append(trade.fpmm == market_id)
+            where_stms.append(trade.fpmm == market_id.lower())
         if filter_by_answer_finalized_not_null:
             where_stms.append(trade.fpmm.answerFinalizedTimestamp != None)
 
@@ -450,12 +466,29 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         items = self._parse_items_from_json(result)
         return [OmenBet.model_validate(i) for i in items]
 
+    def get_bets(
+        self,
+        better_address: ChecksumAddress | None = None,
+        start_time: datetime | None = None,
+        end_time: t.Optional[datetime] = None,
+        market_id: t.Optional[ChecksumAddress] = None,
+        filter_by_answer_finalized_not_null: bool = False,
+    ) -> list[OmenBet]:
+        return self.get_trades(
+            better_address=better_address,
+            start_time=start_time,
+            end_time=end_time,
+            market_id=market_id,
+            filter_by_answer_finalized_not_null=filter_by_answer_finalized_not_null,
+            type_="Buy",  # We consider `bet` to be only the `Buy` trade types.
+        )
+
     def get_resolved_bets(
         self,
         better_address: ChecksumAddress,
         start_time: datetime,
         end_time: t.Optional[datetime] = None,
-        market_id: t.Optional[str] = None,
+        market_id: t.Optional[ChecksumAddress] = None,
     ) -> list[OmenBet]:
         omen_bets = self.get_bets(
             better_address=better_address,
@@ -471,7 +504,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         better_address: ChecksumAddress,
         start_time: datetime,
         end_time: t.Optional[datetime] = None,
-        market_id: t.Optional[str] = None,
+        market_id: t.Optional[ChecksumAddress] = None,
     ) -> list[OmenBet]:
         bets = self.get_resolved_bets(
             better_address=better_address,

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -33,7 +33,7 @@ class PolymarketAgentMarket(AgentMarket):
             question=model.question,
             outcomes=[x.outcome for x in model.tokens],
             resolution=model.resolution,
-            p_yes=model.p_yes,
+            current_p_yes=model.p_yes,
             created_time=None,
             close_time=model.end_date_iso,
             url=model.url,

prediction_market_agent_tooling/monitor/markets/omen.py

@@ -2,7 +2,7 @@ import typing as t
 
 from google.cloud.functions_v2.types.functions import Function
 
-from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.config import APIKeys, PrivateCredentials
 from prediction_market_agent_tooling.deploy.constants import MARKET_TYPE_KEY
 from prediction_market_agent_tooling.gtypes import ChecksumAddress, DatetimeWithTimezone
 from prediction_market_agent_tooling.markets.data_models import ResolvedBet
@@ -49,7 +49,8 @@ class DeployedOmenAgent(DeployedAgent):
             and api_keys.BET_FROM_PRIVATE_KEY
             != APIKeys().BET_FROM_PRIVATE_KEY  # Check that it didn't get if from the default env.
         ):
-            env_vars["omen_public_key"] = api_keys.bet_from_address
+            private_credentials = PrivateCredentials.from_api_keys(api_keys)
+            env_vars["omen_public_key"] = private_credentials.public_key
         return super().from_env_vars_without_prefix(
             env_vars=env_vars, extra_vars=extra_vars
         )
@@ -60,10 +61,11 @@ class DeployedOmenAgent(DeployedAgent):
         start_time: DatetimeWithTimezone,
         api_keys: APIKeys,
     ) -> "DeployedOmenAgent":
+        private_credentials = PrivateCredentials.from_api_keys(api_keys)
         return DeployedOmenAgent(
             name=name,
             start_time=start_time,
-            omen_public_key=api_keys.bet_from_address,
+            omen_public_key=private_credentials.public_key,
         )
 
     @classmethod

prediction_market_agent_tooling/monitor/markets/polymarket.py

@@ -2,7 +2,7 @@ import typing as t
 
 from google.cloud.functions_v2.types.functions import Function
 
-from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.config import APIKeys, PrivateCredentials
 from prediction_market_agent_tooling.deploy.constants import MARKET_TYPE_KEY
 from prediction_market_agent_tooling.gtypes import ChecksumAddress, DatetimeWithTimezone
 from prediction_market_agent_tooling.markets.data_models import ResolvedBet
@@ -28,10 +28,11 @@ class DeployedPolymarketAgent(DeployedAgent):
         start_time: DatetimeWithTimezone,
         api_keys: APIKeys,
     ) -> "DeployedPolymarketAgent":
+        private_credentials = PrivateCredentials.from_api_keys(api_keys)
         return DeployedPolymarketAgent(
             name=name,
             start_time=start_time,
-            polymarket_public_key=api_keys.bet_from_address,
+            polymarket_public_key=private_credentials.public_key,
         )
 
     @classmethod

prediction_market_agent_tooling/monitor/monitor.py

@@ -24,6 +24,7 @@ from prediction_market_agent_tooling.deploy.gcp.utils import (
 )
 from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.data_models import Resolution, ResolvedBet
+from prediction_market_agent_tooling.tools.parallelism import par_map
 from prediction_market_agent_tooling.tools.utils import (
     DatetimeWithTimezone,
     add_utc_timezone_validator,
@@ -259,16 +260,32 @@ def monitor_brier_score(resolved_markets: t.Sequence[AgentMarket]) -> None:
     """
     st.subheader("Brier Score (0-1, lower is better)")
 
-    markets_to_squared_error = {
-        m.created_time: m.get_squared_error() for m in resolved_markets
-    }
+    # We need to use `get_last_trade_p_yes` instead of `current_p_yes` because, for resolved markets, the probabilities can be fixed to 0 and 1 (for example, on Omen).
+    # And for the brier score, we need the true market prediction, not its resolution after the outcome is known.
+    # If no trades were made, take it as 0.5 because the platform didn't provide any valuable information.
+    created_time_and_squared_errors = par_map(
+        list(resolved_markets),
+        lambda m: (
+            m.created_time,
+            (
+                (p_yes - m.boolean_outcome) ** 2
+                if (p_yes := m.get_last_trade_p_yes()) is not None
+                else None
+            ),
+        ),
+    )
+    created_time_and_squared_errors_with_trades = [
+        x for x in created_time_and_squared_errors if x[1] is not None
+    ]
     df = pd.DataFrame(
-        markets_to_squared_error.items(), columns=["Date", "Squared Error"]
+        created_time_and_squared_errors_with_trades, columns=["Date", "Squared Error"]
     ).sort_values(by="Date")
 
     # Compute rolling mean squared error for last 30 markets
     df["Rolling Mean Squared Error"] = df["Squared Error"].rolling(window=30).mean()
 
+    st.write(f"Based on {len(df)} markets with at least one trade.")
+
     col1, col2 = st.columns(2)
     col1.metric(label="Overall", value=f"{df['Squared Error'].mean():.3f}")
     col2.metric(
@@ -293,27 +310,14 @@ def monitor_market_outcome_bias(
     st.subheader("Market Outcome Bias")
 
     date_to_open_yes_proportion = {
-        d: np.mean([int(m.p_yes > 0.5) for m in markets])
+        d: np.mean([int(m.current_p_yes > 0.5) for m in markets])
         for d, markets in groupby(
             open_markets,
             lambda x: check_not_none(x.created_time, "Only markets with created time can be used here.").date(),  # type: ignore # Bug, it says `Never has no attribute "date"  [attr-defined]` with Mypy, but in VSCode it works correctly.
         )
     }
     date_to_resolved_yes_proportion = {
-        d: np.mean(
-            [
-                (
-                    1
-                    if m.resolution == Resolution.YES
-                    else (
-                        0
-                        if m.resolution == Resolution.NO
-                        else should_not_happen(f"Unexpected resolution: {m.resolution}")
-                    )
-                )
-                for m in markets
-            ]
-        )
+        d: np.mean([int(m.boolean_outcome) for m in markets])
         for d, markets in groupby(
             resolved_markets,
             lambda x: check_not_none(x.created_time, "Only markets with created time can be used here.").date(),  # type: ignore # Bug, it says `Never has no attribute "date"  [attr-defined]` with Mypy, but in VSCode it works correctly.
@@ -349,7 +353,9 @@ def monitor_market_outcome_bias(
             use_container_width=True,
         )
 
-    all_open_markets_yes_mean = np.mean([int(m.p_yes > 0.5) for m in open_markets])
+    all_open_markets_yes_mean = np.mean(
+        [int(m.current_p_yes > 0.5) for m in open_markets]
+    )
     all_resolved_markets_yes_mean = np.mean(
         [
             (

prediction_market_agent_tooling/tools/betting_strategies/minimum_bet_to_win.py

@@ -7,6 +7,6 @@ def minimum_bet_to_win(
     """
     Estimates the minimum bet amount to win the given amount based on the current market price.
     """
-    share_price = market.p_yes if answer else market.p_no
+    share_price = market.current_p_yes if answer else market.current_p_no
     bet_amount = amount_to_win / (1 / share_price - 1)
     return bet_amount

prediction_market_agent_tooling/tools/contract.py

@@ -6,12 +6,12 @@ from contextlib import contextmanager
 from pydantic import BaseModel, field_validator
 from web3 import Web3
 
+from prediction_market_agent_tooling.config import PrivateCredentials
 from prediction_market_agent_tooling.gtypes import (
     ABI,
     ChainID,
     ChecksumAddress,
     Nonce,
-    PrivateKey,
     TxParams,
     TxReceipt,
     Wei,
@@ -22,8 +22,8 @@ from prediction_market_agent_tooling.tools.gnosis_rpc import (
 )
 from prediction_market_agent_tooling.tools.web3_utils import (
     call_function_on_contract,
-    private_key_to_public_key,
     send_function_on_contract_tx,
+    send_function_on_contract_tx_using_safe,
 )
 
 
@@ -86,7 +86,7 @@ class ContractBaseClass(BaseModel):
 
     def send(
         self,
-        from_private_key: PrivateKey,
+        private_credentials: PrivateCredentials,
         function_name: str,
         function_params: t.Optional[list[t.Any] | dict[str, t.Any]] = None,
         tx_params: t.Optional[TxParams] = None,
@@ -96,22 +96,33 @@ class ContractBaseClass(BaseModel):
         """
         Used for changing a state (writing) to the contract.
         """
-        with wait_until_nonce_changed(private_key_to_public_key(from_private_key)):
-            receipt = send_function_on_contract_tx(
+
+        if private_credentials.safe_address is not None:
+            return send_function_on_contract_tx_using_safe(
                 web3=web3 or self.get_web3(),
                 contract_address=self.address,
                 contract_abi=self.abi,
-                from_private_key=from_private_key,
+                from_private_key=private_credentials.private_key,
+                safe_address=private_credentials.safe_address,
                 function_name=function_name,
                 function_params=function_params,
                 tx_params=tx_params,
                 timeout=timeout,
             )
-        return receipt
+        return send_function_on_contract_tx(
+            web3=web3 or self.get_web3(),
+            contract_address=self.address,
+            contract_abi=self.abi,
+            from_private_key=private_credentials.private_key,
+            function_name=function_name,
+            function_params=function_params,
+            tx_params=tx_params,
+            timeout=timeout,
+        )
 
     def send_with_value(
         self,
-        from_private_key: PrivateKey,
+        private_credentials: PrivateCredentials,
         function_name: str,
         amount_wei: Wei,
         function_params: t.Optional[list[t.Any] | dict[str, t.Any]] = None,
@@ -123,7 +134,7 @@ class ContractBaseClass(BaseModel):
         Used for changing a state (writing) to the contract, including sending chain's native currency.
         """
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name=function_name,
             function_params=function_params,
             tx_params={"value": amount_wei, **(tx_params or {})},
@@ -147,51 +158,55 @@ class ContractERC20BaseClass(ContractBaseClass):
 
     def approve(
         self,
+        private_credentials: PrivateCredentials,
         for_address: ChecksumAddress,
         amount_wei: Wei,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="approve",
             function_params=[
                 for_address,
                 amount_wei,
             ],
             tx_params=tx_params,
+            web3=web3,
         )
 
     def deposit(
         self,
+        private_credentials: PrivateCredentials,
         amount_wei: Wei,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send_with_value(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="deposit",
             amount_wei=amount_wei,
             tx_params=tx_params,
+            web3=web3,
         )
 
     def withdraw(
         self,
+        private_credentials: PrivateCredentials,
         amount_wei: Wei,
-        from_private_key: PrivateKey,
         tx_params: t.Optional[TxParams] = None,
         web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
-            from_private_key=from_private_key,
+            private_credentials=private_credentials,
             function_name="withdraw",
             function_params=[amount_wei],
             tx_params=tx_params,
             web3=web3,
         )
 
-    def balanceOf(self, for_address: ChecksumAddress) -> Wei:
-        balance: Wei = self.call("balanceOf", [for_address])
+    def balanceOf(self, for_address: ChecksumAddress, web3: Web3 | None = None) -> Wei:
+        balance: Wei = self.call("balanceOf", [for_address], web3=web3)
         return balance
 
 

prediction_market_agent_tooling/tools/costs.py

@@ -0,0 +1,31 @@
+import typing as t
+from contextlib import contextmanager
+from time import time
+
+from langchain_community.callbacks import get_openai_callback
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.benchmark.utils import get_llm_api_call_cost
+
+
+class Costs(BaseModel):
+    time: float
+    cost: float
+
+
+@contextmanager
+def openai_costs(model: str | None = None) -> t.Generator[Costs, None, None]:
+    costs = Costs(time=0, cost=0)
+    start_time = time()
+
+    with get_openai_callback() as cb:
+        yield costs
+        if cb.total_tokens > 0 and cb.total_cost == 0 and model is not None:
+            # TODO: this is a hack to get the cost for an unsupported model
+            cb.total_cost = get_llm_api_call_cost(
+                model=model,
+                prompt_tokens=cb.prompt_tokens,
+                completion_tokens=cb.completion_tokens,
+            )
+        costs.time = time() - start_time
+        costs.cost = cb.total_cost

prediction_market_agent_tooling/tools/parallelism.py

@@ -1,7 +1,7 @@
 import concurrent
 from concurrent.futures import Executor
 from concurrent.futures.thread import ThreadPoolExecutor
-from typing import Callable, TypeVar
+from typing import Callable, Generator, TypeVar
 
 # Max workers to 5 to avoid rate limiting on some APIs, create a custom executor if you need more workers.
 DEFAULT_THREADPOOL_EXECUTOR = ThreadPoolExecutor(max_workers=5)
@@ -25,3 +25,18 @@ def par_map(
     for fut in futures:
         results.append(fut.result())
     return results
+
+
+def par_generator(
+    items: list[A],
+    func: Callable[[A], B],
+    executor: Executor = DEFAULT_THREADPOOL_EXECUTOR,
+) -> Generator[B, None, None]:
+    """Applies the function to each element using the specified executor. Yields results as they come.
+    If executor is ProcessPoolExecutor, make sure the function passed is pickable, e.g. no lambda functions.
+    """
+    futures: list[concurrent.futures._base.Future[B]] = [
+        executor.submit(func, item) for item in items
+    ]
+    for fut in concurrent.futures.as_completed(futures):
+        yield fut.result()

prediction_market_agent_tooling/tools/safe.py

@@ -0,0 +1,130 @@
+from eth_account.signers.local import LocalAccount
+from eth_typing import ChecksumAddress
+from gnosis.eth import EthereumClient
+from gnosis.eth.constants import NULL_ADDRESS
+from gnosis.eth.contracts import get_safe_V1_4_1_contract
+from gnosis.safe.proxy_factory import ProxyFactoryV141
+from gnosis.safe.safe import Safe
+from loguru import logger
+from safe_cli.safe_addresses import (
+    get_default_fallback_handler_address,
+    get_proxy_factory_address,
+    get_safe_contract_address,
+    get_safe_l2_contract_address,
+)
+from web3.types import Wei
+
+from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai
+
+
+def create_safe(
+    ethereum_client: EthereumClient,
+    account: LocalAccount,
+    owners: list[str],
+    salt_nonce: int,
+    threshold: int = 1,
+    without_events: bool = False,  # following safe-cli convention
+) -> ChecksumAddress | None:
+    to = NULL_ADDRESS
+    data = b""
+    payment_token = NULL_ADDRESS
+    payment = 0
+    payment_receiver = NULL_ADDRESS
+
+    if len(owners) < threshold:
+        raise ValueError("Threshold cannot be bigger than the number of unique owners")
+
+    ethereum_network = ethereum_client.get_network()
+
+    safe_contract_address = (
+        get_safe_contract_address(ethereum_client)
+        if without_events
+        else get_safe_l2_contract_address(ethereum_client)
+    )
+    proxy_factory_address = get_proxy_factory_address(ethereum_client)
+    fallback_handler = get_default_fallback_handler_address(ethereum_client)
+
+    if not ethereum_client.is_contract(safe_contract_address):
+        raise EnvironmentError(
+            f"Safe contract address {safe_contract_address} "
+            f"does not exist on network {ethereum_network.name}"
+        )
+    elif not ethereum_client.is_contract(proxy_factory_address):
+        raise EnvironmentError(
+            f"Proxy contract address {proxy_factory_address} "
+            f"does not exist on network {ethereum_network.name}"
+        )
+    elif fallback_handler != NULL_ADDRESS and not ethereum_client.is_contract(
+        fallback_handler
+    ):
+        raise EnvironmentError(
+            f"Fallback handler address {fallback_handler} "
+            f"does not exist on network {ethereum_network.name}"
+        )
+
+    account_balance = ethereum_client.get_balance(account.address)
+    account_balance_xdai = wei_to_xdai(account_balance)
+    # We set a reasonable expected balance below for Safe deployment not to fail.
+    if account_balance_xdai < 0.01:
+        raise ValueError(
+            f"Client's balance is {account_balance_xdai} xDAI, too low for deploying a Safe."
+        )
+
+    logger.info(
+        f"Network {ethereum_client.get_network().name} - Sender {account.address} - "
+        f"Balance: {account_balance_xdai} xDAI"
+    )
+
+    if not ethereum_client.w3.eth.get_code(
+        safe_contract_address
+    ) or not ethereum_client.w3.eth.get_code(proxy_factory_address):
+        raise EnvironmentError("Network not supported")
+
+    logger.info(
+        f"Creating new Safe with owners={owners} threshold={threshold} salt-nonce={salt_nonce}"
+    )
+
+    # We ignore mypy below because using the proper class SafeV141 yields an error and mypy
+    # doesn't understand that there is a hacky factory method (__new__) on this abstract class.
+    safe_version = Safe(safe_contract_address, ethereum_client).retrieve_version()  # type: ignore
+    logger.info(
+        f"Safe-master-copy={safe_contract_address} version={safe_version}\n"
+        f"Fallback-handler={fallback_handler}\n"
+        f"Proxy factory={proxy_factory_address}"
+    )
+
+    # Note that by default a safe contract instance of version 1.4.1 will be fetched (determined
+    # by safe_contract_address), but if a different address (corresponding to an older version, e.g. 1.3.0)
+    # is passed, it will also work, since older versions also have the setup method.
+    safe_contract = get_safe_V1_4_1_contract(ethereum_client.w3, safe_contract_address)
+    safe_creation_tx_data = HexBytes(
+        safe_contract.functions.setup(
+            owners,
+            threshold,
+            to,
+            data,
+            fallback_handler,
+            payment_token,
+            payment,
+            payment_receiver,
+        ).build_transaction({"gas": 1, "gasPrice": Wei(1)})["data"]
+    )
+
+    proxy_factory = ProxyFactoryV141(proxy_factory_address, ethereum_client)
+    expected_safe_address = proxy_factory.calculate_proxy_address(
+        safe_contract_address, safe_creation_tx_data, salt_nonce
+    )
+    if ethereum_client.is_contract(expected_safe_address):
+        logger.info(f"Safe on {expected_safe_address} is already deployed")
+        return expected_safe_address
+
+    ethereum_tx_sent = proxy_factory.deploy_proxy_contract_with_nonce(
+        account, safe_contract_address, safe_creation_tx_data, salt_nonce
+    )
+    logger.info(
+        f"Sent tx with tx-hash={ethereum_tx_sent.tx_hash.hex()} "
+        f"Safe={ethereum_tx_sent.contract_address} is being created"
+    )
+    logger.info(f"Tx parameters={ethereum_tx_sent.tx}")
+    return ethereum_tx_sent.contract_address