prediction-market-agent-tooling 0.53.0__tar.gz → 0.55.0__tar.gz

{prediction_market_agent_tooling-0.53.0 → prediction_market_agent_tooling-0.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.53.0
+Version: 0.55.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12
@@ -44,7 +44,7 @@ Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
 Requires-Dist: streamlit (>=1.31.0,<2.0.0)
 Requires-Dist: subgrounds (>=1.9.1,<2.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
-Requires-Dist: tavily-python (>=0.3.9,<0.4.0)
+Requires-Dist: tavily-python (>=0.5.0,<0.6.0)
 Requires-Dist: tqdm (>=4.66.2,<5.0.0)
 Requires-Dist: typer (>=0.9.0,<1.0.0)
 Requires-Dist: types-python-dateutil (>=2.9.0.20240906,<3.0.0.0)

{prediction_market_agent_tooling-0.53.0 → prediction_market_agent_tooling-0.55.0}/prediction_market_agent_tooling/deploy/agent.py

@@ -8,10 +8,8 @@ from datetime import timedelta
 from enum import Enum
 from functools import cached_property
 
-from pydantic import BaseModel, BeforeValidator, computed_field
+from pydantic import BeforeValidator, computed_field
 from typing_extensions import Annotated
-from web3 import Web3
-from web3.constants import HASH_ZERO
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
@@ -32,11 +30,13 @@ 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 HexStr, xDai, xdai_type
+from prediction_market_agent_tooling.gtypes import xDai, xdai_type
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
+    ProcessedMarket,
+    ProcessedTradedMarket,
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
@@ -49,28 +49,16 @@ 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_invalid import is_invalid
 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 DatetimeUTC, utcnow
-from prediction_market_agent_tooling.tools.web3_utils import ipfscidv0_to_byte32
 
 MAX_AVAILABLE_MARKETS = 20
 TRADER_TAG = "trader"
@@ -122,11 +110,6 @@ class OutOfFundsError(ValueError):
     pass
 
 
-class ProcessedMarket(BaseModel):
-    answer: ProbabilisticAnswer
-    trades: list[PlacedTrade]
-
-
 class AnsweredEnum(str, Enum):
     ANSWERED = "answered"
     NOT_ANSWERED = "not_answered"
@@ -183,9 +166,11 @@ class DeployableAgent:
         return f"{self.__class__.__name__} - {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}"
 
     def __init_subclass__(cls, **kwargs: t.Any) -> None:
-        if "DeployableAgent" not in str(
-            cls.__init__
-        ) and "DeployableTraderAgent" not in str(cls.__init__):
+        if (
+            "DeployableAgent" not in str(cls.__init__)
+            and "DeployableTraderAgent" not in str(cls.__init__)
+            and "DeployablePredictionAgent" not in str(cls.__init__)
+        ):
             raise TypeError(
                 "Cannot override __init__ method of deployable agent class, please override the `load` method to set up the agent."
             )
@@ -292,29 +277,21 @@ def {entrypoint_function_name}(request) -> str:
         return f"{self.__class__.__name__.lower()}-{market_type}-{utcnow().strftime('%Y-%m-%d--%H-%M-%S')}"
 
 
-class DeployableTraderAgent(DeployableAgent):
+class DeployablePredictionAgent(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)
     allow_invalid_questions: bool = False
     same_market_bet_interval: timedelta = timedelta(hours=24)
+    # Only Metaculus allows to post predictions without trading (buying/selling of outcome tokens).
+    supported_markets: t.Sequence[MarketType] = [MarketType.METACULUS]
 
     def __init__(
         self,
         enable_langfuse: bool = APIKeys().default_enable_langfuse,
-        place_bet: bool = True,
+        store_prediction: bool = True,
     ) -> None:
         super().__init__(enable_langfuse=enable_langfuse)
-        self.place_bet = place_bet
-
-    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
-        user_id = market.get_user_id(api_keys=APIKeys())
-
-        total_amount = market.get_tiny_bet_amount().amount
-        if existing_position := market.get_position(user_id=user_id):
-            total_amount += existing_position.total_amount.amount
-
-        return MaxAccuracyBettingStrategy(bet_amount=total_amount)
+        self.store_prediction = store_prediction
 
     def initialize_langfuse(self) -> None:
         super().initialize_langfuse()
@@ -323,7 +300,6 @@ class DeployableTraderAgent(DeployableAgent):
         self.verify_market = observe()(self.verify_market)  # type: ignore[method-assign]
         self.answer_binary_market = observe()(self.answer_binary_market)  # type: ignore[method-assign]
         self.process_market = observe()(self.process_market)  # type: ignore[method-assign]
-        self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
 
     def update_langfuse_trace_by_market(
         self, market_type: MarketType, market: AgentMarket
@@ -353,38 +329,12 @@ class DeployableTraderAgent(DeployableAgent):
             ]
         )
 
-    def check_min_required_balance_to_operate(
-        self,
-        market_type: MarketType,
-        check_for_gas: bool = True,
-        check_for_trades: bool = True,
-    ) -> None:
+    def check_min_required_balance_to_operate(self, market_type: MarketType) -> None:
         api_keys = APIKeys()
-        if (
-            market_type == MarketType.OMEN
-            and check_for_gas
-            and not is_minimum_required_balance(
-                api_keys.public_key,
-                min_required_balance=xdai_type(0.001),
-                sum_wxdai=False,
-            )
-        ):
+
+        if not market_type.market_class.verify_operational_balance(api_keys):
             raise CantPayForGasError(
-                f"{api_keys.public_key=} doesn't have enough xDai to pay for gas."
-            )
-        if self.min_required_balance_to_operate is None:
-            return
-        if (
-            market_type == MarketType.OMEN
-            and check_for_trades
-            and not is_minimum_required_balance(
-                api_keys.bet_from_address,
-                min_required_balance=self.min_required_balance_to_operate,
-            )
-        ):
-            raise OutOfFundsError(
-                f"Minimum required balance {self.min_required_balance_to_operate} "
-                f"for agent with address {api_keys.bet_from_address=} is not met."
+                f"{api_keys=} doesn't have enough operational balance."
             )
 
     def have_bet_on_market_since(self, market: AgentMarket, since: timedelta) -> bool:
@@ -431,21 +381,19 @@ class DeployableTraderAgent(DeployableAgent):
         )
         return available_markets
 
-    def build_trades(
-        self,
-        market: AgentMarket,
-        answer: ProbabilisticAnswer,
-        existing_position: Position | None,
-    ) -> list[Trade]:
-        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
-
     def before_process_market(
         self, market_type: MarketType, market: AgentMarket
     ) -> None:
-        self.update_langfuse_trace_by_market(market_type, market)
+        api_keys = APIKeys()
+
+        if market_type.is_blockchain_market:
+            # Exchange wxdai back to xdai if the balance is getting low, so we can keep paying for fees.
+            if self.min_balance_to_keep_in_native_currency is not None:
+                withdraw_wxdai_to_xdai_to_keep_balance(
+                    api_keys,
+                    min_required_balance=self.min_balance_to_keep_in_native_currency,
+                    withdraw_multiplier=2,
+                )
 
     def process_market(
         self,
@@ -453,129 +401,47 @@ class DeployableTraderAgent(DeployableAgent):
         market: AgentMarket,
         verify_market: bool = True,
     ) -> ProcessedMarket | None:
+        self.update_langfuse_trace_by_market(market_type, market)
         logger.info(f"Processing market {market.question=} from {market.url=}.")
 
-        self.before_process_market(market_type, market)
-
+        answer: ProbabilisticAnswer | None
         if verify_market and not self.verify_market(market_type, market):
             logger.info(f"Market '{market.question}' doesn't meet the criteria.")
-            self.update_langfuse_trace_by_processed_market(market_type, None)
-            return None
-
-        answer = self.answer_binary_market(market)
-
-        if answer is None:
-            logger.info(f"No answer for market '{market.question}'.")
-            self.update_langfuse_trace_by_processed_market(market_type, None)
-            return None
+            answer = None
+        else:
+            answer = self.answer_binary_market(market)
 
-        existing_position = market.get_position(user_id=APIKeys().bet_from_address)
-        trades = self.build_trades(
-            market=market,
-            answer=answer,
-            existing_position=existing_position,
+        processed_market = (
+            ProcessedMarket(answer=answer) if answer is not None else None
         )
 
-        placed_trades = []
-        if self.place_bet:
-            for trade in trades:
-                logger.info(f"Executing trade {trade} on market {market.id}")
-
-                match trade.trade_type:
-                    case TradeType.BUY:
-                        id = market.buy_tokens(
-                            outcome=trade.outcome, amount=trade.amount
-                        )
-                    case TradeType.SELL:
-                        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))
-
-        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=} with {answer=}."
         )
-
-        logger.info(f"Processed market {market.question=} from {market.url=}.")
         return processed_market
 
     def after_process_market(
         self,
         market_type: MarketType,
         market: AgentMarket,
-        processed_market: ProcessedMarket,
+        processed_market: ProcessedMarket | None,
     ) -> None:
-        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_decoded = HexBytes(HASH_ZERO)
-        if keys.enable_ipfs_upload:
-            logger.info("Storing prediction on IPFS.")
-            ipfs_hash = IPFSHandler(keys).store_agent_result(
-                IPFSAgentResult(reasoning=reasoning)
+        if self.store_prediction:
+            market.store_prediction(processed_market=processed_market, keys=keys)
+        else:
+            logger.info(
+                f"Prediction {processed_market} not stored because {self.store_prediction=}."
             )
-            ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
-
-        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=ipfs_hash_decoded,
-            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:
         """
         Executes actions that occur before bets are placed.
         """
         api_keys = APIKeys()
-        if market_type == MarketType.OMEN:
-            # First, check if we have enough xDai to pay for gas, there is no way of doing anything without it.
-            self.check_min_required_balance_to_operate(
-                market_type, check_for_trades=False
-            )
-            # Omen is specific, because the user (agent) needs to manually withdraw winnings from the market.
-            redeem_from_all_user_positions(api_keys)
-            # After redeeming, check if we have enough xDai to pay for gas and place bets.
-            self.check_min_required_balance_to_operate(market_type)
-            # Exchange wxdai back to xdai if the balance is getting low, so we can keep paying for fees.
-            if self.min_balance_to_keep_in_native_currency is not None:
-                withdraw_wxdai_to_xdai_to_keep_balance(
-                    api_keys,
-                    min_required_balance=self.min_balance_to_keep_in_native_currency,
-                    withdraw_multiplier=2,
-                )
+        self.check_min_required_balance_to_operate(market_type)
+        market_type.market_class.redeem_winnings(api_keys)
 
     def process_markets(self, market_type: MarketType) -> None:
         """
@@ -589,10 +455,9 @@ class DeployableTraderAgent(DeployableAgent):
         processed = 0
 
         for market in available_markets:
-            # We need to check it again before each market bet, as the balance might have changed.
-            self.check_min_required_balance_to_operate(market_type)
-
+            self.before_process_market(market_type, market)
             processed_market = self.process_market(market_type, market)
+            self.after_process_market(market_type, market, processed_market)
 
             if processed_market is not None:
                 processed += 1
@@ -603,9 +468,142 @@ class DeployableTraderAgent(DeployableAgent):
         logger.info("All markets processed.")
 
     def after_process_markets(self, market_type: MarketType) -> None:
-        pass
+        "Executes actions that occur after bets are placed."
 
     def run(self, market_type: MarketType) -> None:
+        if market_type not in self.supported_markets:
+            raise ValueError(
+                f"Only {self.supported_markets} are supported by this agent."
+            )
         self.before_process_markets(market_type)
         self.process_markets(market_type)
         self.after_process_markets(market_type)
+
+
+class DeployableTraderAgent(DeployablePredictionAgent):
+    # These markets require place of bet, not just predictions.
+    supported_markets: t.Sequence[MarketType] = [
+        MarketType.OMEN,
+        MarketType.MANIFOLD,
+        MarketType.POLYMARKET,
+    ]
+
+    def __init__(
+        self,
+        enable_langfuse: bool = APIKeys().default_enable_langfuse,
+        store_prediction: bool = True,
+        store_trades: bool = True,
+        place_trades: bool = True,
+    ) -> None:
+        super().__init__(
+            enable_langfuse=enable_langfuse, store_prediction=store_prediction
+        )
+        self.store_trades = store_trades
+        self.place_trades = place_trades
+
+    def initialize_langfuse(self) -> None:
+        super().initialize_langfuse()
+        # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
+        self.get_betting_strategy = observe()(self.get_betting_strategy)  # type: ignore[method-assign]
+        self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
+
+    def check_min_required_balance_to_trade(self, market: AgentMarket) -> None:
+        api_keys = APIKeys()
+
+        # Get the strategy to know how much it will bet.
+        strategy = self.get_betting_strategy(market)
+        # Have a little bandwidth after the bet.
+        min_required_balance_to_trade = strategy.maximum_possible_bet_amount * 1.01
+
+        if market.get_trade_balance(api_keys) < min_required_balance_to_trade:
+            raise OutOfFundsError(
+                f"Minimum required balance {min_required_balance_to_trade} for agent is not met."
+            )
+
+    def get_betting_strategy(self, market: AgentMarket) -> BettingStrategy:
+        user_id = market.get_user_id(api_keys=APIKeys())
+
+        total_amount = market.get_tiny_bet_amount().amount
+        if existing_position := market.get_position(user_id=user_id):
+            total_amount += existing_position.total_amount.amount
+
+        return MaxAccuracyBettingStrategy(bet_amount=total_amount)
+
+    def build_trades(
+        self,
+        market: AgentMarket,
+        answer: ProbabilisticAnswer,
+        existing_position: Position | None,
+    ) -> list[Trade]:
+        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
+
+    def before_process_market(
+        self, market_type: MarketType, market: AgentMarket
+    ) -> None:
+        super().before_process_market(market_type, market)
+        self.check_min_required_balance_to_trade(market)
+
+    def process_market(
+        self,
+        market_type: MarketType,
+        market: AgentMarket,
+        verify_market: bool = True,
+    ) -> ProcessedTradedMarket | None:
+        processed_market = super().process_market(market_type, market, verify_market)
+        if processed_market is None:
+            return None
+
+        api_keys = APIKeys()
+        existing_position = market.get_position(
+            user_id=market.get_user_id(api_keys=api_keys)
+        )
+        trades = self.build_trades(
+            market=market,
+            answer=processed_market.answer,
+            existing_position=existing_position,
+        )
+
+        placed_trades = []
+        for trade in trades:
+            logger.info(f"Executing trade {trade} on market {market.id} ({market.url})")
+
+            if self.place_trades:
+                match trade.trade_type:
+                    case TradeType.BUY:
+                        id = market.buy_tokens(
+                            outcome=trade.outcome, amount=trade.amount
+                        )
+                    case TradeType.SELL:
+                        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))
+            else:
+                logger.info(f"Trade execution skipped because {self.place_trades=}.")
+
+        traded_market = ProcessedTradedMarket(
+            answer=processed_market.answer, trades=placed_trades
+        )
+        logger.info(f"Traded market {market.question=} from {market.url=}.")
+        return traded_market
+
+    def after_process_market(
+        self,
+        market_type: MarketType,
+        market: AgentMarket,
+        processed_market: ProcessedMarket | None,
+    ) -> None:
+        api_keys = APIKeys()
+        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)
+            else:
+                logger.info(
+                    f"Trades {processed_market.trades} not stored because {self.store_trades=}."
+                )

{prediction_market_agent_tooling-0.53.0 → prediction_market_agent_tooling-0.55.0}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -24,6 +24,10 @@ from prediction_market_agent_tooling.tools.betting_strategies.utils import Simpl
 from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
+class GuaranteedLossError(RuntimeError):
+    pass
+
+
 class BettingStrategy(ABC):
     @abstractmethod
     def calculate_trades(
@@ -32,7 +36,12 @@ class BettingStrategy(ABC):
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
-        pass
+        raise NotImplementedError("Subclass should implement this.")
+
+    @property
+    @abstractmethod
+    def maximum_possible_bet_amount(self) -> float:
+        raise NotImplementedError("Subclass should implement this.")
 
     def build_zero_token_amount(self, currency: Currency) -> TokenAmount:
         return TokenAmount(amount=0, currency=currency)
@@ -58,7 +67,7 @@ class BettingStrategy(ABC):
                 )
 
                 if outcome_tokens_to_get.amount < trade.amount.amount:
-                    raise RuntimeError(
+                    raise GuaranteedLossError(
                         f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}."
                     )
 
@@ -126,6 +135,10 @@ class MaxAccuracyBettingStrategy(BettingStrategy):
     def __init__(self, bet_amount: float):
         self.bet_amount = bet_amount
 
+    @property
+    def maximum_possible_bet_amount(self) -> float:
+        return self.bet_amount
+
     def calculate_trades(
         self,
         existing_position: Position | None,
@@ -168,6 +181,10 @@ class KellyBettingStrategy(BettingStrategy):
         self.max_bet_amount = max_bet_amount
         self.max_price_impact = max_price_impact
 
+    @property
+    def maximum_possible_bet_amount(self) -> float:
+        return self.max_bet_amount
+
     def calculate_trades(
         self,
         existing_position: Position | None,
@@ -282,6 +299,10 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
     def __init__(self, max_bet_amount: float = 10):
         self.max_bet_amount = max_bet_amount
 
+    @property
+    def maximum_possible_bet_amount(self) -> float:
+        return self.max_bet_amount
+
     def adjust_bet_amount(
         self, existing_position: Position | None, market: AgentMarket
     ) -> float:

{prediction_market_agent_tooling-0.53.0 → prediction_market_agent_tooling-0.55.0}/prediction_market_agent_tooling/markets/agent_market.py

@@ -11,7 +11,9 @@ from prediction_market_agent_tooling.markets.data_models import (
     Bet,
     BetAmount,
     Currency,
+    PlacedTrade,
     Position,
+    ProbabilisticAnswer,
     Resolution,
     ResolvedBet,
     TokenAmount,
@@ -25,6 +27,14 @@ from prediction_market_agent_tooling.tools.utils import (
 )
 
 
+class ProcessedMarket(BaseModel):
+    answer: ProbabilisticAnswer
+
+
+class ProcessedTradedMarket(ProcessedMarket):
+    trades: list[PlacedTrade]
+
+
 class SortBy(str, Enum):
     CLOSING_SOONEST = "closing-soonest"
     NEWEST = "newest"
@@ -198,6 +208,44 @@ class AgentMarket(BaseModel):
     def get_binary_market(id: str) -> "AgentMarket":
         raise NotImplementedError("Subclasses must implement this method")
 
+    @staticmethod
+    def redeem_winnings(api_keys: APIKeys) -> None:
+        """
+        On some markets (like Omen), it's needed to manually claim the winner bets. If it's not needed, just implement with `pass`.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    @staticmethod
+    def get_trade_balance(api_keys: APIKeys) -> float:
+        """
+        Return balance that can be used to trade on the given market.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    @staticmethod
+    def verify_operational_balance(api_keys: APIKeys) -> bool:
+        """
+        Return `True` if the user has enough of operational balance. If not needed, just return `True`.
+        For example: Omen needs at least some xDai in the wallet to execute transactions.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    def store_prediction(
+        self, processed_market: ProcessedMarket | None, keys: APIKeys
+    ) -> None:
+        """
+        If market allows to upload predictions somewhere, implement it in this method.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    def store_trades(
+        self, traded_market: ProcessedTradedMarket | None, keys: APIKeys
+    ) -> None:
+        """
+        If market allows to upload trades somewhere, implement it in this method.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
     @staticmethod
     def get_bets_made_since(
         better_address: ChecksumAddress, start_time: DatetimeUTC

{prediction_market_agent_tooling-0.53.0 → prediction_market_agent_tooling-0.55.0}/prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -125,6 +125,11 @@ class ManifoldAgentMarket(AgentMarket):
             )
         ]
 
+    @staticmethod
+    def redeem_winnings(api_keys: APIKeys) -> None:
+        # It's done automatically on Manifold.
+        pass
+
     @classmethod
     def get_user_url(cls, keys: APIKeys) -> str:
         return get_authenticated_user(keys.manifold_api_key.get_secret_value()).url

{prediction_market_agent_tooling-0.53.0 → prediction_market_agent_tooling-0.55.0}/prediction_market_agent_tooling/markets/markets.py

@@ -46,6 +46,10 @@ class MarketType(str, Enum):
             raise ValueError(f"Unknown market type: {self}")
         return MARKET_TYPE_TO_AGENT_MARKET[self]
 
+    @property
+    def is_blockchain_market(self) -> bool:
+        return self in [MarketType.OMEN, MarketType.POLYMARKET]
+
 
 MARKET_TYPE_TO_AGENT_MARKET: dict[MarketType, type[AgentMarket]] = {
     MarketType.MANIFOLD: ManifoldAgentMarket,