prediction-market-agent-tooling 0.65.12.dev773__py3-none-any.whl → 0.66.0__py3-none-any.whl

prediction_market_agent_tooling/abis/agentresultmapping.abi.json

@@ -0,0 +1,192 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "string",
+        "name": "_marketPlatformName",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "marketAddress",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "publisherAddress",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "string[]",
+        "name": "outcomes",
+        "type": "string[]"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16[]",
+        "name": "estimatedProbabilitiesBps",
+        "type": "uint16[]"
+      },
+      {
+        "indexed": false,
+        "internalType": "bytes32[]",
+        "name": "txHashes",
+        "type": "bytes32[]"
+      },
+      {
+        "indexed": false,
+        "internalType": "bytes32",
+        "name": "ipfsHash",
+        "type": "bytes32"
+      }
+    ],
+    "name": "PredictionAdded",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "marketAddress", "type": "address" },
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "marketAddress",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "publisherAddress",
+            "type": "address"
+          },
+          { "internalType": "bytes32", "name": "ipfsHash", "type": "bytes32" },
+          {
+            "internalType": "bytes32[]",
+            "name": "txHashes",
+            "type": "bytes32[]"
+          },
+          {
+            "internalType": "string[]",
+            "name": "outcomes",
+            "type": "string[]"
+          },
+          {
+            "internalType": "uint16[]",
+            "name": "estimatedProbabilitiesBps",
+            "type": "uint16[]"
+          }
+        ],
+        "internalType": "struct Prediction",
+        "name": "prediction",
+        "type": "tuple"
+      }
+    ],
+    "name": "addPrediction",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "marketAddress", "type": "address" },
+      { "internalType": "uint256", "name": "index", "type": "uint256" }
+    ],
+    "name": "getPredictionByIndex",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "marketAddress",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "publisherAddress",
+            "type": "address"
+          },
+          { "internalType": "bytes32", "name": "ipfsHash", "type": "bytes32" },
+          {
+            "internalType": "bytes32[]",
+            "name": "txHashes",
+            "type": "bytes32[]"
+          },
+          {
+            "internalType": "string[]",
+            "name": "outcomes",
+            "type": "string[]"
+          },
+          {
+            "internalType": "uint16[]",
+            "name": "estimatedProbabilitiesBps",
+            "type": "uint16[]"
+          }
+        ],
+        "internalType": "struct Prediction",
+        "name": "",
+        "type": "tuple"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "marketAddress", "type": "address" }
+    ],
+    "name": "getPredictions",
+    "outputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "marketAddress",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "publisherAddress",
+            "type": "address"
+          },
+          { "internalType": "bytes32", "name": "ipfsHash", "type": "bytes32" },
+          {
+            "internalType": "bytes32[]",
+            "name": "txHashes",
+            "type": "bytes32[]"
+          },
+          {
+            "internalType": "string[]",
+            "name": "outcomes",
+            "type": "string[]"
+          },
+          {
+            "internalType": "uint16[]",
+            "name": "estimatedProbabilitiesBps",
+            "type": "uint16[]"
+          }
+        ],
+        "internalType": "struct Prediction[]",
+        "name": "",
+        "type": "tuple[]"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "marketPlatformName",
+    "outputs": [{ "internalType": "string", "name": "", "type": "string" }],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

prediction_market_agent_tooling/data_download/langfuse_data_downloader.py

@@ -1,4 +1,6 @@
+import json
 import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any
@@ -14,6 +16,7 @@ from prediction_market_agent_tooling.gtypes import DatetimeUTC, OutcomeStr, Outc
 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.markets import MarketType
 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 (
@@ -24,7 +27,6 @@ from prediction_market_agent_tooling.tools.httpx_cached_client import HttpxCache
 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",
@@ -33,9 +35,11 @@ PREDICTION_STATES = [
 ]
 REPORT_STATES = ["prepare_report"]
 
+TRADE_STATES = ["build_trades"]
+
 MARKET_RESOLUTION_PROVIDERS = {
-    "omen": lambda market_id: OmenAgentMarket.get_binary_market(market_id),
-    "seer": lambda market_id: SeerAgentMarket.from_data_model_with_subgraph(
+    MarketType.OMEN: lambda market_id: OmenAgentMarket.get_binary_market(market_id),
+    MarketType.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,
@@ -58,8 +62,12 @@ class TraceResult(BaseModel):
     prediction_decision: str
     prediction_p_yes: float
     prediction_info_utility: float
+    prediction_confidence: float
     market_resolution: str | None
     resolution_is_valid: bool | None
+    full_market_json: str | None
+    prediction_json: str
+    trades: list[dict[str, Any]] | None
 
 
 def get_langfuse_client() -> Langfuse:
@@ -72,27 +80,39 @@ def get_langfuse_client() -> Langfuse:
     )
 
 
-def download_data(
+def create_output_file_path(
     agent_name: str,
     date_from: DatetimeUTC,
     date_to: DatetimeUTC,
-    only_resolved: bool,
     output_folder: str,
-) -> None:
+) -> str:
+    """Create unique output file path, incrementing version if file exists."""
     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"
-            )
+    index = 0
+    while os.path.exists(output_file):
+        index += 1
+        output_file = os.path.join(output_folder, f"{default_file_name}_v{index}.csv")
 
+    return output_file
+
+
+def download_data_daily(
+    agent_name: str,
+    date_from: DatetimeUTC,
+    date_to: DatetimeUTC,
+    only_resolved: bool,
+    output_file: str,
+    append_mode: bool = False,
+) -> tuple[int, int]:
+    """Download data for a single day/period and return (traces_downloaded, records_saved)."""
     langfuse_client_for_traces = get_langfuse_client()
 
+    logger.info(f"Processing data for {date_from.date()} to {date_to.date()}")
+
     traces = get_traces_for_agent(
         agent_name=agent_name,
         trace_name="process_market",
@@ -103,40 +123,138 @@ def download_data(
         tags=["answered"],
     )
 
+    traces_count = len(traces) if traces else 0
     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,
-    )
+        logger.info(f"No traces found for {date_from.date()}")
+        # If this is the first call and no traces, create empty CSV with header
+        if not append_mode:
+            df_empty = pd.DataFrame(columns=list(TraceResult.model_fields.keys()))
+            df_empty.to_csv(output_file, mode="w", header=True, index=False)
+        return 0, 0
+
+    # Use ThreadPoolExecutor with shared client (thread-safe)
+    results = []
+    with ThreadPoolExecutor(max_workers=3) as executor:
+        # Submit all tasks
+        future_to_trace = {
+            executor.submit(
+                process_trace, trace, only_resolved, langfuse_client_for_traces
+            ): trace
+            for trace in traces
+        }
+
+        # Collect results as they complete
+        for future in as_completed(future_to_trace):
+            try:
+                result = future.result()
+                results.append(result)
+            except Exception as e:
+                trace = future_to_trace[future]
+                logger.exception(f"Error processing trace {trace.id}: {e}")
+                results.append(None)
 
     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:
+        df = pd.DataFrame(results_data)
+
+        df.to_csv(
+            output_file,
+            mode="a" if append_mode else "w",
+            header=not append_mode,
+            index=False,
+        )
+        logger.info(f"Saved {len(successful_results)} records for {date_from.date()}")
+    elif not append_mode:
+        df_empty = pd.DataFrame(columns=list(TraceResult.model_fields.keys()))
+        df_empty.to_csv(output_file, mode="w", header=True, index=False)
+
+    return traces_count, len(successful_results)
+
+
+def download_data(
+    agent_name: str,
+    date_from: DatetimeUTC,
+    date_to: DatetimeUTC,
+    only_resolved: bool,
+    output_folder: str,
+) -> None:
+    output_file = create_output_file_path(agent_name, date_from, date_to, output_folder)
+    total_traces = 0
+    total_saved = 0
+    daily_stats = []
+
+    current_date = date_from
+    first_call = True
+
+    while current_date < date_to:
+        next_date = DatetimeUTC.from_datetime(current_date + timedelta(days=1))
+        if next_date > date_to:
+            next_date = date_to
+
+        traces_downloaded, records_saved = download_data_daily(
+            agent_name=agent_name,
+            date_from=current_date,
+            date_to=next_date,
+            only_resolved=only_resolved,
+            output_file=output_file,
+            append_mode=not first_call,
+        )
+
+        daily_stats.append(
+            {
+                "date": current_date.date(),
+                "traces_downloaded": traces_downloaded,
+                "records_saved": records_saved,
+            }
+        )
+
+        total_traces += traces_downloaded
+        total_saved += records_saved
+        first_call = False
+        current_date = next_date
+
+    # Print daily report
+    logger.info("=" * 60)
+    logger.info("DAILY PROCESSING REPORT")
+    logger.info("=" * 60)
+    for stats in daily_stats:
+        total_traces_downloaded = int(stats["traces_downloaded"])  # type: ignore
+        total_records_saved = int(stats["records_saved"])  # type: ignore
+        success_rate = (
+            (total_records_saved / total_traces_downloaded * 100)
+            if total_traces_downloaded > 0
+            else 0
+        )
+        logger.info(
+            f"{stats['date']}: {total_traces_downloaded} traces downloaded, {total_records_saved} successfully processed ({success_rate:.1f}%)"
+        )
+
+    logger.info("=" * 60)
+    logger.info("OVERALL SUMMARY")
+    logger.info("=" * 60)
+    overall_success_rate = (total_saved / total_traces * 100) if total_traces > 0 else 0
+    logger.info(f"Total traces downloaded: {total_traces}")
+    logger.info(f"Total records saved: {total_saved}")
+    logger.info(f"Overall success rate: {overall_success_rate:.1f}%")
+
+    if total_saved == 0:
         logger.warning("No results to save")
+    else:
+        logger.info(f"Output file: {output_file}")
+    logger.info("=" * 60)
 
 
 def process_trace(
     trace: TraceWithDetails,
     only_resolved: bool,
+    langfuse_client: Langfuse,
+    include_market: bool = True,
 ) -> TraceResult | None:
-    langfuse_client = get_langfuse_client()
     try:
+        logger.info(f"Processing trace {trace.id}")
         observations = langfuse_client.fetch_observations(trace_id=trace.id)
-
+        logger.info(f"Observations downloaded for trace {trace.id}")
         market_state, market_type = get_agent_market_state(trace.input)
 
         prepare_report_obs = [
@@ -145,7 +263,9 @@ def process_trace(
         predict_market_obs = [
             obs for obs in observations.data if obs.name in PREDICTION_STATES
         ]
-
+        build_trades_obs = [
+            obs for obs in observations.data if obs.name in TRADE_STATES
+        ]
         if not prepare_report_obs or not predict_market_obs:
             raise ValueError(f"Missing required observations for trace {trace.id}")
 
@@ -161,7 +281,7 @@ def process_trace(
             agent_name=trace.metadata["agent_class"],
             trace_id=trace.id,
             market_id=market_state.id,
-            market_type=market_type,
+            market_type=market_type.value,
             market_question=market_state.question,
             market_outcomes=list(market_state.outcomes),
             market_outcome_token_pool=market_state.outcome_token_pool,
@@ -169,13 +289,17 @@ def process_trace(
             market_close_time=market_state.close_time,
             analysis=analysis,
             prediction_reasoning=prediction["reasoning"],
-            prediction_decision="YES" if prediction["decision"] == "y" else "NO",
+            prediction_decision="y" if prediction["p_yes"] > 0.5 else "n",
             prediction_p_yes=prediction["p_yes"],
             prediction_info_utility=prediction["info_utility"],
+            prediction_confidence=prediction["confidence"],
+            prediction_json=json.dumps(prediction),
             market_resolution=resolution.outcome if resolution else None,
             resolution_is_valid=not resolution.invalid if resolution else None,
+            full_market_json=market_state.model_dump_json() if include_market else None,
+            trades=build_trades_obs[0].output if build_trades_obs else None,
         )
-
+        logger.info(f"Downloaded trace {trace.id} finished")
         return result
 
     except Exception as e:
@@ -183,7 +307,9 @@ def process_trace(
         return None
 
 
-def get_agent_market_state(input_data: dict[str, Any]) -> tuple[AgentMarket, str]:
+def get_agent_market_state(
+    input_data: dict[str, Any]
+) -> tuple[AgentMarket, MarketType]:
     if not input_data or "args" not in input_data:
         raise ValueError("Invalid input data: missing args")
 
@@ -191,27 +317,38 @@ def get_agent_market_state(input_data: dict[str, Any]) -> tuple[AgentMarket, str
     if len(args) < 2:
         raise ValueError("Invalid args: expected at least 2 elements")
 
-    market_type = args[0]  # e.g., "omen", "seer"
-
+    market_type = MarketType(args[0])
     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
+    # recreate probabilities if not present
+    if "outcome_token_pool" in market_data and "probabilities" not in market_data:
+        market_data["probabilities"] = AgentMarket.build_probability_map(
+            [
+                OutcomeToken(
+                    float(value["value"]) if isinstance(value, dict) else float(value)
+                ).as_outcome_wei
+                for value in market_data["outcome_token_pool"].values()
+            ],
+            list(market_data["outcome_token_pool"].keys()),
+        )
 
+    if market_type == MarketType.OMEN:
+        return OmenAgentMarket.model_validate(market_data), market_type
+    elif market_type == MarketType.SEER:
+        return SeerAgentMarket.model_validate(market_data), market_type
+    else:
+        return AgentMarket.model_validate(market_data), 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}")
+def get_market_resolution(market_id: str, market_type: MarketType) -> Resolution:
+    if market_type not in MARKET_RESOLUTION_PROVIDERS:
+        raise ValueError(f"Unknown market type: {market_type.market_class}")
 
     try:
-        market: AgentMarket | None = MARKET_RESOLUTION_PROVIDERS[market_type_lower](
-            market_id
-        )
+        market: AgentMarket | None = MARKET_RESOLUTION_PROVIDERS[market_type](market_id)
 
         if not market or not market.resolution:
             raise ValueError(f"No resolution found for market: {market_id}")
@@ -220,7 +357,7 @@ def get_market_resolution(market_id: str, market_type: str) -> Resolution:
 
     except Exception as e:
         raise ValueError(
-            f"Failed to fetch {market_type} market {market_id} resolution: {e}"
+            f"Failed to fetch {market_type.market_class} market {market_id} resolution: {e}"
         ) from e
 
 
@@ -234,7 +371,7 @@ def parse_date(date_str: str, param_name: str) -> DatetimeUTC:
 
 
 def main(
-    agent_name: str = "DeployablePredictionProphetGPT4oAgent",
+    agent_name: str = "DeployablePredictionProphet",
     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)"

prediction_market_agent_tooling/deploy/agent.py

@@ -373,7 +373,8 @@ class DeployablePredictionAgent(DeployableAgent):
                 binary_answer = self.answer_binary_market(market)
                 return (
                     CategoricalProbabilisticAnswer.from_probabilistic_answer(
-                        binary_answer
+                        binary_answer,
+                        market.outcomes,
                     )
                     if binary_answer is not None
                     else None
@@ -385,6 +386,27 @@ class DeployablePredictionAgent(DeployableAgent):
 
         return self.answer_categorical_market(market)
 
+    def verify_answer_outcomes(
+        self, market: AgentMarket, answer: CategoricalProbabilisticAnswer
+    ) -> None:
+        outcomes_from_prob_map = list(answer.probabilities.keys())
+
+        if any(
+            outcome_from_answer not in market.outcomes
+            for outcome_from_answer in outcomes_from_prob_map
+        ):
+            raise ValueError(
+                f"Some of generated outcomes ({outcomes_from_prob_map=}) in probability map doesn't match with market's outcomes ({market.outcomes=})."
+            )
+
+        if any(
+            market_outcome not in outcomes_from_prob_map
+            for market_outcome in market.outcomes
+        ):
+            logger.warning(
+                f"Some of market's outcomes ({market.outcomes=}) isn't included in the probability map ({outcomes_from_prob_map=})."
+            )
+
     def process_market(
         self,
         market_type: MarketType,
@@ -399,6 +421,8 @@ class DeployablePredictionAgent(DeployableAgent):
         answer = self.build_answer(
             market=market, market_type=market_type, verify_market=verify_market
         )
+        if answer is not None:
+            self.verify_answer_outcomes(market=market, answer=answer)
 
         processed_market = (
             ProcessedMarket(answer=answer) if answer is not None else None
@@ -406,7 +430,7 @@ class DeployablePredictionAgent(DeployableAgent):
 
         self.update_langfuse_trace_by_processed_market(market_type, processed_market)
         logger.info(
-            f"Processed market {market.question=} from {market.url=} with {answer=}."
+            f"Processed market {market.question=} from {market.url=} with {processed_market=}."
         )
         return processed_market
 

prediction_market_agent_tooling/markets/agent_market.py

@@ -21,7 +21,6 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeWei,
     Probability,
 )
-from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.data_models import (
     USD,
     Bet,
@@ -93,11 +92,6 @@ class AgentMarket(BaseModel):
         outcomes: t.Sequence[OutcomeStr] = check_not_none(info.data.get("outcomes"))
         if set(probs.keys()) != set(outcomes):
             raise ValueError("Keys of `probabilities` must match `outcomes` exactly.")
-        total = float(sum(probs.values()))
-        if not 0.999 <= total <= 1.001:
-            # We simply log a warning because for some use-cases (e.g. existing positions), the
-            # markets might be already closed hence no reliable outcome token prices exist anymore.
-            logger.warning(f"Probabilities for market {info.data=} do not sum to 1.")
         return probs
 
     @field_validator("outcome_token_pool")

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -1,8 +1,15 @@
+from typing import Sequence
+
 from web3 import Web3
 from web3.constants import HASH_ZERO
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import HexBytes, HexStr
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    HexBytes,
+    HexStr,
+    OutcomeStr,
+)
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
 from prediction_market_agent_tooling.markets.omen.data_models import (
@@ -10,18 +17,17 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     IPFSAgentResult,
 )
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
-    OmenAgentResultMappingContract,
+    _AgentResultMappingContract,
 )
 from prediction_market_agent_tooling.tools.ipfs.ipfs_handler import IPFSHandler
 from prediction_market_agent_tooling.tools.utils import BPS_CONSTANT
 from prediction_market_agent_tooling.tools.web3_utils import ipfscidv0_to_byte32
 
-# max uint16 for easy prediction identification (if market does not have YES outcome)
-UINT16_MAX = 2**16 - 1  # = 65535
-
 
 def store_trades(
-    market_id: str,
+    contract: _AgentResultMappingContract,
+    market_id: ChecksumAddress,
+    outcomes: Sequence[OutcomeStr],
     traded_market: ProcessedTradedMarket | None,
     keys: APIKeys,
     agent_name: str,
@@ -31,10 +37,14 @@ def store_trades(
         logger.warning(f"No prediction for market {market_id}, not storing anything.")
         return None
 
-    yes_probability = traded_market.answer.get_yes_probability()
-    if not yes_probability:
-        logger.info("Skipping this since no yes_probability available.")
+    probabilities = traded_market.answer.probabilities
+    if not probabilities:
+        logger.info("Skipping this since no probabilities available.")
         return None
+
+    if all(outcome not in probabilities for outcome in outcomes):
+        raise ValueError("No of the market's outcomes is in the probabilities.")
+
     reasoning = traded_market.answer.reasoning if traded_market.answer.reasoning else ""
 
     ipfs_hash_decoded = HexBytes(HASH_ZERO)
@@ -50,17 +60,23 @@ def store_trades(
         HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
     ]
 
-    estimated_probability_bps = int(yes_probability * BPS_CONSTANT)
+    # Dune dashboard expects the probs to be in the same order as on the market.
+    probabilities_converted = [
+        (outcome, int(probabilities.get(outcome, 0) * BPS_CONSTANT))
+        for outcome in outcomes
+    ]
 
     prediction = ContractPrediction(
+        market=market_id,
         publisher=keys.bet_from_address,
         ipfs_hash=ipfs_hash_decoded,
         tx_hashes=tx_hashes,
-        estimated_probability_bps=estimated_probability_bps,
+        outcomes=[x[0] for x in probabilities_converted],
+        estimated_probabilities_bps=[x[1] for x in probabilities_converted],
     )
-    tx_receipt = OmenAgentResultMappingContract().add_prediction(
+    tx_receipt = contract.add_prediction(
         api_keys=keys,
-        market_address=Web3.to_checksum_address(market_id),
+        market_address=market_id,
         prediction=prediction,
         web3=web3,
     )

prediction_market_agent_tooling/markets/data_models.py

@@ -15,6 +15,10 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.logprobs_parser import FieldLogprobs
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    OMEN_FALSE_OUTCOME,
+    OMEN_TRUE_OUTCOME,
+)
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC, check_not_none
 
 
@@ -142,13 +146,20 @@ class CategoricalProbabilisticAnswer(BaseModel):
     @staticmethod
     def from_probabilistic_answer(
         answer: ProbabilisticAnswer,
+        market_outcomes: Sequence[OutcomeStr] | None = None,
     ) -> "CategoricalProbabilisticAnswer":
         return CategoricalProbabilisticAnswer(
             probabilities={
-                OutcomeStr(YES_OUTCOME_LOWERCASE_IDENTIFIER): answer.p_yes,
-                OutcomeStr(NO_OUTCOME_LOWERCASE_IDENTIFIER): Probability(
-                    1 - answer.p_yes
-                ),
+                (
+                    OMEN_TRUE_OUTCOME
+                    if market_outcomes and OMEN_TRUE_OUTCOME in market_outcomes
+                    else OutcomeStr(YES_OUTCOME_LOWERCASE_IDENTIFIER)
+                ): answer.p_yes,
+                (
+                    OMEN_FALSE_OUTCOME
+                    if market_outcomes and OMEN_FALSE_OUTCOME in market_outcomes
+                    else OutcomeStr(NO_OUTCOME_LOWERCASE_IDENTIFIER)
+                ): Probability(1 - answer.p_yes),
             },
             confidence=answer.confidence,
             reasoning=answer.reasoning,

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -5,7 +5,6 @@ from pydantic_core.core_schema import FieldValidationInfo
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import OutcomeStr, Probability
-from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
@@ -43,13 +42,7 @@ class MetaculusAgentMarket(AgentMarket):
         probs: dict[OutcomeStr, Probability],
         info: FieldValidationInfo,
     ) -> dict[OutcomeStr, Probability]:
-        outcomes: t.Sequence[OutcomeStr] = check_not_none(info.data.get("outcomes"))
-        # We don't check for outcomes match because Metaculus has no filled outcomes.
-        total = float(sum(probs.values()))
-        if not 0.999 <= total <= 1.001:
-            # We simply log a warning because for some use-cases (e.g. existing positions), the
-            # markets might be already closed hence no reliable outcome token prices exist anymore.
-            logger.warning(f"Probabilities for market {info.data=} do not sum to 1.")
+        # We don't check for outcomes match here because Metaculus has no filled outcomes.
         return probs
 
     @staticmethod

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -23,6 +23,10 @@ from prediction_market_agent_tooling.markets.data_models import (
     Resolution,
     ResolvedBet,
 )
+from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    OMEN_FALSE_OUTCOME,
+    OMEN_TRUE_OUTCOME,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
@@ -37,8 +41,6 @@ from prediction_market_agent_tooling.tools.utils import (
     utcnow,
 )
 
-OMEN_TRUE_OUTCOME = OutcomeStr("Yes")
-OMEN_FALSE_OUTCOME = OutcomeStr("No")
 OMEN_BINARY_MARKET_OUTCOMES: t.Sequence[OutcomeStr] = [
     OMEN_TRUE_OUTCOME,
     OMEN_FALSE_OUTCOME,
@@ -826,18 +828,44 @@ class CreatedMarket(BaseModel):
 
 class ContractPrediction(BaseModel):
     model_config = ConfigDict(populate_by_name=True)
+
+    market: str | None = Field(
+        None,
+        alias="marketAddress",
+        description="Market's address. Will be None on older records.",
+    )
     publisher: str = Field(..., alias="publisherAddress")
     ipfs_hash: HexBytes = Field(..., alias="ipfsHash")
     tx_hashes: list[HexBytes] = Field(..., alias="txHashes")
-    estimated_probability_bps: int = Field(..., alias="estimatedProbabilityBps")
+    outcomes: list[OutcomeStr] = Field(...)
+    estimated_probabilities_bps: list[int] = Field(
+        ..., alias="estimatedProbabilitiesBps"
+    )
 
-    @property
-    def estimated_probability(self) -> Probability:
-        return Probability(self.estimated_probability_bps / BPS_CONSTANT)
+    @model_validator(mode="before")
+    @classmethod
+    def handle_legacy_estimated_probability_bps(
+        cls, values: dict[str, t.Any]
+    ) -> dict[str, t.Any]:
+        # If 'estimatedProbabilityBps' is present and 'outcomes'/'estimatedProbabilitiesBps' are not,
+        # convert to the new format using "Yes" and "No" outcomes.
+        # This allows for backward compatibility with old contract events.
+        if (
+            "estimatedProbabilityBps" in values
+            and "outcomes" not in values
+            and "estimatedProbabilitiesBps" not in values
+        ):
+            prob_bps = values["estimatedProbabilityBps"]
+            values["outcomes"] = [
+                OMEN_TRUE_OUTCOME,
+                OMEN_FALSE_OUTCOME,
+            ]
+            values["estimatedProbabilitiesBps"] = [prob_bps, BPS_CONSTANT - prob_bps]
+        return values
 
-    @property
-    def boolean_outcome(self) -> bool:
-        return self.estimated_probability > 0.5
+    def estimated_probability_of_outcome(self, outcome: OutcomeStr) -> Probability:
+        index = self.outcomes.index(outcome)
+        return Probability(self.estimated_probabilities_bps[index] / BPS_CONSTANT)
 
     @computed_field  # type: ignore[prop-decorator] # Mypy issue: https://github.com/python/mypy/issues/14461
     @property
@@ -847,10 +875,12 @@ class ContractPrediction(BaseModel):
     @staticmethod
     def from_tuple(values: tuple[t.Any, ...]) -> "ContractPrediction":
         return ContractPrediction(
-            publisher=values[0],
-            ipfs_hash=values[1],
-            tx_hashes=values[2],
-            estimated_probability_bps=values[3],
+            market=values[0],
+            publisher=values[1],
+            ipfs_hash=values[2],
+            tx_hashes=values[3],
+            outcomes=values[4],
+            estimated_probabilities_bps=values[5],
         )
 
 

prediction_market_agent_tooling/markets/omen/omen.py

@@ -50,6 +50,7 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OMEN_DEFAULT_MARKET_FEE_PERC,
     REALITY_DEFAULT_FINALIZATION_TIMEOUT,
     Arbitrator,
+    OmenAgentResultMappingContract,
     OmenConditionalTokenContract,
     OmenFixedProductMarketMakerContract,
     OmenFixedProductMarketMakerFactoryContract,
@@ -436,10 +437,13 @@ class OmenAgentMarket(AgentMarket):
         web3: Web3 | None = None,
     ) -> None:
         return store_trades(
-            market_id=self.id,
+            contract=OmenAgentResultMappingContract(),
+            market_id=Web3.to_checksum_address(self.id),
+            outcomes=self.outcomes,
             traded_market=traded_market,
             keys=keys,
             agent_name=agent_name,
+            web3=web3,
         )
 
     @staticmethod

prediction_market_agent_tooling/markets/omen/omen_constants.py

@@ -1,8 +1,16 @@
 from web3 import Web3
 
+from prediction_market_agent_tooling.gtypes import OutcomeStr
+
+OMEN_TRUE_OUTCOME = OutcomeStr("Yes")
+OMEN_FALSE_OUTCOME = OutcomeStr("No")
+
 WRAPPED_XDAI_CONTRACT_ADDRESS = Web3.to_checksum_address(
     "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d"
 )
 SDAI_CONTRACT_ADDRESS = Web3.to_checksum_address(
     "0xaf204776c7245bF4147c2612BF6e5972Ee483701"
 )
+METRI_SUPER_GROUP_CONTRACT_ADDRESS = Web3.to_checksum_address(
+    "0x7147A7405fCFe5CFa30c6d5363f9f357a317d082"
+)

prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -33,6 +33,7 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     format_realitio_question,
 )
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
+    METRI_SUPER_GROUP_CONTRACT_ADDRESS,
     SDAI_CONTRACT_ADDRESS,
     WRAPPED_XDAI_CONTRACT_ADDRESS,
 )
@@ -433,7 +434,7 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
 
 class MetriSuperGroup(ContractERC20OnGnosisChain):
     address: ChecksumAddress = Web3.to_checksum_address(
-        "0x7147A7405fCFe5CFa30c6d5363f9f357a317d082"
+        METRI_SUPER_GROUP_CONTRACT_ADDRESS
     )
 
 
@@ -821,20 +822,16 @@ class OmenRealitioContract(ContractOnGnosisChain):
         return is_pending_arbitration
 
 
-class OmenAgentResultMappingContract(ContractOnGnosisChain):
+class _AgentResultMappingContract(ContractOnGnosisChain):
     # Contract ABI taken from built https://github.com/gnosis/labs-contracts.
 
     abi: ABI = abi_field_validator(
         os.path.join(
             os.path.dirname(os.path.realpath(__file__)),
-            "../../abis/omen_agentresultmapping.abi.json",
+            "../../abis/agentresultmapping.abi.json",
         )
     )
 
-    address: ChecksumAddress = Web3.to_checksum_address(
-        "0x260E1077dEA98e738324A6cEfB0EE9A272eD471a"
-    )
-
     def get_predictions(
         self,
         market_address: ChecksumAddress,
@@ -860,6 +857,18 @@ class OmenAgentResultMappingContract(ContractOnGnosisChain):
         )
 
 
+class OmenAgentResultMappingContract(_AgentResultMappingContract):
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x99c43743A2dbd406160CC43cf08113b17178789c"
+    )
+
+
+class SeerAgentResultMappingContract(_AgentResultMappingContract):
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x1aafdfBD38EE92A4a74A44A1614E00894205074e"
+    )
+
+
 class OmenThumbnailMapping(ContractOnGnosisChain):
     # Contract ABI taken from built https://github.com/gnosis/labs-contracts.
     abi: ABI = abi_field_validator(

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -32,6 +32,7 @@ from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     COWContract,
     EUReContract,
     GNOContract,
+    MetriSuperGroup,
     OmenThumbnailMapping,
     SAFEContract,
     WETHContract,
@@ -60,6 +61,7 @@ SAFE_COLLATERAL_TOKENS = (
     EUReContract(),
     SAFEContract(),
     COWContract(),
+    MetriSuperGroup(),
 )
 SAFE_COLLATERAL_TOKENS_ADDRESSES = tuple(
     contract.address for contract in SAFE_COLLATERAL_TOKENS

prediction_market_agent_tooling/markets/seer/seer.py

@@ -27,9 +27,13 @@ from prediction_market_agent_tooling.markets.agent_market import (
     ProcessedTradedMarket,
     SortBy,
 )
+from prediction_market_agent_tooling.markets.blockchain_utils import store_trades
 from prediction_market_agent_tooling.markets.data_models import ExistingPosition
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.omen.omen_contracts import (
+    SeerAgentResultMappingContract,
+)
 from prediction_market_agent_tooling.markets.seer.data_models import (
     RedeemParams,
     SeerMarket,
@@ -113,7 +117,15 @@ class SeerAgentMarket(AgentMarket):
         agent_name: str,
         web3: Web3 | None = None,
     ) -> None:
-        pass
+        return store_trades(
+            contract=SeerAgentResultMappingContract(),
+            market_id=Web3.to_checksum_address(self.id),
+            outcomes=self.outcomes,
+            traded_market=traded_market,
+            keys=keys,
+            agent_name=agent_name,
+            web3=web3,
+        )
 
     def get_token_in_usd(self, x: CollateralToken) -> USD:
         return get_token_in_usd(x, self.collateral_token_contract_address_checksummed)

{prediction_market_agent_tooling-0.65.12.dev773.dist-info → prediction_market_agent_tooling-0.66.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.65.12.dev773
+Version: 0.66.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13

{prediction_market_agent_tooling-0.65.12.dev773.dist-info → prediction_market_agent_tooling-0.66.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
+prediction_market_agent_tooling/abis/agentresultmapping.abi.json,sha256=YWyJBpZFlpLoSDmYZYNavTETAh3Hj7SRpI_iNEebMOg,4753
 prediction_market_agent_tooling/abis/debuggingcontract.abi.json,sha256=KdkCWmif_WO421RFKhc03kGJiccFqsxsZNrgCd8EH_4,571
 prediction_market_agent_tooling/abis/depositablewrapper_erc20.abi.json,sha256=m0Wk3uQyLM8apWRRvX4d3u1d77bWVuXfV38D-aV48t0,4612
 prediction_market_agent_tooling/abis/erc20.abi.json,sha256=b8t6tPUhjBo5dHFq8ipsK-ih_g29dOTbWI0GBZiEWL8,3685
 prediction_market_agent_tooling/abis/erc4626.abi.json,sha256=qvmonhj3tJU5flR4pJjXCSSwB8tgEiJcx4Sc5ilQ5VY,17801
 prediction_market_agent_tooling/abis/erc721.abi.json,sha256=sslrlTfLAkHA7cAJAaAHmGBSsY8_3K6jNK-2OoPUTPs,5396
 prediction_market_agent_tooling/abis/gvp2_settlement.abi.json,sha256=J-OqsRqeqIo81RaT4btCGmwqBv6s7mYuTI9vWLr6Eu4,1790
-prediction_market_agent_tooling/abis/omen_agentresultmapping.abi.json,sha256=TVWP5J6RO8mb1YpI-RA2iCgeCqGfrIw0OfbHngekTSs,5769
 prediction_market_agent_tooling/abis/omen_dxdao.abi.json,sha256=Z1kD1QfgYfGwsZEI2UFDNEGZ4hMOix3HGICk8xlO4Ds,9578
 prediction_market_agent_tooling/abis/omen_fpmm.abi.json,sha256=CDib_b5PVj4m0JBVCB20cTshiVx8st1Be-7E460qFoY,11406
 prediction_market_agent_tooling/abis/omen_fpmm_conditionaltokens.abi.json,sha256=ux30hTxtZiOZ86FsTEK8Xnm910iyjB1CFnkXrCbhfm8,9841
@@ -25,8 +25,8 @@ prediction_market_agent_tooling/benchmark/benchmark.py,sha256=hpIpjjePDFTLhK841s
 prediction_market_agent_tooling/benchmark/utils.py,sha256=xQd7p9H08-OtN3iC4QT2i9bkUTmrXa6rxGXeg9yMhgU,2986
 prediction_market_agent_tooling/chains.py,sha256=1qQstoqXMwqwM7k-KH7MjMz8Ei-D83KZByvDbCZpAxs,116
 prediction_market_agent_tooling/config.py,sha256=-kJfdDr-m0R-tGZ1KRI-hJJk0mXDt142CAlvwaJ2N2I,11778
-prediction_market_agent_tooling/data_download/langfuse_data_downloader.py,sha256=EOtFKEtljwts1ftkcSN_i9Wk8jbfnhMehPRC63BU7l0,8842
-prediction_market_agent_tooling/deploy/agent.py,sha256=ONuXYe9zRO37lzume5z-2hPKTBrCljBg5OD_38gNRc0,25289
+prediction_market_agent_tooling/data_download/langfuse_data_downloader.py,sha256=VY23h324VKIVkevj1B1O-zL1eEp9AElmcfn6SwYDUSc,14246
+prediction_market_agent_tooling/deploy/agent.py,sha256=HLK5rf38PWgKydc_aIUck-wYzWQUnPdhto3Evoq82Lg,26282
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=yS1fWkHynr9MYGNOM2WsCnRWLPaffY4bOc6bIudrdd4,1377
 prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=YYayGjTKW02d3BUavJ8M3NmFk41oldEM3FHbwppZGRM,17184
 prediction_market_agent_tooling/deploy/constants.py,sha256=Qe9cllgsGMkecfmbhXoFkPxuJyG6ATsrT87RF9SmPWM,249
@@ -40,11 +40,11 @@ prediction_market_agent_tooling/jobs/jobs_models.py,sha256=DoZ9dlvVhpNrnINiR1uy6
 prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=qbTZ9HVvu_iP4dDxuvOZxAp6JsRKejvEW2YDYCnRmd4,5039
 prediction_market_agent_tooling/loggers.py,sha256=o1HyvwtK1DbuC0YWQwJNqzXLLbSC41gNBkEUxiAziEg,5796
 prediction_market_agent_tooling/logprobs_parser.py,sha256=DBlBQtWX8_URXhzTU3YWIPa76Zx3QDHlx1ARqbgJsVI,5008
-prediction_market_agent_tooling/markets/agent_market.py,sha256=pnyxTMUrL8cQsP4lmBBpe07R-Mi7S4vNjrvNLdOzAa8,19258
+prediction_market_agent_tooling/markets/agent_market.py,sha256=nMIa6BkoUWdiz12kFDKuKXD_m6PhLzp3to1vgyj63ZQ,18834
 prediction_market_agent_tooling/markets/base_subgraph_handler.py,sha256=7RaYO_4qAmQ6ZGM8oPK2-CkiJfKmV9MxM-rJlduaecU,1971
-prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=gZMwCTO-1d2ALXeY7-LP6U4kCpotJ6GMPZwN11kFOfE,2604
+prediction_market_agent_tooling/markets/blockchain_utils.py,sha256=6REOt70v3vnzmtCbuRcUTdwt6htXy9nAfNkLOH3Bv1U,2987
 prediction_market_agent_tooling/markets/categorize.py,sha256=orLZlPaHgeREU66m1amxfWikeV77idV4sZDPB8NgSD0,1300
-prediction_market_agent_tooling/markets/data_models.py,sha256=seifqxjVpzZdVKJQ7a5sKPPUM749EHV80SdI6pVQ3b4,7542
+prediction_market_agent_tooling/markets/data_models.py,sha256=H3G-2I9QFhWrBY_KI-4BO2jMtb_f9yauzHz-zA4NI5Q,8016
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/manifold/api.py,sha256=tWnjuqvU8pcCuja2B_ynHeds1iiEFc6QWHjeSO_GSxY,7676
 prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=3z1gFbPMEgCDGqeH-IK8wcvqmIHgLdZX8C2M1UQ7iDw,6740
@@ -54,15 +54,15 @@ prediction_market_agent_tooling/markets/market_fees.py,sha256=YeK3ynjYIguB0xf6sO
 prediction_market_agent_tooling/markets/markets.py,sha256=lIEPfPJD1Gz90pTvN2pZi51rpb969STPgQtNFCqHUJg,2667
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=4TRPGytQQbSdf42DCg2M_JWYPAuNjqZ3eBqaQBLkNks,2736
 prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=FaBCTPPezXbBwZ9p791CiVgQ4vB696xnMbz9XVXmiVI,3267
-prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=6iuUpDXgdbFOh-XuxH0rbeAf_m55r2KbHTaSTePNSWA,5614
+prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=S1Kkf_F3KuqFO938d5bun60wd8lsGvnGqxsW-tgEBgw,5110
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/cow_contracts.py,sha256=sl1L4cK5nAJwZ2wdhLzqh8p7h_IEValNvLwKUlInKxw,957
-prediction_market_agent_tooling/markets/omen/data_models.py,sha256=0jCxgUEVpaggt_avkNqgXAnZWdA6D-ew9PE2gm0aqDk,29930
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=q3SqvQEpZAsbFBbSid_rhRn-hVi-roCRN4piGj2wxU8,50301
-prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=D9oflYKafLQiHYtB5sScMHqmXyzM8JP8J0yATmc4SQQ,233
-prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=f0dKbdVM2OUTSpkCSZdPtKqeckS2c48j3rjnK8oD3wE,29716
+prediction_market_agent_tooling/markets/omen/data_models.py,sha256=RsBYSbM4deA6Os4kQ3egH3HvwT80tQho6T1yyoATCMs,31103
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=hTHqS_-Z7jocrwuisqymYWLUUn8bK_WSRwaKPgXz1es,50477
+prediction_market_agent_tooling/markets/omen/omen_constants.py,sha256=XtRk4vpxwUYkTndfjlcmghA-NOIneV8zdHFdyI7tHhM,487
+prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=27-HRngTqfk_wgvttB3GeVHhy_O2YZcz9izo9OufOI0,29991
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=D-ubf_LumHs_c5rBAAntQ8wGKprtO2V1JZeedmChNIE,11035
-prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=149T_tJxK2GFnGCulOlGr2Mwiaa7sa74E4lqYsuCv68,39962
+prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=h-YFRLY5rlhM9RqqceyfbHlno3elltN8Nr_Mnu1kJ90,40006
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=UZ4_TG8ceb9Y-qgsOKs8Qiv8zDt957QkT8IX2c83yqo,4800
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=U1SXTz93FIG3GO1h5BJWSt1hPKn_YAMBeZ3k8IS-ook,4552
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=wCwpZ8Kppy8JG_1HZDfEK_Gg1g1sL7NCbGoPeTeMSko,12756
@@ -71,7 +71,7 @@ prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=8kTeVjXPcXC6D
 prediction_market_agent_tooling/markets/seer/data_models.py,sha256=osM9WaLsxQf-pfVGq0O-IkM93ehP9a7fVUf-hi2VlMs,5523
 prediction_market_agent_tooling/markets/seer/exceptions.py,sha256=cEObdjluivD94tgOLzmimR7wgQEOt6SRakrYdhsRQtk,112
 prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=MClY2NGwOV70nZYIcmzXFy6Ogd8NBIq7telQcQ3VcU4,6243
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=_2Ld3EepmZuzpgAmW6f7eAS5-geXE25XgUKPUrFCWoI,23864
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=vXSJ-iqkO44q4HVsKbu_6gD8lpx7t70Rbx-Or6xOao8,24354
 prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=uMzpHpI6_tgfhWxPzupLdUJlZ1P2wr0rRiYjAGClKgU,4984
 prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=pJxch9_u0EdiIatQP1-UFClt8UEfMZAXBlk5wDO_ovk,9940
 prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=0izxS8Mtzonfdl9UqvFVXrdj0hVzieroekXhogfZKCw,1817
@@ -124,8 +124,8 @@ prediction_market_agent_tooling/tools/tokens/usd.py,sha256=yuW8iPPtcpP4eLH2nORMD
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=RlWSlzS2LavMIWrpwn1fevbzgPZruD4VcXTa-XxjWnE,7343
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=0r26snqCXGdLKCWA8jpe7DV8x2NPYWZwOy4oyKyDCYk,12615
-prediction_market_agent_tooling-0.65.12.dev773.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.65.12.dev773.dist-info/METADATA,sha256=8uXXv5MJUT03fxbHp6U2ahbmtucxDdStcffdokVO8p4,8742
-prediction_market_agent_tooling-0.65.12.dev773.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.65.12.dev773.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.65.12.dev773.dist-info/RECORD,,
+prediction_market_agent_tooling-0.66.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.66.0.dist-info/METADATA,sha256=RwJLAfhZDRncghDhfMIkeKlsjXiwNtcZ-7TgeO6ZlKo,8734
+prediction_market_agent_tooling-0.66.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.66.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.66.0.dist-info/RECORD,,

prediction_market_agent_tooling/abis/omen_agentresultmapping.abi.json

@@ -1,171 +0,0 @@
- [
-        {
-            "type": "constructor",
-            "inputs": [],
-            "stateMutability": "nonpayable"
-        },
-        {
-            "type": "function",
-            "name": "addPrediction",
-            "inputs": [
-                {
-                    "name": "marketAddress",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "prediction",
-                    "type": "tuple",
-                    "internalType": "struct Prediction",
-                    "components": [
-                        {
-                            "name": "publisherAddress",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "ipfsHash",
-                            "type": "bytes32",
-                            "internalType": "bytes32"
-                        },
-                        {
-                            "name": "txHashes",
-                            "type": "bytes32[]",
-                            "internalType": "bytes32[]"
-                        },
-                        {
-                            "name": "estimatedProbabilityBps",
-                            "type": "uint16",
-                            "internalType": "uint16"
-                        }
-                    ]
-                }
-            ],
-            "outputs": [],
-            "stateMutability": "nonpayable"
-        },
-        {
-            "type": "function",
-            "name": "getPredictionByIndex",
-            "inputs": [
-                {
-                    "name": "marketAddress",
-                    "type": "address",
-                    "internalType": "address"
-                },
-                {
-                    "name": "index",
-                    "type": "uint256",
-                    "internalType": "uint256"
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "tuple",
-                    "internalType": "struct Prediction",
-                    "components": [
-                        {
-                            "name": "publisherAddress",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "ipfsHash",
-                            "type": "bytes32",
-                            "internalType": "bytes32"
-                        },
-                        {
-                            "name": "txHashes",
-                            "type": "bytes32[]",
-                            "internalType": "bytes32[]"
-                        },
-                        {
-                            "name": "estimatedProbabilityBps",
-                            "type": "uint16",
-                            "internalType": "uint16"
-                        }
-                    ]
-                }
-            ],
-            "stateMutability": "view"
-        },
-        {
-            "type": "function",
-            "name": "getPredictions",
-            "inputs": [
-                {
-                    "name": "marketAddress",
-                    "type": "address",
-                    "internalType": "address"
-                }
-            ],
-            "outputs": [
-                {
-                    "name": "",
-                    "type": "tuple[]",
-                    "internalType": "struct Prediction[]",
-                    "components": [
-                        {
-                            "name": "publisherAddress",
-                            "type": "address",
-                            "internalType": "address"
-                        },
-                        {
-                            "name": "ipfsHash",
-                            "type": "bytes32",
-                            "internalType": "bytes32"
-                        },
-                        {
-                            "name": "txHashes",
-                            "type": "bytes32[]",
-                            "internalType": "bytes32[]"
-                        },
-                        {
-                            "name": "estimatedProbabilityBps",
-                            "type": "uint16",
-                            "internalType": "uint16"
-                        }
-                    ]
-                }
-            ],
-            "stateMutability": "view"
-        },
-        {
-            "type": "event",
-            "name": "PredictionAdded",
-            "inputs": [
-                {
-                    "name": "marketAddress",
-                    "type": "address",
-                    "indexed": true,
-                    "internalType": "address"
-                },
-                {
-                    "name": "estimatedProbabilityBps",
-                    "type": "uint16",
-                    "indexed": false,
-                    "internalType": "uint16"
-                },
-                {
-                    "name": "publisherAddress",
-                    "type": "address",
-                    "indexed": true,
-                    "internalType": "address"
-                },
-                {
-                    "name": "txHashes",
-                    "type": "bytes32[]",
-                    "indexed": false,
-                    "internalType": "bytes32[]"
-                },
-                {
-                    "name": "ipfsHash",
-                    "type": "bytes32",
-                    "indexed": false,
-                    "internalType": "bytes32"
-                }
-            ],
-            "anonymous": false
-        }
-    ]