prediction-market-agent-tooling 0.61.1.dev489__py3-none-any.whl → 0.62.0__py3-none-any.whl

prediction_market_agent_tooling/tools/_generic_value.py

@@ -0,0 +1,261 @@
+import typing as t
+from decimal import Decimal
+from typing import TypeVar, overload
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+from web3.types import Wei as WeiWeb3
+
+InputValueType = TypeVar(
+    "InputValueType", bound=t.Union[str, int, float, WeiWeb3, Decimal]
+)
+InternalValueType = TypeVar("InternalValueType", bound=t.Union[int, float, WeiWeb3])
+
+
+class _GenericValue(
+    t.Generic[InputValueType, InternalValueType],
+    # Not great, but it allows to serialize this object with plain json.
+    dict[t.Literal["value"] | t.Literal["type"], InternalValueType | str],
+):
+    """
+    A helper class intended for inheritance. Do not instantiate this class directly.
+
+    Example:
+
+    ```python
+    a = _GenericValue(10)
+    b = Token(100) # Token is a subclass of _GenericValue
+    c = xDai(100) # xDai is a subclass of _GenericValue
+    d = Mana(100) # Mana is a subclass of _GenericValue
+    e = xDai(50)
+
+    # Mypy will complain if we try to work with different currencies (types)
+    b - c # mypy will report incompatible types
+    c - d # mypy will report incompatible types
+    c - e # mypy will be ok
+    a - b # mypy won't report issues, as others are subclasses of _GenericValue, and that's a problem, so don't use _GenericValue directly
+
+    # Resulting types after arithmetic operations are as expected, so we don't need to wrap them as before (e.g. xdai_type(c + c))
+    x = c - e # x is of type xDai
+    x = c * e # x if of type xDai
+    x = c / e # x is of type float (pure value after division with same types)
+    x = c / 2 # x is of type xDai
+    x = c // 2 # x is of type xDai
+    x * x * 2 # x is of type xDai
+    ```
+
+    TODO: There are some type ignores which isn't cool, but it works and type-wise values are also correct. Idk how to explain it to mypy though.
+    """
+
+    GenericValueType = TypeVar(
+        "GenericValueType", bound="_GenericValue[InputValueType, InternalValueType]"
+    )
+
+    parser: t.Callable[[InputValueType], InternalValueType]
+
+    def __init_subclass__(
+        cls, parser: t.Callable[[InputValueType], InternalValueType]
+    ) -> None:
+        super().__init_subclass__()
+        cls.parser = parser
+
+    def __init__(self, value: InputValueType) -> None:
+        self.value: InternalValueType = self.parser(value)
+        super().__init__({"value": self.value, "type": self.__class__.__name__})
+
+    def __str__(self) -> str:
+        return f"{self.value}"
+
+    def __neg__(self: GenericValueType) -> GenericValueType:
+        return type(self)(-self.value)  # type: ignore[arg-type]
+
+    def __abs__(self: GenericValueType) -> GenericValueType:
+        return type(self)(abs(self.value))  # type: ignore[arg-type]
+
+    def __sub__(
+        self: GenericValueType, other: GenericValueType | t.Literal[0]
+    ) -> GenericValueType:
+        if other == 0:
+            other = self.zero()
+        if not isinstance(other, _GenericValue):
+            raise TypeError("Cannot subtract different types")
+        if type(self) is not type(other):
+            raise TypeError("Cannot subtract different types")
+        return type(self)(self.value - other.value)
+
+    def __add__(
+        self: GenericValueType, other: GenericValueType | t.Literal[0]
+    ) -> GenericValueType:
+        if other == 0:
+            other = self.zero()
+        if not isinstance(other, _GenericValue):
+            raise TypeError("Cannot add different types")
+        if type(self) is not type(other):
+            raise TypeError("Cannot add different types")
+        return type(self)(self.value + other.value)
+
+    def __mul__(
+        self: GenericValueType, other: GenericValueType | int | float
+    ) -> GenericValueType:
+        if not isinstance(other, (_GenericValue, int, float)):
+            raise TypeError("Cannot multiply different types")
+        if not isinstance(other, (int, float)) and type(self) is not type(other):
+            raise TypeError("Cannot multiply different types")
+        return type(self)(self.value * (other if isinstance(other, (int, float)) else other.value))  # type: ignore
+
+    @overload
+    def __truediv__(self: GenericValueType, other: int | float) -> GenericValueType:
+        ...
+
+    @overload
+    def __truediv__(
+        self: GenericValueType, other: GenericValueType
+    ) -> InternalValueType:
+        ...
+
+    def __truediv__(
+        self: GenericValueType, other: GenericValueType | int | float
+    ) -> GenericValueType | InternalValueType:
+        if not isinstance(other, (_GenericValue, int, float)):
+            raise TypeError("Cannot multiply different types")
+        if not isinstance(other, (int, float)) and type(self) is not type(other):
+            raise TypeError("Cannot multiply different types")
+        if other == 0:
+            raise ZeroDivisionError("Cannot divide by zero")
+        if isinstance(other, (int, float)):
+            return type(self)(self.value / other)  # type: ignore
+        else:
+            return self.value / other.value  # type: ignore
+
+    @overload
+    def __floordiv__(self: GenericValueType, other: int | float) -> GenericValueType:
+        ...
+
+    @overload
+    def __floordiv__(
+        self: GenericValueType, other: GenericValueType
+    ) -> InternalValueType:
+        ...
+
+    def __floordiv__(
+        self: GenericValueType, other: GenericValueType | int | float
+    ) -> GenericValueType | InternalValueType:
+        if not isinstance(other, (_GenericValue, int, float)):
+            raise TypeError("Cannot multiply different types")
+        if not isinstance(other, (int, float)) and type(self) is not type(other):
+            raise TypeError("Cannot multiply different types")
+        if other == 0:
+            raise ZeroDivisionError("Cannot divide by zero")
+        if isinstance(other, (int, float)):
+            return type(self)(self.value // other)  # type: ignore
+        else:
+            return self.value // other.value  # type: ignore
+
+    def __lt__(self: GenericValueType, other: GenericValueType | t.Literal[0]) -> bool:
+        if other == 0:
+            other = self.zero()
+        if not isinstance(other, _GenericValue):
+            raise TypeError("Cannot compare different types")
+        if type(self) is not type(other):
+            raise TypeError("Cannot compare different types")
+        return bool(self.value < other.value)
+
+    def __le__(self: GenericValueType, other: GenericValueType | t.Literal[0]) -> bool:
+        if other == 0:
+            other = self.zero()
+        if not isinstance(other, _GenericValue):
+            raise TypeError("Cannot compare different types")
+        if type(self) is not type(other):
+            raise TypeError("Cannot compare different types")
+        return bool(self.value <= other.value)
+
+    def __gt__(self: GenericValueType, other: GenericValueType | t.Literal[0]) -> bool:
+        if other == 0:
+            other = self.zero()
+        if not isinstance(other, _GenericValue):
+            raise TypeError("Cannot compare different types")
+        if type(self) is not type(other):
+            raise TypeError("Cannot compare different types")
+        return bool(self.value > other.value)
+
+    def __ge__(self: GenericValueType, other: GenericValueType | t.Literal[0]) -> bool:
+        if other == 0:
+            other = self.zero()
+        if not isinstance(other, _GenericValue):
+            raise TypeError("Cannot compare different types")
+        if type(self) is not type(other):
+            raise TypeError("Cannot compare different types")
+        return bool(self.value >= other.value)
+
+    def __eq__(self: GenericValueType, other: GenericValueType | t.Literal[0]) -> bool:  # type: ignore
+        if other == 0:
+            other = self.zero()
+        if not isinstance(other, _GenericValue):
+            raise TypeError("Cannot compare different types")
+        if type(self) is not type(other):
+            raise TypeError("Cannot compare different types")
+        return bool(self.value == other.value)
+
+    def __ne__(self: GenericValueType, other: GenericValueType | t.Literal[0]) -> bool:  # type: ignore
+        if other == 0:
+            other = self.zero()
+        if not isinstance(other, _GenericValue):
+            raise TypeError("Cannot compare different types")
+        if type(self) is not type(other):
+            raise TypeError("Cannot compare different types")
+        return bool(self.value != other.value)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.value})"
+
+    def __float__(self) -> float:
+        return float(self.value)
+
+    def __radd__(
+        self: GenericValueType, other: GenericValueType | t.Literal[0] | int | float
+    ) -> GenericValueType:
+        if isinstance(other, (_GenericValue, int, float)):
+            return self.__add__(other)  # type: ignore[operator]
+
+        elif isinstance(other, (int, float)) and other == 0:
+            return self
+
+        else:
+            raise TypeError("Cannot add different types")
+
+    def __round__(self: GenericValueType, ndigits: int = 0) -> GenericValueType:
+        if not isinstance(self.value, (int, float)):
+            raise TypeError("Cannot round non-numeric types")
+        return type(self)(round(self.value, ndigits))  # type: ignore[arg-type]
+
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: t.Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        # Support for Pydantic usage.
+        dt_schema = handler(str | int | float | dict)
+        return core_schema.no_info_after_validator_function(
+            lambda x: cls(x["value"] if isinstance(x, dict) else x),
+            dt_schema,
+        )
+
+    def with_fraction(self: GenericValueType, fraction: float) -> GenericValueType:
+        if not 0 <= fraction <= 1:
+            raise ValueError(f"Given fraction {fraction} is not in the range [0,1].")
+        return self.__class__(self.value * (1 + fraction))  # type: ignore[arg-type]
+
+    def without_fraction(self: GenericValueType, fraction: float) -> GenericValueType:
+        if not 0 <= fraction <= 1:
+            raise ValueError(f"Given fraction {fraction} is not in the range [0,1].")
+        return self.__class__(self.value * (1 - fraction))  # type: ignore[arg-type]
+
+    @classmethod
+    def zero(cls: type[GenericValueType]) -> GenericValueType:
+        return cls(0)  # type: ignore[arg-type]
+
+    @property
+    def symbol(self) -> str:
+        return self.__class__.__name__

prediction_market_agent_tooling/tools/balances.py

@@ -1,32 +1,35 @@
 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, xDai
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    CollateralToken,
+    xDai,
+    xDaiWei,
+)
 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: xDai
-    sdai: xDai
+    wxdai: CollateralToken
+    sdai: CollateralToken
 
     @property
-    def total(self) -> xDai:
-        return xDai(self.xdai + self.wxdai + self.sdai)
+    def total(self) -> CollateralToken:
+        return self.xdai.as_token + 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 = 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))
+    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
     return Balances(xdai=xdai, wxdai=wxdai, sdai=sdai)

prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,3 +1,4 @@
+from prediction_market_agent_tooling.gtypes import CollateralToken, OutcomeToken
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.tools.betting_strategies.utils import SimpleBet
 
@@ -8,7 +9,7 @@ def check_is_valid_probability(probability: float) -> None:
 
 
 def get_kelly_bet_simplified(
-    max_bet: float,
+    max_bet: CollateralToken,
     market_p_yes: float,
     estimated_p_yes: float,
     confidence: float,
@@ -51,17 +52,17 @@ def get_kelly_bet_simplified(
     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)
+    bet_size = CollateralToken(min(kelly_fraction * max_bet.value, max_bet.value))
 
     return SimpleBet(direction=bet_direction, size=bet_size)
 
 
 def get_kelly_bet_full(
-    yes_outcome_pool_size: float,
-    no_outcome_pool_size: float,
+    yes_outcome_pool_size: OutcomeToken,
+    no_outcome_pool_size: OutcomeToken,
     estimated_p_yes: float,
     confidence: float,
-    max_bet: float,
+    max_bet: CollateralToken,
     fees: MarketFees,
 ) -> SimpleBet:
     """
@@ -97,13 +98,13 @@ def get_kelly_bet_full(
     check_is_valid_probability(confidence)
 
     if max_bet == 0:
-        return SimpleBet(direction=True, size=0)
+        return SimpleBet(direction=True, size=CollateralToken(0))
 
-    x = yes_outcome_pool_size
-    y = no_outcome_pool_size
+    x = yes_outcome_pool_size.value
+    y = no_outcome_pool_size.value
     p = estimated_p_yes
     c = confidence
-    b = max_bet
+    b = max_bet.value
     f = 1 - fee
 
     if x == y:
@@ -144,5 +145,6 @@ 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=min(max_bet, abs(kelly_bet_amount))
+        direction=kelly_bet_amount > 0,
+        size=CollateralToken(min(max_bet.value, abs(kelly_bet_amount))),
     )

prediction_market_agent_tooling/tools/betting_strategies/market_moving.py

@@ -2,19 +2,22 @@ from functools import reduce
 
 import numpy as np
 
-from prediction_market_agent_tooling.gtypes import Probability, Wei, xDai
+from prediction_market_agent_tooling.gtypes import (
+    CollateralToken,
+    OutcomeToken,
+    Probability,
+)
 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: float,
-    no_outcome_pool_size: float,
+    yes_outcome_pool_size: OutcomeToken,
+    no_outcome_pool_size: OutcomeToken,
     market_p_yes: float,
     target_p_yes: float,
     fees: MarketFees,
@@ -42,20 +45,21 @@ 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 = 0.0
-    max_bet_amount = 100 * (
+    min_bet_amount = CollateralToken(0.0)
+    max_bet_amount = (
         yes_outcome_pool_size + no_outcome_pool_size
-    )  # TODO set a better upper bound
+    ).as_token * 100  # 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_bet_size_after_fees(bet_amount)
+        amounts_diff = fees.get_after_fees(bet_amount)
+        amounts_diff_as_ot = OutcomeToken.from_token(amounts_diff)
 
         # Initial new amounts are old amounts + equal new amounts for each outcome
-        yes_outcome_new_pool_size = yes_outcome_pool_size + amounts_diff
-        no_outcome_new_pool_size = no_outcome_pool_size + amounts_diff
-        new_amounts = {
+        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] = {
             True: yes_outcome_new_pool_size,
             False: no_outcome_new_pool_size,
         }
@@ -63,15 +67,20 @@ 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] -= dx
+        new_amounts[bet_direction] -= OutcomeToken(dx)
 
         # Check that the invariant is restored
         assert np.isclose(
-            reduce(lambda x, y: x * y, list(new_amounts.values()), 1.0),
+            reduce(lambda x, y: x * y.value, list(new_amounts.values()), 1.0),
             float(fixed_product),
         )
 
-        new_p_yes = Probability(new_amounts[False] / sum(list(new_amounts.values())))
+        new_p_yes = Probability(
+            (
+                new_amounts[False]
+                / sum(list(new_amounts.values()), start=OutcomeToken(0))
+            )
+        )
         if abs(target_p_yes - new_p_yes) < 1e-6:
             break
         elif new_p_yes > target_p_yes:
@@ -97,33 +106,31 @@ 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=xdai_to_wei(xDai(bet_to_check.size)),
+        investment_amount=bet_to_check.size.as_wei,
         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_)))
+    buy_amount = buy_amount_.as_outcome_token
 
     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
+    market_const = yes_outcome_pool_size.value * no_outcome_pool_size.value
 
-    bet_to_check_size_after_fees = market.fees.get_bet_size_after_fees(
-        bet_to_check.size
-    )
+    bet_to_check_size_after_fees = market.fees.get_after_fees(bet_to_check.size).value
 
     # 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
+        yes_outcome_pool_size.value
         + bet_to_check_size_after_fees
-        - float(bet_to_check.direction) * buy_amount
+        - float(bet_to_check.direction) * buy_amount.value
     )
     new_no_outcome_pool_size = (
-        no_outcome_pool_size
+        no_outcome_pool_size.value
         + bet_to_check_size_after_fees
-        - float(not bet_to_check.direction) * buy_amount
+        - float(not bet_to_check.direction) * buy_amount.value
     )
     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,6 +1,8 @@
 from pydantic import BaseModel
 
+from prediction_market_agent_tooling.gtypes import CollateralToken
+
 
 class SimpleBet(BaseModel):
     direction: bool
-    size: float
+    size: CollateralToken

prediction_market_agent_tooling/tools/contract.py

@@ -14,6 +14,7 @@ from prediction_market_agent_tooling.gtypes import (
     ABI,
     ChainID,
     ChecksumAddress,
+    CollateralToken,
     Nonce,
     TxParams,
     TxReceipt,
@@ -153,7 +154,7 @@ class ContractBaseClass(BaseModel):
             api_keys=api_keys,
             function_name=function_name,
             function_params=function_params,
-            tx_params={"value": amount_wei, **(tx_params or {})},
+            tx_params={"value": amount_wei.value, **(tx_params or {})},
             timeout=timeout,
             web3=web3,
         )
@@ -243,12 +244,13 @@ class ContractERC20BaseClass(ContractBaseClass):
         )
 
     def balanceOf(self, for_address: ChecksumAddress, web3: Web3 | None = None) -> Wei:
-        balance: Wei = self.call("balanceOf", [for_address], web3=web3)
+        balance = Wei(self.call("balanceOf", [for_address], web3=web3))
         return balance
 
-    def get_in_shares(self, amount: Wei, web3: Web3 | None = None) -> Wei:
-        # ERC-20 just holds the token, so the exact amount we send there, is the amount of shares we have there.
-        return amount
+    def balance_of_in_tokens(
+        self, for_address: ChecksumAddress, web3: Web3 | None = None
+    ) -> CollateralToken:
+        return self.balanceOf(for_address, web3=web3).as_token
 
 
 class ContractDepositableWrapperERC20BaseClass(ContractERC20BaseClass):
@@ -355,11 +357,11 @@ class ContractERC4626BaseClass(ContractERC20BaseClass):
         return self.withdraw(api_keys=api_keys, assets_wei=assets, web3=web3)
 
     def convertToShares(self, assets: Wei, web3: Web3 | None = None) -> Wei:
-        shares: Wei = self.call("convertToShares", [assets], web3=web3)
+        shares = Wei(self.call("convertToShares", [assets], web3=web3))
         return shares
 
     def convertToAssets(self, shares: Wei, web3: Web3 | None = None) -> Wei:
-        assets: Wei = self.call("convertToAssets", [shares], web3=web3)
+        assets = Wei(self.call("convertToAssets", [shares], web3=web3))
         return assets
 
     def get_asset_token_contract(
@@ -434,8 +436,8 @@ class ContractERC721BaseClass(ContractBaseClass):
             web3=web3,
         )
 
-    def balanceOf(self, owner: ChecksumAddress, web3: Web3 | None = None) -> int:
-        balance: int = self.call("balanceOf", [owner], web3=web3)
+    def balanceOf(self, owner: ChecksumAddress, web3: Web3 | None = None) -> Wei:
+        balance = Wei(self.call("balanceOf", [owner], web3=web3))
         return balance
 
     def owner_of(self, token_id: int, web3: Web3 | None = None) -> ChecksumAddress:
@@ -604,12 +606,14 @@ def contract_implements_function(
 
 
 def init_collateral_token_contract(
-    address: ChecksumAddress, web3: Web3
+    address: ChecksumAddress, web3: Web3 | None
 ) -> ContractERC20BaseClass:
     """
     Checks if the given contract is Depositable ERC-20, ERC-20 or ERC-4626 and returns the appropriate class instance.
     Throws an error if the contract is neither of them.
     """
+    web3 = web3 or RPCConfig().get_web3()
+
     if contract_implements_function(address, "asset", web3=web3):
         return ContractERC4626BaseClass(address=address)
 

prediction_market_agent_tooling/tools/cow/cow_manager.py

@@ -19,10 +19,9 @@ from web3 import Web3
 from web3.constants import ADDRESS_ZERO
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei, xDai
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, CollateralToken, Wei
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
-from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
 
 COW_ENV: Envs = "prod"
 
@@ -94,14 +93,14 @@ class CowManager:
 
     @staticmethod
     def swap(
-        amount: xDai,
+        amount: CollateralToken,
         sell_token: ChecksumAddress,
         buy_token: ChecksumAddress,
         api_keys: APIKeys,
         web3: Web3 | None = None,
     ) -> OrderMetaData:
         order_metadata = swap_tokens_waiting(
-            amount_wei=xdai_to_wei(amount),
+            amount_wei=amount.as_wei,
             sell_token=sell_token,
             buy_token=buy_token,
             api_keys=api_keys,