prediction-market-agent-tooling 0.48.17__py3-none-any.whl → 0.49.0__py3-none-any.whl

prediction_market_agent_tooling/deploy/agent.py

@@ -38,6 +38,7 @@ from prediction_market_agent_tooling.markets.agent_market import (
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
+    PlacedTrade,
     Position,
     ProbabilisticAnswer,
     Trade,
@@ -110,7 +111,7 @@ class OutOfFundsError(ValueError):
 
 class ProcessedMarket(BaseModel):
     answer: ProbabilisticAnswer
-    trades: list[Trade]
+    trades: list[PlacedTrade]
 
 
 class AnsweredEnum(str, Enum):
@@ -282,8 +283,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()
-    allow_opposite_bets: bool = False
 
     def __init__(
         self,
@@ -293,6 +292,15 @@ class DeployableTraderAgent(DeployableAgent):
         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_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()
         # Auto-observe all the methods where it makes sense, so that subclassses don't need to do it manually.
@@ -411,7 +419,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
 
@@ -444,24 +453,32 @@ 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}")
 
                 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)
 
         logger.info(f"Processed market {market.question=} from {market.url=}.")

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,
             ),
         }
@@ -141,6 +120,9 @@ class MaxAccuracyBettingStrategy(BettingStrategy):
     def calculate_direction(market_p_yes: float, estimate_p_yes: float) -> bool:
         return estimate_p_yes >= 0.5
 
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(bet_amount={self.bet_amount})"
+
 
 class MaxExpectedValueBettingStrategy(MaxAccuracyBettingStrategy):
     @staticmethod
@@ -152,6 +134,53 @@ class MaxExpectedValueBettingStrategy(MaxAccuracyBettingStrategy):
 
 
 class KellyBettingStrategy(BettingStrategy):
+    def __init__(self, max_bet_amount: float):
+        self.max_bet_amount = max_bet_amount
+
+    def calculate_trades(
+        self,
+        existing_position: Position | None,
+        answer: ProbabilisticAnswer,
+        market: AgentMarket,
+    ) -> list[Trade]:
+        outcome_token_pool = check_not_none(market.outcome_token_pool)
+        kelly_bet = (
+            get_kelly_bet_full(
+                yes_outcome_pool_size=outcome_token_pool[
+                    market.get_outcome_str_from_bool(True)
+                ],
+                no_outcome_pool_size=outcome_token_pool[
+                    market.get_outcome_str_from_bool(False)
+                ],
+                estimated_p_yes=answer.p_yes,
+                max_bet=self.max_bet_amount,
+                confidence=answer.confidence,
+            )
+            if market.has_token_pool()
+            else get_kelly_bet_simplified(
+                self.max_bet_amount,
+                market.current_p_yes,
+                answer.p_yes,
+                answer.confidence,
+            )
+        )
+
+        amounts = {
+            market.get_outcome_str_from_bool(kelly_bet.direction): TokenAmount(
+                amount=kelly_bet.size, currency=market.currency
+            ),
+        }
+        target_position = Position(market_id=market.id, amounts=amounts)
+        trades = self._build_rebalance_trades_from_positions(
+            existing_position, target_position, market=market
+        )
+        return trades
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount})"
+
+
+class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
     def __init__(self, max_bet_amount: float = 10):
         self.max_bet_amount = max_bet_amount
 
@@ -171,6 +200,11 @@ class KellyBettingStrategy(BettingStrategy):
     ) -> list[Trade]:
         adjusted_bet_amount = self.adjust_bet_amount(existing_position, market)
         outcome_token_pool = check_not_none(market.outcome_token_pool)
+
+        # Fixed direction of bet, only use Kelly to adjust the bet size based on market's outcome pool size.
+        estimated_p_yes = float(answer.p_yes > 0.5)
+        confidence = 1.0
+
         kelly_bet = (
             get_kelly_bet_full(
                 yes_outcome_pool_size=outcome_token_pool[
@@ -179,16 +213,16 @@ class KellyBettingStrategy(BettingStrategy):
                 no_outcome_pool_size=outcome_token_pool[
                     market.get_outcome_str_from_bool(False)
                 ],
-                estimated_p_yes=answer.p_yes,
+                estimated_p_yes=estimated_p_yes,
                 max_bet=adjusted_bet_amount,
-                confidence=answer.confidence,
+                confidence=confidence,
             )
             if market.has_token_pool()
             else get_kelly_bet_simplified(
                 adjusted_bet_amount,
                 market.current_p_yes,
-                answer.p_yes,
-                answer.confidence,
+                estimated_p_yes,
+                confidence,
             )
         )
 
@@ -202,3 +236,6 @@ class KellyBettingStrategy(BettingStrategy):
             existing_position, target_position, market=market
         )
         return trades
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount})"

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),

prediction_market_agent_tooling/markets/agent_market.py

@@ -166,13 +166,13 @@ class AgentMarket(BaseModel):
     def liquidate_existing_positions(self, outcome: bool) -> None:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def place_bet(self, outcome: bool, amount: BetAmount) -> None:
+    def place_bet(self, outcome: bool, amount: BetAmount) -> str:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def buy_tokens(self, outcome: bool, amount: TokenAmount) -> None:
+    def buy_tokens(self, outcome: bool, amount: TokenAmount) -> str:
         return self.place_bet(outcome=outcome, amount=amount)
 
-    def sell_tokens(self, outcome: bool, amount: TokenAmount) -> None:
+    def sell_tokens(self, outcome: bool, amount: TokenAmount) -> str:
         raise NotImplementedError("Subclasses must implement this method")
 
     @staticmethod
@@ -281,3 +281,11 @@ class AgentMarket(BaseModel):
             raise ValueError("Outcome token pool is not available.")
 
         return self.outcome_token_pool[outcome]
+
+    @staticmethod
+    def get_user_balance(user_id: str) -> float:
+        raise NotImplementedError("Subclasses must implement this method")
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        raise NotImplementedError("Subclasses must implement this method")

prediction_market_agent_tooling/markets/data_models.py

@@ -37,6 +37,7 @@ ProfitAmount: TypeAlias = TokenAmount
 
 
 class Bet(BaseModel):
+    id: str
     amount: BetAmount
     outcome: bool
     created_time: datetime
@@ -126,3 +127,16 @@ class Trade(BaseModel):
     trade_type: TradeType
     outcome: bool
     amount: TokenAmount
+
+
+class PlacedTrade(Trade):
+    id: str
+
+    @staticmethod
+    def from_trade(trade: Trade, id: str) -> "PlacedTrade":
+        return PlacedTrade(
+            trade_type=trade.trade_type,
+            outcome=trade.outcome,
+            amount=trade.amount,
+            id=id,
+        )

prediction_market_agent_tooling/markets/manifold/api.py

@@ -110,7 +110,7 @@ def get_one_manifold_binary_market() -> ManifoldMarket:
 )
 def place_bet(
     amount: Mana, market_id: str, outcome: bool, manifold_api_key: SecretStr
-) -> None:
+) -> ManifoldBet:
     outcome_str = "YES" if outcome else "NO"
     url = f"{MANIFOLD_API_BASE_URL}/v0/bet"
     params = {
@@ -131,6 +131,7 @@ def place_bet(
             raise RuntimeError(
                 f"Placing bet failed: {response.status_code} {response.reason} {response.text}"
             )
+        return ManifoldBet.model_validate(data)
     else:
         raise Exception(
             f"Placing bet failed: {response.status_code} {response.reason} {response.text}"
@@ -209,6 +210,7 @@ def manifold_to_generic_resolved_bet(
 
     market_outcome = market.get_resolved_boolean_outcome()
     return ResolvedBet(
+        id=bet.id,
         amount=BetAmount(amount=bet.amount, currency=Currency.Mana),
         outcome=bet.get_resolved_boolean_outcome(),
         created_time=bet.createdTime,

prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -49,15 +49,16 @@ class ManifoldAgentMarket(AgentMarket):
         # Manifold lowest bet is 1 Mana, so we need to ceil the result.
         return mana_type(ceil(minimum_bet_to_win(answer, amount_to_win, self)))
 
-    def place_bet(self, outcome: bool, amount: BetAmount) -> None:
+    def place_bet(self, outcome: bool, amount: BetAmount) -> str:
         if amount.currency != self.currency:
             raise ValueError(f"Manifold bets are made in Mana. Got {amount.currency}.")
-        place_bet(
+        bet = place_bet(
             amount=Mana(amount.amount),
             market_id=self.id,
             outcome=outcome,
             manifold_api_key=APIKeys().manifold_api_key,
         )
+        return bet.id
 
     @staticmethod
     def from_data_model(model: FullManifoldMarket) -> "ManifoldAgentMarket":
@@ -119,3 +120,7 @@ class ManifoldAgentMarket(AgentMarket):
     @classmethod
     def get_user_url(cls, keys: APIKeys) -> str:
         return get_authenticated_user(keys.manifold_api_key.get_secret_value()).url
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        return api_keys.manifold_user_id

prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -1,6 +1,7 @@
 import typing as t
 from datetime import datetime
 
+from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
@@ -104,3 +105,7 @@ class MetaculusAgentMarket(AgentMarket):
     def submit_prediction(self, p_yes: Probability, reasoning: str) -> None:
         make_prediction(self.id, p_yes)
         post_question_comment(self.id, reasoning)
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        return str(api_keys.metaculus_user_id)

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -382,7 +382,7 @@ class OmenBetCreator(BaseModel):
 
 
 class OmenBet(BaseModel):
-    id: HexAddress
+    id: HexAddress  # A concatenation of: FPMM contract ID, trader ID and nonce. See https://github.com/protofire/omen-subgraph/blob/f92bbfb6fa31ed9cd5985c416a26a2f640837d8b/src/FixedProductMarketMakerMapping.ts#L109
     title: str
     collateralToken: HexAddress
     outcomeTokenMarginalPrice: xDai
@@ -431,6 +431,9 @@ class OmenBet(BaseModel):
 
     def to_bet(self) -> Bet:
         return Bet(
+            id=str(
+                self.transactionHash
+            ),  # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
             amount=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,
@@ -445,6 +448,9 @@ class OmenBet(BaseModel):
             )
 
         return ResolvedBet(
+            id=str(
+                self.transactionHash
+            ),  # Use the transaction hash instead of the bet id - both are valid, but we return the transaction hash from the trade functions, so be consistent here.
             amount=BetAmount(amount=self.collateralAmountUSD, currency=Currency.xDai),
             outcome=self.boolean_outcome,
             created_time=self.creation_datetime,

prediction_market_agent_tooling/markets/omen/omen.py

@@ -189,7 +189,7 @@ class OmenAgentMarket(AgentMarket):
         omen_auto_deposit: bool = True,
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
-    ) -> None:
+    ) -> str:
         if not self.can_be_traded():
             raise ValueError(
                 f"Market {self.id} is not open for trading. Cannot place bet."
@@ -197,7 +197,7 @@ class OmenAgentMarket(AgentMarket):
         if amount.currency != self.currency:
             raise ValueError(f"Omen bets are made in xDai. Got {amount.currency}.")
         amount_xdai = xDai(amount.amount)
-        binary_omen_buy_outcome_tx(
+        return binary_omen_buy_outcome_tx(
             api_keys=api_keys if api_keys is not None else APIKeys(),
             amount=amount_xdai,
             market=self,
@@ -212,7 +212,7 @@ class OmenAgentMarket(AgentMarket):
         amount: TokenAmount,
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
-    ) -> None:
+    ) -> str:
         return self.place_bet(
             outcome=outcome,
             amount=amount,
@@ -245,7 +245,7 @@ class OmenAgentMarket(AgentMarket):
         auto_withdraw: bool = False,
         api_keys: APIKeys | None = None,
         web3: Web3 | None = None,
-    ) -> None:
+    ) -> str:
         if not self.can_be_traded():
             raise ValueError(
                 f"Market {self.id} is not open for trading. Cannot sell tokens."
@@ -258,7 +258,7 @@ class OmenAgentMarket(AgentMarket):
             outcome=outcome,
             web3=web3,
         )
-        binary_omen_sell_outcome_tx(
+        return binary_omen_sell_outcome_tx(
             amount=collateral,
             api_keys=api_keys if api_keys is not None else APIKeys(),
             market=self,
@@ -633,6 +633,14 @@ class OmenAgentMarket(AgentMarket):
         )
         return Probability(new_p_yes)
 
+    @staticmethod
+    def get_user_balance(user_id: str) -> float:
+        return float(get_balances(Web3.to_checksum_address(user_id)).total)
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        return api_keys.bet_from_address
+
 
 def get_omen_user_url(address: ChecksumAddress) -> str:
     return f"https://gnosisscan.io/address/{address}"
@@ -659,7 +667,7 @@ def omen_buy_outcome_tx(
     outcome: str,
     auto_deposit: bool,
     web3: Web3 | None = None,
-) -> None:
+) -> str:
     """
     Bets the given amount of xDai for the given outcome in the given market.
     """
@@ -695,7 +703,7 @@ def omen_buy_outcome_tx(
         )
 
     # Buy shares using the deposited xDai in the collateral token.
-    market_contract.buy(
+    tx_receipt = market_contract.buy(
         api_keys=api_keys,
         amount_wei=amount_wei_to_buy,
         outcome_index=outcome_index,
@@ -703,6 +711,8 @@ def omen_buy_outcome_tx(
         web3=web3,
     )
 
+    return tx_receipt["transactionHash"].hex()
+
 
 def binary_omen_buy_outcome_tx(
     api_keys: APIKeys,
@@ -711,8 +721,8 @@ def binary_omen_buy_outcome_tx(
     binary_outcome: bool,
     auto_deposit: bool,
     web3: Web3 | None = None,
-) -> None:
-    omen_buy_outcome_tx(
+) -> str:
+    return omen_buy_outcome_tx(
         api_keys=api_keys,
         amount=amount,
         market=market,
@@ -729,7 +739,7 @@ def omen_sell_outcome_tx(
     outcome: str,
     auto_withdraw: bool,
     web3: Web3 | None = None,
-) -> None:
+) -> str:
     """
     Sells the given xDai value of shares corresponding to the given outcome in
     the given market.
@@ -770,7 +780,7 @@ def omen_sell_outcome_tx(
         web3=web3,
     )
     # Sell the shares.
-    market_contract.sell(
+    tx_receipt = market_contract.sell(
         api_keys,
         amount_wei,
         outcome_index,
@@ -792,6 +802,8 @@ def omen_sell_outcome_tx(
             web3,
         )
 
+    return tx_receipt["transactionHash"].hex()
+
 
 def binary_omen_sell_outcome_tx(
     api_keys: APIKeys,
@@ -800,8 +812,8 @@ def binary_omen_sell_outcome_tx(
     binary_outcome: bool,
     auto_withdraw: bool,
     web3: Web3 | None = None,
-) -> None:
-    omen_sell_outcome_tx(
+) -> str:
+    return omen_sell_outcome_tx(
         api_keys=api_keys,
         amount=amount,
         market=market,
@@ -930,7 +942,7 @@ def omen_fund_market_tx(
     web3: Web3 | None = None,
 ) -> None:
     market_contract = market.get_contract()
-    collateral_token_contract = market_contract.get_collateral_token_contract()
+    collateral_token_contract = market_contract.get_collateral_token_contract(web3=web3)
 
     amount_to_fund = collateral_token_contract.get_in_shares(funds, web3)
 
@@ -1048,8 +1060,12 @@ def omen_remove_fund_market_tx(
     """
     from_address = api_keys.bet_from_address
     market_contract = market.get_contract()
-    market_collateral_token_contract = market_contract.get_collateral_token_contract()
-    original_balance = market_collateral_token_contract.balanceOf(from_address)
+    market_collateral_token_contract = market_contract.get_collateral_token_contract(
+        web3=web3
+    )
+    original_balance = market_collateral_token_contract.balanceOf(
+        from_address, web3=web3
+    )
 
     total_shares = market_contract.balanceOf(from_address, web3=web3)
     if total_shares == 0:
@@ -1084,11 +1100,11 @@ def omen_remove_fund_market_tx(
         web3=web3,
     )
 
-    new_balance = market_collateral_token_contract.balanceOf(from_address)
+    new_balance = market_collateral_token_contract.balanceOf(from_address, web3=web3)
 
     logger.debug(f"Result from merge positions {result}")
     logger.info(
-        f"Withdrawn {new_balance - original_balance} {market_collateral_token_contract.symbol_cached()} from liquidity at {market.url=}."
+        f"Withdrawn {new_balance - original_balance} {market_collateral_token_contract.symbol_cached(web3=web3)} from liquidity at {market.url=}."
     )
 
 

prediction_market_agent_tooling/markets/omen/omen_resolving.py

@@ -66,7 +66,9 @@ def claim_bonds_on_realitio_question(
     realitio_contract = OmenRealitioContract()
 
     # Get all answers for the question.
-    responses = OmenSubgraphHandler().get_responses(question_id=question.questionId)
+    responses = OmenSubgraphHandler().get_responses(
+        limit=None, question_id=question.questionId
+    )
 
     # They need to be processed in order.
     responses = sorted(responses, key=lambda x: x.timestamp)

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -677,6 +677,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
 
     def get_questions(
         self,
+        limit: int | None,
         user: HexAddress | None = None,
         claimed: bool | None = None,
         current_answer_before: datetime | None = None,
@@ -694,7 +695,12 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             id_in=id_in,
             question_id_in=question_id_in,
         )
-        questions = self.realityeth_subgraph.Query.questions(where=where_stms)
+        questions = self.realityeth_subgraph.Query.questions(
+            first=(
+                limit if limit else sys.maxsize
+            ),  # if not limit, we fetch all possible
+            where=where_stms,
+        )
         fields = self._get_fields_for_reality_questions(questions)
         result = self.sg.query_json(fields)
         items = self._parse_items_from_json(result)
@@ -715,10 +721,14 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
 
     def get_responses(
         self,
+        limit: int | None,
         user: HexAddress | None = None,
         question_id: HexBytes | None = None,
         question_claimed: bool | None = None,
         question_finalized_before: datetime | None = None,
+        question_finalized_after: datetime | None = None,
+        question_current_answer_before: datetime | None = None,
+        question_id_in: list[HexBytes] | None = None,
     ) -> list[RealityResponse]:
         where_stms: dict[str, t.Any] = {}
 
@@ -729,9 +739,17 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             question_id=question_id,
             claimed=question_claimed,
             finalized_before=question_finalized_before,
+            finalized_after=question_finalized_after,
+            current_answer_before=question_current_answer_before,
+            question_id_in=question_id_in,
         )
 
-        responses = self.realityeth_subgraph.Query.responses(where=where_stms)
+        responses = self.realityeth_subgraph.Query.responses(
+            first=(
+                limit if limit else sys.maxsize
+            ),  # if not limit, we fetch all possible
+            where=where_stms,
+        )
         fields = self._get_fields_for_responses(responses)
         result = self.sg.query_json(fields)
         items = self._parse_items_from_json(result)

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -46,7 +46,7 @@ class PolymarketAgentMarket(AgentMarket):
     def get_tiny_bet_amount(cls) -> BetAmount:
         raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
 
-    def place_bet(self, outcome: bool, amount: BetAmount) -> None:
+    def place_bet(self, outcome: bool, amount: BetAmount) -> str:
         raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
 
     @staticmethod

prediction_market_agent_tooling/monitor/markets/polymarket.py

@@ -43,3 +43,7 @@ class DeployedPolymarketAgent(DeployedAgent):
         == MarketType.POLYMARKET.value,
     ) -> t.Sequence["DeployedPolymarketAgent"]:
         return super().from_all_gcp_functions(filter_=filter_)
+
+    @staticmethod
+    def get_user_id(api_keys: APIKeys) -> str:
+        return api_keys.bet_from_address

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -7,9 +7,9 @@ from langfuse.client import TraceWithDetails
 from pydantic import BaseModel
 
 from prediction_market_agent_tooling.markets.data_models import (
+    PlacedTrade,
     ProbabilisticAnswer,
     ResolvedBet,
-    Trade,
     TradeType,
 )
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
@@ -20,10 +20,10 @@ class ProcessMarketTrace(BaseModel):
     timestamp: datetime
     market: OmenAgentMarket
     answer: ProbabilisticAnswer
-    trades: list[Trade]
+    trades: list[PlacedTrade]
 
     @property
-    def buy_trade(self) -> Trade:
+    def buy_trade(self) -> PlacedTrade:
         buy_trades = [t for t in self.trades if t.trade_type == TradeType.BUY]
         if len(buy_trades) == 1:
             return buy_trades[0]
@@ -107,10 +107,10 @@ def trace_to_answer(trace: TraceWithDetails) -> ProbabilisticAnswer:
     return ProbabilisticAnswer.model_validate(trace.output["answer"])
 
 
-def trace_to_trades(trace: TraceWithDetails) -> list[Trade]:
+def trace_to_trades(trace: TraceWithDetails) -> list[PlacedTrade]:
     assert trace.output is not None, "Trace output is None"
     assert trace.output["trades"] is not None, "Trace output trades is None"
-    return [Trade.model_validate(t) for t in trace.output["trades"]]
+    return [PlacedTrade.model_validate(t) for t in trace.output["trades"]]
 
 
 def get_closest_datetime_from_list(

prediction_market_agent_tooling/tools/omen/reality_accuracy.py

@@ -0,0 +1,74 @@
+from datetime import timedelta
+
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
+    ChecksumAddress,
+    OmenSubgraphHandler,
+    RealityResponse,
+)
+from prediction_market_agent_tooling.tools.utils import utcnow
+
+
+class RealityAccuracyReport(BaseModel):
+    total: int
+    correct: int
+
+    @property
+    def accuracy(self) -> float:
+        return self.correct / self.total
+
+
+def reality_accuracy(user: ChecksumAddress, since: timedelta) -> RealityAccuracyReport:
+    now = utcnow()
+    start_from = now - since
+
+    # Get all question ids where we placed the higher bond.
+    user_responses = OmenSubgraphHandler().get_responses(
+        limit=None,
+        user=user,
+        question_finalized_before=now,
+        question_finalized_after=start_from,
+    )
+    unique_question_ids = set(r.question.questionId for r in user_responses)
+
+    # Get all responses for these questions (including not ours)
+    question_to_responses = {
+        question_id: OmenSubgraphHandler().get_responses(
+            limit=None, question_id=question_id
+        )
+        for question_id in unique_question_ids
+    }
+
+    total = 0
+    correct = 0
+
+    for question_id, responses in question_to_responses.items():
+        is_correct = user_was_correct(user, responses)
+        assert (
+            is_correct is not None
+        ), f"All these questions should be challenged by provided user: {responses[0].question.url}"
+
+        total += 1
+        correct += int(is_correct)
+
+    return RealityAccuracyReport(total=total, correct=correct)
+
+
+def user_was_correct(
+    user: ChecksumAddress, responses: list[RealityResponse]
+) -> bool | None:
+    sorted_responses = sorted(responses, key=lambda r: r.timestamp)
+    users_sorted_responses = [r for r in sorted_responses if r.user_checksummed == user]
+
+    if not users_sorted_responses:
+        return None
+
+    # Find the user's last response
+    users_last_response = users_sorted_responses[-1]
+
+    # Last response is the final one (if market is finalized)
+    actual_resolution = sorted_responses[-1]
+
+    # Compare the user's last answer with the actual resolution
+    return users_last_response.answer == actual_resolution.answer

prediction_market_agent_tooling/tools/utils.py

@@ -1,3 +1,4 @@
+import json
 import os
 import subprocess
 import typing as t
@@ -6,12 +7,14 @@ from typing import Any, NoReturn, Optional, Type, TypeVar, cast
 
 import pytz
 import requests
+from google.cloud import secretmanager
 from pydantic import BaseModel, ValidationError
 from scipy.optimize import newton
 from scipy.stats import entropy
 
 from prediction_market_agent_tooling.gtypes import (
     DatetimeWithTimezone,
+    PrivateKey,
     Probability,
     SecretStr,
 )
@@ -210,3 +213,18 @@ def calculate_sell_amount_in_collateral(
 
     amount_to_sell = newton(f, 0)
     return float(amount_to_sell) * 0.999999  # Avoid rounding errors
+
+
+def get_private_key_from_gcp_secret(
+    secret_id: str,
+    project_id: str = "582587111398",  # Gnosis AI default project_id
+    version_id: str = "latest",
+) -> PrivateKey:
+    client = secretmanager.SecretManagerServiceClient()
+    name = f"projects/{project_id}/secrets/{secret_id}/versions/{version_id}"
+    response = client.access_secret_version(request={"name": name})
+    secret_payload = response.payload.data.decode("UTF-8")
+    secret_json = json.loads(secret_payload)
+    if "private_key" not in secret_json:
+        raise ValueError(f"Private key not found in gcp secret {secret_id}")
+    return PrivateKey(SecretStr(secret_json["private_key"]))

{prediction_market_agent_tooling-0.48.17.dist-info → prediction_market_agent_tooling-0.49.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.48.17
+Version: 0.49.0
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12

{prediction_market_agent_tooling-0.48.17.dist-info → prediction_market_agent_tooling-0.49.0.dist-info}/RECORD

@@ -15,9 +15,9 @@ prediction_market_agent_tooling/benchmark/agents.py,sha256=BwE3U11tQq0rfOJBn-Xn5
 prediction_market_agent_tooling/benchmark/benchmark.py,sha256=xiHKzZx5GHSsDerFHMZ9j_LXAXnSaITSvv67iPe3MEU,21095
 prediction_market_agent_tooling/benchmark/utils.py,sha256=D0MfUkVZllmvcU0VOurk9tcKT7JTtwwOp-63zuCBVuc,2880
 prediction_market_agent_tooling/config.py,sha256=9h68Nb9O1YZabZqtOBrH1S-4U5aIdLKfVYLSKspfUeA,6008
-prediction_market_agent_tooling/deploy/agent.py,sha256=xT0L1BLU89t7lfBcbbqojcH_4H7ElnXKMQB2wjFxwos,19112
+prediction_market_agent_tooling/deploy/agent.py,sha256=QiGREI3YDafVP6kA7H6ejSTxMGBUEG-iYibda43k7vY,19749
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=edatJ7temvl9TBTy05JjtFCAlaoVXCfLOQlYWJ61wvw,7636
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=eCmKpi3EJxFNbPiT7zDYRxJrP76mj0idvSlzin1wtWg,8990
 prediction_market_agent_tooling/deploy/constants.py,sha256=M5ty8URipYMGe_G-RzxRydK3AFL6CyvmqCraJUrLBnE,82
 prediction_market_agent_tooling/deploy/gcp/deploy.py,sha256=CYUgnfy-9XVk04kkxA_5yp0GE9Mw5caYqlFUZQ2j3ks,3739
 prediction_market_agent_tooling/deploy/gcp/kubernetes_models.py,sha256=qYIHRxQLac3yxtZ8ChikiPG9O1aUQucHW0muTSm1nto,2627
@@ -26,35 +26,35 @@ prediction_market_agent_tooling/gtypes.py,sha256=O77co9-GWmHJo_NyBzRVkli5L1xqweI
 prediction_market_agent_tooling/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/jobs/jobs.py,sha256=I07yh0GJ-xhlvQaOUQB8xlSnihhcbU2c7DZ4ZND14c0,1246
 prediction_market_agent_tooling/jobs/jobs_models.py,sha256=8JS9n_EVgmNzqRg1YUjopPVZRjqFneVYCKnX4UEFy3I,1326
-prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=EAzo63vhSt1P7ddoDubdmvgzFf-ieQRTDCRLzYkH3js,3922
+prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=Mr6fZqfOs4tzGYsp7g0ygolYjQaFCLG7ljP1mKs71ng,3946
 prediction_market_agent_tooling/loggers.py,sha256=Am6HHXRNO545BO3l7Ue9Wb2TkYE1OK8KKhGbI3XypVU,3751
-prediction_market_agent_tooling/markets/agent_market.py,sha256=nVJO1MY7_l-YP1Q7-mGLtRgIHK8M-yt3Ht1yyQPwImM,10176
+prediction_market_agent_tooling/markets/agent_market.py,sha256=OmnoGgcH_jnYb-y7vG5XH9bEwb0VdCrBqfHAxLd7eIw,10457
 prediction_market_agent_tooling/markets/categorize.py,sha256=jsoHWvZk9pU6n17oWSCcCxNNYVwlb_NXsZxKRI7vmsk,1301
-prediction_market_agent_tooling/markets/data_models.py,sha256=vaJ049j2Anf5sZWjNflsCEag-Y0G1mTu6bCWT74HxqM,3266
+prediction_market_agent_tooling/markets/data_models.py,sha256=DoSWVrHgzrEbEELSZ19hK38ckBShJLobmp6IetZaL8E,3563
 prediction_market_agent_tooling/markets/manifold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/markets/manifold/api.py,sha256=AC2zmkzpBU3P4kyybs7CgPbDg4hLAx3GY5mjgDi7qDo,7221
+prediction_market_agent_tooling/markets/manifold/api.py,sha256=pliGOyehEcApj1l6OaoVDeuGrws8AN2bymiTuP1y4t0,7295
 prediction_market_agent_tooling/markets/manifold/data_models.py,sha256=2Rh3j9SM2om-q61Mbxm_UjOzXfxnoej-f_Vyx0LMMfE,6467
-prediction_market_agent_tooling/markets/manifold/manifold.py,sha256=t_FyV7jBMSIV_MA_EWih3SpvChxpmBey5g8HYQrYde0,4316
+prediction_market_agent_tooling/markets/manifold/manifold.py,sha256=e4T6IAxV2OfIHsPMOTqSpfTRfLZ7CxegAYbCLc35Os8,4450
 prediction_market_agent_tooling/markets/manifold/utils.py,sha256=cPPFWXm3vCYH1jy7_ctJZuQH9ZDaPL4_AgAYzGWkoow,513
 prediction_market_agent_tooling/markets/markets.py,sha256=EN0MgOBBk2ASSVTfqlk0MrsHxg3CVRyQl23jtzfeEi8,3222
 prediction_market_agent_tooling/markets/metaculus/api.py,sha256=gvPQVAM5NlCyWzEMt4WML9saRBsK9eiHAZP6jwirVqc,2750
 prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=6TBy17xntdLBR61QCE5wddwTa_k2D0D8ZgK6p7sGUuc,2448
-prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=1aaainHlMExDSp6nfKY31iATQsaJx1LdYp9p2PkQVAs,3453
+prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=vvdN2DbOeSPyvCIzZyZmrAqAnmWqwCJgQ5bb5zRBlL4,3625
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/markets/omen/data_models.py,sha256=PQyoENpXkhu5TXZhbUdDvKLsb2sQt8rwryPTVQ9fIeM,17029
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=TGXthQITMoYvx1iK388nHbv8U0DQeX_jyHb-OEinvfg,46676
+prediction_market_agent_tooling/markets/omen/data_models.py,sha256=B5EfIkq_ezfGiGFbWXPbtVTUDAsrcQ0DM9lmcLXzoHw,17675
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=euiia_WHnHeAEPEh0WeHLleKVl6Yp289oKyQZDGMTZo,47147
 prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=MfaWfDDfEzHYVAbeT3Dgtl8KG7XsqEpdY3m3-rsOPwo,23588
-prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=Awaw1r32IBAClCktrXbYJ24RNyLDWcLb8RqAx6FGSkI,9529
-prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=W3JIq3NDGoJuHZlPtv2Gv_EmCtYVwsgZwClSY-RloZw,30219
+prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=udzte2jD33tONHPfMGhQbkAlHePRuw5iF8YXy71P8qo,9555
+prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=2K-B5rnT05oC0K1YbrB0cKXOz3wjagoDLXQ9fxBTlBs,30902
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=HXmA1akA0qDj0m3e-GEvWG8x75pm6BX4H7YJPQcST7I,4767
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=9CJzakyEcsn6DQBK2nOXjOMzTZBLAmK_KqevXvW17DI,4292
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=IPsFT3FX9Ge5l5zR1nBd2w-sd5ue7oR8PJSW710vFWY,12479
-prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=wQ_jzwuPNB-u2eB7okw2I6qbvNZbUT0qH4pAIKXHBkI,2774
+prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=SONMs6gFAR_j8xgVK8MmQDTrFx64_JCi5IfVr52EeKE,2773
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=m4JG6WULh5epCJt4XBMHg0ae5NoVhqlOvAl0A7DR9iM,2023
 prediction_market_agent_tooling/monitor/markets/manifold.py,sha256=GdYpgRX1GahDi-75Mr53jgtEg6nWcs_rHDUkg4o_7dQ,3352
 prediction_market_agent_tooling/monitor/markets/metaculus.py,sha256=S8zeDVN2aA6yvQykQNPb8GUGohczfJuCYt9Ds9ESCzs,1473
 prediction_market_agent_tooling/monitor/markets/omen.py,sha256=jOLPnIbDU9syjnYtHfOb2xa6-Ize3vbplgh-8WWkuT4,3323
-prediction_market_agent_tooling/monitor/markets/polymarket.py,sha256=I9z9aO1wncyGI3a09ihrw17JkeBKjAuMmC0I9pl_9o4,1781
+prediction_market_agent_tooling/monitor/markets/polymarket.py,sha256=y7HVAEzeybfphB_VZPZpmAsQqjxPUM1uM7ZttQ56mm8,1888
 prediction_market_agent_tooling/monitor/monitor.py,sha256=tvYzHJg8Nau4vGWVTngjUAcM26LcH3Emss76351xl2o,14636
 prediction_market_agent_tooling/monitor/monitor_app.py,sha256=1e4LuzhAVjb7cPS6rGPZuZHMwMiNOeRhSxG8AVG-e0o,4839
 prediction_market_agent_tooling/monitor/monitor_settings.py,sha256=Xiozs3AsufuJ04JOe1vjUri-IAMWHjjmc2ugGGiHNH4,947
@@ -75,17 +75,18 @@ prediction_market_agent_tooling/tools/image_gen/image_gen.py,sha256=HzRwBx62hOXB
 prediction_market_agent_tooling/tools/image_gen/market_thumbnail_gen.py,sha256=8A3U2uxsCsOfLjru-6R_PPIAuiKY4qFkWp_GSBPV6-s,1280
 prediction_market_agent_tooling/tools/is_predictable.py,sha256=QapzvJVgUZdhucgmxhzWAQ885BwSwvYUi0SG8mkLQMQ,6738
 prediction_market_agent_tooling/tools/langfuse_.py,sha256=jI_4ROxqo41CCnWGS1vN_AeDVhRzLMaQLxH3kxDu3L8,1153
-prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=HZ8PN__CahMeNLaEx4v9esOqow6XEeezuYOOZD9-Ol8,4741
+prediction_market_agent_tooling/tools/langfuse_client_utils.py,sha256=PcBi9CSEkyjdSKU8AoGvC2guBsCrUzFNw9BhMkm-vvI,4771
+prediction_market_agent_tooling/tools/omen/reality_accuracy.py,sha256=M1SF7iSW1gVlQSTskdVFTn09uPLST23YeipVIWj54io,2236
 prediction_market_agent_tooling/tools/parallelism.py,sha256=6Gou0hbjtMZrYvxjTDFUDZuxmE2nqZVbb6hkg1hF82A,1022
 prediction_market_agent_tooling/tools/safe.py,sha256=h0xOO0eNtitClf0fPkn-0oTc6A_bflDTee98V_aiV-A,5195
 prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0rnVhtQGzwoUdAgn_7u_GBM,729
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
 prediction_market_agent_tooling/tools/tavily_storage/tavily_models.py,sha256=Uq2iyDygVRxp6qHAnz9t5c1uTLGV2RPQE15sVJFLds8,6341
 prediction_market_agent_tooling/tools/tavily_storage/tavily_storage.py,sha256=xrtQH9v5pXycBRyc5j45pWqkSffkoc9efNIU1_G633Q,3706
-prediction_market_agent_tooling/tools/utils.py,sha256=JE9YWtPPhnTgLiOyGAZDNG5K8nCwUY9IZEuAlm9UcxA,6611
+prediction_market_agent_tooling/tools/utils.py,sha256=uItjuwR5ZB6Qy7mmc5Dzx7fa2lkLO7oHhk2nzJMrIVo,7341
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=IZDxHhUJH5RsaRkK9DW6z1RYdk2cz5RqLMZG3T6Gv1U,11602
-prediction_market_agent_tooling-0.48.17.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.48.17.dist-info/METADATA,sha256=sAyQzhlLTgPYGu4SF0z2dfSpSkZeJkZJYStbvagwh18,7848
-prediction_market_agent_tooling-0.48.17.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-prediction_market_agent_tooling-0.48.17.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.48.17.dist-info/RECORD,,
+prediction_market_agent_tooling-0.49.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.49.0.dist-info/METADATA,sha256=DjQQylYgmiw5_M2v-5BHozKAUGyX8Ykmpr1WlWyyiKE,7847
+prediction_market_agent_tooling-0.49.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+prediction_market_agent_tooling-0.49.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.49.0.dist-info/RECORD,,