prediction-market-agent-tooling 0.48.10__tar.gz → 0.48.12__tar.gz

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/PKG-INFO

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

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/prediction_market_agent_tooling/deploy/agent.py

@@ -15,6 +15,7 @@ from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
     BettingStrategy,
     MaxAccuracyBettingStrategy,
+    TradeType,
 )
 from prediction_market_agent_tooling.deploy.constants import (
     MARKET_TYPE_KEY,
@@ -37,10 +38,9 @@ from prediction_market_agent_tooling.markets.agent_market import (
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
-    BetAmount,
+    Position,
     ProbabilisticAnswer,
-    TokenAmount,
-    TokenAmountAndDirection,
+    Trade,
 )
 from prediction_market_agent_tooling.markets.markets import (
     MarketType,
@@ -110,7 +110,7 @@ class OutOfFundsError(ValueError):
 
 class ProcessedMarket(BaseModel):
     answer: ProbabilisticAnswer
-    amount: BetAmount
+    trades: list[Trade]
 
 
 class AnsweredEnum(str, Enum):
@@ -283,6 +283,7 @@ class DeployableTraderAgent(DeployableAgent):
     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,
@@ -298,8 +299,8 @@ class DeployableTraderAgent(DeployableAgent):
         self.have_bet_on_market_since = observe()(self.have_bet_on_market_since)  # type: ignore[method-assign]
         self.verify_market = observe()(self.verify_market)  # type: ignore[method-assign]
         self.answer_binary_market = observe()(self.answer_binary_market)  # type: ignore[method-assign]
-        self.calculate_bet_amount_and_direction = observe()(self.calculate_bet_amount_and_direction)  # type: ignore[method-assign]
         self.process_market = observe()(self.process_market)  # type: ignore[method-assign]
+        self.build_trades = observe()(self.build_trades)  # type: ignore[method-assign]
 
     def update_langfuse_trace_by_market(
         self, market_type: MarketType, market: AgentMarket
@@ -314,18 +315,6 @@ class DeployableTraderAgent(DeployableAgent):
             },
         )
 
-    def calculate_bet_amount_and_direction(
-        self, answer: ProbabilisticAnswer, market: AgentMarket
-    ) -> TokenAmountAndDirection:
-        amount_and_direction = self.strategy.calculate_bet_amount_and_direction(
-            answer, market
-        )
-        if amount_and_direction.currency != market.currency:
-            raise ValueError(
-                f"Currency mismatch. Strategy yields {amount_and_direction.currency}, market has currency {market.currency}"
-            )
-        return amount_and_direction
-
     def update_langfuse_trace_by_processed_market(
         self, market_type: MarketType, processed_market: ProcessedMarket | None
     ) -> None:
@@ -416,13 +405,26 @@ class DeployableTraderAgent(DeployableAgent):
         )
         return available_markets
 
+    def build_trades(
+        self,
+        market: AgentMarket,
+        answer: ProbabilisticAnswer,
+        existing_position: Position | None,
+    ) -> list[Trade]:
+        trades = self.strategy.calculate_trades(existing_position, answer, market)
+        BettingStrategy.assert_trades_currency_match_markets(market, trades)
+        return trades
+
     def before_process_market(
         self, market_type: MarketType, market: AgentMarket
     ) -> None:
         self.update_langfuse_trace_by_market(market_type, market)
 
     def process_market(
-        self, market_type: MarketType, market: AgentMarket, verify_market: bool = True
+        self,
+        market_type: MarketType,
+        market: AgentMarket,
+        verify_market: bool = True,
     ) -> ProcessedMarket | None:
         self.before_process_market(market_type, market)
 
@@ -438,26 +440,26 @@ class DeployableTraderAgent(DeployableAgent):
             self.update_langfuse_trace_by_processed_market(market_type, None)
             return None
 
-        amount_and_direction = self.calculate_bet_amount_and_direction(answer, market)
+        existing_position = market.get_position(user_id=APIKeys().bet_from_address)
+        trades = self.build_trades(
+            market=market, answer=answer, existing_position=existing_position
+        )
 
         if self.place_bet:
-            logger.info(
-                f"Placing bet on {market} with direction {amount_and_direction.direction} and amount {amount_and_direction.amount}"
-            )
-            market.place_bet(
-                amount=TokenAmount(
-                    amount=amount_and_direction.amount,
-                    currency=amount_and_direction.currency,
-                ),
-                outcome=amount_and_direction.direction,
-            )
+            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)
+                    case TradeType.SELL:
+                        market.sell_tokens(outcome=trade.outcome, amount=trade.amount)
+                    case _:
+                        raise ValueError(f"Unexpected trade type {trade.trade_type}.")
 
         self.after_process_market(market_type, market)
 
-        processed_market = ProcessedMarket(
-            answer=answer,
-            amount=amount_and_direction,
-        )
+        processed_market = ProcessedMarket(answer=answer, trades=trades)
         self.update_langfuse_trace_by_processed_market(market_type, processed_market)
 
         return processed_market

prediction_market_agent_tooling-0.48.12/prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -0,0 +1,187 @@
+from abc import ABC, abstractmethod
+
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.markets.data_models import (
+    Currency,
+    Position,
+    ProbabilisticAnswer,
+    TokenAmount,
+    Trade,
+    TradeType,
+)
+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,
+)
+
+
+class BettingStrategy(ABC):
+    @abstractmethod
+    def calculate_trades(
+        self,
+        existing_position: Position | None,
+        answer: ProbabilisticAnswer,
+        market: AgentMarket,
+    ) -> list[Trade]:
+        pass
+
+    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]
+    ) -> None:
+        currencies_match = all([t.amount.currency == market.currency for t in trades])
+        if not currencies_match:
+            raise ValueError(
+                "Cannot handle trades with currencies that deviate from market's currency"
+            )
+
+    def _build_rebalance_trades_from_positions(
+        self,
+        existing_position: Position | None,
+        target_position: Position,
+        market: AgentMarket,
+    ) -> list[Trade]:
+        """
+        This helper method builds trades by rebalancing token allocations to each outcome.
+        For example, if we have an existing position with 10 tokens in outcome 0 and 5 in outcome 1,
+        and our target position is 20 tokens in outcome 0 and 0 in outcome 1, we would return these trades:
+        trades = [
+            Trade(outcome=0, amount=10, trade_type=TradeType.BUY),
+            Trade(outcome=1, amount=5, trade_type=TradeType.SELL)
+        ]
+        Note that we order the trades to first buy then sell, in order to minimally tilt the odds so that
+        sell price is higher.
+        """
+        trades = []
+        for outcome in [
+            market.get_outcome_str_from_bool(True),
+            market.get_outcome_str_from_bool(False),
+        ]:
+            outcome_bool = get_boolean_outcome(outcome)
+            prev_amount: TokenAmount = (
+                existing_position.amounts[outcome]
+                if existing_position and outcome in existing_position.amounts
+                else self.build_zero_token_amount(currency=market.currency)
+            )
+            new_amount: TokenAmount = target_position.amounts.get(
+                outcome, self.build_zero_token_amount(currency=market.currency)
+            )
+
+            if prev_amount.currency != new_amount.currency:
+                raise ValueError("Cannot handle positions with different currencies")
+            diff_amount = prev_amount.amount - new_amount.amount
+            if diff_amount == 0:
+                continue
+            trade_type = TradeType.SELL if diff_amount < 0 else TradeType.BUY
+            trade = Trade(
+                amount=TokenAmount(amount=abs(diff_amount), currency=market.currency),
+                outcome=outcome_bool,
+                trade_type=trade_type,
+            )
+
+            trades.append(trade)
+
+        # Sort inplace with SELL last
+        trades.sort(key=lambda t: t.trade_type == TradeType.SELL)
+        BettingStrategy.assert_trades_currency_match_markets(market, trades)
+        return trades
+
+
+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):
+        self.bet_amount = bet_amount
+
+    def calculate_trades(
+        self,
+        existing_position: Position | None,
+        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,
+                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
+
+    @staticmethod
+    def calculate_direction(market_p_yes: float, estimate_p_yes: float) -> bool:
+        return estimate_p_yes >= 0.5
+
+
+class MaxExpectedValueBettingStrategy(MaxAccuracyBettingStrategy):
+    @staticmethod
+    def calculate_direction(market_p_yes: float, estimate_p_yes: float) -> bool:
+        # If estimate_p_yes >= market.current_p_yes, then bet TRUE, else bet FALSE.
+        # This is equivalent to saying EXPECTED_VALUE = (estimate_p_yes * num_tokens_obtained_by_betting_yes) -
+        # ((1 - estimate_p_yes) * num_tokens_obtained_by_betting_no) >= 0
+        return estimate_p_yes >= market_p_yes
+
+
+class KellyBettingStrategy(BettingStrategy):
+    def __init__(self, max_bet_amount: float = 10):
+        self.max_bet_amount = max_bet_amount
+
+    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
+        )
+        return self.max_bet_amount + existing_position_total_amount
+
+    def calculate_trades(
+        self,
+        existing_position: Position | None,
+        answer: ProbabilisticAnswer,
+        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,
+        )
+
+        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

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/prediction_market_agent_tooling/markets/agent_market.py

@@ -4,9 +4,10 @@ from enum import Enum
 
 from eth_typing import ChecksumAddress
 from pydantic import BaseModel, field_validator
+from pydantic_core.core_schema import FieldValidationInfo
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import Probability
+from prediction_market_agent_tooling.gtypes import OutcomeStr, Probability
 from prediction_market_agent_tooling.markets.data_models import (
     Bet,
     BetAmount,
@@ -49,6 +50,9 @@ class AgentMarket(BaseModel):
     question: str
     description: str | None
     outcomes: list[str]
+    outcome_token_pool: dict[
+        str, float
+    ] | None  # Should be in currency of `currency` above.
     resolution: Resolution | None
     created_time: datetime | None
     close_time: datetime | None
@@ -63,6 +67,22 @@ class AgentMarket(BaseModel):
         add_utc_timezone_validator
     )
 
+    @field_validator("outcome_token_pool")
+    def validate_outcome_token_pool(
+        cls,
+        outcome_token_pool: dict[str, float] | None,
+        info: FieldValidationInfo,
+    ) -> dict[str, float] | None:
+        outcomes: list[str] = check_not_none(info.data.get("outcomes"))
+        if outcome_token_pool is not None:
+            outcome_keys = set(outcome_token_pool.keys())
+            expected_keys = set(outcomes)
+            if outcome_keys != expected_keys:
+                raise ValueError(
+                    f"Keys of outcome_token_pool ({outcome_keys}) do not match outcomes ({expected_keys})."
+                )
+        return outcome_token_pool
+
     @property
     def current_p_no(self) -> Probability:
         return Probability(1 - self.current_p_yes)
@@ -133,10 +153,19 @@ class AgentMarket(BaseModel):
     def get_bet_amount(self, amount: float) -> BetAmount:
         return BetAmount(amount=amount, currency=self.currency)
 
+    @classmethod
+    def get_liquidatable_amount(cls) -> BetAmount:
+        tiny_amount = cls.get_tiny_bet_amount()
+        tiny_amount.amount /= 10
+        return tiny_amount
+
     @classmethod
     def get_tiny_bet_amount(cls) -> BetAmount:
         raise NotImplementedError("Subclasses must implement this method")
 
+    def liquidate_existing_positions(self, outcome: bool) -> None:
+        raise NotImplementedError("Subclasses must implement this method")
+
     def place_bet(self, outcome: bool, amount: BetAmount) -> None:
         raise NotImplementedError("Subclasses must implement this method")
 
@@ -190,6 +219,9 @@ class AgentMarket(BaseModel):
     def has_unsuccessful_resolution(self) -> bool:
         return self.resolution in [Resolution.CANCEL, Resolution.MKT]
 
+    def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
+        raise NotImplementedError("Subclasses must implement this method")
+
     def get_outcome_str(self, outcome_index: int) -> str:
         try:
             return self.outcomes[outcome_index]
@@ -207,6 +239,9 @@ class AgentMarket(BaseModel):
     def get_token_balance(self, user_id: str, outcome: str) -> TokenAmount:
         raise NotImplementedError("Subclasses must implement this method")
 
+    def get_position(self, user_id: str) -> Position | None:
+        raise NotImplementedError("Subclasses must implement this method")
+
     @classmethod
     def get_positions(
         cls, user_id: str, liquid_only: bool = False, larger_than: float = 0
@@ -236,3 +271,12 @@ class AgentMarket(BaseModel):
     @classmethod
     def get_user_url(cls, keys: APIKeys) -> str:
         raise NotImplementedError("Subclasses must implement this method")
+
+    def has_token_pool(self) -> bool:
+        return self.outcome_token_pool is not None
+
+    def get_pool_tokens(self, outcome: str) -> float:
+        if not self.outcome_token_pool:
+            raise ValueError("Outcome token pool is not available.")
+
+        return self.outcome_token_pool[outcome]

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/prediction_market_agent_tooling/markets/data_models.py

@@ -115,3 +115,14 @@ class Position(BaseModel):
             for outcome, amount in self.amounts.items()
         )
         return f"Position for market id {self.market_id}: {amounts_str}"
+
+
+class TradeType(str, Enum):
+    SELL = "sell"
+    BUY = "buy"
+
+
+class Trade(BaseModel):
+    trade_type: TradeType
+    outcome: bool
+    amount: TokenAmount

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/prediction_market_agent_tooling/markets/manifold/data_models.py

@@ -19,6 +19,12 @@ class ManifoldPool(BaseModel):
     NO: float
     YES: float
 
+    def size_for_outcome(self, outcome: str) -> float:
+        if hasattr(self, outcome):
+            return float(getattr(self, outcome))
+        else:
+            should_not_happen(f"Unexpected outcome string, '{outcome}'.")
+
 
 class ManifoldAnswersMode(str, Enum):
     ANYONE = "ANYONE"

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -72,6 +72,9 @@ class ManifoldAgentMarket(AgentMarket):
             current_p_yes=model.probability,
             url=model.url,
             volume=model.volume,
+            outcome_token_pool={
+                o: model.pool.size_for_outcome(o) for o in model.outcomes
+            },
         )
 
     @staticmethod

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/prediction_market_agent_tooling/markets/metaculus/metaculus.py

@@ -43,6 +43,7 @@ class MetaculusAgentMarket(AgentMarket):
             volume=None,
             have_predicted=model.my_predictions is not None
             and len(model.my_predictions.predictions) > 0,
+            outcome_token_pool=None,
         )
 
     @staticmethod

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/prediction_market_agent_tooling/markets/omen/data_models.py

@@ -44,6 +44,10 @@ def get_boolean_outcome(outcome_str: str) -> bool:
     raise ValueError(f"Outcome `{outcome_str}` is not a valid boolean outcome.")
 
 
+def get_bet_outcome(binary_outcome: bool) -> str:
+    return OMEN_TRUE_OUTCOME if binary_outcome else OMEN_FALSE_OUTCOME
+
+
 class Condition(BaseModel):
     id: HexBytes
     outcomeSlotCount: int

{prediction_market_agent_tooling-0.48.10 → prediction_market_agent_tooling-0.48.12}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -40,6 +40,8 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
     OmenBet,
     OmenMarket,
     OmenUserPosition,
+    get_bet_outcome,
+    get_boolean_outcome,
 )
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OMEN_DEFAULT_MARKET_FEE,
@@ -75,6 +77,7 @@ from prediction_market_agent_tooling.tools.web3_utils import (
 )
 
 OMEN_DEFAULT_REALITIO_BOND_VALUE = xdai_type(0.01)
+OMEN_TINY_BET_AMOUNT = xdai_type(0.00001)
 
 
 class OmenAgentMarket(AgentMarket):
@@ -147,7 +150,41 @@ class OmenAgentMarket(AgentMarket):
 
     @classmethod
     def get_tiny_bet_amount(cls) -> BetAmount:
-        return BetAmount(amount=0.00001, currency=cls.currency)
+        return BetAmount(amount=OMEN_TINY_BET_AMOUNT, currency=cls.currency)
+
+    def liquidate_existing_positions(
+        self,
+        bet_outcome: bool,
+        web3: Web3 | None = None,
+        api_keys: APIKeys | None = None,
+        larger_than: float | None = None,
+    ) -> None:
+        """
+        Liquidates all previously existing positions.
+        Returns the amount in collateral obtained by selling the positions.
+        """
+        api_keys = api_keys if api_keys is not None else APIKeys()
+        better_address = api_keys.bet_from_address
+        larger_than = (
+            larger_than
+            if larger_than is not None
+            else self.get_liquidatable_amount().amount
+        )
+        prev_positions_for_market = self.get_positions(
+            user_id=better_address, liquid_only=True, larger_than=larger_than
+        )
+
+        for prev_position in prev_positions_for_market:
+            for position_outcome, token_amount in prev_position.amounts.items():
+                position_outcome_bool = get_boolean_outcome(position_outcome)
+                if position_outcome_bool != bet_outcome:
+                    # We keep it as collateral since we want to place a bet immediately after this function.
+                    self.sell_tokens(
+                        outcome=position_outcome_bool,
+                        amount=token_amount,
+                        auto_withdraw=False,
+                        web3=web3,
+                    )
 
     def place_bet(
         self,
@@ -310,6 +347,10 @@ class OmenAgentMarket(AgentMarket):
             volume=wei_to_xdai(model.collateralVolume),
             close_time=model.close_time,
             fee=float(wei_to_xdai(model.fee)) if model.fee is not None else 0.0,
+            outcome_token_pool={
+                model.outcomes[i]: wei_to_xdai(Wei(model.outcomeTokenAmounts[i]))
+                for i in range(len(model.outcomes))
+            },
         )
 
     @staticmethod
@@ -381,6 +422,11 @@ class OmenAgentMarket(AgentMarket):
             cls.get_outcome_str(cls.index_set_to_outcome_index(index_set))
         )
 
+    def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
+        return (
+            OutcomeStr(OMEN_TRUE_OUTCOME) if outcome else OutcomeStr(OMEN_FALSE_OUTCOME)
+        )
+
     def get_token_balance(
         self, user_id: str, outcome: str, web3: Web3 | None = None
     ) -> TokenAmount:
@@ -393,6 +439,18 @@ class OmenAgentMarket(AgentMarket):
             currency=self.currency,
         )
 
+    def get_position(self, user_id: str) -> Position | None:
+        liquidatable_amount = self.get_liquidatable_amount()
+        existing_positions = self.get_positions(
+            user_id=user_id,
+            liquid_only=True,
+            larger_than=liquidatable_amount.amount,
+        )
+        existing_position = next(
+            iter([i for i in existing_positions if i.market_id == self.id]), None
+        )
+        return existing_position
+
     @classmethod
     def get_positions(
         cls,
@@ -553,12 +611,15 @@ def omen_buy_outcome_tx(
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
     collateral_token_contract = market_contract.get_collateral_token_contract()
 
+    # In case of ERC4626, obtained (for example) sDai out of xDai could be lower than the `amount_wei`, so we need to handle it.
+    amount_wei_to_buy = collateral_token_contract.get_in_shares(amount_wei, web3)
+
     # Get the index of the outcome we want to buy.
     outcome_index: int = market.get_outcome_index(outcome)
 
     # Calculate the amount of shares we will get for the given investment amount.
     expected_shares = market_contract.calcBuyAmount(
-        amount_wei, outcome_index, web3=web3
+        amount_wei_to_buy, outcome_index, web3=web3
     )
     # Allow 1% slippage.
     expected_shares = remove_fraction(expected_shares, 0.01)
@@ -566,11 +627,12 @@ def omen_buy_outcome_tx(
     collateral_token_contract.approve(
         api_keys=api_keys,
         for_address=market_contract.address,
-        amount_wei=amount_wei,
+        amount_wei=amount_wei_to_buy,
         web3=web3,
     )
 
     if auto_deposit:
+        # In auto-depositing, we need to deposit the original `amount_wei`, e.g. we can deposit 2 xDai, but receive 1.8 sDai, so for the bet we will use `amount_wei_to_buy`.
         auto_deposit_collateral_token(
             collateral_token_contract, amount_wei, api_keys, web3
         )
@@ -578,7 +640,7 @@ def omen_buy_outcome_tx(
     # Buy shares using the deposited xDai in the collateral token.
     market_contract.buy(
         api_keys=api_keys,
-        amount_wei=amount_wei,
+        amount_wei=amount_wei_to_buy,
         outcome_index=outcome_index,
         min_outcome_tokens_to_buy=expected_shares,
         web3=web3,
@@ -597,7 +659,7 @@ def binary_omen_buy_outcome_tx(
         api_keys=api_keys,
         amount=amount,
         market=market,
-        outcome=OMEN_TRUE_OUTCOME if binary_outcome else OMEN_FALSE_OUTCOME,
+        outcome=get_bet_outcome(binary_outcome),
         auto_deposit=auto_deposit,
         web3=web3,
     )
@@ -686,7 +748,7 @@ def binary_omen_sell_outcome_tx(
         api_keys=api_keys,
         amount=amount,
         market=market,
-        outcome=OMEN_TRUE_OUTCOME if binary_outcome else OMEN_FALSE_OUTCOME,
+        outcome=get_bet_outcome(binary_outcome),
         auto_withdraw=auto_withdraw,
         web3=web3,
     )
@@ -769,6 +831,7 @@ def omen_create_market_tx(
             web3=web3,
         )
 
+    # In case of ERC4626, obtained (for example) sDai out of xDai could be lower than the `amount_wei`, so we need to handle it.
     initial_funds_in_shares = collateral_token_contract.get_in_shares(
         amount=initial_funds_wei, web3=web3
     )