prediction-market-agent-tooling 0.48.18__py3-none-any.whl → 0.49.1__py3-none-any.whl

prediction_market_agent_tooling/abis/debuggingcontract.abi.json

@@ -0,0 +1,29 @@
+[
+  {
+    "constant": false,
+    "inputs": [],
+    "name": "inc",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "counter",
+    "outputs": [{ "name": "", "type": "uint256" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "getNow",
+    "outputs": [{ "name": "", "type": "uint32" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

prediction_market_agent_tooling/abis/omen_agentresultmapping.abi.json

@@ -0,0 +1,171 @@
+ [
+        {
+            "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
+        }
+    ]

prediction_market_agent_tooling/benchmark/benchmark.py

@@ -1,7 +1,6 @@
 import concurrent.futures
 import os
 import typing as t
-from collections import defaultdict
 
 import numpy as np
 import pandas as pd
@@ -436,92 +435,6 @@ class Benchmarker:
             ],
         }
 
-    def calculate_expected_returns(
-        self, prediction: Prediction, market: AgentMarket
-    ) -> float | None:
-        """
-        The expected value if betting on a binary market in its initialized state of 50:50 'yes' and 'no' shares, with the assumption that the correct `p_yes` is that of the market.
-        """
-        if not prediction.is_answered:
-            return None
-
-        # TODO: Add support for different bet sizes -- if we bet a low amount (such as <10 units), the real shares will be very close to that we calculate below (bet_units / share_price),
-        # but if one bets a lot, it will change the share price along the way, and so he/she receives less than `bet_units / share_price`, but it's more complicated to calculate.
-        bet_units = 10  # Assuming the agent always bet 10 units per market.
-
-        assert prediction.outcome_prediction is not None
-        # Assume that market starts at 50/50 and so the price is 0.5 at the time we are buying it,
-        # we can't use {yes,no}_outcome_price atm, because it would just cancel out to EV = 0.0,
-        # as it's the same as the probability.
-        yes_shares = (
-            bet_units / 0.5  # market.yes_outcome_price
-            if prediction.outcome_prediction.probable_resolution == Resolution.YES
-            and market.yes_outcome_price > 0
-            else 0
-        )
-        no_shares = (
-            bet_units / 0.5  # market.no_outcome_price
-            if prediction.outcome_prediction.probable_resolution == Resolution.NO
-            and market.no_outcome_price > 0
-            else 0
-        )
-
-        # If we don't bet, we don't have any expected returns.
-        if yes_shares == 0 and no_shares == 0:
-            return None
-
-        expected_value = (
-            yes_shares * market.current_p_yes
-            + no_shares * (1 - market.current_p_yes)
-            - bet_units
-        )
-        expected_returns_perc = 100 * expected_value / bet_units
-
-        return expected_returns_perc
-
-    def compute_expected_returns_summary(
-        self,
-    ) -> t.Tuple[dict[str, list[str | float]], dict[str, list[str | float | None]]]:
-        overall_summary: dict[str, list[str | float]] = defaultdict(list)
-
-        for agent in self.registered_agents:
-            expected_returns = []
-
-            for market in self.markets:
-                if (
-                    prediction := self.get_prediction(agent.agent_name, market.question)
-                ).is_answered and (
-                    expected_return := self.calculate_expected_returns(
-                        prediction, market
-                    )
-                ) is not None:
-                    expected_returns.append(expected_return)
-
-            overall_summary["Agent"].append(agent.agent_name)
-            overall_summary["Mean expected returns"].append(
-                float(np.mean(expected_returns))
-            )
-            overall_summary["Median expected returns"].append(
-                float(np.median(expected_returns))
-            )
-            overall_summary["Total expected returns"].append(
-                float(np.sum(expected_returns))
-            )
-
-        per_market: dict[str, list[str | float | None]] = defaultdict(list)
-
-        for market in self.markets:
-            per_market["Market Question"].append(market.question)
-
-            for agent in self.registered_agents:
-                per_market[agent.agent_name].append(
-                    self.calculate_expected_returns(
-                        self.get_prediction(agent.agent_name, market.question), market
-                    )
-                )
-
-        return dict(overall_summary), dict(per_market)
-
     def generate_markdown_report(self) -> str:
         md = "# Comparison Report\n\n"
         md += "## Market Results\n\n"
@@ -533,10 +446,4 @@ class Benchmarker:
         md += "\n\n"
         md += "### Markets\n\n"
         md += pd.DataFrame(self.get_markets_summary()).to_markdown(index=False)
-        md += "\n\n"
-        md += "### Expected value\n\n"
-        overall_summary, per_market = self.compute_expected_returns_summary()
-        md += pd.DataFrame(overall_summary).to_markdown(index=False)
-        md += "\n\n"
-        md += pd.DataFrame(per_market).to_markdown(index=False)
         return md

prediction_market_agent_tooling/config.py

@@ -35,6 +35,7 @@ class APIKeys(BaseSettings):
     SAFE_ADDRESS: t.Optional[ChecksumAddress] = None
     OPENAI_API_KEY: t.Optional[SecretStr] = None
     GRAPH_API_KEY: t.Optional[SecretStr] = None
+    TENDERLY_FORK_RPC: t.Optional[str] = None
 
     GOOGLE_SEARCH_API_KEY: t.Optional[SecretStr] = None
     GOOGLE_SEARCH_ENGINE_ID: t.Optional[SecretStr] = None
@@ -44,6 +45,9 @@ class APIKeys(BaseSettings):
     LANGFUSE_HOST: t.Optional[str] = None
     LANGFUSE_DEPLOYMENT_VERSION: t.Optional[str] = None
 
+    PINATA_API_KEY: t.Optional[SecretStr] = None
+    PINATA_API_SECRET: t.Optional[SecretStr] = None
+
     TAVILY_API_KEY: t.Optional[SecretStr] = None
 
     SQLALCHEMY_DB_URL: t.Optional[SecretStr] = None
@@ -147,6 +151,18 @@ class APIKeys(BaseSettings):
             and self.LANGFUSE_HOST is not None
         )
 
+    @property
+    def pinata_api_key(self) -> SecretStr:
+        return check_not_none(
+            self.PINATA_API_KEY, "PINATA_API_KEY missing in the environment."
+        )
+
+    @property
+    def pinata_api_secret(self) -> SecretStr:
+        return check_not_none(
+            self.PINATA_API_SECRET, "PINATA_API_SECRET missing in the environment."
+        )
+
     @property
     def tavily_api_key(self) -> SecretStr:
         return check_not_none(

prediction_market_agent_tooling/deploy/agent.py

@@ -10,6 +10,7 @@ from functools import cached_property
 
 from pydantic import BaseModel, BeforeValidator, computed_field
 from typing_extensions import Annotated
+from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
@@ -30,7 +31,7 @@ from prediction_market_agent_tooling.deploy.gcp.utils import (
     gcp_function_is_active,
     gcp_resolve_api_keys_secrets,
 )
-from prediction_market_agent_tooling.gtypes import xDai, xdai_type
+from prediction_market_agent_tooling.gtypes import HexStr, xDai, xdai_type
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
@@ -38,6 +39,7 @@ from prediction_market_agent_tooling.markets.agent_market import (
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
+    PlacedTrade,
     Position,
     ProbabilisticAnswer,
     Trade,
@@ -46,17 +48,27 @@ from prediction_market_agent_tooling.markets.markets import (
     MarketType,
     have_bet_on_market_since,
 )
+from prediction_market_agent_tooling.markets.omen.data_models import (
+    ContractPrediction,
+    IPFSAgentResult,
+)
 from prediction_market_agent_tooling.markets.omen.omen import (
     is_minimum_required_balance,
     redeem_from_all_user_positions,
     withdraw_wxdai_to_xdai_to_keep_balance,
 )
+from prediction_market_agent_tooling.markets.omen.omen_contracts import (
+    OmenAgentResultMappingContract,
+)
 from prediction_market_agent_tooling.monitor.monitor_app import (
     MARKET_TYPE_TO_DEPLOYED_AGENT,
 )
+from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+from prediction_market_agent_tooling.tools.ipfs.ipfs_handler import IPFSHandler
 from prediction_market_agent_tooling.tools.is_predictable import is_predictable_binary
 from prediction_market_agent_tooling.tools.langfuse_ import langfuse_context, observe
 from prediction_market_agent_tooling.tools.utils import DatetimeWithTimezone, utcnow
+from prediction_market_agent_tooling.tools.web3_utils import ipfscidv0_to_byte32
 
 MAX_AVAILABLE_MARKETS = 20
 TRADER_TAG = "trader"
@@ -110,7 +122,7 @@ class OutOfFundsError(ValueError):
 
 class ProcessedMarket(BaseModel):
     answer: ProbabilisticAnswer
-    trades: list[Trade]
+    trades: list[PlacedTrade]
 
 
 class AnsweredEnum(str, Enum):
@@ -282,7 +294,6 @@ class DeployableTraderAgent(DeployableAgent):
     bet_on_n_markets_per_run: int = 1
     min_required_balance_to_operate: xDai | None = xdai_type(1)
     min_balance_to_keep_in_native_currency: xDai | None = xdai_type(0.1)
-    strategy: BettingStrategy = MaxAccuracyBettingStrategy()
 
     def __init__(
         self,
@@ -291,6 +302,16 @@ class DeployableTraderAgent(DeployableAgent):
     ) -> None:
         super().__init__(enable_langfuse=enable_langfuse)
         self.place_bet = place_bet
+        self.ipfs_handler = IPFSHandler(APIKeys())
+
+    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
+        user_id = market.get_user_id(api_keys=APIKeys())
+
+        total_amount = market.get_user_balance(user_id=user_id) * 0.1
+        if existing_position := market.get_position(user_id=user_id):
+            total_amount += existing_position.total_amount.amount
+
+        return MaxAccuracyBettingStrategy(bet_amount=total_amount)
 
     def initialize_langfuse(self) -> None:
         super().initialize_langfuse()
@@ -410,7 +431,8 @@ class DeployableTraderAgent(DeployableAgent):
         answer: ProbabilisticAnswer,
         existing_position: Position | None,
     ) -> list[Trade]:
-        trades = self.strategy.calculate_trades(existing_position, answer, market)
+        strategy = self.get_betting_strategy(market=market)
+        trades = strategy.calculate_trades(existing_position, answer, market)
         BettingStrategy.assert_trades_currency_match_markets(market, trades)
         return trades
 
@@ -443,33 +465,84 @@ class DeployableTraderAgent(DeployableAgent):
 
         existing_position = market.get_position(user_id=APIKeys().bet_from_address)
         trades = self.build_trades(
-            market=market, answer=answer, existing_position=existing_position
+            market=market,
+            answer=answer,
+            existing_position=existing_position,
         )
 
+        placed_trades = []
         if self.place_bet:
             for trade in trades:
-                logger.info(f"Executing trade {trade}")
+                logger.info(f"Executing trade {trade} on market {market.id}")
 
                 match trade.trade_type:
                     case TradeType.BUY:
-                        market.buy_tokens(outcome=trade.outcome, amount=trade.amount)
+                        id = market.buy_tokens(
+                            outcome=trade.outcome, amount=trade.amount
+                        )
                     case TradeType.SELL:
-                        market.sell_tokens(outcome=trade.outcome, amount=trade.amount)
+                        id = market.sell_tokens(
+                            outcome=trade.outcome, amount=trade.amount
+                        )
                     case _:
                         raise ValueError(f"Unexpected trade type {trade.trade_type}.")
+                placed_trades.append(PlacedTrade.from_trade(trade, id))
 
-        self.after_process_market(market_type, market)
-
-        processed_market = ProcessedMarket(answer=answer, trades=trades)
+        processed_market = ProcessedMarket(answer=answer, trades=placed_trades)
         self.update_langfuse_trace_by_processed_market(market_type, processed_market)
 
+        self.after_process_market(
+            market_type, market, processed_market=processed_market
+        )
+
         logger.info(f"Processed market {market.question=} from {market.url=}.")
         return processed_market
 
     def after_process_market(
-        self, market_type: MarketType, market: AgentMarket
+        self,
+        market_type: MarketType,
+        market: AgentMarket,
+        processed_market: ProcessedMarket,
     ) -> None:
-        pass
+        if market_type != MarketType.OMEN:
+            logger.info(
+                f"Skipping after_process_market since market_type {market_type} != OMEN"
+            )
+            return
+        keys = APIKeys()
+        self.store_prediction(
+            market_id=market.id, processed_market=processed_market, keys=keys
+        )
+
+    def store_prediction(
+        self, market_id: str, processed_market: ProcessedMarket, keys: APIKeys
+    ) -> None:
+        reasoning = (
+            processed_market.answer.reasoning
+            if processed_market.answer.reasoning
+            else ""
+        )
+        ipfs_hash = self.ipfs_handler.store_agent_result(
+            IPFSAgentResult(reasoning=reasoning)
+        )
+
+        tx_hashes = [
+            HexBytes(HexStr(i.id)) for i in processed_market.trades if i.id is not None
+        ]
+        prediction = ContractPrediction(
+            publisher=keys.public_key,
+            ipfs_hash=ipfscidv0_to_byte32(ipfs_hash),
+            tx_hashes=tx_hashes,
+            estimated_probability_bps=int(processed_market.answer.p_yes * 10000),
+        )
+        tx_receipt = OmenAgentResultMappingContract().add_prediction(
+            api_keys=keys,
+            market_address=Web3.to_checksum_address(market_id),
+            prediction=prediction,
+        )
+        logger.info(
+            f"Added prediction to market {market_id}. - receipt {tx_receipt['transactionHash'].hex()}."
+        )
 
     def before_process_markets(self, market_type: MarketType) -> None:
         """

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -30,12 +30,6 @@ class BettingStrategy(ABC):
     def build_zero_token_amount(self, currency: Currency) -> TokenAmount:
         return TokenAmount(amount=0, currency=currency)
 
-    @abstractmethod
-    def adjust_bet_amount(
-        self, existing_position: Position | None, market: AgentMarket
-    ) -> float:
-        pass
-
     @staticmethod
     def assert_trades_currency_match_markets(
         market: AgentMarket, trades: list[Trade]
@@ -99,20 +93,7 @@ class BettingStrategy(ABC):
 
 
 class MaxAccuracyBettingStrategy(BettingStrategy):
-    def adjust_bet_amount(
-        self, existing_position: Position | None, market: AgentMarket
-    ) -> float:
-        existing_position_total_amount = (
-            existing_position.total_amount.amount if existing_position else 0
-        )
-        bet_amount = (
-            market.get_tiny_bet_amount().amount
-            if self.bet_amount is None
-            else self.bet_amount
-        )
-        return bet_amount + existing_position_total_amount
-
-    def __init__(self, bet_amount: float | None = None):
+    def __init__(self, bet_amount: float):
         self.bet_amount = bet_amount
 
     def calculate_trades(
@@ -121,13 +102,11 @@ class MaxAccuracyBettingStrategy(BettingStrategy):
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
-        adjusted_bet_amount = self.adjust_bet_amount(existing_position, market)
-
         direction = self.calculate_direction(market.current_p_yes, answer.p_yes)
 
         amounts = {
             market.get_outcome_str_from_bool(direction): TokenAmount(
-                amount=adjusted_bet_amount,
+                amount=self.bet_amount,
                 currency=market.currency,
             ),
         }
@@ -155,24 +134,15 @@ class MaxExpectedValueBettingStrategy(MaxAccuracyBettingStrategy):
 
 
 class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: float = 10):
+    def __init__(self, max_bet_amount: float):
         self.max_bet_amount = max_bet_amount
 
-    def adjust_bet_amount(
-        self, existing_position: Position | None, market: AgentMarket
-    ) -> float:
-        existing_position_total_amount = (
-            existing_position.total_amount.amount if existing_position else 0
-        )
-        return self.max_bet_amount + existing_position_total_amount
-
     def calculate_trades(
         self,
         existing_position: Position | None,
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
-        adjusted_bet_amount = self.adjust_bet_amount(existing_position, market)
         outcome_token_pool = check_not_none(market.outcome_token_pool)
         kelly_bet = (
             get_kelly_bet_full(
@@ -183,12 +153,12 @@ class KellyBettingStrategy(BettingStrategy):
                     market.get_outcome_str_from_bool(False)
                 ],
                 estimated_p_yes=answer.p_yes,
-                max_bet=adjusted_bet_amount,
+                max_bet=self.max_bet_amount,
                 confidence=answer.confidence,
             )
             if market.has_token_pool()
             else get_kelly_bet_simplified(
-                adjusted_bet_amount,
+                self.max_bet_amount,
                 market.current_p_yes,
                 answer.p_yes,
                 answer.confidence,

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -83,7 +83,8 @@ def compute_job_reward(
     market: OmenAgentMarket, max_bond: float, web3: Web3 | None = None
 ) -> float:
     # Because jobs are powered by prediction markets, potentional reward depends on job's liquidity and our will to bond (bet) our xDai into our job completion.
-    required_trades = KellyBettingStrategy(max_bet_amount=max_bond).calculate_trades(
+    strategy = KellyBettingStrategy(max_bet_amount=max_bond)
+    required_trades = strategy.calculate_trades(
         existing_position=None,
         # We assume that we finish the job and so the probability of the market happening will be 100%.
         answer=ProbabilisticAnswer(p_yes=Probability(1.0), confidence=1.0),