prediction-market-agent-tooling 0.44.0__tar.gz → 0.45.0__tar.gz

{prediction_market_agent_tooling-0.44.0 → prediction_market_agent_tooling-0.45.0}/PKG-INFO

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

prediction_market_agent_tooling-0.45.0/prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -0,0 +1,67 @@
+from enum import Enum
+
+from pydantic import BaseModel
+
+
+class BetDirection(str, Enum):
+    YES = "Yes"
+    NO = "No"
+
+
+class KellyBet(BaseModel):
+    direction: BetDirection
+    size: float
+
+
+def check_is_valid_probability(probability: float) -> None:
+    if not 0 <= probability <= 1:
+        raise ValueError("Probability must be between 0 and 1")
+
+
+def get_kelly_bet(
+    max_bet: float,
+    market_p_yes: float,
+    estimated_p_yes: float,
+    confidence: float,
+) -> KellyBet:
+    """
+    Calculate the optimal bet amount using the Kelly Criterion for a binary outcome market.
+
+    From https://en.wikipedia.org/wiki/Kelly_criterion:
+
+    f* = p - q / b
+
+    where:
+    - f* is the fraction of the current bankroll to wager
+    - p is the probability of a win
+    - q = 1-p is the probability of a loss
+    - b is the proportion of the bet gained with a win
+
+    Note: this calculation does not factor in that the bet changes the market
+    odds. This means the calculation is only accurate if the bet size is small
+    compared to the market volume. See discussion here for more detail:
+    https://github.com/gnosis/prediction-market-agent-tooling/pull/330#discussion_r1698269328
+    """
+    check_is_valid_probability(market_p_yes)
+    check_is_valid_probability(estimated_p_yes)
+    check_is_valid_probability(confidence)
+
+    if estimated_p_yes > market_p_yes:
+        bet_direction = BetDirection.YES
+        market_prob = market_p_yes
+    else:
+        bet_direction = BetDirection.NO
+        market_prob = 1 - market_p_yes
+
+    # Handle the case where market_prob is 0
+    if market_prob == 0:
+        market_prob = 1e-10
+
+    edge = abs(estimated_p_yes - market_p_yes) * confidence
+    odds = (1 / market_prob) - 1
+    kelly_fraction = edge / odds
+
+    # 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)

{prediction_market_agent_tooling-0.44.0 → prediction_market_agent_tooling-0.45.0}/pyproject.toml

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

prediction_market_agent_tooling-0.44.0/prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,110 +0,0 @@
-import typing as t
-
-from prediction_market_agent_tooling.gtypes import Probability, wei_type, xDai
-from prediction_market_agent_tooling.markets.omen.data_models import OmenMarket
-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]
-
-
-def _get_kelly_criterion_bet(
-    x: int, y: int, p: float, c: float, b: int, f: float
-) -> int:
-    """
-    Implments https://en.wikipedia.org/wiki/Kelly_criterion
-
-    Taken from https://github.com/valory-xyz/trader/blob/main/strategies/kelly_criterion/kelly_criterion.py
-
-    ```
-    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.
-    ```
-
-    x: Number of tokens in the selected outcome pool
-    y: Number of tokens in the other outcome pool
-    p: Probability of winning
-    c: Confidence
-    b: Bankroll
-    f: Fee fraction
-    """
-    if b == 0:
-        return 0
-    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)
-    if denominator == 0:
-        return 0
-    kelly_bet_amount = numerator / denominator
-    return int(kelly_bet_amount)
-
-
-def get_kelly_criterion_bet(
-    market: OmenMarket,
-    estimated_p_yes: Probability,
-    max_bet: xDai,
-) -> t.Tuple[xDai, OutcomeIndex]:
-    if len(market.outcomeTokenAmounts) != 2:
-        raise ValueError("Only binary markets are supported.")
-
-    current_p_yes = check_not_none(
-        market.outcomeTokenProbabilities, "No probabilities, is marked closed?"
-    )[0]
-    outcome_index: OutcomeIndex = 0 if estimated_p_yes > current_p_yes else 1
-    estimated_p_win = estimated_p_yes if outcome_index == 0 else 1 - estimated_p_yes
-
-    kelly_bet_wei = wei_type(
-        _get_kelly_criterion_bet(
-            x=market.outcomeTokenAmounts[outcome_index],
-            y=market.outcomeTokenAmounts[1 - outcome_index],
-            p=estimated_p_win,
-            c=1,  # confidence
-            b=xdai_to_wei(max_bet),  # bankroll, or max bet, in Wei
-            f=(
-                xdai_to_wei(ONE_XDAI)
-                - check_not_none(market.fee, "No fee for the market.")
-            )
-            / xdai_to_wei(ONE_XDAI),  # fee fraction
-        )
-    )
-    return wei_to_xdai(kelly_bet_wei), outcome_index