prediction-market-agent-tooling 0.65.9__py3-none-any.whl → 0.65.11__py3-none-any.whl

prediction_market_agent_tooling/data_download/langfuse_data_downloader.py

@@ -0,0 +1,268 @@
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import typer
+from langfuse import Langfuse
+from langfuse.client import TraceWithDetails
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import DatetimeUTC, OutcomeStr, OutcomeToken
+from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.markets.data_models import Resolution
+from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.seer.seer import SeerAgentMarket
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
+from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+from prediction_market_agent_tooling.tools.httpx_cached_client import HttpxCachedClient
+from prediction_market_agent_tooling.tools.langfuse_client_utils import (
+    get_traces_for_agent,
+)
+from prediction_market_agent_tooling.tools.parallelism import par_map
+
+PREDICTION_STATES = [
+    "predict_market",
+    "_make_prediction_categorical",
+    "make_prediction",
+]
+REPORT_STATES = ["prepare_report"]
+
+MARKET_RESOLUTION_PROVIDERS = {
+    "omen": lambda market_id: OmenAgentMarket.get_binary_market(market_id),
+    "seer": lambda market_id: SeerAgentMarket.from_data_model_with_subgraph(
+        model=SeerSubgraphHandler().get_market_by_id(HexBytes(market_id)),
+        seer_subgraph=SeerSubgraphHandler(),
+        must_have_prices=False,
+    ),
+}
+
+
+class TraceResult(BaseModel):
+    agent_name: str
+    trace_id: str
+    market_id: str
+    market_type: str
+    market_question: str
+    market_outcomes: list[str]
+    market_outcome_token_pool: dict[OutcomeStr, OutcomeToken] | None
+    market_created_time: DatetimeUTC | None
+    market_close_time: DatetimeUTC | None
+    analysis: str
+    prediction_reasoning: str
+    prediction_decision: str
+    prediction_p_yes: float
+    prediction_info_utility: float
+    market_resolution: str | None
+    resolution_is_valid: bool | None
+
+
+def get_langfuse_client() -> Langfuse:
+    api_keys = APIKeys()
+    return Langfuse(
+        secret_key=api_keys.langfuse_secret_key.get_secret_value(),
+        public_key=api_keys.langfuse_public_key,
+        host=api_keys.langfuse_host,
+        httpx_client=HttpxCachedClient().get_client(),
+    )
+
+
+def download_data(
+    agent_name: str,
+    date_from: DatetimeUTC,
+    date_to: DatetimeUTC,
+    only_resolved: bool,
+    output_folder: str,
+) -> None:
+    Path(output_folder).mkdir(parents=True, exist_ok=True)
+    index = 0
+    default_file_name = f"{agent_name}_{date_from.date()}_{date_to.date()}"
+    output_file = os.path.join(output_folder, f"{default_file_name}.csv")
+
+    if os.path.exists(output_file):
+        while os.path.exists(output_file):
+            index += 1
+            output_file = os.path.join(
+                output_folder, f"{default_file_name}_v{index}.csv"
+            )
+
+    langfuse_client_for_traces = get_langfuse_client()
+
+    traces = get_traces_for_agent(
+        agent_name=agent_name,
+        trace_name="process_market",
+        from_timestamp=date_from,
+        to_timestamp=date_to,
+        has_output=True,
+        client=langfuse_client_for_traces,
+        tags=["answered"],
+    )
+
+    if not traces:
+        raise ValueError("No traces found for the specified criteria")
+
+    trace_args = [
+        (
+            trace,
+            only_resolved,
+        )
+        for trace in traces
+    ]
+
+    results = par_map(
+        items=trace_args,
+        func=lambda args: process_trace(*args),
+        max_workers=5,
+    )
+
+    successful_results = [r for r in results if r is not None]
+    if successful_results:
+        results_data = [result.model_dump() for result in successful_results]
+        pd.DataFrame(results_data).to_csv(output_file, index=False)
+        logger.info(f"Saved {len(successful_results)} records to {output_file}")
+    else:
+        logger.warning("No results to save")
+
+
+def process_trace(
+    trace: TraceWithDetails,
+    only_resolved: bool,
+) -> TraceResult | None:
+    langfuse_client = get_langfuse_client()
+    try:
+        observations = langfuse_client.fetch_observations(trace_id=trace.id)
+
+        market_state, market_type = get_agent_market_state(trace.input)
+
+        prepare_report_obs = [
+            obs for obs in observations.data if obs.name in REPORT_STATES
+        ]
+        predict_market_obs = [
+            obs for obs in observations.data if obs.name in PREDICTION_STATES
+        ]
+
+        if not prepare_report_obs or not predict_market_obs:
+            raise ValueError(f"Missing required observations for trace {trace.id}")
+
+        analysis = prepare_report_obs[0].output
+        prediction = predict_market_obs[0].output
+
+        resolution = get_market_resolution(market_state.id, market_type)
+
+        if only_resolved and not resolution:
+            raise ValueError(f"No resolution found for market {market_state.id}")
+
+        result = TraceResult(
+            agent_name=trace.metadata["agent_class"],
+            trace_id=trace.id,
+            market_id=market_state.id,
+            market_type=market_type,
+            market_question=market_state.question,
+            market_outcomes=list(market_state.outcomes),
+            market_outcome_token_pool=market_state.outcome_token_pool,
+            market_created_time=market_state.created_time,
+            market_close_time=market_state.close_time,
+            analysis=analysis,
+            prediction_reasoning=prediction["reasoning"],
+            prediction_decision="YES" if prediction["decision"] == "y" else "NO",
+            prediction_p_yes=prediction["p_yes"],
+            prediction_info_utility=prediction["info_utility"],
+            market_resolution=resolution.outcome if resolution else None,
+            resolution_is_valid=not resolution.invalid if resolution else None,
+        )
+
+        return result
+
+    except Exception as e:
+        logger.exception(f"Error processing trace {trace.id}: {e}")
+        return None
+
+
+def get_agent_market_state(input_data: dict[str, Any]) -> tuple[AgentMarket, str]:
+    if not input_data or "args" not in input_data:
+        raise ValueError("Invalid input data: missing args")
+
+    args = input_data["args"]
+    if len(args) < 2:
+        raise ValueError("Invalid args: expected at least 2 elements")
+
+    market_type = args[0]  # e.g., "omen", "seer"
+
+    if market_type not in MARKET_RESOLUTION_PROVIDERS:
+        raise ValueError(f"Unknown market type: {market_type}")
+
+    market_data = args[1]  # market object data
+    market_state = AgentMarket.model_construct(**market_data)
+
+    return market_state, market_type
+
+
+def get_market_resolution(market_id: str, market_type: str) -> Resolution:
+    market_type_lower = market_type.lower()
+
+    if market_type_lower not in MARKET_RESOLUTION_PROVIDERS:
+        raise ValueError(f"Unknown market type: {market_type}")
+
+    try:
+        market: AgentMarket | None = MARKET_RESOLUTION_PROVIDERS[market_type_lower](
+            market_id
+        )
+
+        if not market or not market.resolution:
+            raise ValueError(f"No resolution found for market: {market_id}")
+
+        return market.resolution
+
+    except Exception as e:
+        raise ValueError(
+            f"Failed to fetch {market_type} market {market_id} resolution: {e}"
+        ) from e
+
+
+def parse_date(date_str: str, param_name: str) -> DatetimeUTC:
+    try:
+        return DatetimeUTC.to_datetime_utc(date_str)
+    except ValueError as e:
+        typer.echo(f"Error: Invalid date format for {param_name}: {date_str}")
+        typer.echo("Expected format: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS")
+        raise typer.Exit(1) from e
+
+
+def main(
+    agent_name: str = "DeployablePredictionProphetGPT4oAgent",
+    only_resolved: bool = True,
+    date_from: str = typer.Option(
+        None, help="Start date in ISO format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS)"
+    ),
+    date_to: str = typer.Option(
+        None, help="End date in ISO format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS)"
+    ),
+    output_folder: str = "./agent_trades_output/",
+) -> None:
+    date_from_dt = (
+        parse_date(date_from, "date_from")
+        if date_from
+        else DatetimeUTC.from_datetime(datetime.now() - timedelta(days=1))
+    )
+    date_to_dt = (
+        parse_date(date_to, "date_to")
+        if date_to
+        else DatetimeUTC.from_datetime(datetime.now())
+    )
+
+    download_data(
+        agent_name=agent_name,
+        date_from=date_from_dt,
+        date_to=date_to_dt,
+        only_resolved=only_resolved,
+        output_folder=output_folder,
+    )
+
+
+if __name__ == "__main__":
+    typer.run(main)

prediction_market_agent_tooling/loggers.py

@@ -10,6 +10,8 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 from pythonjsonlogger import jsonlogger
 from tenacity import RetryError
 
+UNPATCHED_PRINT_FN = builtins.print
+
 
 class LogFormat(str, Enum):
     DEFAULT = "default"
@@ -153,7 +155,13 @@ def print_using_logger_info(
     end: str = "\n",
     **kwargs: t.Any,
 ) -> None:
-    logger.info(sep.join(map(str, values)) + end)
+    # If `logger.exception` is used, loguru+traceback somehow uses `print` statement to format the error stack,
+    # if that happens, without this if condition, it errors out because of deadlock and/or recursion errors.
+    # This is hacky, but that's exactly how loguru is checking for it internally..
+    if getattr(logger._core.handlers[1]._lock_acquired, "acquired", False):  # type: ignore # They use stubs and didn't type this.
+        UNPATCHED_PRINT_FN(*values, sep=sep, end=end, **kwargs)
+    else:
+        logger.info(sep.join(map(str, values)) + end)
 
 
 patch_logger()

prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -284,6 +284,9 @@ def omen_resolve_market_tx(
             logger.warning(
                 f"Market {market.url=} not resolved, because `condition not prepared or found`, skipping."
             )
+        elif "payout denominator already set" in str(e):
+            # We can just skip, it's been resolved already.
+            logger.info(f"Market {market.url=} is already resolved.")
         else:
             raise
 

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 from urllib.parse import urljoin
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -13,12 +14,14 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeWei,
     Web3Wei,
+    Wei,
 )
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     SeerParentMarket,
 )
 from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 
 class CreateCategoricalMarketsParams(BaseModel):
@@ -133,3 +136,19 @@ class RedeemParams(BaseModel):
     market: ChecksumAddress
     outcome_indices: list[int] = Field(alias="outcomeIndexes")
     amounts: list[OutcomeWei]
+
+
+class ExactInputSingleParams(BaseModel):
+    # from https://gnosisscan.io/address/0xffb643e73f280b97809a8b41f7232ab401a04ee1#code
+    model_config = ConfigDict(populate_by_name=True)
+    token_in: ChecksumAddress = Field(alias="tokenIn")
+    token_out: ChecksumAddress = Field(alias="tokenOut")
+    recipient: ChecksumAddress
+    deadline: int = Field(
+        default_factory=lambda: int((utcnow() + timedelta(minutes=10)).timestamp())
+    )
+    amount_in: Wei = Field(alias="amountIn")
+    amount_out_minimum: Wei = Field(alias="amountOutMinimum")
+    limit_sqrt_price: Wei = Field(
+        alias="limitSqrtPrice", default_factory=lambda: Wei(0)
+    )  # 0 for convenience, we also don't expect major price shifts

prediction_market_agent_tooling/markets/seer/seer.py

@@ -1,3 +1,4 @@
+import asyncio
 import typing as t
 from datetime import timedelta
 
@@ -15,6 +16,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeToken,
     OutcomeWei,
+    Wei,
     xDai,
 )
 from prediction_market_agent_tooling.loggers import logger
@@ -46,16 +48,21 @@ from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     NewMarketEvent,
 )
+from prediction_market_agent_tooling.markets.seer.swap_pool_handler import (
+    SwapPoolHandler,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
+    cancel_order,
     get_buy_token_amount_else_raise,
     get_orders_by_owner,
     get_trades_by_owner,
     swap_tokens_waiting,
+    wait_for_order_completion,
 )
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
@@ -441,6 +448,60 @@ class SeerAgentMarket(AgentMarket):
         outcome_idx = self.outcomes.index(outcome)
         return self.wrapped_tokens[outcome_idx]
 
+    def _swap_tokens_with_fallback(
+        self,
+        sell_token: ChecksumAddress,
+        buy_token: ChecksumAddress,
+        amount_wei: Wei,
+        api_keys: APIKeys,
+        web3: Web3 | None,
+    ) -> str:
+        """
+        Helper method to swap tokens with a fallback to direct pool swapping if the order times out.
+
+        Args:
+            sell_token: Address of the token to sell
+            buy_token: Address of the token to buy
+            amount_wei: Amount to swap in wei
+            api_keys: API keys for the transaction
+            web3: Web3 instance
+
+        Returns:
+            Transaction hash of the successful swap
+        """
+        _, order = swap_tokens_waiting(
+            amount_wei=amount_wei,
+            sell_token=sell_token,
+            buy_token=buy_token,
+            api_keys=api_keys,
+            web3=web3,
+            wait_order_complete=False,
+        )
+
+        try:
+            order_metadata = asyncio.run(wait_for_order_completion(order=order))
+            logger.debug(
+                f"Swapped {sell_token} for {buy_token}. Order details {order_metadata}"
+            )
+            return order_metadata.uid.root
+
+        except TimeoutError:
+            # Since timeout occurred, we need to cancel the order before trying to swap again.
+            asyncio.run(cancel_order(order_uids=[order.uid.root], api_keys=api_keys))
+            logger.info("TimeoutError. Trying to swap directly on Swapr pools.")
+
+            tx_receipt = SwapPoolHandler(
+                api_keys=api_keys,
+                market_id=self.id,
+                collateral_token_address=self.collateral_token_contract_address_checksummed,
+            ).buy_or_sell_outcome_token(
+                token_in=sell_token,
+                token_out=buy_token,
+                amount_wei=amount_wei,
+                web3=web3,
+            )
+            return tx_receipt["transactionHash"].hex()
+
     def place_bet(
         self,
         outcome: OutcomeStr,
@@ -449,6 +510,7 @@ class SeerAgentMarket(AgentMarket):
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
     ) -> str:
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
         api_keys = api_keys if api_keys is not None else APIKeys()
         if not self.can_be_traded():
             raise ValueError(
@@ -464,27 +526,21 @@ class SeerAgentMarket(AgentMarket):
                 collateral_contract, amount_wei, api_keys, web3
             )
 
-        collateral_balance = collateral_contract.balanceOf(api_keys.bet_from_address)
+        collateral_balance = collateral_contract.balanceOf(
+            api_keys.bet_from_address, web3=web3
+        )
         if collateral_balance < amount_wei:
             raise ValueError(
                 f"Balance {collateral_balance} not enough for bet size {amount}"
             )
 
-        outcome_token = self.get_wrapped_token_for_outcome(outcome)
-
-        #  Sell sDAI using token address
-        order_metadata = swap_tokens_waiting(
-            amount_wei=amount_wei,
+        return self._swap_tokens_with_fallback(
             sell_token=collateral_contract.address,
             buy_token=outcome_token,
+            amount_wei=amount_wei,
             api_keys=api_keys,
             web3=web3,
         )
-        logger.debug(
-            f"Purchased {outcome_token} in exchange for {collateral_contract.address}. Order details {order_metadata}"
-        )
-
-        return order_metadata.uid.root
 
     def sell_tokens(
         self,
@@ -506,21 +562,27 @@ class SeerAgentMarket(AgentMarket):
             else self.get_in_token(amount).as_wei
         )
 
-        order_metadata = swap_tokens_waiting(
-            amount_wei=token_amount,
+        return self._swap_tokens_with_fallback(
             sell_token=outcome_token,
             buy_token=Web3.to_checksum_address(
                 self.collateral_token_contract_address_checksummed
             ),
+            amount_wei=token_amount,
             api_keys=api_keys,
             web3=web3,
         )
 
-        logger.debug(
-            f"Sold {outcome_token} in exchange for {self.collateral_token_contract_address_checksummed}. Order details {order_metadata}"
+    def get_token_balance(
+        self, user_id: str, outcome: OutcomeStr, web3: Web3 | None = None
+    ) -> OutcomeToken:
+        erc20_token = ContractERC20OnGnosisChain(
+            address=self.get_wrapped_token_for_outcome(outcome)
+        )
+        return OutcomeToken.from_token(
+            erc20_token.balance_of_in_tokens(
+                for_address=Web3.to_checksum_address(user_id), web3=web3
+            )
         )
-
-        return order_metadata.uid.root
 
 
 def seer_create_market_tx(

prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -11,11 +11,15 @@ from prediction_market_agent_tooling.gtypes import (
     TxReceipt,
     xDai,
 )
-from prediction_market_agent_tooling.markets.seer.data_models import RedeemParams
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    ExactInputSingleParams,
+    RedeemParams,
+)
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     CreateCategoricalMarketsParams,
 )
 from prediction_market_agent_tooling.tools.contract import (
+    ContractERC20OnGnosisChain,
     ContractOnGnosisChain,
     abi_field_validator,
 )
@@ -110,3 +114,38 @@ class GnosisRouter(ContractOnGnosisChain):
             web3=web3,
         )
         return receipt_tx
+
+
+class SwaprRouterContract(ContractOnGnosisChain):
+    # File content taken from https://github.com/protofire/omen-exchange/blob/master/app/src/abi/marketMaker.json.
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)),
+            "../../abis/swapr_router.abi.json",
+        )
+    )
+
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0xffb643e73f280b97809a8b41f7232ab401a04ee1"
+    )
+
+    def exact_input_single(
+        self,
+        api_keys: APIKeys,
+        params: ExactInputSingleParams,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        erc20_token = ContractERC20OnGnosisChain(address=params.token_in)
+
+        if (
+            erc20_token.allowance(api_keys.bet_from_address, self.address, web3=web3)
+            < params.amount_in
+        ):
+            erc20_token.approve(api_keys, self.address, params.amount_in, web3=web3)
+
+        return self.send(
+            api_keys=api_keys,
+            function_name="exactInputSingle",
+            function_params=[tuple(dict(params).values())],
+            web3=web3,
+        )

prediction_market_agent_tooling/markets/seer/swap_pool_handler.py

@@ -0,0 +1,96 @@
+from web3 import Web3
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    CollateralToken,
+    HexBytes,
+    HexStr,
+    TxReceipt,
+    Wei,
+)
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    ExactInputSingleParams,
+)
+from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
+from prediction_market_agent_tooling.markets.seer.seer_contracts import (
+    SwaprRouterContract,
+)
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
+
+
+class SwapPoolHandler:
+    def __init__(
+        self,
+        api_keys: APIKeys,
+        market_id: str,
+        collateral_token_address: ChecksumAddress,
+        seer_subgraph: SeerSubgraphHandler | None = None,
+    ):
+        self.api_keys = api_keys
+        self.market_id = market_id
+        self.collateral_token_address = collateral_token_address
+        self.seer_subgraph = seer_subgraph or SeerSubgraphHandler()
+
+    def _calculate_amount_out_minimum(
+        self,
+        amount_wei: Wei,
+        token_in: ChecksumAddress,
+        price_outcome_token: CollateralToken,
+        buffer_pct: float = 0.05,
+    ) -> Wei:
+        is_buying_outcome = token_in == self.collateral_token_address
+
+        if is_buying_outcome:
+            value = amount_wei.value * (1.0 - buffer_pct) / price_outcome_token.value
+        else:
+            value = amount_wei.value * price_outcome_token.value * (1.0 - buffer_pct)
+        return Wei(int(value))
+
+    def buy_or_sell_outcome_token(
+        self,
+        amount_wei: Wei,
+        token_in: ChecksumAddress,
+        token_out: ChecksumAddress,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        """Buys/sells outcome_tokens in exchange for collateral tokens"""
+        if self.collateral_token_address not in [token_in, token_out]:
+            raise ValueError(
+                f"trading outcome_token for a token different than collateral_token {self.collateral_token_address} is not supported. {token_in=} {token_out=}"
+            )
+
+        outcome_token = (
+            token_in if token_in != self.collateral_token_address else token_out
+        )
+
+        # We could use a quoter contract (https://github.com/SwaprHQ/swapr-sdk/blob/develop/src/entities/trades/swapr-v3/constants.ts#L7), but since there is normally 1 pool per outcome token/collateral pair, it's not necessary.
+
+        price_outcome_token = PriceManager.build(
+            HexBytes(HexStr(self.market_id))
+        ).get_token_price_from_pools(token=outcome_token)
+        if not price_outcome_token:
+            raise ValueError(
+                f"Could not find price for {outcome_token=} and {self.collateral_token_address}"
+            )
+
+        amount_out_minimum = self._calculate_amount_out_minimum(
+            amount_wei=amount_wei,
+            token_in=token_in,
+            price_outcome_token=price_outcome_token,
+        )
+
+        p = ExactInputSingleParams(
+            token_in=token_in,
+            token_out=token_out,
+            recipient=self.api_keys.bet_from_address,
+            amount_in=amount_wei,
+            amount_out_minimum=amount_out_minimum,
+        )
+
+        tx_receipt = SwaprRouterContract().exact_input_single(
+            api_keys=self.api_keys, params=p, web3=web3
+        )
+        return tx_receipt