prediction-market-agent-tooling 0.66.1__tar.gz → 0.66.3__tar.gz

{prediction_market_agent_tooling-0.66.1 → prediction_market_agent_tooling-0.66.3}/PKG-INFO

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

{prediction_market_agent_tooling-0.66.1 → prediction_market_agent_tooling-0.66.3}/prediction_market_agent_tooling/deploy/agent.py

@@ -571,7 +571,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         Given the market and prediction, agent uses this method to calculate optimal outcome and bet size.
         """
         total_amount = self.get_total_amount_to_bet(market)
-        return MultiCategoricalMaxAccuracyBettingStrategy(bet_amount=total_amount)
+        return MultiCategoricalMaxAccuracyBettingStrategy(
+            max_position_amount=total_amount
+        )
 
     def build_trades(
         self,

{prediction_market_agent_tooling-0.66.1 → prediction_market_agent_tooling-0.66.3}/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Sequence
 
+import numpy as np
 from scipy.optimize import minimize_scalar
 
 from prediction_market_agent_tooling.benchmark.utils import get_most_probable_outcome
@@ -39,6 +40,9 @@ class GuaranteedLossError(RuntimeError):
 
 
 class BettingStrategy(ABC):
+    def __init__(self, take_profit: bool = True) -> None:
+        self.take_profit = take_profit
+
     @abstractmethod
     def calculate_trades(
         self,
@@ -94,6 +98,76 @@ class BettingStrategy(ABC):
         )
         return trades
 
+    @staticmethod
+    def cap_to_profitable_bet_amount(
+        market: AgentMarket,
+        bet_amount: USD,
+        outcome: OutcomeStr,
+        iters: int = 10,
+    ) -> USD:
+        """
+        Use a binary search (tree-based search) to efficiently find the largest profitable bet amount.
+        """
+        # First, try it with the desired amount right away.
+        if (
+            market.get_in_usd(
+                check_not_none(
+                    market.get_buy_token_amount(bet_amount, outcome)
+                ).as_token
+            )
+            > bet_amount
+        ):
+            return bet_amount
+
+        # If it wasn't profitable, try binary search to find the highest, but profitable, amount.
+        lower = USD(0)
+        # It doesn't make sense to try to bet more than the liquidity itself, so override it as maximal value if it's lower.
+        upper = min(bet_amount, market.get_in_usd(market.get_liquidity()))
+        best_profitable = USD(0)
+
+        for _ in range(iters):
+            mid = (lower + upper) / 2
+            potential_outcome_value = market.get_in_usd(
+                check_not_none(market.get_buy_token_amount(mid, outcome)).as_token
+            )
+
+            if potential_outcome_value > mid:
+                # Profitable, try higher
+                best_profitable = mid
+                lower = mid
+
+            else:
+                # Not profitable, try lower
+                upper = mid
+
+            # If the search interval is very small, break early
+            if float(upper - lower) < 1e-8:
+                break
+
+        if np.isclose(best_profitable.value, 0):
+            best_profitable = USD(0)
+
+        return best_profitable
+
+    @staticmethod
+    def cap_to_profitable_position(
+        market: AgentMarket,
+        existing_position: USD,
+        wanted_position: USD,
+        outcome_to_bet_on: OutcomeStr,
+    ) -> USD:
+        # If the wanted position is lower, it means the agent is gonna sell and that's profitable always.
+        if wanted_position > existing_position:
+            difference = wanted_position - existing_position
+            # Cap the difference we would like to buy to a profitable one.
+            capped_difference = BettingStrategy.cap_to_profitable_bet_amount(
+                market, difference, outcome_to_bet_on
+            )
+            # Lowered the actual wanted position such that it remains profitable.
+            wanted_position = existing_position + capped_difference
+
+        return wanted_position
+
     def _build_rebalance_trades_from_positions(
         self,
         existing_position: ExistingPosition | None,
@@ -138,10 +212,22 @@ class BettingStrategy(ABC):
             )
 
             diff_amount = target_amount - existing_amount
+
             if diff_amount == 0:
                 continue
 
             trade_type = TradeType.SELL if diff_amount < 0 else TradeType.BUY
+
+            # We work with positions, so imagine following scenario: Agent invested $10 when probs were 50:50,
+            # now the probs are 99:1 and his initial $10 is worth $100.
+            # If `take_profit` is set to False, agent won't sell the $90 to get back to the $10 position.
+            if (
+                not self.take_profit
+                and target_amount > 0
+                and trade_type == TradeType.SELL
+            ):
+                continue
+
             trade = Trade(
                 amount=abs(diff_amount),
                 outcome=outcome,
@@ -160,12 +246,13 @@ class BettingStrategy(ABC):
 
 
 class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
-    def __init__(self, bet_amount: USD):
-        self.bet_amount = bet_amount
+    def __init__(self, max_position_amount: USD, take_profit: bool = True):
+        super().__init__(take_profit=take_profit)
+        self.max_position_amount = max_position_amount
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.bet_amount
+        return self.max_position_amount
 
     @staticmethod
     def calculate_direction(
@@ -196,11 +283,23 @@ class MultiCategoricalMaxAccuracyBettingStrategy(BettingStrategy):
         market: AgentMarket,
     ) -> list[Trade]:
         """We place bet on only one outcome."""
-
         outcome_to_bet_on = self.calculate_direction(market, answer)
 
+        # Will be lowered if the amount that we would need to buy would be unprofitable.
+        actual_wanted_position = BettingStrategy.cap_to_profitable_position(
+            market,
+            (
+                existing_position.amounts_current.get(outcome_to_bet_on, USD(0))
+                if existing_position
+                else USD(0)
+            ),
+            self.max_position_amount,
+            outcome_to_bet_on,
+        )
+
         target_position = Position(
-            market_id=market.id, amounts_current={outcome_to_bet_on: self.bet_amount}
+            market_id=market.id,
+            amounts_current={outcome_to_bet_on: actual_wanted_position},
         )
         trades = self._build_rebalance_trades_from_positions(
             existing_position=existing_position,
@@ -253,13 +352,19 @@ class MaxExpectedValueBettingStrategy(MultiCategoricalMaxAccuracyBettingStrategy
 
 
 class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD, max_price_impact: float | None = None):
-        self.max_bet_amount = max_bet_amount
+    def __init__(
+        self,
+        max_position_amount: USD,
+        max_price_impact: float | None = None,
+        take_profit: bool = True,
+    ):
+        super().__init__(take_profit=take_profit)
+        self.max_position_amount = max_position_amount
         self.max_price_impact = max_price_impact
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.max_bet_amount
+        return self.max_position_amount
 
     @staticmethod
     def get_kelly_bet(
@@ -321,7 +426,7 @@ class KellyBettingStrategy(BettingStrategy):
 
         kelly_bet = self.get_kelly_bet(
             market=market,
-            max_bet_amount=self.max_bet_amount,
+            max_bet_amount=self.max_position_amount,
             direction=direction,
             other_direction=other_direction,
             answer=answer,
@@ -405,16 +510,21 @@ class KellyBettingStrategy(BettingStrategy):
         return CollateralToken(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount}, max_price_impact={self.max_price_impact})"
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount}, max_price_impact={self.max_price_impact})"
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD):
-        self.max_bet_amount = max_bet_amount
+    def __init__(
+        self,
+        max_position_amount: USD,
+        take_profit: bool = True,
+    ):
+        super().__init__(take_profit)
+        self.max_position_amount = max_position_amount
 
     @property
     def maximum_possible_bet_amount(self) -> USD:
-        return self.max_bet_amount
+        return self.max_position_amount
 
     def adjust_bet_amount(
         self, existing_position: ExistingPosition | None, market: AgentMarket
@@ -422,7 +532,7 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         existing_position_total_amount = (
             existing_position.total_amount_current if existing_position else USD(0)
         )
-        return self.max_bet_amount + existing_position_total_amount
+        return self.max_position_amount + existing_position_total_amount
 
     def calculate_trades(
         self,
@@ -471,4 +581,4 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
         return trades
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount})"
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_position_amount})"

{prediction_market_agent_tooling-0.66.1 → prediction_market_agent_tooling-0.66.3}/prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -93,7 +93,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
     def get_job_trade(self, max_bond: USD, 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)
+        strategy = KellyBettingStrategy(max_position_amount=max_bond)
         required_trades = strategy.calculate_trades(
             existing_position=None,
             answer=self.get_job_answer(result),

{prediction_market_agent_tooling-0.66.1 → prediction_market_agent_tooling-0.66.3}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -104,6 +104,7 @@ class OmenAgentMarket(AgentMarket):
 
     collateral_token_contract_address_checksummed: ChecksumAddress
     market_maker_contract_address_checksummed: ChecksumAddress
+    outcome_token_pool: dict[OutcomeStr, OutcomeToken]
     condition: Condition
     finalized_time: DatetimeUTC | None
     created_time: DatetimeUTC
@@ -620,11 +621,10 @@ class OmenAgentMarket(AgentMarket):
         Note: this is only valid if the market instance's token pool is
         up-to-date with the smart contract.
         """
-        outcome_token_pool = check_not_none(self.outcome_token_pool)
         amount = get_buy_outcome_token_amount(
             investment_amount=self.get_in_token(bet_amount),
             outcome_index=self.get_outcome_index(outcome),
-            pool_balances=[outcome_token_pool[x] for x in self.outcomes],
+            pool_balances=[self.outcome_token_pool[x] for x in self.outcomes],
             fees=self.fees,
         )
         return amount

{prediction_market_agent_tooling-0.66.1 → prediction_market_agent_tooling-0.66.3}/prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -53,7 +53,7 @@ from prediction_market_agent_tooling.tools.web3_utils import (
     unwrap_generic_value,
 )
 
-SAFE_COLLATERAL_TOKENS = (
+SAFE_COLLATERAL_TOKENS = [
     WrappedxDaiContract(),
     sDaiContract(),
     GNOContract(),
@@ -62,10 +62,10 @@ SAFE_COLLATERAL_TOKENS = (
     SAFEContract(),
     COWContract(),
     MetriSuperGroup(),
-)
-SAFE_COLLATERAL_TOKENS_ADDRESSES = tuple(
+]
+SAFE_COLLATERAL_TOKENS_ADDRESSES = [
     contract.address for contract in SAFE_COLLATERAL_TOKENS
-)
+]
 
 
 class OmenSubgraphHandler(BaseSubgraphHandler):
@@ -237,7 +237,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         liquidity_bigger_than: Wei | None,
         condition_id_in: list[HexBytes] | None,
         id_in: list[str] | None,
-        collateral_token_address_in: tuple[ChecksumAddress, ...] | None,
+        collateral_token_address_in: t.Sequence[ChecksumAddress] | None,
         category: str | None,
         include_categorical_markets: bool = False,
         include_scalar_markets: bool = False,
@@ -348,7 +348,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         created_after: DatetimeUTC | None = None,
         excluded_questions: set[str] | None = None,  # question titles
         collateral_token_address_in: (
-            tuple[ChecksumAddress, ...] | None
+            t.Sequence[ChecksumAddress] | None
         ) = SAFE_COLLATERAL_TOKENS_ADDRESSES,
         category: str | None = None,
         creator_in: t.Sequence[HexAddress] | None = None,
@@ -416,7 +416,7 @@ class OmenSubgraphHandler(BaseSubgraphHandler):
         sort_by_field: FieldPath | None = None,
         sort_direction: str | None = None,
         collateral_token_address_in: (
-            tuple[ChecksumAddress, ...] | None
+            t.Sequence[ChecksumAddress] | None
         ) = SAFE_COLLATERAL_TOKENS_ADDRESSES,
         category: str | None = None,
         include_categorical_markets: bool = True,

{prediction_market_agent_tooling-0.66.1 → prediction_market_agent_tooling-0.66.3}/prediction_market_agent_tooling/markets/seer/seer.py

@@ -198,9 +198,7 @@ class SeerAgentMarket(AgentMarket):
                 )
             )
 
-            amounts_ot[
-                OutcomeStr(outcome_str)
-            ] = outcome_token_balance_wei.as_outcome_token
+            amounts_ot[outcome_str] = outcome_token_balance_wei.as_outcome_token
 
         amounts_current = {
             k: self.get_token_in_usd(self.get_sell_value_of_outcome_token(k, v))

{prediction_market_agent_tooling-0.66.1 → prediction_market_agent_tooling-0.66.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.66.1"
+version = "0.66.3"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"