prediction-market-agent-tooling 0.67.2__py3-none-any.whl → 0.67.4__py3-none-any.whl

prediction_market_agent_tooling/abis/erc1155.abi.json

@@ -0,0 +1,352 @@
+[
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Approval",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "from",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "to",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "Transfer",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "owner",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "allowance",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "approve",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      }
+    ],
+    "name": "balanceOf",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "burn",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "decimals",
+    "outputs": [
+      {
+        "internalType": "uint8",
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "subtractedValue",
+        "type": "uint256"
+      }
+    ],
+    "name": "decreaseAllowance",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "factory",
+    "outputs": [
+      {
+        "internalType": "contract Wrapped1155Factory",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "addedValue",
+        "type": "uint256"
+      }
+    ],
+    "name": "increaseAllowance",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "account",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "mint",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "multiToken",
+    "outputs": [
+      {
+        "internalType": "contract IERC1155",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "name",
+    "outputs": [
+      {
+        "internalType": "string",
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "symbol",
+    "outputs": [
+      {
+        "internalType": "string",
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "tokenId",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "totalSupply",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "transfer",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "sender",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "transferFrom",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]

prediction_market_agent_tooling/deploy/agent.py

@@ -22,6 +22,7 @@ from prediction_market_agent_tooling.gtypes import USD, OutcomeToken, xDai
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
+    ConditionalFilterType,
     FilterBy,
     ProcessedMarket,
     ProcessedTradedMarket,
@@ -48,7 +49,7 @@ 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.rephrase import (
-    rephrase_question_to_unconditioned,
+    rephrase_question_to_unconditional,
 )
 from prediction_market_agent_tooling.tools.tokens.main_token import (
     MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES,
@@ -199,7 +200,7 @@ class DeployablePredictionAgent(DeployableAgent):
     trade_on_markets_created_after: DatetimeUTC | None = None
     get_markets_sort_by: SortBy = SortBy.CLOSING_SOONEST
     get_markets_filter_by: FilterBy = FilterBy.OPEN
-    rephrase_conditioned_markets: bool = True
+    rephrase_conditional_markets: bool = True
 
     # Agent behaviour when filtering fetched markets
     allow_invalid_questions: bool = False
@@ -230,7 +231,7 @@ class DeployablePredictionAgent(DeployableAgent):
         self.answer_categorical_market = observe()(self.answer_categorical_market)  # type: ignore[method-assign]
         self.answer_scalar_market = observe()(self.answer_scalar_market)  # type: ignore[method-assign]
         self.process_market = observe()(self.process_market)  # type: ignore[method-assign]
-        self.rephrase_market_to_unconditioned = observe()(self.rephrase_market_to_unconditioned)  # type: ignore[method-assign]
+        self.rephrase_market_to_unconditional = observe()(self.rephrase_market_to_unconditional)  # type: ignore[method-assign]
 
     def update_langfuse_trace_by_market(
         self, market_type: MarketType, market: AgentMarket
@@ -305,21 +306,21 @@ class DeployablePredictionAgent(DeployableAgent):
 
         return True
 
-    def rephrase_market_to_unconditioned(
+    def rephrase_market_to_unconditional(
         self,
         market_: AgentMarket,
     ) -> AgentMarket:
         """
-        If `rephrase_conditioned_markets` is set to True,
+        If `rephrase_conditional_markets` is set to True,
         this method will be used to rephrase the question to account for the parent's market probability in the agent's decision process.
         """
         new = market_.model_copy(deep=True)
 
         if new.parent is not None and new.parent.market.parent is not None:
-            new.parent.market = self.rephrase_market_to_unconditioned(new.parent.market)
+            new.parent.market = self.rephrase_market_to_unconditional(new.parent.market)
 
         rephrased_question = (
-            rephrase_question_to_unconditioned(
+            rephrase_question_to_unconditional(
                 new.question,
                 new.parent.market.question,
                 new.parent.market.outcomes[new.parent.parent_outcome],
@@ -373,14 +374,10 @@ class DeployablePredictionAgent(DeployableAgent):
         return False
 
     @property
-    def include_conditional_markets(self) -> bool:
-        # TODO: All should work in our code, except that currently CoW most of the time completely fails to swap xDai into outcome tokens of conditioned market.
-        # Enable after https://github.com/gnosis/prediction-market-agent-tooling/issues/748 and/or https://github.com/gnosis/prediction-market-agent-tooling/issues/759 is resolved.
-        return False
-        # `include_conditional_markets` if `rephrase_conditioned_markets` is enabled.
-        # We can expand this method in teh future, when we implement also more complex logic about conditional markets.
-        # Note that conditional market isn't a type of the market like Binary or Categorical, it means that it uses outcome tokens from parent market as a collateral token in this market.
-        return self.rephrase_conditioned_markets
+    def conditional_filter_type(self) -> ConditionalFilterType:
+        if self.rephrase_conditional_markets:
+            return ConditionalFilterType.ALL
+        return ConditionalFilterType.ONLY_NOT_CONDITIONAL
 
     @property
     def agent_question_type(self) -> QuestionType:
@@ -407,7 +404,7 @@ class DeployablePredictionAgent(DeployableAgent):
             filter_by=self.get_markets_filter_by,
             created_after=self.trade_on_markets_created_after,
             question_type=self.agent_question_type,
-            include_conditional_markets=self.include_conditional_markets,
+            conditional_filter_type=self.conditional_filter_type,
         )
         return available_markets
 
@@ -440,8 +437,8 @@ class DeployablePredictionAgent(DeployableAgent):
 
         logger.info(f"Answering market '{market.question}'.")
 
-        if self.rephrase_conditioned_markets and market.parent is not None:
-            market = self.rephrase_market_to_unconditioned(market)
+        if self.rephrase_conditional_markets and market.parent is not None:
+            market = self.rephrase_market_to_unconditional(market)
 
         if market.is_binary:
             try:
@@ -633,6 +630,7 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         super().initialize_langfuse()
         # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
         self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
+        self.execute_trades = observe()(self.execute_trades)  # type: ignore[method-assign]
 
     def check_min_required_balance_to_trade(self, market: AgentMarket) -> None:
         api_keys = APIKeys()
@@ -678,37 +676,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         trades = strategy.calculate_trades(existing_position, answer, market)
         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()
-        user_id = market.get_user_id(api_keys=api_keys)
-
-        try:
-            existing_position = market.get_position(user_id=user_id)
-        except Exception as e:
-            logger.warning(f"Could not get position for user {user_id}, exception {e}")
-            return None
-
-        trades = self.build_trades(
-            market=market,
-            answer=processed_market.answer,
-            existing_position=existing_position,
-        )
-
+    def execute_trades(
+        self, market: AgentMarket, trades: list[Trade]
+    ) -> list[PlacedTrade]:
         # It can take quite some time before agent processes all the markets, recheck here if the market didn't get closed in the meantime, to not error out completely.
         # Unfortunately, we can not just add some room into closing time of the market while fetching them, because liquidity can be removed at any time by the liquidity providers.
         still_tradeable = market.can_be_traded()
@@ -717,7 +687,8 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                 f"Market {market.question=} ({market.url}) was selected to processing, but is not tradeable anymore."
             )
 
-        placed_trades = []
+        placed_trades: list[PlacedTrade] = []
+
         for trade in trades:
             logger.info(f"Executing trade {trade} on market {market.id} ({market.url})")
 
@@ -730,7 +701,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                     case TradeType.SELL:
                         # Get actual value of the position we are going to sell, and if it's less than we wanted to sell, simply sell all of it.
                         current_position = check_not_none(
-                            market.get_position(user_id),
+                            market.get_position(
+                                market.get_user_id(api_keys=self.api_keys)
+                            ),
                             "Should exists if we are going to sell outcomes.",
                         )
 
@@ -758,6 +731,39 @@ class DeployableTraderAgent(DeployablePredictionAgent):
                     f"Trade execution skipped because, {self.place_trades=} or {still_tradeable=}."
                 )
 
+        return placed_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
+
+        user_id = market.get_user_id(api_keys=self.api_keys)
+
+        try:
+            existing_position = market.get_position(user_id=user_id)
+        except Exception as e:
+            logger.warning(f"Could not get position for user {user_id}, exception {e}")
+            return None
+
+        trades = self.build_trades(
+            market=market,
+            answer=processed_market.answer,
+            existing_position=existing_position,
+        )
+        placed_trades = self.execute_trades(market, trades)
+
         traded_market = ProcessedTradedMarket(
             answer=processed_market.answer, trades=placed_trades
         )

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -84,7 +84,7 @@ class BettingStrategy(ABC):
 
                 if outcome_tokens_to_get_in_usd <= trade.amount:
                     raise GuaranteedLossError(
-                        f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}. Halting execution."
+                        f"Trade {trade=} on market {market.url=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}. Halting execution."
                     )
 
             clean_trades.append(trade)
@@ -443,8 +443,11 @@ class KellyBettingStrategy(BettingStrategy):
             kelly_bet_size = min(kelly_bet.size, max_price_impact_bet_amount)
 
         bet_outcome = direction if kelly_bet.direction else other_direction
+
         amounts = {
-            bet_outcome: market.get_token_in_usd(kelly_bet_size),
+            bet_outcome: BettingStrategy.cap_to_profitable_bet_amount(
+                market, market.get_token_in_usd(kelly_bet_size), bet_outcome
+            ),
         }
         target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(
@@ -475,12 +478,12 @@ class KellyBettingStrategy(BettingStrategy):
         self, market: AgentMarket, kelly_bet: SimpleBet, direction: OutcomeStr
     ) -> CollateralToken:
         def calculate_price_impact_deviation_from_target_price_impact(
-            bet_amount_usd: float,  # Needs to be float because it's used in minimize_scalar internally.
+            bet_amount_collateral: float,  # Needs to be float because it's used in minimize_scalar internally.
         ) -> float:
             outcome_idx = market.get_outcome_index(direction)
             price_impact = self.calculate_price_impact_for_bet_amount(
                 outcome_idx=outcome_idx,
-                bet_amount=market.get_usd_in_token(USD(bet_amount_usd)),
+                bet_amount=CollateralToken(bet_amount_collateral),
                 pool_balances=pool_balances,
                 fees=market.fees,
             )
@@ -504,7 +507,7 @@ class KellyBettingStrategy(BettingStrategy):
             calculate_price_impact_deviation_from_target_price_impact,
             bounds=(0, 1000 * total_pool_balance),
             method="bounded",
-            tol=1e-11,
+            tol=1e-13,
             options={"maxiter": 10000},
         )
         return CollateralToken(optimized_bet_amount.x)

prediction_market_agent_tooling/markets/agent_market.py

@@ -76,6 +76,12 @@ class QuestionType(str, Enum):
     BINARY = "binary"
 
 
+class ConditionalFilterType(Enum):
+    ALL = 1
+    ONLY_CONDITIONAL = 2
+    ONLY_NOT_CONDITIONAL = 3
+
+
 class AgentMarket(BaseModel):
     """
     Common market class that can be created from vendor specific markets.
@@ -147,6 +153,23 @@ class AgentMarket(BaseModel):
         if "fees" not in data and "fee" in data:
             data["fees"] = MarketFees(absolute=0.0, bet_proportion=data["fee"])
             del data["fee"]
+        # Backward compatibility for older `AgentMarket` without `probabilities`.
+        if "probabilities" not in data and "current_p_yes" in data:
+            yes_outcome = data["outcomes"][
+                [o.lower() for o in data["outcomes"]].index(
+                    YES_OUTCOME_LOWERCASE_IDENTIFIER
+                )
+            ]
+            no_outcome = data["outcomes"][
+                [o.lower() for o in data["outcomes"]].index(
+                    NO_OUTCOME_LOWERCASE_IDENTIFIER
+                )
+            ]
+            data["probabilities"] = {
+                yes_outcome: data["current_p_yes"],
+                no_outcome: 1 - data["current_p_yes"],
+            }
+            del data["current_p_yes"]
         return data
 
     def market_outcome_for_probability_key(
@@ -384,7 +407,7 @@ class AgentMarket(BaseModel):
         created_after: t.Optional[DatetimeUTC] = None,
         excluded_questions: set[str] | None = None,
         question_type: QuestionType = QuestionType.ALL,
-        include_conditional_markets: bool = False,
+        conditional_filter_type: ConditionalFilterType = ConditionalFilterType.ONLY_NOT_CONDITIONAL,
     ) -> t.Sequence["AgentMarket"]:
         raise NotImplementedError("Subclasses must implement this method")
 

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -37,6 +37,10 @@ def store_trades(
         logger.warning(f"No prediction for market {market_id}, not storing anything.")
         return None
 
+    logger.info(
+        f"Storing trades for market {market_id}, with outcomes {outcomes}, {traded_market=}."
+    )
+
     probabilities = traded_market.answer.probabilities
     if not probabilities:
         logger.info("Skipping this since no probabilities available.")
@@ -56,9 +60,7 @@ def store_trades(
         ipfs_hash_decoded = ipfscidv0_to_byte32(ipfs_hash)
 
     # tx_hashes must be list of bytes32 (see Solidity contract).
-    tx_hashes = [
-        HexBytes(HexStr(i.id)) for i in traded_market.trades if i.id is not None
-    ]
+    tx_hashes = [HexBytes(HexStr(i.id)) for i in traded_market.trades]
 
     # Dune dashboard expects the probs to be in the same order as on the market.
     probabilities_converted = [