prediction-market-agent-tooling 0.48.14__tar.gz → 0.48.16__tar.gz

{prediction_market_agent_tooling-0.48.14 → prediction_market_agent_tooling-0.48.16}/PKG-INFO

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

{prediction_market_agent_tooling-0.48.14 → prediction_market_agent_tooling-0.48.16}/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-0.48.14 → prediction_market_agent_tooling-0.48.16}/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-0.48.14 → prediction_market_agent_tooling-0.48.16}/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-0.48.16/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-0.48.16/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."""
+
+    @classmethod
+    @abstractmethod
+    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-0.48.16/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-0.48.14 → prediction_market_agent_tooling-0.48.16}/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-0.48.14 → prediction_market_agent_tooling-0.48.16}/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}"
@@ -1165,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-0.48.14 → prediction_market_agent_tooling-0.48.16}/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-0.48.14 → prediction_market_agent_tooling-0.48.16}/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-0.48.16/prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -0,0 +1,142 @@
+from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
+
+
+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_simplified(
+    max_bet: float,
+    market_p_yes: float,
+    estimated_p_yes: float,
+    confidence: float,
+) -> SimpleBet:
+    """
+    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 = True
+        market_prob = market_p_yes
+    else:
+        bet_direction = False
+        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 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))
+    )