prediction-market-agent-tooling 0.61.1.dev463__py3-none-any.whl → 0.61.1.dev482__py3-none-any.whl

prediction_market_agent_tooling/markets/seer/seer.py

@@ -4,16 +4,15 @@ from eth_typing import ChecksumAddress
 from web3 import Web3
 from web3.types import TxReceipt
 
-from prediction_market_agent_tooling.config import APIKeys, RPCConfig
+from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.gtypes import (
-    USD,
     HexAddress,
     HexBytes,
     OutcomeStr,
-    OutcomeToken,
-    OutcomeWei,
-    Token,
+    Wei,
+    wei_type,
     xDai,
+    xdai_type,
 )
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
@@ -24,9 +23,15 @@ from prediction_market_agent_tooling.markets.agent_market import (
     SortBy,
 )
 from prediction_market_agent_tooling.markets.blockchain_utils import store_trades
-from prediction_market_agent_tooling.markets.data_models import ExistingPosition
+from prediction_market_agent_tooling.markets.data_models import (
+    BetAmount,
+    Currency,
+    Position,
+    TokenAmount,
+)
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.omen.omen_contracts import sDaiContract
 from prediction_market_agent_tooling.markets.seer.data_models import (
     NewMarketEvent,
     SeerMarket,
@@ -38,6 +43,7 @@ from prediction_market_agent_tooling.markets.seer.seer_contracts import (
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
+from prediction_market_agent_tooling.tools.balances import get_balances
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
@@ -51,16 +57,14 @@ from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
     auto_deposit_collateral_token,
 )
-from prediction_market_agent_tooling.tools.tokens.usd import (
-    get_token_in_usd,
-    get_usd_in_token,
-)
+from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai, xdai_to_wei
 
 # We place a larger bet amount by default than Omen so that cow presents valid quotes.
-SEER_TINY_BET_AMOUNT = USD(0.1)
+SEER_TINY_BET_AMOUNT = xdai_type(0.1)
 
 
 class SeerAgentMarket(AgentMarket):
+    currency = Currency.sDai
     wrapped_tokens: list[ChecksumAddress]
     creator: HexAddress
     collateral_token_contract_address_checksummed: ChecksumAddress
@@ -70,16 +74,6 @@ class SeerAgentMarket(AgentMarket):
         None  # Seer markets don't have a description, so just default to None.
     )
 
-    def get_collateral_token_contract(
-        self, web3: Web3 | None = None
-    ) -> ContractERC20OnGnosisChain:
-        web3 = web3 or RPCConfig().get_web3()
-        return to_gnosis_chain_contract(
-            init_collateral_token_contract(
-                self.collateral_token_contract_address_checksummed, web3
-            )
-        )
-
     def store_prediction(
         self,
         processed_market: ProcessedMarket | None,
@@ -101,28 +95,29 @@ class SeerAgentMarket(AgentMarket):
             agent_name=agent_name,
         )
 
-    def get_token_in_usd(self, x: Token) -> USD:
-        return get_token_in_usd(x, self.collateral_token_contract_address_checksummed)
-
-    def get_usd_in_token(self, x: USD) -> Token:
-        return get_usd_in_token(x, self.collateral_token_contract_address_checksummed)
+    def _convert_bet_amount_into_wei(self, bet_amount: BetAmount) -> Wei:
+        if bet_amount.currency == self.currency:
+            return xdai_to_wei(xdai_type(bet_amount.amount))
+        raise ValueError(
+            f"Currencies don't match. Currency bet amount {bet_amount.currency} currency market: {self.currency}"
+        )
 
     def get_buy_token_amount(
-        self, bet_amount: USD | Token, direction: bool
-    ) -> OutcomeToken:
+        self, bet_amount: BetAmount, direction: bool
+    ) -> TokenAmount:
         """Returns number of outcome tokens returned for a given bet expressed in collateral units."""
 
         outcome_token = self.get_wrapped_token_for_outcome(direction)
-        bet_amount_in_tokens = self.get_in_token(bet_amount)
-        bet_amount_in_wei = bet_amount_in_tokens.as_wei
+
+        bet_amount_in_wei = self._convert_bet_amount_into_wei(bet_amount=bet_amount)
 
         quote = CowManager().get_quote(
             buy_token=outcome_token,
             sell_amount=bet_amount_in_wei,
             collateral_token=self.collateral_token_contract_address_checksummed,
         )
-        sell_amount = OutcomeWei(quote.quote.buyAmount.root).as_outcome_token
-        return sell_amount
+        sell_amount = wei_to_xdai(wei_type(quote.quote.buyAmount.root))
+        return TokenAmount(amount=sell_amount, currency=bet_amount.currency)
 
     def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
         outcome_translated = SeerOutcomeEnum.from_bool(outcome)
@@ -130,46 +125,33 @@ class SeerAgentMarket(AgentMarket):
         return OutcomeStr(self.outcomes[idx])
 
     @staticmethod
-    def get_trade_balance(api_keys: APIKeys) -> USD:
+    def get_trade_balance(api_keys: APIKeys) -> float:
         return OmenAgentMarket.get_trade_balance(api_keys=api_keys)
 
-    def get_tiny_bet_amount(self) -> Token:
-        return self.get_in_token(SEER_TINY_BET_AMOUNT)
+    @classmethod
+    def get_tiny_bet_amount(cls) -> BetAmount:
+        return BetAmount(amount=SEER_TINY_BET_AMOUNT, currency=cls.currency)
 
-    def get_position(
-        self, user_id: str, web3: Web3 | None = None
-    ) -> ExistingPosition | None:
+    def get_position(self, user_id: str, web3: Web3 | None = None) -> Position | None:
         """
         Fetches position from the user in a given market.
         We ignore the INVALID balances since we are only interested in binary outcomes.
         """
 
-        amounts_ot: dict[OutcomeStr, OutcomeToken] = {}
+        amounts = {}
 
         for outcome in [True, False]:
             wrapped_token = self.get_wrapped_token_for_outcome(outcome)
 
-            outcome_token_balance_wei = OutcomeWei.from_wei(
-                ContractERC20OnGnosisChain(address=wrapped_token).balanceOf(
-                    for_address=Web3.to_checksum_address(user_id), web3=web3
-                )
-            )
+            outcome_token_balance = ContractERC20OnGnosisChain(
+                address=wrapped_token
+            ).balanceOf(for_address=Web3.to_checksum_address(user_id), web3=web3)
             outcome_str = self.get_outcome_str_from_bool(outcome=outcome)
-            amounts_ot[outcome_str] = outcome_token_balance_wei.as_outcome_token
-
-        amounts_current = {
-            k: self.get_token_in_usd(self.get_sell_value_of_outcome_token(k, v))
-            for k, v in amounts_ot.items()
-        }
-        amounts_potential = {
-            k: self.get_token_in_usd(v.as_token) for k, v in amounts_ot.items()
-        }
-        return ExistingPosition(
-            market_id=self.id,
-            amounts_current=amounts_current,
-            amounts_potential=amounts_potential,
-            amounts_ot=amounts_ot,
-        )
+            amounts[outcome_str] = TokenAmount(
+                amount=wei_to_xdai(outcome_token_balance), currency=self.currency
+            )
+
+        return Position(market_id=self.id, amounts=amounts)
 
     @staticmethod
     def get_user_id(api_keys: APIKeys) -> str:
@@ -228,9 +210,9 @@ class SeerAgentMarket(AgentMarket):
             CowManager().get_quote(
                 collateral_token=self.collateral_token_contract_address_checksummed,
                 buy_token=outcome_token,
-                sell_amount=Token(
-                    1
-                ).as_wei,  # we take 1 as a baseline value for common trades the agents take.
+                sell_amount=xdai_to_wei(
+                    xdai_type(1)
+                ),  # we take 1 xDai as a baseline value for common trades the agents take.
             )
             return True
         except NoLiquidityAvailableOnCowException:
@@ -254,7 +236,7 @@ class SeerAgentMarket(AgentMarket):
     def place_bet(
         self,
         outcome: bool,
-        amount: USD,
+        amount: BetAmount,
         auto_deposit: bool = True,
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
@@ -265,27 +247,32 @@ class SeerAgentMarket(AgentMarket):
                 f"Market {self.id} is not open for trading. Cannot place bet."
             )
 
-        amount_in_token = self.get_usd_in_token(amount)
-        amount_wei = amount_in_token.as_wei
-        collateral_contract = self.get_collateral_token_contract()
+        if amount.currency != self.currency:
+            raise ValueError(f"Seer bets are made in xDai. Got {amount.currency}.")
 
+        collateral_contract = sDaiContract()
         if auto_deposit:
+            # We convert the deposit amount (in sDai) to assets in order to convert.
+            asset_amount = collateral_contract.convertToAssets(
+                xdai_to_wei(xdai_type(amount.amount))
+            )
             auto_deposit_collateral_token(
-                collateral_contract, amount_wei, api_keys, web3
+                collateral_contract, asset_amount, api_keys, web3
             )
 
-        collateral_balance = collateral_contract.balanceOf(api_keys.bet_from_address)
-        if collateral_balance < amount_wei:
+        # We require that amount is given in sDAI.
+        collateral_balance = get_balances(address=api_keys.bet_from_address, web3=web3)
+        if collateral_balance.sdai < amount.amount:
             raise ValueError(
-                f"Balance {collateral_balance} not enough for bet size {amount}"
+                f"Balance {collateral_balance.sdai} not enough for bet size {amount.amount}"
             )
 
         outcome_token = self.get_wrapped_token_for_outcome(outcome)
-        # Sell using token address
+        #  Sell sDAI using token address
         order_metadata = CowManager().swap(
-            amount=amount_in_token,
+            amount=xdai_type(amount.amount),
             sell_token=collateral_contract.address,
-            buy_token=outcome_token,
+            buy_token=Web3.to_checksum_address(outcome_token),
             api_keys=api_keys,
             web3=web3,
         )
@@ -295,17 +282,18 @@ class SeerAgentMarket(AgentMarket):
 
 def seer_create_market_tx(
     api_keys: APIKeys,
-    initial_funds: USD | Token,
+    initial_funds: xDai,
     question: str,
     opening_time: DatetimeUTC,
     language: str,
-    outcomes: t.Sequence[OutcomeStr],
+    outcomes: list[str],
     auto_deposit: bool,
     category: str,
     min_bond_xdai: xDai,
     web3: Web3 | None = None,
 ) -> ChecksumAddress:
     web3 = web3 or SeerMarketFactory.get_web3()  # Default to Gnosis web3.
+    initial_funds_wei = xdai_to_wei(initial_funds)
 
     factory_contract = SeerMarketFactory()
     collateral_token_address = factory_contract.collateral_token(web3=web3)
@@ -313,26 +301,24 @@ def seer_create_market_tx(
         init_collateral_token_contract(collateral_token_address, web3)
     )
 
-    initial_funds_in_collateral = (
-        get_usd_in_token(initial_funds, collateral_token_address)
-        if isinstance(initial_funds, USD)
-        else initial_funds
-    )
-    initial_funds_in_collateral_wei = initial_funds_in_collateral.as_wei
-
     if auto_deposit:
         auto_deposit_collateral_token(
             collateral_token_contract=collateral_token_contract,
             api_keys=api_keys,
-            collateral_amount_wei_or_usd=initial_funds_in_collateral_wei,
+            amount_wei=initial_funds_wei,
             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
+    )
+
     # Approve the market maker to withdraw our collateral token.
     collateral_token_contract.approve(
         api_keys=api_keys,
         for_address=factory_contract.address,
-        amount_wei=initial_funds_in_collateral_wei,
+        amount_wei=initial_funds_in_shares,
         web3=web3,
     )
 
@@ -343,7 +329,7 @@ def seer_create_market_tx(
         opening_time=opening_time,
         language=language,
         category=category,
-        min_bond=min_bond_xdai,
+        min_bond_xdai=min_bond_xdai,
     )
     tx_receipt = factory_contract.create_categorical_market(
         api_keys=api_keys, params=params, web3=web3

prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -1,16 +1,10 @@
 import os
-import typing as t
 
 from web3 import Web3
 from web3.types import TxReceipt
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import (
-    ABI,
-    ChecksumAddress,
-    OutcomeStr,
-    xDai,
-)
+from prediction_market_agent_tooling.gtypes import ABI, ChecksumAddress, xDai
 from prediction_market_agent_tooling.markets.seer.data_models import (
     CreateCategoricalMarketsParams,
 )
@@ -19,6 +13,7 @@ from prediction_market_agent_tooling.tools.contract import (
     abi_field_validator,
 )
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
 
 
 class SeerMarketFactory(ContractOnGnosisChain):
@@ -36,9 +31,9 @@ class SeerMarketFactory(ContractOnGnosisChain):
     @staticmethod
     def build_market_params(
         market_question: str,
-        outcomes: t.Sequence[OutcomeStr],
+        outcomes: list[str],
         opening_time: DatetimeUTC,
-        min_bond: xDai,
+        min_bond_xdai: xDai,
         language: str = "en_US",
         category: str = "misc",
     ) -> CreateCategoricalMarketsParams:
@@ -47,7 +42,7 @@ class SeerMarketFactory(ContractOnGnosisChain):
             token_names=[
                 o.upper() for o in outcomes
             ],  # Following usual token names on Seer (YES,NO).
-            min_bond=min_bond.as_xdai_wei.value,
+            min_bond=xdai_to_wei(min_bond_xdai),
             opening_time=int(opening_time.timestamp()),
             outcomes=outcomes,
             lang=language,

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -15,7 +15,6 @@ from prediction_market_agent_tooling.markets.seer.data_models import (
 )
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
-from prediction_market_agent_tooling.tools.web3_utils import unwrap_generic_value
 
 
 class SeerSubgraphHandler(BaseSubgraphHandler):
@@ -50,6 +49,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             markets_field.creator,
             markets_field.conditionId,
             markets_field.marketName,
+            markets_field.outcomesSupply,
             markets_field.parentOutcome,
             markets_field.outcomes,
             markets_field.payoutReported,
@@ -121,12 +121,16 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         match sort_by:
             case SortBy.NEWEST:
                 sort_direction = "desc"
-                sort_by_field = self.seer_subgraph.Market.block_timestamp
+                sort_by_field = self.seer_subgraph.Market.blockTimestamp
             case SortBy.CLOSING_SOONEST:
                 sort_direction = "asc"
-                sort_by_field = self.seer_subgraph.Market.opening_ts
-            # ToDo - Implement liquidity conditions by looking up Swapr subgraph.
-            case SortBy.NONE | SortBy.HIGHEST_LIQUIDITY | SortBy.LOWEST_LIQUIDITY:
+                sort_by_field = self.seer_subgraph.Market.openingTs
+            case SortBy.HIGHEST_LIQUIDITY | SortBy.LOWEST_LIQUIDITY:
+                sort_direction = (
+                    "desc" if sort_by == SortBy.HIGHEST_LIQUIDITY else "asc"
+                )
+                sort_by_field = self.seer_subgraph.Market.outcomesSupply
+            case SortBy.NONE:
                 sort_direction = None
                 sort_by_field = None
             case _:
@@ -159,7 +163,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             first=(
                 limit if limit else sys.maxsize
             ),  # if not limit, we fetch all possible markets,
-            where=unwrap_generic_value(where_stms),
+            where=where_stms,
             **optional_params,
         )
         fields = self._get_fields_for_markets(markets_field)
@@ -201,6 +205,9 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
         fields = [
             pools_field.id,
             pools_field.liquidity,
+            pools_field.sqrtPrice,
+            pools_field.token0Price,
+            pools_field.token1Price,
             pools_field.token0.id,
             pools_field.token0.name,
             pools_field.token0.symbol,
@@ -220,9 +227,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
                     {"token1": wrapped_token.lower()},
                 ]
             )
-        pools_field = self.swapr_algebra_subgraph.Query.pools(
-            where=unwrap_generic_value({"or": wheres})
-        )
+        pools_field = self.swapr_algebra_subgraph.Query.pools(where={"or": wheres})
         fields = self._get_fields_for_pools(pools_field)
         pools = self.do_query(fields=fields, pydantic_model=SeerPool)
         return pools

prediction_market_agent_tooling/monitor/monitor.py

@@ -186,12 +186,12 @@ def monitor_agent(agent: DeployedAgent) -> None:
         return
     bets_info = {
         "Market Question": [bet.market_question for bet in agent_bets],
-        "Bet Amount": [bet.amount for bet in agent_bets],
+        "Bet Amount": [bet.amount.amount for bet in agent_bets],
         "Bet Outcome": [bet.outcome for bet in agent_bets],
         "Created Time": [bet.created_time for bet in agent_bets],
         "Resolved Time": [bet.resolved_time for bet in agent_bets],
         "Is Correct": [bet.is_correct for bet in agent_bets],
-        "Profit": [round(bet.profit, 2) for bet in agent_bets],
+        "Profit": [round(bet.profit.amount, 2) for bet in agent_bets],
     }
 
     # Time column to use for x-axes and sorting

prediction_market_agent_tooling/tools/balances.py

@@ -1,30 +1,32 @@
 from pydantic import BaseModel
 from tenacity import retry, stop_after_attempt, wait_fixed
 from web3 import Web3
+from web3.types import Wei
 
-from prediction_market_agent_tooling.gtypes import ChecksumAddress, Token, xDai, xDaiWei
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, xDai
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     WrappedxDaiContract,
     sDaiContract,
 )
+from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai
 
 
 class Balances(BaseModel):
     xdai: xDai
-    wxdai: Token
-    sdai: Token
+    wxdai: xDai
+    sdai: xDai
 
     @property
-    def total(self) -> Token:
-        return self.xdai.as_token + self.wxdai + self.sdai
+    def total(self) -> xDai:
+        return xDai(self.xdai + self.wxdai + self.sdai)
 
 
 @retry(stop=stop_after_attempt(3), wait=wait_fixed(1))
 def get_balances(address: ChecksumAddress, web3: Web3 | None = None) -> Balances:
     if not web3:
         web3 = WrappedxDaiContract().get_web3()
-    xdai_balance = xDaiWei(web3.eth.get_balance(address))
-    xdai = xdai_balance.as_xdai
-    wxdai = WrappedxDaiContract().balanceOf(address, web3=web3).as_token
-    sdai = sDaiContract().balanceOf(address, web3=web3).as_token
+    xdai_balance = Wei(web3.eth.get_balance(address))
+    xdai = wei_to_xdai(xdai_balance)
+    wxdai = wei_to_xdai(WrappedxDaiContract().balanceOf(address, web3=web3))
+    sdai = wei_to_xdai(sDaiContract().balanceOf(address, web3=web3))
     return Balances(xdai=xdai, wxdai=wxdai, sdai=sdai)

prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,4 +1,3 @@
-from prediction_market_agent_tooling.gtypes import OutcomeToken, Token
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
 
@@ -9,7 +8,7 @@ def check_is_valid_probability(probability: float) -> None:
 
 
 def get_kelly_bet_simplified(
-    max_bet: Token,
+    max_bet: float,
     market_p_yes: float,
     estimated_p_yes: float,
     confidence: float,
@@ -52,17 +51,17 @@ def get_kelly_bet_simplified(
     kelly_fraction = edge / odds
 
     # Ensure bet size is non-negative does not exceed the wallet balance
-    bet_size = Token(min(kelly_fraction * max_bet.value, max_bet.value))
+    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: OutcomeToken,
-    no_outcome_pool_size: OutcomeToken,
+    yes_outcome_pool_size: float,
+    no_outcome_pool_size: float,
     estimated_p_yes: float,
     confidence: float,
-    max_bet: Token,
+    max_bet: float,
     fees: MarketFees,
 ) -> SimpleBet:
     """
@@ -98,13 +97,13 @@ def get_kelly_bet_full(
     check_is_valid_probability(confidence)
 
     if max_bet == 0:
-        return SimpleBet(direction=True, size=Token(0))
+        return SimpleBet(direction=True, size=0)
 
-    x = yes_outcome_pool_size.value
-    y = no_outcome_pool_size.value
+    x = yes_outcome_pool_size
+    y = no_outcome_pool_size
     p = estimated_p_yes
     c = confidence
-    b = max_bet.value
+    b = max_bet
     f = 1 - fee
 
     if x == y:
@@ -145,6 +144,5 @@ def get_kelly_bet_full(
 
     # Clip the bet size to max_bet to account for rounding errors.
     return SimpleBet(
-        direction=kelly_bet_amount > 0,
-        size=Token(min(max_bet.value, abs(kelly_bet_amount))),
+        direction=kelly_bet_amount > 0, size=min(max_bet, abs(kelly_bet_amount))
     )

prediction_market_agent_tooling/tools/betting_strategies/market_moving.py

@@ -2,18 +2,19 @@ from functools import reduce
 
 import numpy as np
 
-from prediction_market_agent_tooling.gtypes import OutcomeToken, Probability, Token
+from prediction_market_agent_tooling.gtypes import Probability, Wei, xDai
 from prediction_market_agent_tooling.markets.omen.omen import (
     MarketFees,
     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 wei_to_xdai, xdai_to_wei
 
 
 def get_market_moving_bet(
-    yes_outcome_pool_size: OutcomeToken,
-    no_outcome_pool_size: OutcomeToken,
+    yes_outcome_pool_size: float,
+    no_outcome_pool_size: float,
     market_p_yes: float,
     target_p_yes: float,
     fees: MarketFees,
@@ -41,21 +42,20 @@ def get_market_moving_bet(
     fixed_product = yes_outcome_pool_size * no_outcome_pool_size
     bet_direction: bool = target_p_yes > market_p_yes
 
-    min_bet_amount = Token(0.0)
-    max_bet_amount = (
+    min_bet_amount = 0.0
+    max_bet_amount = 100 * (
         yes_outcome_pool_size + no_outcome_pool_size
-    ).as_token * 100  # TODO set a better upper bound
+    )  # 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
-        amounts_diff = fees.get_after_fees(bet_amount)
-        amounts_diff_as_ot = OutcomeToken.from_token(amounts_diff)
+        amounts_diff = fees.get_bet_size_after_fees(bet_amount)
 
         # Initial new amounts are old amounts + equal new amounts for each outcome
-        yes_outcome_new_pool_size = yes_outcome_pool_size + amounts_diff_as_ot
-        no_outcome_new_pool_size = no_outcome_pool_size + amounts_diff_as_ot
-        new_amounts: dict[bool, OutcomeToken] = {
+        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,
         }
@@ -63,20 +63,15 @@ def get_market_moving_bet(
         # Now give away tokens at `bet_outcome_index` to restore invariant
         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] -= OutcomeToken(dx)
+        new_amounts[bet_direction] -= dx
 
         # Check that the invariant is restored
         assert np.isclose(
-            reduce(lambda x, y: x * y.value, list(new_amounts.values()), 1.0),
+            reduce(lambda x, y: x * y, list(new_amounts.values()), 1.0),
             float(fixed_product),
         )
 
-        new_p_yes = Probability(
-            (
-                new_amounts[False]
-                / sum(list(new_amounts.values()), start=OutcomeToken(0))
-            )
-        )
+        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:
@@ -102,31 +97,33 @@ def _sanity_check_omen_market_moving_bet(
     using the adjusted outcome pool sizes to calculate the new p_yes.
     """
     buy_amount_ = market.get_contract().calcBuyAmount(
-        investment_amount=bet_to_check.size.as_wei,
+        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 = buy_amount_.as_outcome_token
+    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.value * no_outcome_pool_size.value
+    market_const = yes_outcome_pool_size * no_outcome_pool_size
 
-    bet_to_check_size_after_fees = market.fees.get_after_fees(bet_to_check.size).value
+    bet_to_check_size_after_fees = market.fees.get_bet_size_after_fees(
+        bet_to_check.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.value
+        yes_outcome_pool_size
         + bet_to_check_size_after_fees
-        - float(bet_to_check.direction) * buy_amount.value
+        - float(bet_to_check.direction) * buy_amount
     )
     new_no_outcome_pool_size = (
-        no_outcome_pool_size.value
+        no_outcome_pool_size
         + bet_to_check_size_after_fees
-        - float(not bet_to_check.direction) * buy_amount.value
+        - 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

prediction_market_agent_tooling/tools/betting_strategies/utils.py

@@ -1,8 +1,6 @@
 from pydantic import BaseModel
 
-from prediction_market_agent_tooling.gtypes import Token
-
 
 class SimpleBet(BaseModel):
     direction: bool
-    size: Token
+    size: float