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

prediction_market_agent_tooling/markets/agent_market.py

@@ -6,17 +6,22 @@ from pydantic import BaseModel, field_validator, model_validator
 from pydantic_core.core_schema import FieldValidationInfo
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import OutcomeStr, Probability
+from prediction_market_agent_tooling.gtypes import (
+    OutcomeStr,
+    OutcomeToken,
+    Probability,
+    Token,
+)
 from prediction_market_agent_tooling.markets.data_models import (
+    USD,
     Bet,
-    BetAmount,
-    Currency,
+    ExistingPosition,
     PlacedTrade,
     Position,
     ProbabilisticAnswer,
     Resolution,
     ResolvedBet,
-    TokenAmount,
+    Token,
 )
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.tools.utils import (
@@ -55,31 +60,28 @@ class AgentMarket(BaseModel):
     Contains everything that is needed for an agent to make a prediction.
     """
 
-    currency: t.ClassVar[Currency]
     base_url: t.ClassVar[str]
 
     id: str
     question: str
     description: str | None
-    outcomes: list[str]
-    outcome_token_pool: (
-        dict[str, float] | None
-    )  # Should be in currency of `currency` above.
+    outcomes: t.Sequence[OutcomeStr]
+    outcome_token_pool: dict[str, OutcomeToken] | None
     resolution: Resolution | None
     created_time: DatetimeUTC | None
     close_time: DatetimeUTC | None
     current_p_yes: Probability
     url: str
-    volume: float | None  # Should be in currency of `currency` above.
+    volume: Token | None
     fees: MarketFees
 
     @field_validator("outcome_token_pool")
     def validate_outcome_token_pool(
         cls,
-        outcome_token_pool: dict[str, float] | None,
+        outcome_token_pool: dict[str, OutcomeToken] | None,
         info: FieldValidationInfo,
-    ) -> dict[str, float] | None:
-        outcomes: list[str] = check_not_none(info.data.get("outcomes"))
+    ) -> dict[str, OutcomeToken] | None:
+        outcomes: t.Sequence[OutcomeStr] = 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)
@@ -102,20 +104,28 @@ class AgentMarket(BaseModel):
         return Probability(1 - self.current_p_yes)
 
     @property
-    def yes_outcome_price(self) -> float:
+    def yes_outcome_price(self) -> Token:
         """
         Price at prediction market is equal to the probability of given outcome.
         Keep as an extra property, in case it wouldn't be true for some prediction market platform.
         """
-        return self.current_p_yes
+        return Token(self.current_p_yes)
+
+    @property
+    def yes_outcome_price_usd(self) -> USD:
+        return self.get_token_in_usd(self.yes_outcome_price)
 
     @property
-    def no_outcome_price(self) -> float:
+    def no_outcome_price(self) -> Token:
         """
         Price at prediction market is equal to the probability of given outcome.
         Keep as an extra property, in case it wouldn't be true for some prediction market platform.
         """
-        return self.current_p_no
+        return Token(self.current_p_no)
+
+    @property
+    def no_outcome_price_usd(self) -> USD:
+        return self.get_token_in_usd(self.no_outcome_price)
 
     @property
     def probable_resolution(self) -> Resolution:
@@ -150,48 +160,86 @@ class AgentMarket(BaseModel):
         """
         raise NotImplementedError("Subclasses must implement this method")
 
-    def get_last_trade_yes_outcome_price(self) -> float | None:
+    def get_last_trade_yes_outcome_price(self) -> Token | None:
         # Price on prediction markets are, by definition, equal to the probability of an outcome.
         # Just making it explicit in this function.
         if last_trade_p_yes := self.get_last_trade_p_yes():
-            return float(last_trade_p_yes)
+            return Token(last_trade_p_yes)
         return None
 
-    def get_last_trade_no_outcome_price(self) -> float | None:
+    def get_last_trade_yes_outcome_price_usd(self) -> USD | None:
+        if last_trade_yes_outcome_price := self.get_last_trade_yes_outcome_price():
+            return self.get_token_in_usd(last_trade_yes_outcome_price)
+        return None
+
+    def get_last_trade_no_outcome_price(self) -> Token | None:
         # Price on prediction markets are, by definition, equal to the probability of an outcome.
         # Just making it explicit in this function.
         if last_trade_p_no := self.get_last_trade_p_no():
-            return float(last_trade_p_no)
+            return Token(last_trade_p_no)
         return None
 
-    def get_bet_amount(self, amount: float) -> BetAmount:
-        return BetAmount(amount=amount, currency=self.currency)
+    def get_last_trade_no_outcome_price_usd(self) -> USD | None:
+        if last_trade_no_outcome_price := self.get_last_trade_no_outcome_price():
+            return self.get_token_in_usd(last_trade_no_outcome_price)
+        return None
 
-    @classmethod
-    def get_liquidatable_amount(cls) -> BetAmount:
-        tiny_amount = cls.get_tiny_bet_amount()
-        tiny_amount.amount /= 10
-        return tiny_amount
+    def get_liquidatable_amount(self) -> OutcomeToken:
+        tiny_amount = self.get_tiny_bet_amount()
+        return OutcomeToken.from_token(tiny_amount / 10)
 
-    @classmethod
-    def get_tiny_bet_amount(cls) -> BetAmount:
+    def get_token_in_usd(self, x: Token) -> USD:
+        """
+        Token of this market can have whatever worth (e.g. sDai and ETH markets will have different worth of 1 token). Use this to convert it to USD.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    def get_usd_in_token(self, x: USD) -> Token:
+        """
+        Markets on a single platform can have different tokens as collateral (sDai, wxDai, GNO, ...). Use this to convert USD to the token of this market.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    def get_sell_value_of_outcome_token(
+        self, outcome: str, amount: OutcomeToken
+    ) -> Token:
+        """
+        When you hold OutcomeToken(s), it's easy to calculate how much you get at the end if you win (1 OutcomeToken will equal to 1 Token).
+        But use this to figure out, how much are these outcome tokens worth right now (for how much you can sell them).
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+
+    def get_in_usd(self, x: USD | Token) -> USD:
+        if isinstance(x, USD):
+            return x
+        return self.get_token_in_usd(x)
+
+    def get_in_token(self, x: USD | Token) -> Token:
+        if isinstance(x, Token):
+            return x
+        return self.get_usd_in_token(x)
+
+    def get_tiny_bet_amount(self) -> Token:
+        """
+        Tiny bet amount that the platform still allows us to do.
+        """
         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) -> str:
+    def place_bet(self, outcome: bool, amount: USD) -> str:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def buy_tokens(self, outcome: bool, amount: TokenAmount) -> str:
+    def buy_tokens(self, outcome: bool, amount: USD) -> str:
         return self.place_bet(outcome=outcome, amount=amount)
 
     def get_buy_token_amount(
-        self, bet_amount: BetAmount, direction: bool
-    ) -> TokenAmount:
+        self, bet_amount: USD | Token, direction: bool
+    ) -> OutcomeToken:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def sell_tokens(self, outcome: bool, amount: TokenAmount) -> str:
+    def sell_tokens(self, outcome: bool, amount: USD | OutcomeToken) -> str:
         raise NotImplementedError("Subclasses must implement this method")
 
     @staticmethod
@@ -215,8 +263,8 @@ class AgentMarket(BaseModel):
         """
         raise NotImplementedError("Subclasses must implement this method")
 
-    @staticmethod
-    def get_trade_balance(api_keys: APIKeys) -> float:
+    @classmethod
+    def get_trade_balance(cls, api_keys: APIKeys) -> USD:
         """
         Return balance that can be used to trade on the given market.
         """
@@ -272,11 +320,11 @@ class AgentMarket(BaseModel):
     def is_resolved(self) -> bool:
         return self.resolution is not None
 
-    def get_liquidity(self) -> TokenAmount:
+    def get_liquidity(self) -> Token:
         raise NotImplementedError("Subclasses must implement this method")
 
     def has_liquidity(self) -> bool:
-        return self.get_liquidity().amount > 0
+        return self.get_liquidity() > 0
 
     def has_successful_resolution(self) -> bool:
         return self.resolution in [Resolution.YES, Resolution.NO]
@@ -287,7 +335,7 @@ class AgentMarket(BaseModel):
     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:
+    def get_outcome_str(self, outcome_index: int) -> OutcomeStr:
         try:
             return self.outcomes[outcome_index]
         except IndexError:
@@ -301,16 +349,19 @@ class AgentMarket(BaseModel):
         except ValueError:
             raise ValueError(f"Outcome `{outcome}` not found in `{self.outcomes}`.")
 
-    def get_token_balance(self, user_id: str, outcome: str) -> TokenAmount:
+    def get_token_balance(self, user_id: str, outcome: str) -> OutcomeToken:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def get_position(self, user_id: str) -> Position | None:
+    def get_position(self, user_id: str) -> ExistingPosition | None:
         raise NotImplementedError("Subclasses must implement this method")
 
     @classmethod
     def get_positions(
-        cls, user_id: str, liquid_only: bool = False, larger_than: float = 0
-    ) -> list[Position]:
+        cls,
+        user_id: str,
+        liquid_only: bool = False,
+        larger_than: OutcomeToken = OutcomeToken(0),
+    ) -> t.Sequence[Position]:
         """
         Get all non-zero positions a user has in any market.
 
@@ -321,13 +372,6 @@ class AgentMarket(BaseModel):
         """
         raise NotImplementedError("Subclasses must implement this method")
 
-    @classmethod
-    def get_positions_value(cls, positions: list[Position]) -> BetAmount:
-        """
-        Get the total value of all positions held by a user.
-        """
-        raise NotImplementedError("Subclasses must implement this method")
-
     def can_be_traded(self) -> bool:
         if self.is_closed() or not self.has_liquidity():
             return False
@@ -340,7 +384,7 @@ class AgentMarket(BaseModel):
     def has_token_pool(self) -> bool:
         return self.outcome_token_pool is not None
 
-    def get_pool_tokens(self, outcome: str) -> float:
+    def get_pool_tokens(self, outcome: str) -> OutcomeToken:
         if not self.outcome_token_pool:
             raise ValueError("Outcome token pool is not available.")
 

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -2,13 +2,7 @@ from web3 import Web3
 from web3.constants import HASH_ZERO
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import (
-    ChecksumAddress,
-    HexBytes,
-    HexStr,
-    xDai,
-    xdai_type,
-)
+from prediction_market_agent_tooling.gtypes import HexBytes, HexStr
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
 from prediction_market_agent_tooling.markets.omen.data_models import (
@@ -18,31 +12,11 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OmenAgentResultMappingContract,
 )
-from prediction_market_agent_tooling.tools.balances import get_balances
 from prediction_market_agent_tooling.tools.ipfs.ipfs_handler import IPFSHandler
 from prediction_market_agent_tooling.tools.utils import BPS_CONSTANT
 from prediction_market_agent_tooling.tools.web3_utils import ipfscidv0_to_byte32
 
 
-def get_total_balance(
-    address: ChecksumAddress,
-    web3: Web3 | None = None,
-    sum_xdai: bool = True,
-    sum_wxdai: bool = True,
-) -> xDai:
-    """
-    Checks if the total balance of xDai and wxDai in the wallet is above the minimum required balance.
-    """
-    current_balances = get_balances(address, web3)
-    # xDai and wxDai have equal value and can be exchanged for almost no cost, so we can sum them up.
-    total_balance = 0.0
-    if sum_xdai:
-        total_balance += current_balances.xdai
-    if sum_wxdai:
-        total_balance += current_balances.wxdai
-    return xdai_type(total_balance)
-
-
 def store_trades(
     market_id: str,
     traded_market: ProcessedTradedMarket | None,

prediction_market_agent_tooling/markets/data_models.py

@@ -1,19 +1,18 @@
 from enum import Enum
-from typing import Annotated, TypeAlias
+from typing import Annotated
 
 from pydantic import BaseModel, BeforeValidator, computed_field
 
-from prediction_market_agent_tooling.gtypes import OutcomeStr, Probability
+from prediction_market_agent_tooling.gtypes import (
+    USD,
+    OutcomeStr,
+    OutcomeToken,
+    Probability,
+    Token,
+)
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
-class Currency(str, Enum):
-    xDai = "xDai"
-    sDai = "sDai"
-    Mana = "Mana"
-    USDC = "USDC"
-
-
 class Resolution(str, Enum):
     YES = "YES"
     NO = "NO"
@@ -25,21 +24,9 @@ class Resolution(str, Enum):
         return Resolution.YES if value else Resolution.NO
 
 
-class TokenAmount(BaseModel):
-    amount: float
-    currency: Currency
-
-    def __str__(self) -> str:
-        return f"Amount {self.amount} currency {self.currency}"
-
-
-BetAmount: TypeAlias = TokenAmount
-ProfitAmount: TypeAlias = TokenAmount
-
-
 class Bet(BaseModel):
     id: str
-    amount: BetAmount
+    amount: Token
     outcome: bool
     created_time: DatetimeUTC
     market_question: str
@@ -52,7 +39,7 @@ class Bet(BaseModel):
 class ResolvedBet(Bet):
     market_outcome: bool
     resolved_time: DatetimeUTC
-    profit: ProfitAmount
+    profit: Token
 
     @computed_field  # type: ignore[prop-decorator]
     @property
@@ -63,10 +50,6 @@ class ResolvedBet(Bet):
         return f"Resolved bet for market {self.market_id} for question {self.market_question} created at {self.created_time}: {self.amount} on {self.outcome}. Bet was resolved at {self.resolved_time} and was {'correct' if self.is_correct else 'incorrect'}. Profit was {self.profit}"
 
 
-class TokenAmountAndDirection(TokenAmount):
-    direction: bool
-
-
 def to_boolean_outcome(value: str | bool) -> bool:
     if isinstance(value, bool):
         return value
@@ -102,23 +85,36 @@ class ProbabilisticAnswer(BaseModel):
 
 class Position(BaseModel):
     market_id: str
-    amounts: dict[OutcomeStr, TokenAmount]
+    # This is for how much we could buy or sell the position right now.
+    amounts_current: dict[OutcomeStr, USD]
 
     @property
-    def total_amount(self) -> TokenAmount:
-        return TokenAmount(
-            amount=sum(amount.amount for amount in self.amounts.values()),
-            currency=self.amounts[next(iter(self.amounts.keys()))].currency,
-        )
+    def total_amount_current(self) -> USD:
+        return sum(self.amounts_current.values(), start=USD(0))
 
     def __str__(self) -> str:
         amounts_str = ", ".join(
-            f"{amount.amount} '{outcome}' tokens"
-            for outcome, amount in self.amounts.items()
+            f"{amount} USD of '{outcome}' tokens"
+            for outcome, amount in self.amounts_current.items()
         )
         return f"Position for market id {self.market_id}: {amounts_str}"
 
 
+class ExistingPosition(Position):
+    # This is how much we will get if we win.
+    amounts_potential: dict[OutcomeStr, USD]
+    # These are raw outcome tokens of the market.
+    amounts_ot: dict[OutcomeStr, OutcomeToken]
+
+    @property
+    def total_amount_potential(self) -> USD:
+        return sum(self.amounts_potential.values(), start=USD(0))
+
+    @property
+    def total_amount_ot(self) -> OutcomeToken:
+        return sum(self.amounts_ot.values(), start=OutcomeToken(0))
+
+
 class TradeType(str, Enum):
     SELL = "sell"
     BUY = "buy"
@@ -127,7 +123,7 @@ class TradeType(str, Enum):
 class Trade(BaseModel):
     trade_type: TradeType
     outcome: bool
-    amount: TokenAmount
+    amount: USD
 
 
 class PlacedTrade(Trade):
@@ -149,12 +145,12 @@ class SimulatedBetDetail(BaseModel):
     market_p_yes: float
     agent_p_yes: float
     agent_conf: float
-    org_bet: float
-    sim_bet: float
+    org_bet: Token
+    sim_bet: Token
     org_dir: bool
     sim_dir: bool
-    org_profit: float
-    sim_profit: float
+    org_profit: Token
+    sim_profit: Token
     timestamp: DatetimeUTC
 
 
@@ -166,10 +162,10 @@ class SharpeOutput(BaseModel):
 
 class SimulatedLifetimeDetail(BaseModel):
     p_yes_mse: float
-    total_bet_amount: float
-    total_bet_profit: float
-    total_simulated_amount: float
-    total_simulated_profit: float
+    total_bet_amount: Token
+    total_bet_profit: Token
+    total_simulated_amount: Token
+    total_simulated_profit: Token
     roi: float
     simulated_roi: float
     sharpe_output_original: SharpeOutput

prediction_market_agent_tooling/markets/manifold/api.py

@@ -5,11 +5,7 @@ import tenacity
 
 from prediction_market_agent_tooling.gtypes import Mana, SecretStr
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.data_models import (
-    BetAmount,
-    Currency,
-    ResolvedBet,
-)
+from prediction_market_agent_tooling.markets.data_models import ResolvedBet
 from prediction_market_agent_tooling.markets.manifold.data_models import (
     FullManifoldMarket,
     ManifoldBet,
@@ -211,7 +207,7 @@ def manifold_to_generic_resolved_bet(
     market_outcome = market.get_resolved_boolean_outcome()
     return ResolvedBet(
         id=bet.id,
-        amount=BetAmount(amount=bet.amount, currency=Currency.Mana),
+        amount=bet.amount,
         outcome=bet.get_resolved_boolean_outcome(),
         created_time=bet.createdTime,
         market_question=market.question,

prediction_market_agent_tooling/markets/manifold/data_models.py

@@ -3,24 +3,37 @@ from enum import Enum
 
 from pydantic import BaseModel
 
-from prediction_market_agent_tooling.gtypes import Mana, Probability
-from prediction_market_agent_tooling.markets.data_models import (
-    Currency,
-    ProfitAmount,
-    Resolution,
+from prediction_market_agent_tooling.gtypes import (
+    USD,
+    Mana,
+    OutcomeStr,
+    OutcomeToken,
+    Probability,
+    Token,
 )
+from prediction_market_agent_tooling.markets.data_models import Resolution
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC, should_not_happen
 
 MANIFOLD_BASE_URL = "https://manifold.markets"
 
 
+def mana_to_usd(mana: Mana) -> USD:
+    # Not really, but for sake of simplicity. Mana are just play money.
+    return USD(mana.value)
+
+
+def usd_to_mana(usd: USD) -> Mana:
+    # Not really, but for sake of simplicity. Mana are just play money.
+    return Mana(usd.value)
+
+
 class ManifoldPool(BaseModel):
-    NO: float
-    YES: float
+    NO: OutcomeToken
+    YES: OutcomeToken
 
-    def size_for_outcome(self, outcome: str) -> float:
+    def size_for_outcome(self, outcome: str) -> OutcomeToken:
         if hasattr(self, outcome):
-            return float(getattr(self, outcome))
+            return OutcomeToken(getattr(self, outcome))
         else:
             should_not_happen(f"Unexpected outcome string, '{outcome}'.")
 
@@ -49,8 +62,6 @@ class ManifoldMarket(BaseModel):
     https://docs.manifold.markets/api#get-v0markets
     """
 
-    BET_AMOUNT_CURRENCY: t.ClassVar[Currency] = Currency.Mana
-
     id: str
     question: str
     creatorId: str
@@ -71,15 +82,15 @@ class ManifoldMarket(BaseModel):
     pool: ManifoldPool
     probability: Probability
     slug: str
-    totalLiquidity: t.Optional[Mana] = None
+    totalLiquidity: t.Optional[Token] = None
     uniqueBettorCount: int
     url: str
-    volume: Mana
-    volume24Hours: Mana
+    volume: Token
+    volume24Hours: Token
 
     @property
-    def outcomes(self) -> list[str]:
-        return list(self.pool.model_fields.keys())
+    def outcomes(self) -> t.Sequence[OutcomeStr]:
+        return [OutcomeStr(o) for o in self.pool.model_fields.keys()]
 
     def get_resolved_boolean_outcome(self) -> bool:
         if self.resolution == Resolution.YES:
@@ -170,18 +181,18 @@ class ManifoldBet(BaseModel):
     https://docs.manifold.markets/api#get-v0bets
     """
 
-    shares: float
+    shares: Token
     probBefore: Probability
     isFilled: t.Optional[bool] = None
     probAfter: Probability
     userId: str
-    amount: Mana
+    amount: Token
     contractId: str
     id: str
     fees: ManifoldBetFees
     isCancelled: t.Optional[bool] = None
-    loanAmount: Mana | None
-    orderAmount: t.Optional[Mana] = None
+    loanAmount: Token | None
+    orderAmount: t.Optional[Token] = None
     fills: t.Optional[list[ManifoldBetFills]] = None
     createdTime: DatetimeUTC
     outcome: Resolution
@@ -194,16 +205,13 @@ class ManifoldBet(BaseModel):
         else:
             should_not_happen(f"Unexpected bet outcome string, '{self.outcome.value}'.")
 
-    def get_profit(self, market_outcome: bool) -> ProfitAmount:
+    def get_profit(self, market_outcome: bool) -> Token:
         profit = (
             self.shares - self.amount
             if self.get_resolved_boolean_outcome() == market_outcome
             else -self.amount
         )
-        return ProfitAmount(
-            amount=profit,
-            currency=Currency.Mana,
-        )
+        return profit
 
 
 class ManifoldContractMetric(BaseModel):

prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -2,14 +2,13 @@ import typing as t
 from math import ceil
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import Mana, Probability, mana_type
+from prediction_market_agent_tooling.gtypes import USD, Mana, Probability, Token
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     FilterBy,
     MarketFees,
     SortBy,
 )
-from prediction_market_agent_tooling.markets.data_models import BetAmount, Currency
 from prediction_market_agent_tooling.markets.manifold.api import (
     get_authenticated_user,
     get_manifold_binary_markets,
@@ -19,6 +18,7 @@ from prediction_market_agent_tooling.markets.manifold.api import (
 from prediction_market_agent_tooling.markets.manifold.data_models import (
     MANIFOLD_BASE_URL,
     FullManifoldMarket,
+    usd_to_mana,
 )
 from prediction_market_agent_tooling.tools.betting_strategies.minimum_bet_to_win import (
     minimum_bet_to_win,
@@ -31,7 +31,6 @@ class ManifoldAgentMarket(AgentMarket):
     Manifold's market class that can be used by agents to make predictions.
     """
 
-    currency: t.ClassVar[Currency] = Currency.Mana
     base_url: t.ClassVar[str] = MANIFOLD_BASE_URL
 
     # Manifold has additional fees than `platform_absolute`, but they don't expose them in the API before placing the bet, see https://docs.manifold.markets/api.
@@ -49,19 +48,17 @@ class ManifoldAgentMarket(AgentMarket):
         """On Manifold, probablities aren't updated after the closure, so we can just use the current probability"""
         return self.current_p_no
 
-    @classmethod
-    def get_tiny_bet_amount(cls) -> BetAmount:
-        return BetAmount(amount=1, currency=cls.currency)
+    def get_tiny_bet_amount(self) -> Token:
+        return Token(1)
 
     def get_minimum_bet_to_win(self, answer: bool, amount_to_win: float) -> Mana:
         # Manifold lowest bet is 1 Mana, so we need to ceil the result.
-        return mana_type(ceil(minimum_bet_to_win(answer, amount_to_win, self)))
+        return Mana(ceil(minimum_bet_to_win(answer, amount_to_win, self)))
 
-    def place_bet(self, outcome: bool, amount: BetAmount) -> str:
-        if amount.currency != self.currency:
-            raise ValueError(f"Manifold bets are made in Mana. Got {amount.currency}.")
+    def place_bet(self, outcome: bool, amount: USD) -> str:
+        self.get_usd_in_token(amount)
         bet = place_bet(
-            amount=Mana(amount.amount),
+            amount=usd_to_mana(amount),
             market_id=self.id,
             outcome=outcome,
             manifold_api_key=APIKeys().manifold_api_key,