prediction-market-agent-tooling 0.48.13__py3-none-any.whl → 0.48.15__py3-none-any.whl

prediction_market_agent_tooling/deploy/agent.py

@@ -426,6 +426,8 @@ class DeployableTraderAgent(DeployableAgent):
         market: AgentMarket,
         verify_market: bool = True,
     ) -> ProcessedMarket | None:
+        logger.info(f"Processing market {market.question=} from {market.url=}.")
+
         self.before_process_market(market_type, market)
 
         if verify_market and not self.verify_market(market_type, market):
@@ -462,6 +464,7 @@ class DeployableTraderAgent(DeployableAgent):
         processed_market = ProcessedMarket(answer=answer, trades=trades)
         self.update_langfuse_trace_by_processed_market(market_type, processed_market)
 
+        logger.info(f"Processed market {market.question=} from {market.url=}.")
         return processed_market
 
     def after_process_market(
@@ -495,7 +498,11 @@ class DeployableTraderAgent(DeployableAgent):
         """
         Processes bets placed by agents on a given market.
         """
+        logger.info("Start processing of markets.")
         available_markets = self.get_markets(market_type)
+        logger.info(
+            f"Fetched {len(available_markets)=} markets to process, going to process {self.bet_on_n_markets_per_run=}."
+        )
         processed = 0
 
         for market in available_markets:
@@ -510,6 +517,8 @@ class DeployableTraderAgent(DeployableAgent):
             if processed == self.bet_on_n_markets_per_run:
                 break
 
+        logger.info("All markets processed.")
+
     def after_process_markets(self, market_type: MarketType) -> None:
         pass
 

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -11,8 +11,10 @@ from prediction_market_agent_tooling.markets.data_models import (
 )
 from prediction_market_agent_tooling.markets.omen.data_models import get_boolean_outcome
 from prediction_market_agent_tooling.tools.betting_strategies.kelly_criterion import (
-    get_kelly_bet,
+    get_kelly_bet_full,
+    get_kelly_bet_simplified,
 )
+from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
 class BettingStrategy(ABC):
@@ -168,11 +170,26 @@ class KellyBettingStrategy(BettingStrategy):
         market: AgentMarket,
     ) -> list[Trade]:
         adjusted_bet_amount = self.adjust_bet_amount(existing_position, market)
-        kelly_bet = get_kelly_bet(
-            adjusted_bet_amount,
-            market.current_p_yes,
-            answer.p_yes,
-            answer.confidence,
+        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=adjusted_bet_amount,
+                confidence=answer.confidence,
+            )
+            if market.has_token_pool()
+            else get_kelly_bet_simplified(
+                adjusted_bet_amount,
+                market.current_p_yes,
+                answer.p_yes,
+                answer.confidence,
+            )
         )
 
         amounts = {

prediction_market_agent_tooling/gtypes.py

@@ -27,7 +27,7 @@ PrivateKey = NewType("PrivateKey", SecretStr)
 xDai = NewType("xDai", float)
 GNO = NewType("GNO", float)
 ABI = NewType("ABI", str)
-OmenOutcomeToken = NewType("OmenOutcomeToken", int)
+OmenOutcomeToken = NewType("OmenOutcomeToken", Wei)
 OutcomeStr = NewType("OutcomeStr", str)
 Probability = NewType("Probability", float)
 Mana = NewType("Mana", float)  # Manifold's "currency"

prediction_market_agent_tooling/jobs/jobs.py

@@ -0,0 +1,45 @@
+import typing as t
+
+from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
+from prediction_market_agent_tooling.jobs.omen.omen_jobs import OmenJobAgentMarket
+from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy
+from prediction_market_agent_tooling.markets.markets import MarketType
+
+JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET: dict[MarketType, type[JobAgentMarket]] = {
+    MarketType.OMEN: OmenJobAgentMarket,
+}
+
+
+@t.overload
+def get_jobs(
+    market_type: t.Literal[MarketType.OMEN],
+    limit: int | None,
+    filter_by: FilterBy = FilterBy.OPEN,
+    sort_by: SortBy = SortBy.NONE,
+) -> t.Sequence[OmenJobAgentMarket]:
+    ...
+
+
+@t.overload
+def get_jobs(
+    market_type: MarketType,
+    limit: int | None,
+    filter_by: FilterBy = FilterBy.OPEN,
+    sort_by: SortBy = SortBy.NONE,
+) -> t.Sequence[JobAgentMarket]:
+    ...
+
+
+def get_jobs(
+    market_type: MarketType,
+    limit: int | None,
+    filter_by: FilterBy = FilterBy.OPEN,
+    sort_by: SortBy = SortBy.NONE,
+) -> t.Sequence[JobAgentMarket]:
+    job_class = JOB_MARKET_TYPE_TO_JOB_AGENT_MARKET[market_type]
+    markets = job_class.get_jobs(
+        limit=limit,
+        sort_by=sort_by,
+        filter_by=filter_by,
+    )
+    return markets

prediction_market_agent_tooling/jobs/jobs_models.py

@@ -0,0 +1,53 @@
+import typing as t
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
+    FilterBy,
+    SortBy,
+)
+
+
+class SimpleJob(BaseModel):
+    id: str
+    job: str
+    reward: float
+    currency: str
+    deadline: datetime
+
+
+class JobAgentMarket(AgentMarket, ABC):
+    CATEGORY: t.ClassVar[str]
+
+    @property
+    @abstractmethod
+    def job(self) -> str:
+        """Holds description of the job that needs to be done."""
+
+    @property
+    @abstractmethod
+    def deadline(self) -> datetime:
+        """Deadline for the job completion."""
+
+    @abstractmethod
+    def get_reward(self, max_bond: float) -> float:
+        """Reward for completing this job."""
+
+    @abstractmethod
+    @classmethod
+    def get_jobs(
+        cls, limit: int | None, filter_by: FilterBy, sort_by: SortBy
+    ) -> t.Sequence["JobAgentMarket"]:
+        """Get all available jobs."""
+
+    def to_simple_job(self, max_bond: float) -> SimpleJob:
+        return SimpleJob(
+            id=self.id,
+            job=self.job,
+            reward=self.get_reward(max_bond),
+            currency=self.currency.value,
+            deadline=self.deadline,
+        )

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -0,0 +1,113 @@
+import typing as t
+from datetime import datetime
+
+from web3 import Web3
+
+from prediction_market_agent_tooling.deploy.betting_strategy import (
+    Currency,
+    KellyBettingStrategy,
+    ProbabilisticAnswer,
+    TradeType,
+)
+from prediction_market_agent_tooling.gtypes import Probability
+from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
+from prediction_market_agent_tooling.markets.omen.omen import (
+    BetAmount,
+    OmenAgentMarket,
+    OmenMarket,
+)
+from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
+    FilterBy,
+    OmenSubgraphHandler,
+    SortBy,
+)
+
+
+class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
+    CATEGORY = "jobs"
+
+    @property
+    def job(self) -> str:
+        """Omen market's have only question, so that's where the job description is."""
+        return self.question
+
+    @property
+    def deadline(self) -> datetime:
+        return self.close_time
+
+    def get_reward(self, max_bond: float) -> float:
+        return compute_job_reward(self, max_bond)
+
+    @classmethod
+    def get_jobs(
+        cls, limit: int | None, filter_by: FilterBy, sort_by: SortBy
+    ) -> t.Sequence["OmenJobAgentMarket"]:
+        markets = OmenSubgraphHandler().get_omen_binary_markets_simple(
+            limit=limit,
+            filter_by=filter_by,
+            sort_by=sort_by,
+            category=cls.CATEGORY,
+        )
+        return [OmenJobAgentMarket.from_omen_market(market) for market in markets]
+
+    @staticmethod
+    def from_omen_market(market: OmenMarket) -> "OmenJobAgentMarket":
+        return OmenJobAgentMarket.from_omen_agent_market(
+            OmenAgentMarket.from_data_model(market)
+        )
+
+    @staticmethod
+    def from_omen_agent_market(market: OmenAgentMarket) -> "OmenJobAgentMarket":
+        return OmenJobAgentMarket(
+            id=market.id,
+            question=market.question,
+            description=market.description,
+            outcomes=market.outcomes,
+            outcome_token_pool=market.outcome_token_pool,
+            resolution=market.resolution,
+            created_time=market.created_time,
+            close_time=market.close_time,
+            current_p_yes=market.current_p_yes,
+            url=market.url,
+            volume=market.volume,
+            creator=market.creator,
+            collateral_token_contract_address_checksummed=market.collateral_token_contract_address_checksummed,
+            market_maker_contract_address_checksummed=market.market_maker_contract_address_checksummed,
+            condition=market.condition,
+            finalized_time=market.finalized_time,
+            fee=market.fee,
+        )
+
+
+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(
+        existing_position=None,
+        # We assume that we finish the job and so the probability of the market happening will be 100%.
+        answer=ProbabilisticAnswer(p_yes=Probability(1.0), confidence=1.0),
+        market=market,
+    )
+
+    assert (
+        len(required_trades) == 1
+    ), f"Shouldn't process same job twice: {required_trades}"
+    trade = required_trades[0]
+    assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
+    assert trade.outcome, "Should buy only YES on job markets."
+    assert (
+        trade.amount.currency == Currency.xDai
+    ), "Should work only on real-money markets."
+
+    reward = (
+        market.get_buy_token_amount(
+            bet_amount=BetAmount(
+                amount=trade.amount.amount, currency=trade.amount.currency
+            ),
+            direction=trade.outcome,
+        ).amount
+        - trade.amount.amount
+    )
+
+    return reward

prediction_market_agent_tooling/markets/omen/data_models.py

@@ -9,6 +9,7 @@ from prediction_market_agent_tooling.gtypes import (
     ChecksumAddress,
     HexAddress,
     HexBytes,
+    HexStr,
     OmenOutcomeToken,
     Probability,
     Wei,
@@ -30,8 +31,10 @@ from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai
 
 OMEN_TRUE_OUTCOME = "Yes"
 OMEN_FALSE_OUTCOME = "No"
+OMEN_BINARY_MARKET_OUTCOMES = [OMEN_TRUE_OUTCOME, OMEN_FALSE_OUTCOME]
 INVALID_ANSWER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
 INVALID_ANSWER_HEX_BYTES = HexBytes(INVALID_ANSWER)
+INVALID_ANSWER_STR = HexStr(INVALID_ANSWER_HEX_BYTES.hex())
 OMEN_BASE_URL = "https://aiomen.eth.limo"
 PRESAGIO_BASE_URL = "https://presagio.pages.dev"
 

prediction_market_agent_tooling/markets/omen/omen.py

@@ -97,10 +97,6 @@ class OmenAgentMarket(AgentMarket):
     close_time: datetime
     fee: float  # proportion, from 0 to 1
 
-    INVALID_MARKET_ANSWER: HexStr = HexStr(
-        "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
-    )
-
     _binary_market_p_yes_history: list[Probability] | None = None
     description: str | None = (
         None  # Omen markets don't have a description, so just default to None.
@@ -577,6 +573,66 @@ class OmenAgentMarket(AgentMarket):
     def get_user_url(cls, keys: APIKeys) -> str:
         return get_omen_user_url(keys.bet_from_address)
 
+    def get_buy_token_amount(
+        self, bet_amount: BetAmount, direction: bool
+    ) -> TokenAmount:
+        """
+        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=bet_amount.amount,
+            buy_direction=direction,
+            yes_outcome_pool_size=outcome_token_pool[OMEN_TRUE_OUTCOME],
+            no_outcome_pool_size=outcome_token_pool[OMEN_FALSE_OUTCOME],
+            fee=self.fee,
+        )
+        return TokenAmount(amount=amount, currency=self.currency)
+
+    def _get_buy_token_amount_from_smart_contract(
+        self, bet_amount: BetAmount, direction: bool
+    ) -> TokenAmount:
+        received_token_amount_wei = Wei(
+            self.get_contract().calcBuyAmount(
+                investment_amount=xdai_to_wei(xDai(bet_amount.amount)),
+                outcome_index=self.get_outcome_index(
+                    self.get_outcome_str_from_bool(direction)
+                ),
+            )
+        )
+        received_token_amount = float(wei_to_xdai(received_token_amount_wei))
+        return TokenAmount(amount=received_token_amount, currency=self.currency)
+
+    def get_new_p_yes(self, bet_amount: BetAmount, direction: bool) -> Probability:
+        """
+        Calculate the new p_yes based on the bet amount and direction.
+        """
+        if not self.has_token_pool():
+            raise ValueError("Outcome token pool is required to calculate new p_yes.")
+
+        outcome_token_pool = check_not_none(self.outcome_token_pool)
+        yes_outcome_pool_size = outcome_token_pool[self.get_outcome_str_from_bool(True)]
+        no_outcome_pool_size = outcome_token_pool[self.get_outcome_str_from_bool(False)]
+
+        new_yes_outcome_pool_size = yes_outcome_pool_size + (
+            bet_amount.amount * (1 - self.fee)
+        )
+        new_no_outcome_pool_size = no_outcome_pool_size + (
+            bet_amount.amount * (1 - self.fee)
+        )
+
+        received_token_amount = self.get_buy_token_amount(bet_amount, direction).amount
+        if direction:
+            new_yes_outcome_pool_size -= received_token_amount
+        else:
+            new_no_outcome_pool_size -= received_token_amount
+
+        new_p_yes = new_no_outcome_pool_size / (
+            new_yes_outcome_pool_size + new_no_outcome_pool_size
+        )
+        return Probability(new_p_yes)
+
 
 def get_omen_user_url(address: ChecksumAddress) -> str:
     return f"https://gnosisscan.io/address/{address}"
@@ -876,17 +932,20 @@ def omen_fund_market_tx(
     market_contract = market.get_contract()
     collateral_token_contract = market_contract.get_collateral_token_contract()
 
-    if auto_deposit:
-        auto_deposit_collateral_token(collateral_token_contract, funds, api_keys, web3)
+    amount_to_fund = collateral_token_contract.get_in_shares(funds, web3)
 
     collateral_token_contract.approve(
         api_keys=api_keys,
         for_address=market_contract.address,
-        amount_wei=funds,
+        amount_wei=amount_to_fund,
         web3=web3,
     )
 
-    market_contract.addFunding(api_keys, funds, web3=web3)
+    if auto_deposit:
+        # In auto-depositing, we need to deposit the original `funds`, e.g. we can deposit 2 xDai, but receive 1.8 sDai, so for the funding we will use `amount_to_fund`.
+        auto_deposit_collateral_token(collateral_token_contract, funds, api_keys, web3)
+
+    market_contract.addFunding(api_keys, amount_to_fund, web3=web3)
 
 
 def build_parent_collection_id() -> HexStr:
@@ -1162,3 +1221,33 @@ def withdraw_wxdai_to_xdai_to_keep_balance(
     logger.info(
         f"Withdrew {need_to_withdraw} wxDai to keep the balance above the minimum required balance {min_required_balance}."
     )
+
+
+def get_buy_outcome_token_amount(
+    investment_amount: float,
+    buy_direction: bool,
+    yes_outcome_pool_size: float,
+    no_outcome_pool_size: float,
+    fee: float,
+) -> float:
+    """
+    Calculates the amount of outcome tokens received for a given investment
+
+    Taken from https://github.com/gnosis/conditional-tokens-market-makers/blob/6814c0247c745680bb13298d4f0dd7f5b574d0db/contracts/FixedProductMarketMaker.sol#L264
+    """
+    investment_amount_minus_fees = investment_amount * (1 - fee)
+    buy_token_pool_balance = (
+        yes_outcome_pool_size if buy_direction else no_outcome_pool_size
+    )
+
+    pool_balance = no_outcome_pool_size if buy_direction else yes_outcome_pool_size
+    denominator = pool_balance + investment_amount_minus_fees
+    ending_outcome_balance = buy_token_pool_balance * pool_balance / denominator
+
+    if ending_outcome_balance <= 0:
+        raise ValueError("must have non-zero balances")
+
+    result = (
+        buy_token_pool_balance + investment_amount_minus_fees - ending_outcome_balance
+    )
+    return result

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -19,8 +19,7 @@ from prediction_market_agent_tooling.gtypes import (
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy
 from prediction_market_agent_tooling.markets.omen.data_models import (
-    OMEN_FALSE_OUTCOME,
-    OMEN_TRUE_OUTCOME,
+    OMEN_BINARY_MARKET_OUTCOMES,
     OmenBet,
     OmenMarket,
     OmenPosition,
@@ -204,7 +203,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         self,
         creator: t.Optional[HexAddress] = None,
         creator_in: t.Optional[t.Sequence[HexAddress]] = None,
-        outcomes: list[str] = [OMEN_TRUE_OUTCOME, OMEN_FALSE_OUTCOME],
+        outcomes: list[str] = OMEN_BINARY_MARKET_OUTCOMES,
         created_after: t.Optional[datetime] = None,
         opened_before: t.Optional[datetime] = None,
         opened_after: t.Optional[datetime] = None,
@@ -217,6 +216,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         id_in: list[str] | None = None,
         excluded_questions: set[str] | None = None,
         collateral_token_address_in: tuple[ChecksumAddress, ...] | None = None,
+        category: str | None = None,
     ) -> dict[str, t.Any]:
         where_stms: dict[str, t.Any] = {
             "isPendingArbitration": False,
@@ -282,6 +282,9 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
                 finalized_after
             )
 
+        if category:
+            where_stms["category"] = category
+
         # `excluded_question_titles` can not be an empty list, otherwise the API bugs out and returns nothing.
         excluded_question_titles = [""]
         if excluded_questions:
@@ -324,8 +327,10 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         # Additional filters, these can not be modified by the enums above.
         created_after: datetime | None = None,
         excluded_questions: set[str] | None = None,  # question titles
-        collateral_token_address_in: tuple[ChecksumAddress, ...]
-        | None = SAFE_COLLATERAL_TOKEN_MARKETS,
+        collateral_token_address_in: (
+            tuple[ChecksumAddress, ...] | None
+        ) = SAFE_COLLATERAL_TOKEN_MARKETS,
+        category: str | None = None,
     ) -> t.List[OmenMarket]:
         """
         Simplified `get_omen_binary_markets` method, which allows to fetch markets based on the filter_by and sort_by values.
@@ -363,6 +368,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             created_after=created_after,
             excluded_questions=excluded_questions,
             collateral_token_address_in=collateral_token_address_in,
+            category=category,
         )
 
     def get_omen_binary_markets(
@@ -383,9 +389,11 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         excluded_questions: set[str] | None = None,  # question titles
         sort_by_field: FieldPath | None = None,
         sort_direction: str | None = None,
-        outcomes: list[str] = [OMEN_TRUE_OUTCOME, OMEN_FALSE_OUTCOME],
-        collateral_token_address_in: tuple[ChecksumAddress, ...]
-        | None = SAFE_COLLATERAL_TOKEN_MARKETS,
+        outcomes: list[str] = OMEN_BINARY_MARKET_OUTCOMES,
+        collateral_token_address_in: (
+            tuple[ChecksumAddress, ...] | None
+        ) = SAFE_COLLATERAL_TOKEN_MARKETS,
+        category: str | None = None,
     ) -> t.List[OmenMarket]:
         """
         Complete method to fetch Omen binary markets with various filters, use `get_omen_binary_markets_simple` for simplified version that uses FilterBy and SortBy enums.
@@ -406,6 +414,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             excluded_questions=excluded_questions,
             liquidity_bigger_than=liquidity_bigger_than,
             collateral_token_address_in=collateral_token_address_in,
+            category=category,
         )
 
         # These values can not be set to `None`, but they can be omitted.

prediction_market_agent_tooling/monitor/monitor.py

@@ -211,7 +211,11 @@ def monitor_agent(agent: DeployedAgent) -> None:
         key=f"{agent.name}_x_axis_column",
     )
 
-    bets_df = pd.DataFrame(bets_info).sort_values(by=x_axis_column, ascending=False)
+    bets_df = (
+        pd.DataFrame(bets_info)
+        .sort_values(by=x_axis_column, ascending=False)
+        .reset_index(drop=True)
+    )
     bets_df["x-axis-day"] = bets_df[x_axis_column].dt.date
 
     # Metrics

prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
 
 
 def check_is_valid_probability(probability: float) -> None:
@@ -6,17 +6,12 @@ def check_is_valid_probability(probability: float) -> None:
         raise ValueError("Probability must be between 0 and 1")
 
 
-class KellyBet(BaseModel):
-    direction: bool
-    size: float
-
-
-def get_kelly_bet(
+def get_kelly_bet_simplified(
     max_bet: float,
     market_p_yes: float,
     estimated_p_yes: float,
     confidence: float,
-) -> KellyBet:
+) -> SimpleBet:
     """
     Calculate the optimal bet amount using the Kelly Criterion for a binary outcome market.
 
@@ -57,4 +52,91 @@ def get_kelly_bet(
     # Ensure bet size is non-negative does not exceed the wallet balance
     bet_size = min(kelly_fraction * max_bet, max_bet)
 
-    return KellyBet(direction=bet_direction, size=bet_size)
+    return SimpleBet(direction=bet_direction, size=bet_size)
+
+
+def get_kelly_bet_full(
+    yes_outcome_pool_size: float,
+    no_outcome_pool_size: float,
+    estimated_p_yes: float,
+    confidence: float,
+    max_bet: float,
+    fee: float = 0.0,  # proportion, 0 to 1
+) -> SimpleBet:
+    """
+    Calculate the optimal bet amount using the Kelly Criterion for a binary outcome market.
+
+    'Full' as in it accounts for how the bet changes the market odds.
+
+    Taken from https://github.com/valory-xyz/trader/blob/main/strategies/kelly_criterion/kelly_criterion.py
+
+    with derivation in PR description: https://github.com/valory-xyz/trader/pull/119
+
+    ```
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+    ```
+    """
+    check_is_valid_probability(estimated_p_yes)
+    check_is_valid_probability(confidence)
+    check_is_valid_probability(fee)
+
+    if max_bet == 0:
+        return SimpleBet(direction=True, size=0)
+
+    x = yes_outcome_pool_size
+    y = no_outcome_pool_size
+    p = estimated_p_yes
+    c = confidence
+    b = max_bet
+    f = 1 - fee
+
+    if x == y:
+        # Add a delta to prevent division by zero
+        y += 1e-10
+
+    numerator = (
+        -4 * x**2 * y
+        + b * y**2 * p * c * f
+        + 2 * b * x * y * p * c * f
+        + b * x**2 * p * c * f
+        - 2 * b * y**2 * f
+        - 2 * b * x * y * f
+        + (
+            (
+                4 * x**2 * y
+                - b * y**2 * p * c * f
+                - 2 * b * x * y * p * c * f
+                - b * x**2 * p * c * f
+                + 2 * b * y**2 * f
+                + 2 * b * x * y * f
+            )
+            ** 2
+            - (
+                4
+                * (x**2 * f - y**2 * f)
+                * (
+                    -4 * b * x * y**2 * p * c
+                    - 4 * b * x**2 * y * p * c
+                    + 4 * b * x * y**2
+                )
+            )
+        )
+        ** (1 / 2)
+    )
+    denominator = 2 * (x**2 * f - y**2 * f)
+    kelly_bet_amount = numerator / denominator
+
+    # Clip the bet size to max_bet to account for rounding errors.
+    return SimpleBet(
+        direction=kelly_bet_amount > 0, size=min(max_bet, abs(kelly_bet_amount))
+    )

prediction_market_agent_tooling/tools/betting_strategies/market_moving.py

@@ -1,29 +1,22 @@
-import typing as t
 from functools import reduce
 
 import numpy as np
 
-from prediction_market_agent_tooling.gtypes import Probability, wei_type, xDai
-from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.omen.data_models import OmenMarket
+from prediction_market_agent_tooling.gtypes import Probability, Wei, xDai
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
 from prediction_market_agent_tooling.tools.utils import check_not_none
-from prediction_market_agent_tooling.tools.web3_utils import (
-    ONE_XDAI,
-    wei_to_xdai,
-    xdai_to_wei,
-)
-
-OutcomeIndex = t.Literal[0, 1]
+from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai, xdai_to_wei
 
 
 def get_market_moving_bet(
-    market: OmenMarket,
-    target_p_yes: Probability,
+    yes_outcome_pool_size: float,
+    no_outcome_pool_size: float,
+    market_p_yes: float,
+    target_p_yes: float,
+    fee: float = 0.0,  # proportion, 0 to 1
     max_iters: int = 100,
-    check_vs_contract: bool = False,  # Disable by default, as it's slow
-    verbose: bool = False,
-) -> t.Tuple[xDai, OutcomeIndex]:
+) -> SimpleBet:
     """
     Implements a binary search to determine the bet that will move the market's
     `p_yes` to that of the target.
@@ -43,74 +36,97 @@ def get_market_moving_bet(
     new_product - fixed_product = dx * na_y
     dx = (new_product - fixed_product) / na_y
     """
-    market_agent = OmenAgentMarket.from_data_model(market)
-    amounts = market.outcomeTokenAmounts
-    prices = check_not_none(
-        market.outcomeTokenProbabilities, "No probabilities, is marked closed?"
-    )
-    if len(amounts) != 2 or len(prices) != 2:
-        raise ValueError("Only binary markets are supported.")
-
-    fixed_product = reduce(lambda x, y: x * y, amounts, 1)
-    assert np.isclose(float(sum(prices)), 1)
+    fixed_product = yes_outcome_pool_size * no_outcome_pool_size
+    bet_direction: bool = target_p_yes > market_p_yes
 
-    # For FPMMs, the probability is equal to the marginal price
-    current_p_yes = Probability(prices[0])
-    bet_outcome_index: OutcomeIndex = 0 if target_p_yes > current_p_yes else 1
-
-    min_bet_amount = 0
-    max_bet_amount = 100 * sum(amounts)  # TODO set a better upper bound
+    min_bet_amount = 0.0
+    max_bet_amount = 100 * (
+        yes_outcome_pool_size + no_outcome_pool_size
+    )  # TODO set a better upper bound
 
     # Binary search for the optimal bet amount
     for _ in range(max_iters):
-        bet_amount = (min_bet_amount + max_bet_amount) // 2
-        bet_amount_ = (
-            bet_amount
-            * (
-                xdai_to_wei(ONE_XDAI)
-                - check_not_none(market.fee, "No fee for the market.")
-            )
-            / xdai_to_wei(ONE_XDAI)
-        )
+        bet_amount = (min_bet_amount + max_bet_amount) / 2
+        amounts_diff = bet_amount * (1 - fee)
 
         # Initial new amounts are old amounts + equal new amounts for each outcome
-        amounts_diff = bet_amount_
-        new_amounts = [amounts[i] + amounts_diff for i in range(len(amounts))]
+        yes_outcome_new_pool_size = yes_outcome_pool_size + amounts_diff
+        no_outcome_new_pool_size = no_outcome_pool_size + amounts_diff
+        new_amounts = {
+            True: yes_outcome_new_pool_size,
+            False: no_outcome_new_pool_size,
+        }
 
         # Now give away tokens at `bet_outcome_index` to restore invariant
-        new_product = reduce(lambda x, y: x * y, new_amounts, 1.0)
-        dx = (new_product - fixed_product) / new_amounts[1 - bet_outcome_index]
-
-        # Sanity check the number of tokens against the contract
-        if check_vs_contract:
-            expected_trade = market_agent.get_contract().calcBuyAmount(
-                investment_amount=wei_type(bet_amount),
-                outcome_index=bet_outcome_index,
-            )
-            assert np.isclose(float(expected_trade), dx)
-
-        new_amounts[bet_outcome_index] -= dx
+        new_product = yes_outcome_new_pool_size * no_outcome_new_pool_size
+        dx = (new_product - fixed_product) / new_amounts[not bet_direction]
+        new_amounts[bet_direction] -= dx
+
         # Check that the invariant is restored
         assert np.isclose(
-            reduce(lambda x, y: x * y, new_amounts, 1.0), float(fixed_product)
+            reduce(lambda x, y: x * y, list(new_amounts.values()), 1.0),
+            float(fixed_product),
         )
-        new_p_yes = Probability(new_amounts[1] / sum(new_amounts))
-        bet_amount_wei = wei_type(bet_amount)
-        if verbose:
-            outcome = market_agent.get_outcome_str(bet_outcome_index)
-            logger.debug(
-                f"Target p_yes: {target_p_yes:.2f}, bet: {wei_to_xdai(bet_amount_wei):.2f}{market_agent.currency} for {outcome}, new p_yes: {new_p_yes:.2f}"
-            )
-        if abs(target_p_yes - new_p_yes) < 0.01:
+
+        new_p_yes = Probability(new_amounts[False] / sum(list(new_amounts.values())))
+        if abs(target_p_yes - new_p_yes) < 1e-6:
             break
         elif new_p_yes > target_p_yes:
-            if bet_outcome_index == 0:
+            if bet_direction:
                 max_bet_amount = bet_amount
             else:
                 min_bet_amount = bet_amount
         else:
-            if bet_outcome_index == 0:
+            if bet_direction:
                 min_bet_amount = bet_amount
             else:
                 max_bet_amount = bet_amount
-    return wei_to_xdai(bet_amount_wei), bet_outcome_index
+
+    return SimpleBet(direction=bet_direction, size=bet_amount)
+
+
+def _sanity_check_omen_market_moving_bet(
+    bet_to_check: SimpleBet, market: OmenAgentMarket, target_p_yes: float
+) -> None:
+    """
+    A util function for checking that a bet moves the market to the target_p_yes
+    by calling the market's calcBuyAmount method from the smart contract, and
+    using the adjusted outcome pool sizes to calculate the new p_yes.
+    """
+    buy_amount_ = market.get_contract().calcBuyAmount(
+        investment_amount=xdai_to_wei(xDai(bet_to_check.size)),
+        outcome_index=market.get_outcome_index(
+            market.get_outcome_str_from_bool(bet_to_check.direction)
+        ),
+    )
+    buy_amount = float(wei_to_xdai(Wei(buy_amount_)))
+
+    outcome_token_pool = check_not_none(market.outcome_token_pool)
+    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)]
+    market_const = yes_outcome_pool_size * no_outcome_pool_size
+
+    # When you buy 'yes' tokens, you add your bet size to the both pools, then
+    # subtract `buy_amount` from the 'yes' pool. And vice versa for 'no' tokens.
+    new_yes_outcome_pool_size = (
+        yes_outcome_pool_size
+        + (bet_to_check.size * (1 - market.fee))
+        - float(bet_to_check.direction) * buy_amount
+    )
+    new_no_outcome_pool_size = (
+        no_outcome_pool_size
+        + (bet_to_check.size * (1 - market.fee))
+        - float(not bet_to_check.direction) * buy_amount
+    )
+    new_market_const = new_yes_outcome_pool_size * new_no_outcome_pool_size
+    # Check the invariant is restored
+    assert np.isclose(new_market_const, market_const)
+
+    # Now check that the market's new p_yes is equal to the target_p_yes
+    new_p_yes = new_no_outcome_pool_size / (
+        new_yes_outcome_pool_size + new_no_outcome_pool_size
+    )
+    if not np.isclose(new_p_yes, target_p_yes, atol=0.01):
+        raise ValueError(
+            f"Bet does not move market to target_p_yes {target_p_yes=}. Got {new_p_yes=}"
+        )

prediction_market_agent_tooling/tools/betting_strategies/utils.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class SimpleBet(BaseModel):
+    direction: bool
+    size: float

prediction_market_agent_tooling/tools/is_predictable.py

@@ -1,3 +1,4 @@
+import tenacity
 from loguru import logger
 
 from prediction_market_agent_tooling.config import APIKeys
@@ -76,6 +77,7 @@ Finally, write your final decision, write `decision: ` followed by either "yes i
 
 
 @persistent_inmemory_cache
+@tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
 @observe()
 def is_predictable_binary(
     question: str,
@@ -111,6 +113,7 @@ def is_predictable_binary(
 
 
 @persistent_inmemory_cache
+@tenacity.retry(stop=tenacity.stop_after_attempt(3), wait=tenacity.wait_fixed(1))
 @observe()
 def is_predictable_without_description(
     question: str,

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -0,0 +1,159 @@
+import typing as t
+from datetime import datetime
+
+import numpy as np
+from langfuse import Langfuse
+from langfuse.client import TraceWithDetails
+from pydantic import BaseModel
+
+from prediction_market_agent_tooling.markets.data_models import (
+    ProbabilisticAnswer,
+    ResolvedBet,
+    Trade,
+    TradeType,
+)
+from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.tools.utils import add_utc_timezone_validator
+
+
+class ProcessMarketTrace(BaseModel):
+    timestamp: datetime
+    market: OmenAgentMarket
+    answer: ProbabilisticAnswer
+    trades: list[Trade]
+
+    @property
+    def buy_trade(self) -> Trade:
+        buy_trades = [t for t in self.trades if t.trade_type == TradeType.BUY]
+        if len(buy_trades) == 1:
+            return buy_trades[0]
+        raise ValueError("No buy trade found")
+
+    @staticmethod
+    def from_langfuse_trace(
+        trace: TraceWithDetails,
+    ) -> t.Optional["ProcessMarketTrace"]:
+        market = trace_to_omen_agent_market(trace)
+        answer = trace_to_answer(trace)
+        trades = trace_to_trades(trace)
+
+        if not market or not answer or not trades:
+            return None
+
+        return ProcessMarketTrace(
+            market=market,
+            answer=answer,
+            trades=trades,
+            timestamp=trace.timestamp,
+        )
+
+
+class ResolvedBetWithTrace(BaseModel):
+    bet: ResolvedBet
+    trace: ProcessMarketTrace
+
+
+def get_traces_for_agent(
+    agent_name: str,
+    trace_name: str,
+    from_timestamp: datetime,
+    has_output: bool,
+    client: Langfuse,
+) -> list[TraceWithDetails]:
+    """
+    Fetch agent traces using pagination
+    """
+    page = 1  # index starts from 1
+    all_agent_traces = []
+    while True:
+        traces = client.fetch_traces(
+            name=trace_name,
+            limit=100,
+            page=page,
+            from_timestamp=from_timestamp,
+        )
+        if not traces.data:
+            break
+        page += 1
+
+        agent_traces = [
+            t
+            for t in traces.data
+            if t.session_id is not None and agent_name in t.session_id
+        ]
+        if has_output:
+            agent_traces = [t for t in agent_traces if t.output is not None]
+        all_agent_traces.extend(agent_traces)
+    return all_agent_traces
+
+
+def trace_to_omen_agent_market(trace: TraceWithDetails) -> OmenAgentMarket | None:
+    if not trace.input:
+        return None
+    if not trace.input["args"]:
+        return None
+    assert len(trace.input["args"]) == 2 and trace.input["args"][0] == "omen"
+    try:
+        # If the market model is invalid (e.g. outdated), it will raise an exception
+        market = OmenAgentMarket.model_validate(trace.input["args"][1])
+        return market
+    except Exception:
+        return None
+
+
+def trace_to_answer(trace: TraceWithDetails) -> ProbabilisticAnswer:
+    assert trace.output is not None, "Trace output is None"
+    assert trace.output["answer"] is not None, "Trace output result is None"
+    return ProbabilisticAnswer.model_validate(trace.output["answer"])
+
+
+def trace_to_trades(trace: TraceWithDetails) -> list[Trade]:
+    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"]]
+
+
+def get_closest_datetime_from_list(
+    ref_datetime: datetime, datetimes: list[datetime]
+) -> int:
+    """Get the index of the closest datetime to the reference datetime"""
+    if len(datetimes) == 1:
+        return 0
+
+    closest_datetime = min(datetimes, key=lambda dt: abs(dt - ref_datetime))
+    return datetimes.index(closest_datetime)
+
+
+def get_trace_for_bet(
+    bet: ResolvedBet, traces: list[ProcessMarketTrace]
+) -> ProcessMarketTrace | None:
+    # Filter for traces with the same market id
+    traces = [t for t in traces if t.market.id == bet.market_id]
+
+    # Filter for traces with the same bet outcome and amount
+    traces_for_bet: list[ProcessMarketTrace] = []
+    for t in traces:
+        # Cannot use exact comparison due to gas fees
+        if t.buy_trade.outcome == bet.outcome and np.isclose(
+            t.buy_trade.amount.amount, bet.amount.amount
+        ):
+            traces_for_bet.append(t)
+
+    if not traces_for_bet:
+        return None
+    elif len(traces_for_bet) == 1:
+        return traces_for_bet[0]
+    else:
+        # In-case there are multiple traces for the same market, get the closest
+        # trace to the bet
+        closest_trace_index = get_closest_datetime_from_list(
+            add_utc_timezone_validator(bet.created_time),
+            [t.timestamp for t in traces_for_bet],
+        )
+        # Sanity check - the trace should be after the bet
+        if traces_for_bet[closest_trace_index].timestamp < add_utc_timezone_validator(
+            bet.created_time
+        ):
+            return None
+
+        return traces_for_bet[closest_trace_index]

{prediction_market_agent_tooling-0.48.13.dist-info → prediction_market_agent_tooling-0.48.15.dist-info}/METADATA

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

{prediction_market_agent_tooling-0.48.13.dist-info → prediction_market_agent_tooling-0.48.15.dist-info}/RECORD

@@ -15,14 +15,18 @@ 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=vLAfzWXzgIdNft07gqHsGDOWQHb8jTM9jqKECAi44j0,18700
+prediction_market_agent_tooling/deploy/agent.py,sha256=xT0L1BLU89t7lfBcbbqojcH_4H7ElnXKMQB2wjFxwos,19112
 prediction_market_agent_tooling/deploy/agent_example.py,sha256=dIIdZashExWk9tOdyDjw87AuUcGyM7jYxNChYrVK2dM,1001
-prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=TX5xRaUz7JWQs92dPp8Y_cdRiJH8I9yvtaSMmNkty10,6905
+prediction_market_agent_tooling/deploy/betting_strategy.py,sha256=edatJ7temvl9TBTy05JjtFCAlaoVXCfLOQlYWJ61wvw,7636
 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
 prediction_market_agent_tooling/deploy/gcp/utils.py,sha256=oyW0jgrUT2Tr49c7GlpcMsYNQjoCSOcWis3q-MmVAhU,6089
-prediction_market_agent_tooling/gtypes.py,sha256=ezM2iAycTRJ0uHKK03s0z76a8YFSF438kjOwT_BAqz4,2474
+prediction_market_agent_tooling/gtypes.py,sha256=O77co9-GWmHJo_NyBzRVkli5L1xqweI28JmsyaAHUHs,2474
+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=wlBhh-D8pUegBCTpzTfla6crGlNMSqqNX7yDqMcRLYI,1326
+prediction_market_agent_tooling/jobs/omen/omen_jobs.py,sha256=EAzo63vhSt1P7ddoDubdmvgzFf-ieQRTDCRLzYkH3js,3922
 prediction_market_agent_tooling/loggers.py,sha256=JiBTgvb34O9dKHYKZyQ0UzojPUy6KSFQSTfbBIXopSY,3721
 prediction_market_agent_tooling/markets/agent_market.py,sha256=nVJO1MY7_l-YP1Q7-mGLtRgIHK8M-yt3Ht1yyQPwImM,10176
 prediction_market_agent_tooling/markets/categorize.py,sha256=jsoHWvZk9pU6n17oWSCcCxNNYVwlb_NXsZxKRI7vmsk,1301
@@ -37,11 +41,11 @@ prediction_market_agent_tooling/markets/metaculus/api.py,sha256=gvPQVAM5NlCyWzEM
 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/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prediction_market_agent_tooling/markets/omen/data_models.py,sha256=vCDr8FX3FA5LIQydormq8q1aU4GxMh2tQ8i59v_X134,16887
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=BuDfmZBegHqqJCErFDstzbqzVDLVuFpoSbyYD4ZteSI,42972
+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/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=EwknHxU_EkK8H5-6fWW5IN5k6OAW5il4T2FhXrSKEJc,29984
+prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=W3JIq3NDGoJuHZlPtv2Gv_EmCtYVwsgZwClSY-RloZw,30219
 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
@@ -51,15 +55,16 @@ prediction_market_agent_tooling/monitor/markets/manifold.py,sha256=GdYpgRX1GahDi
 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/monitor.py,sha256=snMSPmoHFV7QchqsFBaNkOEQhHJshF1qmIGPuID1giQ,14579
+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
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/tools/balances.py,sha256=nR8_dSfbm3yTOOmMAwhGlurftEiNo1w1WIVzbskjdmM,837
-prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=IoLx8fIOqjC9d2gSWIc5Y-3wlukib6cuJaJzguHqNbU,1835
-prediction_market_agent_tooling/tools/betting_strategies/market_moving.py,sha256=wtrHVQRuA0uDx06z0OxQLYbswuOpHQ1UyCWwLCrD_oM,4400
+prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=a_0VmjfQIVU2rrQjAcnWRl_WSYTqeq-7Wj35zUgpokY,4464
+prediction_market_agent_tooling/tools/betting_strategies/market_moving.py,sha256=pCS0ISf6SgdhNx_t-h8_aHsLffnQ7kaLXVPPM7rGKJY,5163
 prediction_market_agent_tooling/tools/betting_strategies/minimum_bet_to_win.py,sha256=-FUSuQQgjcWSSnoFxnlAyTeilY6raJABJVM2QKkFqAY,438
 prediction_market_agent_tooling/tools/betting_strategies/stretch_bet_between.py,sha256=THMXwFlskvzbjnX_OiYtDSzI8XVFyULWfP2525_9UGc,429
+prediction_market_agent_tooling/tools/betting_strategies/utils.py,sha256=kpIb-ci67Vc1Yqqaa-_S4OUkbhWSIYog4_Iwp69HU_k,97
 prediction_market_agent_tooling/tools/cache.py,sha256=tGHHd9HCiE_hCCtPtloHZQdDfBuiow9YsqJNYi2Tx_0,499
 prediction_market_agent_tooling/tools/contract.py,sha256=0XcT94HSiFMjca3f0WtoxzCGeCcj3Gcw-o0NGi6Fb3g,19627
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
@@ -68,8 +73,9 @@ prediction_market_agent_tooling/tools/google.py,sha256=SfVDxb3oEOUK8mpd0l3mTX9yb
 prediction_market_agent_tooling/tools/hexbytes_custom.py,sha256=Bp94qgPjvjWf1Vb4lNzGFDXRdThw1rJ91vL6r2PWq5E,2096
 prediction_market_agent_tooling/tools/image_gen/image_gen.py,sha256=HzRwBx62hOXBOmrtpkXaP9Qq1Ku03uUGdREocyjLQ_k,1266
 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=GqBgp4aHbY97PdprKfCHV-lJy2bbGIrd9yCtkqg6gEc,6558
+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=EljGXIal3xApSzi5oaNJl4pRm66nayBWEpXR68SuVy0,4951
 prediction_market_agent_tooling/tools/parallelism.py,sha256=Rz8QdVUWX8KCbr8UZfaC_b1GBWIb3bXwITUumuvBJ60,1633
 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
@@ -78,8 +84,8 @@ prediction_market_agent_tooling/tools/tavily_storage/tavily_models.py,sha256=Uq2
 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/web3_utils.py,sha256=IZDxHhUJH5RsaRkK9DW6z1RYdk2cz5RqLMZG3T6Gv1U,11602
-prediction_market_agent_tooling-0.48.13.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.48.13.dist-info/METADATA,sha256=hzpD4sc9MsTT8zyAaLg8feXkawAQ25AnDorJfCuQBKI,7811
-prediction_market_agent_tooling-0.48.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-prediction_market_agent_tooling-0.48.13.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.48.13.dist-info/RECORD,,
+prediction_market_agent_tooling-0.48.15.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.48.15.dist-info/METADATA,sha256=vp4AH8yoRuOMnzAizjbHTWMTVxKWnvRLNrJxLt-Utm0,7811
+prediction_market_agent_tooling-0.48.15.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+prediction_market_agent_tooling-0.48.15.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.48.15.dist-info/RECORD,,