prediction-market-agent-tooling 0.55.2.dev120__py3-none-any.whl → 0.56.0__py3-none-any.whl

prediction_market_agent_tooling/deploy/agent.py

@@ -153,10 +153,10 @@ class DeployableAgent:
             input=input,
             output=output,
             user_id=user_id or getpass.getuser(),
-            session_id=session_id
-            or self.session_id,  # All traces within a single run execution will be grouped under a single session.
-            version=version
-            or APIKeys().LANGFUSE_DEPLOYMENT_VERSION,  # Optionally, mark the current deployment with version (e.g. add git commit hash during docker building).
+            session_id=session_id or self.session_id,
+            # All traces within a single run execution will be grouped under a single session.
+            version=version or APIKeys().LANGFUSE_DEPLOYMENT_VERSION,
+            # Optionally, mark the current deployment with version (e.g. add git commit hash during docker building).
             release=release,
             metadata=metadata,
             tags=tags,
@@ -342,6 +342,10 @@ class DeployablePredictionAgent(DeployableAgent):
             ]
         )
 
+    @property
+    def agent_name(self) -> str:
+        return self.__class__.__name__
+
     def check_min_required_balance_to_operate(self, market_type: MarketType) -> None:
         api_keys = APIKeys()
 
@@ -444,7 +448,9 @@ class DeployablePredictionAgent(DeployableAgent):
     ) -> None:
         keys = APIKeys()
         if self.store_prediction:
-            market.store_prediction(processed_market=processed_market, keys=keys)
+            market.store_prediction(
+                processed_market=processed_market, keys=keys, agent_name=self.agent_name
+            )
         else:
             logger.info(
                 f"Prediction {processed_market} not stored because {self.store_prediction=}."
@@ -613,10 +619,14 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         processed_market: ProcessedMarket | None,
     ) -> None:
         api_keys = APIKeys()
-        super().after_process_market(market_type, market, processed_market)
+        super().after_process_market(
+            market_type,
+            market,
+            processed_market,
+        )
         if isinstance(processed_market, ProcessedTradedMarket):
             if self.store_trades:
-                market.store_trades(processed_market, api_keys)
+                market.store_trades(processed_market, api_keys, self.agent_name)
             else:
                 logger.info(
                     f"Trades {processed_market.trades} not stored because {self.store_trades=}."

prediction_market_agent_tooling/jobs/jobs_models.py

@@ -3,7 +3,12 @@ from abc import ABC, abstractmethod
 
 from pydantic import BaseModel
 
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.deploy.betting_strategy import ProbabilisticAnswer
+from prediction_market_agent_tooling.gtypes import Probability
+from prediction_market_agent_tooling.markets.agent_market import (
+    AgentMarket,
+    ProcessedTradedMarket,
+)
 from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
     FilterBy,
     SortBy,
@@ -39,10 +44,24 @@ class JobAgentMarket(AgentMarket, ABC):
     @classmethod
     @abstractmethod
     def get_jobs(
-        cls, limit: int | None, filter_by: FilterBy, sort_by: SortBy
+        cls,
+        limit: int | None,
+        filter_by: FilterBy = FilterBy.OPEN,
+        sort_by: SortBy = SortBy.CLOSING_SOONEST,
     ) -> t.Sequence["JobAgentMarket"]:
         """Get all available jobs."""
 
+    @staticmethod
+    @abstractmethod
+    def get_job(id: str) -> "JobAgentMarket":
+        """Get a single job by its id."""
+
+    @abstractmethod
+    def submit_job_result(
+        self, agent_name: str, max_bond: float, result: str
+    ) -> ProcessedTradedMarket:
+        """Submit the completed result for this job."""
+
     def to_simple_job(self, max_bond: float) -> SimpleJob:
         return SimpleJob(
             id=self.id,
@@ -51,3 +70,9 @@ class JobAgentMarket(AgentMarket, ABC):
             currency=self.currency.value,
             deadline=self.deadline,
         )
+
+    def get_job_answer(self, result: str) -> ProbabilisticAnswer:
+        # Just return 100% yes with 100% confidence, because we assume the job is completed correctly.
+        return ProbabilisticAnswer(
+            p_yes=Probability(1.0), confidence=1.0, reasoning=result
+        )

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -1,15 +1,14 @@
 import typing as t
 
-from web3 import Web3
-
+from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
     Currency,
     KellyBettingStrategy,
-    ProbabilisticAnswer,
     TradeType,
 )
-from prediction_market_agent_tooling.gtypes import Probability
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
+from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
+from prediction_market_agent_tooling.markets.data_models import PlacedTrade, Trade
 from prediction_market_agent_tooling.markets.omen.omen import (
     BetAmount,
     OmenAgentMarket,
@@ -36,11 +35,27 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         return self.close_time
 
     def get_reward(self, max_bond: float) -> float:
-        return compute_job_reward(self, max_bond)
+        trade = self.get_job_trade(
+            max_bond,
+            result="",  # Pass empty result, as we are computing only potential reward at this point.
+        )
+        reward = (
+            self.get_buy_token_amount(
+                bet_amount=BetAmount(
+                    amount=trade.amount.amount, currency=trade.amount.currency
+                ),
+                direction=trade.outcome,
+            ).amount
+            - trade.amount.amount
+        )
+        return reward
 
     @classmethod
     def get_jobs(
-        cls, limit: int | None, filter_by: FilterBy, sort_by: SortBy
+        cls,
+        limit: int | None,
+        filter_by: FilterBy = FilterBy.OPEN,
+        sort_by: SortBy = SortBy.CLOSING_SOONEST,
     ) -> t.Sequence["OmenJobAgentMarket"]:
         markets = OmenSubgraphHandler().get_omen_binary_markets_simple(
             limit=limit,
@@ -50,6 +65,52 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         )
         return [OmenJobAgentMarket.from_omen_market(market) for market in markets]
 
+    @staticmethod
+    def get_job(id: str) -> "OmenJobAgentMarket":
+        return OmenJobAgentMarket.from_omen_agent_market(
+            OmenJobAgentMarket.get_binary_market(id=id)
+        )
+
+    def submit_job_result(
+        self, agent_name: str, max_bond: float, result: str
+    ) -> ProcessedTradedMarket:
+        if not APIKeys().enable_ipfs_upload:
+            raise RuntimeError(
+                f"ENABLE_IPFS_UPLOAD must be set to True to upload job results."
+            )
+
+        trade = self.get_job_trade(max_bond, result)
+        buy_id = self.buy_tokens(outcome=trade.outcome, amount=trade.amount)
+
+        processed_traded_market = ProcessedTradedMarket(
+            answer=self.get_job_answer(result),
+            trades=[PlacedTrade.from_trade(trade, id=buy_id)],
+        )
+
+        keys = APIKeys()
+        self.store_trades(processed_traded_market, keys, agent_name)
+
+        return processed_traded_market
+
+    def get_job_trade(self, max_bond: float, result: str) -> Trade:
+        # 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.
+        strategy = KellyBettingStrategy(max_bet_amount=max_bond)
+        required_trades = strategy.calculate_trades(
+            existing_position=None,
+            answer=self.get_job_answer(result),
+            market=self,
+        )
+        assert (
+            len(required_trades) == 1
+        ), f"Shouldn't process same job twice: {required_trades}"
+        trade = required_trades[0]
+        assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
+        assert trade.outcome, "Should buy only YES on job markets."
+        assert (
+            trade.amount.currency == Currency.xDai
+        ), "Should work only on real-money markets."
+        return required_trades[0]
+
     @staticmethod
     def from_omen_market(market: OmenMarket) -> "OmenJobAgentMarket":
         return OmenJobAgentMarket.from_omen_agent_market(
@@ -77,38 +138,3 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
             finalized_time=market.finalized_time,
             fees=market.fees,
         )
-
-
-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.
-    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),
-        market=market,
-    )
-
-    assert (
-        len(required_trades) == 1
-    ), f"Shouldn't process same job twice: {required_trades}"
-    trade = required_trades[0]
-    assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
-    assert trade.outcome, "Should buy only YES on job markets."
-    assert (
-        trade.amount.currency == Currency.xDai
-    ), "Should work only on real-money markets."
-
-    reward = (
-        market.get_buy_token_amount(
-            bet_amount=BetAmount(
-                amount=trade.amount.amount, currency=trade.amount.currency
-            ),
-            direction=trade.outcome,
-        ).amount
-        - trade.amount.amount
-    )
-
-    return reward

prediction_market_agent_tooling/markets/agent_market.py

@@ -231,7 +231,10 @@ class AgentMarket(BaseModel):
         raise NotImplementedError("Subclasses must implement this method")
 
     def store_prediction(
-        self, processed_market: ProcessedMarket | None, keys: APIKeys
+        self,
+        processed_market: ProcessedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
     ) -> None:
         """
         If market allows to upload predictions somewhere, implement it in this method.
@@ -239,7 +242,10 @@ class AgentMarket(BaseModel):
         raise NotImplementedError("Subclasses must implement this method")
 
     def store_trades(
-        self, traded_market: ProcessedTradedMarket | None, keys: APIKeys
+        self,
+        traded_market: ProcessedTradedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
     ) -> None:
         """
         If market allows to upload trades somewhere, implement it in this method.

prediction_market_agent_tooling/markets/markets.py

@@ -3,6 +3,8 @@ from datetime import timedelta
 from enum import Enum
 
 from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
+from prediction_market_agent_tooling.jobs.omen.omen_jobs import OmenJobAgentMarket
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
@@ -46,6 +48,12 @@ class MarketType(str, Enum):
             raise ValueError(f"Unknown market type: {self}")
         return MARKET_TYPE_TO_AGENT_MARKET[self]
 
+    @property
+    def job_class(self) -> type[JobAgentMarket]:
+        if self not in JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET:
+            raise ValueError(f"Unknown market type: {self}")
+        return JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET[self]
+
     @property
     def is_blockchain_market(self) -> bool:
         return self in [MarketType.OMEN, MarketType.POLYMARKET]
@@ -58,6 +66,10 @@ MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
     MarketType.METACULUS: MetaculusAgentMarket,
 }
 
+JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
+    MarketType.OMEN: OmenJobAgentMarket,
+}
+
 
 def get_binary_markets(
     limit: int,

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -107,7 +107,7 @@ class MetaculusAgentMarket(AgentMarket):
         return [MetaculusAgentMarket.from_data_model(q) for q in all_questions[:limit]]
 
     def store_prediction(
-        self, processed_market: ProcessedMarket | None, keys: APIKeys
+        self, processed_market: ProcessedMarket | None, keys: APIKeys, agent_name: str
     ) -> None:
         if processed_market is not None:
             make_prediction(self.id, processed_market.answer.p_yes)

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -24,6 +24,7 @@ from prediction_market_agent_tooling.markets.data_models import (
     ResolvedBet,
 )
 from prediction_market_agent_tooling.tools.utils import (
+    BPS_CONSTANT,
     DatetimeUTC,
     check_not_none,
     should_not_happen,
@@ -502,7 +503,7 @@ class OmenBet(BaseModel):
     feeAmount: Wei
     outcomeIndex: int
     outcomeTokensTraded: Wei
-    transactionHash: HexAddress
+    transactionHash: HexBytes
     fpmm: OmenMarket
 
     @property
@@ -785,6 +786,14 @@ class ContractPrediction(BaseModel):
     tx_hashes: list[HexBytes] = Field(..., alias="txHashes")
     estimated_probability_bps: int = Field(..., alias="estimatedProbabilityBps")
 
+    @property
+    def estimated_probability(self) -> Probability:
+        return Probability(self.estimated_probability_bps / BPS_CONSTANT)
+
+    @property
+    def boolean_outcome(self) -> bool:
+        return self.estimated_probability > 0.5
+
     @computed_field  # type: ignore[prop-decorator] # Mypy issue: https://github.com/python/mypy/issues/14461
     @property
     def publisher_checksummed(self) -> ChecksumAddress:
@@ -798,7 +807,7 @@ class ContractPrediction(BaseModel):
 
 class IPFSAgentResult(BaseModel):
     reasoning: str
-
+    agent_name: str
     model_config = ConfigDict(
         extra="forbid",
     )

prediction_market_agent_tooling/markets/omen/omen.py

@@ -78,6 +78,7 @@ from prediction_market_agent_tooling.tools.contract import (
 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.utils import (
+    BPS_CONSTANT,
     DatetimeUTC,
     calculate_sell_amount_in_collateral,
     check_not_none,
@@ -413,17 +414,21 @@ class OmenAgentMarket(AgentMarket):
     @staticmethod
     def verify_operational_balance(api_keys: APIKeys) -> bool:
         return get_total_balance(
-            api_keys.public_key,  # Use `public_key`, not `bet_from_address` because transaction costs are paid from the EOA wallet.
+            api_keys.public_key,
+            # Use `public_key`, not `bet_from_address` because transaction costs are paid from the EOA wallet.
             sum_wxdai=False,
         ) > xdai_type(0.001)
 
     def store_prediction(
-        self, processed_market: ProcessedMarket | None, keys: APIKeys
+        self, processed_market: ProcessedMarket | None, keys: APIKeys, agent_name: str
     ) -> None:
         """On Omen, we have to store predictions along with trades, see `store_trades`."""
 
     def store_trades(
-        self, traded_market: ProcessedTradedMarket | None, keys: APIKeys
+        self,
+        traded_market: ProcessedTradedMarket | None,
+        keys: APIKeys,
+        agent_name: str,
     ) -> None:
         if traded_market is None:
             logger.warning(f"No prediction for market {self.id}, not storing anything.")
@@ -437,7 +442,7 @@ class OmenAgentMarket(AgentMarket):
         if keys.enable_ipfs_upload:
             logger.info("Storing prediction on IPFS.")
             ipfs_hash = IPFSHandler(keys).store_agent_result(
-                IPFSAgentResult(reasoning=reasoning)
+                IPFSAgentResult(reasoning=reasoning, agent_name=agent_name)
             )
             ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
 
@@ -448,7 +453,7 @@ class OmenAgentMarket(AgentMarket):
             publisher=keys.public_key,
             ipfs_hash=ipfs_hash_decoded,
             tx_hashes=tx_hashes,
-            estimated_probability_bps=int(traded_market.answer.p_yes * 10000),
+            estimated_probability_bps=int(traded_market.answer.p_yes * BPS_CONSTANT),
         )
         tx_receipt = OmenAgentResultMappingContract().add_prediction(
             api_keys=keys,
@@ -1237,12 +1242,12 @@ def redeem_from_all_user_positions(
 
         if not conditional_token_contract.is_condition_resolved(condition_id):
             logger.info(
-                f"[{index+1} / {len(user_positions)}] Skipping redeem, {user_position.id=} isn't resolved yet."
+                f"[{index + 1} / {len(user_positions)}] Skipping redeem, {user_position.id=} isn't resolved yet."
             )
             continue
 
         logger.info(
-            f"[{index+1} / {len(user_positions)}] Processing redeem from {user_position.id=}."
+            f"[{index + 1} / {len(user_positions)}] Processing redeem from {user_position.id=}."
         )
 
         original_balances = get_balances(public_key, web3)
@@ -1263,9 +1268,11 @@ def redeem_from_all_user_positions(
 def get_binary_market_p_yes_history(market: OmenAgentMarket) -> list[Probability]:
     history: list[Probability] = []
     trades = sorted(
-        OmenSubgraphHandler().get_trades(  # We need to look at price both after buying or selling, so get trades, not bets.
+        OmenSubgraphHandler().get_trades(
+            # We need to look at price both after buying or selling, so get trades, not bets.
             market_id=market.market_maker_contract_address_checksummed,
-            end_time=market.close_time,  # Even after market is closed, there can be many `Sell` trades which will converge the probability to the true one.
+            end_time=market.close_time,
+            # Even after market is closed, there can be many `Sell` trades which will converge the probability to the true one.
         ),
         key=lambda x: x.creation_datetime,
     )

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -908,3 +908,17 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         if not items:
             return []
         return [ContractPrediction.model_validate(i) for i in items]
+
+    def get_agent_results_for_bet(self, bet: OmenBet) -> ContractPrediction | None:
+        results = [
+            result
+            for result in self.get_agent_results_for_market(bet.fpmm.id)
+            if bet.transactionHash in result.tx_hashes
+        ]
+
+        if not results:
+            return None
+        elif len(results) > 1:
+            raise RuntimeError("Multiple results found for a single bet.")
+
+        return results[0]