prediction-market-agent-tooling 0.17.0__tar.gz → 0.19.0__tar.gz

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.17.0
+Version: 0.19.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12
@@ -22,6 +22,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0)
 Requires-Dist: langchain (>=0.1.9,<0.2.0) ; extra == "langchain"
 Requires-Dist: langchain-community (>=0.0.19)
 Requires-Dist: langchain-openai (>=0.0.5,<0.0.6) ; extra == "langchain"
+Requires-Dist: langfuse (>=2.27.1,<3.0.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)
 Requires-Dist: mech-client (>=0.2.13,<0.3.0)
 Requires-Dist: numpy (>=1.26.4,<2.0.0)

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/config.py

@@ -1,5 +1,7 @@
 import typing as t
 
+from gnosis.eth import EthereumClient
+from gnosis.safe import Safe
 from pydantic import BaseModel
 from pydantic.types import SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -30,6 +32,10 @@ class APIKeys(BaseSettings):
     GOOGLE_SEARCH_API_KEY: t.Optional[SecretStr] = None
     GOOGLE_SEARCH_ENGINE_ID: t.Optional[SecretStr] = None
 
+    LANGFUSE_SECRET_KEY: t.Optional[SecretStr] = None
+    LANGFUSE_PUBLIC_KEY: t.Optional[SecretStr] = None
+    LANGFUSE_HOST: t.Optional[str] = None
+
     ENABLE_CACHE: bool = True
     CACHE_DIR: str = "./.cache"
 
@@ -72,6 +78,24 @@ class APIKeys(BaseSettings):
             "GOOGLE_SEARCH_ENGINE_ID missing in the environment.",
         )
 
+    @property
+    def langfuse_secret_key(self) -> SecretStr:
+        return check_not_none(
+            self.LANGFUSE_SECRET_KEY, "LANGFUSE_SECRET_KEY missing in the environment."
+        )
+
+    @property
+    def langfuse_public_key(self) -> SecretStr:
+        return check_not_none(
+            self.LANGFUSE_PUBLIC_KEY, "LANGFUSE_PUBLIC_KEY missing in the environment."
+        )
+
+    @property
+    def langfuse_host(self) -> str:
+        return check_not_none(
+            self.LANGFUSE_HOST, "LANGFUSE_HOST missing in the environment."
+        )
+
     def model_dump_public(self) -> dict[str, t.Any]:
         return {
             k: v
@@ -110,3 +134,11 @@ class PrivateCredentials(BaseModel):
             private_key=api_keys.bet_from_private_key,
             safe_address=api_keys.SAFE_ADDRESS,
         )
+
+    def check_if_is_safe_owner(self, ethereum_client: EthereumClient) -> bool:
+        if not self.safe_address:
+            raise ValueError("Cannot check ownership if safe_address is not defined.")
+
+        s = Safe(self.safe_address, ethereum_client)  # type: ignore[abstract]
+        public_key_from_signer = private_key_to_public_key(self.private_key)
+        return s.retrieve_is_owner(public_key_from_signer)

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/deploy/agent.py

@@ -3,7 +3,7 @@ import os
 import tempfile
 import time
 import typing as t
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from loguru import logger
 from pydantic import BaseModel, BeforeValidator
@@ -30,13 +30,20 @@ from prediction_market_agent_tooling.markets.agent_market import (
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import BetAmount
-from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.markets import (
+    MarketType,
+    have_bet_on_market_since,
+)
 from prediction_market_agent_tooling.markets.omen.omen import (
     redeem_from_all_user_positions,
 )
+from prediction_market_agent_tooling.monitor.langfuse.langfuse_wrapper import (
+    LangfuseWrapper,
+)
 from prediction_market_agent_tooling.monitor.monitor_app import (
     MARKET_TYPE_TO_DEPLOYED_AGENT,
 )
+from prediction_market_agent_tooling.tools.is_predictable import is_predictable_binary
 from prediction_market_agent_tooling.tools.utils import DatetimeWithTimezone, utcnow
 
 MAX_AVAILABLE_MARKETS = 20
@@ -77,7 +84,10 @@ class Answer(BaseModel):
 
 
 class DeployableAgent:
+    bet_on_n_markets_per_run: int = 1
+
     def __init__(self) -> None:
+        self.langfuse_wrapper = LangfuseWrapper(agent_name=self.__class__.__name__)
         self.load()
 
     def __init_subclass__(cls, **kwargs: t.Any) -> None:
@@ -89,11 +99,30 @@ class DeployableAgent:
     def load(self) -> None:
         pass
 
+    def have_bet_on_market_since(self, market: AgentMarket, since: timedelta) -> bool:
+        return have_bet_on_market_since(keys=APIKeys(), market=market, since=since)
+
     def pick_markets(self, markets: t.Sequence[AgentMarket]) -> t.Sequence[AgentMarket]:
         """
-        This method should be implemented by the subclass to pick the markets to bet on. By default, it picks only the first market.
+        Subclasses can implement their own logic instead of this one, or on top of this one.
+        By default, it picks only the first {n_markets_per_run} markets where user didn't bet recently and it's a reasonable question.
         """
-        return markets[:1]
+        picked: list[AgentMarket] = []
+
+        for market in markets:
+            if len(picked) >= self.bet_on_n_markets_per_run:
+                break
+
+            if self.have_bet_on_market_since(market, since=timedelta(hours=24)):
+                continue
+
+            # Do as a last check, as it uses paid OpenAI API.
+            if not is_predictable_binary(market.question):
+                continue
+
+            picked.append(market)
+
+        return picked
 
     def answer_binary_market(self, market: AgentMarket) -> Answer | None:
         """

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/markets/markets.py

@@ -1,19 +1,29 @@
 import typing as t
-from datetime import datetime
+from datetime import datetime, timedelta
 from enum import Enum
 
+from prediction_market_agent_tooling.config import APIKeys, PrivateCredentials
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     SortBy,
 )
+from prediction_market_agent_tooling.markets.manifold.api import (
+    get_authenticated_user,
+    get_manifold_bets,
+    get_manifold_market,
+)
 from prediction_market_agent_tooling.markets.manifold.manifold import (
     ManifoldAgentMarket,
 )
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
+    OmenSubgraphHandler,
+)
 from prediction_market_agent_tooling.markets.polymarket.polymarket import (
     PolymarketAgentMarket,
 )
+from prediction_market_agent_tooling.tools.utils import should_not_happen, utcnow
 
 
 class MarketType(str, Enum):
@@ -52,3 +62,35 @@ def get_binary_markets(
         excluded_questions=excluded_questions,
     )
     return markets
+
+
+def have_bet_on_market_since(
+    keys: APIKeys, market: AgentMarket, since: timedelta
+) -> bool:
+    start_time = utcnow() - since
+    credentials = PrivateCredentials.from_api_keys(keys)
+    recently_betted_questions = (
+        set(
+            get_manifold_market(b.contractId).question
+            for b in get_manifold_bets(
+                user_id=get_authenticated_user(
+                    keys.manifold_api_key.get_secret_value()
+                ).id,
+                start_time=start_time,
+                end_time=None,
+            )
+        )
+        if isinstance(market, ManifoldAgentMarket)
+        else (
+            set(
+                b.title
+                for b in OmenSubgraphHandler().get_bets(
+                    better_address=credentials.public_key,
+                    start_time=start_time,
+                )
+            )
+            if isinstance(market, OmenAgentMarket)
+            else should_not_happen(f"Uknown market: {market}")
+        )
+    )
+    return market.question in recently_betted_questions

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -432,6 +432,7 @@ def omen_sell_outcome_tx(
     market: OmenAgentMarket,
     outcome: str,
     auto_withdraw: bool,
+    web3: Web3 | None = None,
 ) -> None:
     """
     Sells the given xDai value of shares corresponding to the given outcome in
@@ -447,7 +448,10 @@ def omen_sell_outcome_tx(
     collateral_token = OmenCollateralTokenContract()
 
     # Verify, that markets uses conditional tokens that we expect.
-    if market_contract.conditionalTokens() != conditional_token_contract.address:
+    if (
+        market_contract.conditionalTokens(web3=web3)
+        != conditional_token_contract.address
+    ):
         raise ValueError(
             f"Market {market.id} uses conditional token that we didn't expect, {market_contract.conditionalTokens()} != {conditional_token_contract.address=}"
         )
@@ -457,7 +461,7 @@ def omen_sell_outcome_tx(
 
     # Calculate the amount of shares we will sell for the given selling amount of xdai.
     max_outcome_tokens_to_sell = market_contract.calcSellAmount(
-        amount_wei, outcome_index
+        amount_wei, outcome_index, web3=web3
     )
     # Allow 1% slippage.
     max_outcome_tokens_to_sell = add_fraction(max_outcome_tokens_to_sell, 0.01)
@@ -467,6 +471,7 @@ def omen_sell_outcome_tx(
         private_credentials=private_credentials,
         for_address=market_contract.address,
         approve=True,
+        web3=web3,
     )
     # Sell the shares.
     market_contract.sell(
@@ -474,12 +479,12 @@ def omen_sell_outcome_tx(
         amount_wei,
         outcome_index,
         max_outcome_tokens_to_sell,
+        web3=web3,
     )
     if auto_withdraw:
         # Optionally, withdraw from the collateral token back to the `from_address` wallet.
         collateral_token.withdraw(
-            private_credentials=private_credentials,
-            amount_wei=amount_wei,
+            private_credentials=private_credentials, amount_wei=amount_wei, web3=web3
         )
 
 
@@ -489,6 +494,7 @@ def binary_omen_sell_outcome_tx(
     market: OmenAgentMarket,
     binary_outcome: bool,
     auto_withdraw: bool,
+    web3: Web3 | None = None,
 ) -> None:
     omen_sell_outcome_tx(
         private_credentials=private_credentials,
@@ -496,6 +502,7 @@ def binary_omen_sell_outcome_tx(
         market=market,
         outcome=OMEN_TRUE_OUTCOME if binary_outcome else OMEN_FALSE_OUTCOME,
         auto_withdraw=auto_withdraw,
+        web3=web3,
     )
 
 
@@ -509,6 +516,7 @@ def omen_create_market_tx(
     outcomes: list[str],
     auto_deposit: bool,
     fee: float = OMEN_DEFAULT_MARKET_FEE,
+    web3: Web3 | None = None,
 ) -> ChecksumAddress:
     """
     Based on omen-exchange TypeScript code: https://github.com/protofire/omen-exchange/blob/b0b9a3e71b415d6becf21fe428e1c4fc0dad2e80/app/src/services/cpk/cpk.ts#L308
@@ -539,19 +547,22 @@ def omen_create_market_tx(
         private_credentials=private_credentials,
         for_address=factory_contract.address,
         amount_wei=initial_funds_wei,
+        web3=web3,
     )
 
     # Deposit xDai to the collateral token,
     # this can be skipped, if we know we already have enough collateral tokens.
     collateral_token_balance = collateral_token_contract.balanceOf(
-        for_address=from_address,
+        for_address=from_address, web3=web3
     )
     if (
         auto_deposit
         and initial_funds_wei > 0
         and collateral_token_balance < initial_funds_wei
     ):
-        collateral_token_contract.deposit(private_credentials, initial_funds_wei)
+        collateral_token_contract.deposit(
+            private_credentials, initial_funds_wei, web3=web3
+        )
 
     # Create the question on Realitio.
     question_id = realitio_contract.askQuestion(
@@ -562,6 +573,7 @@ def omen_create_market_tx(
         language=language,
         arbitrator=Arbitrator.KLEROS,
         opening=closing_time,  # The question is opened at the closing time of the market.
+        web3=web3,
     )
 
     # Construct the condition id.
@@ -569,13 +581,15 @@ def omen_create_market_tx(
         question_id=question_id,
         oracle_address=oracle_contract.address,
         outcomes_slot_count=len(outcomes),
+        web3=web3,
     )
-    if not conditional_token_contract.does_condition_exists(condition_id):
+    if not conditional_token_contract.does_condition_exists(condition_id, web3=web3):
         conditional_token_contract.prepareCondition(
             private_credentials=private_credentials,
             question_id=question_id,
             oracle_address=oracle_contract.address,
             outcomes_slot_count=len(outcomes),
+            web3=web3,
         )
 
     # Create the market.
@@ -584,6 +598,7 @@ def omen_create_market_tx(
         condition_id=condition_id,
         fee=fee,
         initial_funds_wei=initial_funds_wei,
+        web3=web3,
     )
 
     # Note: In the Omen's Typescript code, there is futher a creation of `stakingRewardsFactoryAddress`,
@@ -602,6 +617,7 @@ def omen_fund_market_tx(
     market: OmenAgentMarket,
     funds: Wei,
     auto_deposit: bool,
+    web3: Web3 | None = None,
 ) -> None:
     from_address = private_credentials.public_key
     market_contract = market.get_contract()
@@ -611,20 +627,19 @@ def omen_fund_market_tx(
     # this can be skipped, if we know we already have enough collateral tokens.
     if (
         auto_deposit
-        and collateral_token_contract.balanceOf(
-            for_address=from_address,
-        )
+        and collateral_token_contract.balanceOf(for_address=from_address, web3=web3)
         < funds
     ):
-        collateral_token_contract.deposit(private_credentials, funds)
+        collateral_token_contract.deposit(private_credentials, funds, web3=web3)
 
     collateral_token_contract.approve(
         private_credentials=private_credentials,
         for_address=market_contract.address,
         amount_wei=funds,
+        web3=web3,
     )
 
-    market_contract.addFunding(private_credentials, funds)
+    market_contract.addFunding(private_credentials, funds, web3=web3)
 
 
 def build_parent_collection_id() -> HexStr:
@@ -727,7 +742,7 @@ def omen_remove_fund_market_tx(
     """
     from_address = private_credentials.public_key
     market_contract = market.get_contract()
-    original_balances = get_balances(from_address)
+    original_balances = get_balances(from_address, web3=web3)
 
     total_shares = market_contract.balanceOf(from_address, web3=web3)
     if total_shares == 0:
@@ -763,7 +778,8 @@ def omen_remove_fund_market_tx(
         amount=amount_to_merge,
         web3=web3,
     )
-    new_balances = get_balances(from_address)
+
+    new_balances = get_balances(from_address, web3)
 
     logger.debug(f"Result from merge positions {result}")
     logger.info(
@@ -800,7 +816,7 @@ def redeem_from_all_user_positions(
             f"[{index+1} / {len(user_positions)}] Processing redeem from {user_position.id=}."
         )
 
-        original_balances = get_balances(public_key)
+        original_balances = get_balances(public_key, web3)
         conditional_token_contract.redeemPositions(
             private_credentials=private_credentials,
             collateral_token_address=user_position.position.collateral_token_contract_address_checksummed,
@@ -809,7 +825,7 @@ def redeem_from_all_user_positions(
             index_sets=user_position.position.indexSets,
             web3=web3,
         )
-        new_balances = get_balances(public_key)
+        new_balances = get_balances(public_key, web3)
 
         logger.info(
             f"Redeemed {new_balances.wxdai - original_balances.wxdai} wxDai from position {user_position.id=}."

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -56,6 +56,7 @@ class OmenOracleContract(ContractOnGnosisChain):
         template_id: int,
         question_raw: str,
         n_outcomes: int,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
             private_credentials=private_credentials,
@@ -66,6 +67,7 @@ class OmenOracleContract(ContractOnGnosisChain):
                 question=question_raw,
                 numOutcomes=n_outcomes,
             ),
+            web3=web3,
         )
 
 
@@ -86,11 +88,13 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
         question_id: HexBytes,
         oracle_address: ChecksumAddress,
         outcomes_slot_count: int,
+        web3: Web3 | None = None,
     ) -> HexBytes:
         id_ = HexBytes(
             self.call(
                 "getConditionId",
                 [oracle_address, question_id, outcomes_slot_count],
+                web3=web3,
             )
         )
         return id_
@@ -177,34 +181,29 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
         )
 
     def getOutcomeSlotCount(
-        self,
-        condition_id: HexBytes,
+        self, condition_id: HexBytes, web3: Web3 | None = None
     ) -> int:
-        count: int = self.call(
-            "getOutcomeSlotCount",
-            [condition_id],
-        )
+        count: int = self.call("getOutcomeSlotCount", [condition_id], web3=web3)
         return count
 
     def does_condition_exists(
-        self,
-        condition_id: HexBytes,
+        self, condition_id: HexBytes, web3: Web3 | None = None
     ) -> bool:
-        return self.getOutcomeSlotCount(condition_id) > 0
+        return self.getOutcomeSlotCount(condition_id, web3=web3) > 0
 
     def is_condition_resolved(
-        self,
-        condition_id: HexBytes,
+        self, condition_id: HexBytes, web3: Web3 | None = None
     ) -> bool:
         # from ConditionalTokens.redeemPositions:
         # uint den = payoutDenominator[conditionId]; require(den > 0, "result for condition not received yet");
-        payout_for_condition = self.payoutDenominator(condition_id)
+        payout_for_condition = self.payoutDenominator(condition_id, web3=web3)
         return payout_for_condition > 0
 
-    def payoutDenominator(self, condition_id: HexBytes) -> int:
+    def payoutDenominator(
+        self, condition_id: HexBytes, web3: Web3 | None = None
+    ) -> int:
         payoutForCondition: int = self.call(
-            "payoutDenominator",
-            [condition_id],
+            "payoutDenominator", [condition_id], web3=web3
         )
         return payoutForCondition
 
@@ -214,6 +213,7 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
         for_address: ChecksumAddress,
         approve: bool,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
             private_credentials=private_credentials,
@@ -223,6 +223,7 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
                 approve,
             ],
             tx_params=tx_params,
+            web3=web3,
         )
 
     def prepareCondition(
@@ -232,6 +233,7 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
         question_id: HexBytes,
         outcomes_slot_count: int,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
             private_credentials=private_credentials,
@@ -242,6 +244,7 @@ class OmenConditionalTokenContract(ContractOnGnosisChain):
                 outcomes_slot_count,
             ],
             tx_params=tx_params,
+            web3=web3,
         )
 
 
@@ -272,25 +275,18 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         return calculated_shares
 
     def calcSellAmount(
-        self,
-        return_amount: Wei,
-        outcome_index: int,
+        self, return_amount: Wei, outcome_index: int, web3: Web3 | None = None
     ) -> OmenOutcomeToken:
         """
         Returns amount of shares we will sell for the requested wei.
         """
         calculated_shares: OmenOutcomeToken = self.call(
-            "calcSellAmount",
-            [return_amount, outcome_index],
+            "calcSellAmount", [return_amount, outcome_index], web3=web3
         )
         return calculated_shares
 
-    def conditionalTokens(
-        self,
-    ) -> HexAddress:
-        address: HexAddress = self.call(
-            "conditionalTokens",
-        )
+    def conditionalTokens(self, web3: Web3 | None = None) -> HexAddress:
+        address: HexAddress = self.call("conditionalTokens", web3=web3)
         return address
 
     def buy(
@@ -321,6 +317,7 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         outcome_index: int,
         max_outcome_tokens_to_sell: OmenOutcomeToken,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
             private_credentials=private_credentials,
@@ -331,6 +328,7 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
                 max_outcome_tokens_to_sell,
             ],
             tx_params=tx_params,
+            web3=web3,
         )
 
     def addFunding(
@@ -338,6 +336,7 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         private_credentials: PrivateCredentials,
         add_funding: Wei,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         """
         Funding is added in Weis (xDai) and then converted to shares.
@@ -349,6 +348,7 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
             function_name="addFunding",
             function_params=[add_funding, distribution_hint],
             tx_params=tx_params,
+            web3=web3,
         )
 
     def removeFunding(
@@ -369,9 +369,9 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
             web3=web3,
         )
 
-    def totalSupply(self) -> Wei:
+    def totalSupply(self, web3: Web3 | None = None) -> Wei:
         # This is the liquidity you seen on the Omen website (but in Wei).
-        total_supply: Wei = self.call("totalSupply")
+        total_supply: Wei = self.call("totalSupply", web3=web3)
         return total_supply
 
 
@@ -412,6 +412,7 @@ class OmenFixedProductMarketMakerFactoryContract(ContractOnGnosisChain):
         initial_funds_wei: Wei,
         fee: float = OMEN_DEFAULT_MARKET_FEE,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         fee_wei = xdai_to_wei(
             xdai_type(fee)
@@ -431,6 +432,7 @@ class OmenFixedProductMarketMakerFactoryContract(ContractOnGnosisChain):
                 distributionHint=[],
             ),
             tx_params=tx_params,
+            web3=web3,
         )
 
 
@@ -498,6 +500,7 @@ class OmenRealitioContract(ContractOnGnosisChain):
         opening: datetime,
         nonce: int | None = None,
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> HexBytes:
         """
         After the question is created, you can find it at https://reality.eth.link/app/#!/creator/{from_address}.
@@ -528,6 +531,7 @@ class OmenRealitioContract(ContractOnGnosisChain):
                 ),  # Two equal questions need to have different nonces.
             ),
             tx_params=tx_params,
+            web3=web3,
         )
         question_id = HexBytes(
             receipt_tx["logs"][0]["topics"][1]
@@ -542,6 +546,7 @@ class OmenRealitioContract(ContractOnGnosisChain):
         outcomes: list[str],
         bond: Wei,
         max_previous: Wei | None = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         if max_previous is None:
             # If not provided, defaults to 0, which means no checking,
@@ -563,6 +568,7 @@ class OmenRealitioContract(ContractOnGnosisChain):
                 max_previous=max_previous,
             ),
             amount_wei=bond,
+            web3=web3,
         )
 
     def claimWinnings(
@@ -574,6 +580,7 @@ class OmenRealitioContract(ContractOnGnosisChain):
         bonds: list[Wei],
         answers: list[HexBytes],
         tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
             private_credentials=private_credentials,
@@ -586,17 +593,22 @@ class OmenRealitioContract(ContractOnGnosisChain):
                 answers=answers,
             ),
             tx_params=tx_params,
+            web3=web3,
         )
 
-    def balanceOf(self, from_address: ChecksumAddress) -> Wei:
-        balance = wei_type(self.call("balanceOf", [from_address]))
+    def balanceOf(
+        self,
+        from_address: ChecksumAddress,
+        web3: Web3 | None = None,
+    ) -> Wei:
+        balance = wei_type(self.call("balanceOf", [from_address], web3=web3))
         return balance
 
     def withdraw(
         self,
         private_credentials: PrivateCredentials,
+        web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
-            private_credentials=private_credentials,
-            function_name="withdraw",
+            private_credentials=private_credentials, function_name="withdraw", web3=web3
         )

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -38,6 +38,7 @@ def claim_bonds_on_realitio_questions(
     private_credentials: PrivateCredentials,
     questions: list[RealityQuestion],
     auto_withdraw: bool,
+    web3: Web3 | None = None,
 ) -> list[HexBytes]:
     claimed_questions: list[HexBytes] = []
 
@@ -46,7 +47,7 @@ def claim_bonds_on_realitio_questions(
             f"[{idx+1} / {len(questions)}] Claiming bond for {question.questionId=} {question.url=}"
         )
         claim_bonds_on_realitio_question(
-            private_credentials, question, auto_withdraw=auto_withdraw
+            private_credentials, question, auto_withdraw=auto_withdraw, web3=web3
         )
         claimed_questions.append(question.questionId)
 
@@ -57,6 +58,7 @@ def claim_bonds_on_realitio_question(
     private_credentials: PrivateCredentials,
     question: RealityQuestion,
     auto_withdraw: bool,
+    web3: Web3 | None = None,
 ) -> None:
     public_key = private_credentials.public_key
     realitio_contract = OmenRealitioContract()
@@ -109,18 +111,20 @@ def claim_bonds_on_realitio_question(
         addresses=addresses,
         bonds=bonds,
         answers=answers,
+        web3=web3,
     )
 
-    current_balance = realitio_contract.balanceOf(public_key)
+    current_balance = realitio_contract.balanceOf(public_key, web3=web3)
     # Keeping balance on Realitio is not useful, so it's recommended to just withdraw it.
     if current_balance > 0 and auto_withdraw:
         logger.info(f"Withdrawing remaining balance {current_balance=}")
-        realitio_contract.withdraw(private_credentials)
+        realitio_contract.withdraw(private_credentials, web3=web3)
 
 
 def finalize_markets(
     private_credentials: PrivateCredentials,
     markets_with_resolutions: list[tuple[OmenMarket, Resolution | None]],
+    web3: Web3 | None = None,
 ) -> list[HexAddress]:
     finalized_markets: list[HexAddress] = []
 
@@ -139,6 +143,7 @@ def finalize_markets(
                 market,
                 resolution,
                 OMEN_DEFAULT_REALITIO_BOND_VALUE,
+                web3=web3,
             )
             finalized_markets.append(market.id)
             logger.info(f"Finalized {market.url=}")
@@ -152,6 +157,7 @@ def finalize_markets(
 def resolve_markets(
     private_credentials: PrivateCredentials,
     markets: list[OmenMarket],
+    web3: Web3 | None = None,
 ) -> list[HexAddress]:
     resolved_markets: list[HexAddress] = []
 
@@ -159,7 +165,7 @@ def resolve_markets(
         logger.info(
             f"[{idx+1} / {len(markets)}] Resolving {market.url=} {market.question_title=}"
         )
-        omen_resolve_market_tx(private_credentials, market)
+        omen_resolve_market_tx(private_credentials, market, web3=web3)
         resolved_markets.append(market.id)
 
     return resolved_markets
@@ -170,6 +176,7 @@ def omen_submit_answer_market_tx(
     market: OmenMarket,
     resolution: Resolution,
     bond: xDai,
+    web3: Web3 | None = None,
 ) -> None:
     """
     After the answer is submitted, there is 24h waiting period where the answer can be challenged by others.
@@ -182,12 +189,14 @@ def omen_submit_answer_market_tx(
         answer=resolution.value,
         outcomes=market.question.outcomes,
         bond=xdai_to_wei(bond),
+        web3=web3,
     )
 
 
 def omen_resolve_market_tx(
     private_credentials: PrivateCredentials,
     market: OmenMarket,
+    web3: Web3 | None = None,
 ) -> None:
     """
     Market can be resolved 24h after last answer was submitted via `omen_submit_answer_market_tx`.
@@ -199,6 +208,7 @@ def omen_resolve_market_tx(
         template_id=market.question.templateId,
         question_raw=market.question.question_raw,
         n_outcomes=market.question.n_outcomes,
+        web3=web3,
     )
 
 

prediction_market_agent_tooling-0.19.0/prediction_market_agent_tooling/monitor/langfuse/langfuse_wrapper.py

@@ -0,0 +1,26 @@
+from functools import cached_property
+
+from langfuse.callback import CallbackHandler
+from pydantic import BaseModel, computed_field
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.tools.utils import utcnow
+
+
+class LangfuseWrapper(BaseModel):
+    agent_name: str
+
+    @computed_field  # type: ignore[misc] # Mypy issue: https://github.com/python/mypy/issues/14461
+    @cached_property
+    def session_id(self) -> str:
+        return f"{self.agent_name} - {utcnow()}"
+
+    def get_langfuse_handler(self) -> CallbackHandler:
+        keys = APIKeys()
+        langfuse_handler = CallbackHandler(
+            secret_key=keys.langfuse_secret_key.get_secret_value(),
+            public_key=keys.langfuse_public_key.get_secret_value(),
+            host=keys.langfuse_host,
+            session_id=self.session_id,
+        )
+        return langfuse_handler

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/monitor/monitor.py

@@ -258,27 +258,31 @@ def monitor_brier_score(resolved_markets: t.Sequence[AgentMarket]) -> None:
     - the overall brier score
     - the brier score for the last 30 markets
     """
-    st.subheader("Brier Score (0-1, lower is better)")
+    st.subheader("Brier Score (0-2, lower is better)")
 
     # 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(
+    created_time_and_squared_errors_summed_across_outcomes = par_map(
         list(resolved_markets),
         lambda m: (
             m.created_time,
             (
                 (p_yes - m.boolean_outcome) ** 2
+                + ((1 - p_yes) - (1 - 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
+    created_time_and_squared_errors_summed_across_outcomes_with_trades = [
+        x
+        for x in created_time_and_squared_errors_summed_across_outcomes
+        if x[1] is not None
     ]
     df = pd.DataFrame(
-        created_time_and_squared_errors_with_trades, columns=["Date", "Squared Error"]
+        created_time_and_squared_errors_summed_across_outcomes_with_trades,
+        columns=["Date", "Squared Error"],
     ).sort_values(by="Date")
 
     # Compute rolling mean squared error for last 30 markets

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/tools/balances.py

@@ -1,10 +1,11 @@
 from pydantic import BaseModel
+from web3 import Web3
+from web3.types import Wei
 
 from prediction_market_agent_tooling.gtypes import ChecksumAddress, xDai
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     WrappedxDaiContract,
 )
-from prediction_market_agent_tooling.tools.gnosis_rpc import get_balance
 from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai
 
 
@@ -13,7 +14,10 @@ class Balances(BaseModel):
     wxdai: xDai
 
 
-def get_balances(address: ChecksumAddress) -> Balances:
-    xdai = wei_to_xdai(get_balance(address))
-    wxdai = wei_to_xdai(WrappedxDaiContract().balanceOf(address))
+def get_balances(address: ChecksumAddress, web3: Web3 | None) -> Balances:
+    if not web3:
+        web3 = WrappedxDaiContract().get_web3()
+    xdai_balance = Wei(web3.eth.get_balance(address))
+    xdai = wei_to_xdai(xdai_balance)
+    wxdai = wei_to_xdai(WrappedxDaiContract().balanceOf(address, web3=web3))
     return Balances(xdai=xdai, wxdai=wxdai)

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/tools/contract.py

@@ -190,6 +190,23 @@ class ContractERC20BaseClass(ContractBaseClass):
             web3=web3,
         )
 
+    def transferFrom(
+        self,
+        private_credentials: PrivateCredentials,
+        sender: ChecksumAddress,
+        recipient: ChecksumAddress,
+        amount_wei: Wei,
+        tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        return self.send(
+            private_credentials=private_credentials,
+            function_name="transferFrom",
+            function_params=[sender, recipient, amount_wei],
+            tx_params=tx_params,
+            web3=web3,
+        )
+
     def withdraw(
         self,
         private_credentials: PrivateCredentials,

prediction_market_agent_tooling-0.19.0/prediction_market_agent_tooling/tools/gnosis_rpc.py

@@ -0,0 +1,6 @@
+import os
+
+from prediction_market_agent_tooling.gtypes import ChainID
+
+GNOSIS_NETWORK_ID = ChainID(100)  # xDai network.
+GNOSIS_RPC_URL = os.getenv("GNOSIS_RPC_URL", "https://gnosis-rpc.publicnode.com")

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/prediction_market_agent_tooling/tools/web3_utils.py

@@ -116,8 +116,20 @@ def prepare_tx(
     function_params: Optional[list[Any] | dict[str, Any]] = None,
     tx_params: Optional[TxParams] = None,
 ) -> TxParams:
+    tx_params_new = _prepare_tx_params(web3, from_address, 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
+
+
+def _prepare_tx_params(
+    web3: Web3,
+    from_address: ChecksumAddress | None,
+    tx_params: Optional[TxParams] = None,
+) -> TxParams:
     # Fill in required defaults, if not provided.
     tx_params_new = TxParams()
     if tx_params:
@@ -135,11 +147,6 @@ def prepare_tx(
         from_checksummed = Web3.to_checksum_address(tx_params_new["from"])
         tx_params_new["nonce"] = web3.eth.get_transaction_count(from_checksummed)
 
-    # 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)
-    gas = web3.eth.estimate_gas(tx_params_new)
-    tx_params_new["gas"] = gas
     return tx_params_new
 
 
@@ -176,16 +183,10 @@ def send_function_on_contract_tx(
         function_params=function_params,
         tx_params=tx_params,
     )
-    # Sign with the private key.
-    signed_tx = web3.eth.account.sign_transaction(
-        tx_params, private_key=from_private_key.get_secret_value()
+
+    receipt_tx = sign_send_and_get_receipt_tx(
+        web3, tx_params, from_private_key, timeout
     )
-    # Send the signed transaction.
-    send_tx = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
-    # And wait for the receipt.
-    receipt_tx = web3.eth.wait_for_transaction_receipt(send_tx, timeout=timeout)
-    # Verify it didn't fail.
-    check_tx_receipt(receipt_tx)
     return receipt_tx
 
 
@@ -237,3 +238,52 @@ def send_function_on_contract_tx_using_safe(
     receipt_tx = web3.eth.wait_for_transaction_receipt(tx_hash, timeout=timeout)
     check_tx_receipt(receipt_tx)
     return receipt_tx
+
+
+def sign_send_and_get_receipt_tx(
+    web3: Web3,
+    tx_params_new: TxParams,
+    from_private_key: PrivateKey,
+    timeout: int = 180,
+) -> TxReceipt:
+    # Sign with the private key.
+    signed_tx = web3.eth.account.sign_transaction(
+        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)
+    # And wait for the receipt.
+    receipt_tx = web3.eth.wait_for_transaction_receipt(send_tx, timeout=timeout)
+    # Verify it didn't fail.
+    check_tx_receipt(receipt_tx)
+    return receipt_tx
+
+
+def send_xdai_to(
+    web3: Web3,
+    from_private_key: PrivateKey,
+    to_address: ChecksumAddress,
+    value: Wei,
+    tx_params: Optional[TxParams] = None,
+    timeout: int = 180,
+) -> TxReceipt:
+    from_address = private_key_to_public_key(from_private_key)
+
+    tx_params_new: TxParams = {"value": value, "to": to_address}
+    if tx_params:
+        tx_params_new.update(tx_params)
+    tx_params_new = _prepare_tx_params(web3, from_address, tx_params_new)
+
+    # We need gas and gasPrice here (and not elsewhere) because we are not calling
+    # contract.functions.myFunction().build_transaction, which autofills some params
+    # with defaults, incl. gas and gasPrice.
+    gas = web3.eth.estimate_gas(tx_params_new)
+    tx_params_new["gas"] = int(
+        gas * 1.5
+    )  # We conservatively overestimate gas here, knowing it will be returned if unused
+    tx_params_new["gasPrice"] = web3.eth.gas_price
+
+    receipt_tx = sign_send_and_get_receipt_tx(
+        web3, tx_params_new, from_private_key, timeout
+    )
+    return receipt_tx

{prediction_market_agent_tooling-0.17.0 → prediction_market_agent_tooling-0.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.17.0"
+version = "0.19.0"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"
@@ -41,6 +41,7 @@ eth-account = "^0.8.0"
 prompt-toolkit = "^3.0.43"
 safe-cli = "^1.0.0"
 mech-client = "^0.2.13"
+langfuse = "^2.27.1"
 
 [tool.poetry.extras]
 langchain = ["langchain", "langchain-openai"]

prediction_market_agent_tooling-0.17.0/prediction_market_agent_tooling/tools/gnosis_rpc.py

@@ -1,24 +0,0 @@
-import os
-
-import requests
-
-from prediction_market_agent_tooling.gtypes import ChainID, HexAddress, HexBytes, Wei
-
-GNOSIS_NETWORK_ID = ChainID(100)  # xDai network.
-GNOSIS_RPC_URL = os.getenv("GNOSIS_RPC_URL", "https://gnosis-rpc.publicnode.com")
-
-
-def get_balance(address: HexAddress) -> Wei:
-    response = requests.post(
-        GNOSIS_RPC_URL,
-        json={
-            "jsonrpc": "2.0",
-            "method": "eth_getBalance",
-            "params": [address, "latest"],
-            "id": 1,
-        },
-        headers={"content-type": "application/json"},
-    ).json()
-    balance_bytes = HexBytes(response["result"])
-    balance = Wei(balance_bytes.as_int())
-    return balance