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

prediction_market_agent_tooling/markets/agent_market.py

@@ -6,22 +6,17 @@ 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,
-    OutcomeToken,
-    Probability,
-    Token,
-)
+from prediction_market_agent_tooling.gtypes import OutcomeStr, Probability
 from prediction_market_agent_tooling.markets.data_models import (
-    USD,
     Bet,
-    ExistingPosition,
+    BetAmount,
+    Currency,
     PlacedTrade,
     Position,
     ProbabilisticAnswer,
     Resolution,
     ResolvedBet,
-    Token,
+    TokenAmount,
 )
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.tools.utils import (
@@ -60,28 +55,31 @@ 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: t.Sequence[OutcomeStr]
-    outcome_token_pool: dict[str, OutcomeToken] | None
+    outcomes: list[str]
+    outcome_token_pool: (
+        dict[str, float] | None
+    )  # Should be in currency of `currency` above.
     resolution: Resolution | None
     created_time: DatetimeUTC | None
     close_time: DatetimeUTC | None
     current_p_yes: Probability
     url: str
-    volume: Token | None
+    volume: float | None  # Should be in currency of `currency` above.
     fees: MarketFees
 
     @field_validator("outcome_token_pool")
     def validate_outcome_token_pool(
         cls,
-        outcome_token_pool: dict[str, OutcomeToken] | None,
+        outcome_token_pool: dict[str, float] | None,
         info: FieldValidationInfo,
-    ) -> dict[str, OutcomeToken] | None:
-        outcomes: t.Sequence[OutcomeStr] = check_not_none(info.data.get("outcomes"))
+    ) -> 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)
@@ -104,28 +102,20 @@ class AgentMarket(BaseModel):
         return Probability(1 - self.current_p_yes)
 
     @property
-    def yes_outcome_price(self) -> Token:
+    def yes_outcome_price(self) -> float:
         """
         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 Token(self.current_p_yes)
-
-    @property
-    def yes_outcome_price_usd(self) -> USD:
-        return self.get_token_in_usd(self.yes_outcome_price)
+        return self.current_p_yes
 
     @property
-    def no_outcome_price(self) -> Token:
+    def no_outcome_price(self) -> float:
         """
         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 Token(self.current_p_no)
-
-    @property
-    def no_outcome_price_usd(self) -> USD:
-        return self.get_token_in_usd(self.no_outcome_price)
+        return self.current_p_no
 
     @property
     def probable_resolution(self) -> Resolution:
@@ -160,86 +150,48 @@ class AgentMarket(BaseModel):
         """
         raise NotImplementedError("Subclasses must implement this method")
 
-    def get_last_trade_yes_outcome_price(self) -> Token | None:
+    def get_last_trade_yes_outcome_price(self) -> float | 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 Token(last_trade_p_yes)
+            return float(last_trade_p_yes)
         return 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:
+    def get_last_trade_no_outcome_price(self) -> float | 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 Token(last_trade_p_no)
-        return None
-
-    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 float(last_trade_p_no)
         return None
 
-    def get_liquidatable_amount(self) -> OutcomeToken:
-        tiny_amount = self.get_tiny_bet_amount()
-        return OutcomeToken.from_token(tiny_amount / 10)
-
-    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_bet_amount(self, amount: float) -> BetAmount:
+        return BetAmount(amount=amount, currency=self.currency)
 
-    def get_in_token(self, x: USD | Token) -> Token:
-        if isinstance(x, Token):
-            return x
-        return self.get_usd_in_token(x)
+    @classmethod
+    def get_liquidatable_amount(cls) -> BetAmount:
+        tiny_amount = cls.get_tiny_bet_amount()
+        tiny_amount.amount /= 10
+        return tiny_amount
 
-    def get_tiny_bet_amount(self) -> Token:
-        """
-        Tiny bet amount that the platform still allows us to do.
-        """
+    @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: USD) -> str:
+    def place_bet(self, outcome: bool, amount: BetAmount) -> str:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def buy_tokens(self, outcome: bool, amount: USD) -> str:
+    def buy_tokens(self, outcome: bool, amount: TokenAmount) -> str:
         return self.place_bet(outcome=outcome, amount=amount)
 
     def get_buy_token_amount(
-        self, bet_amount: USD | Token, direction: bool
-    ) -> OutcomeToken:
+        self, bet_amount: BetAmount, direction: bool
+    ) -> TokenAmount:
         raise NotImplementedError("Subclasses must implement this method")
 
-    def sell_tokens(self, outcome: bool, amount: USD | OutcomeToken) -> str:
+    def sell_tokens(self, outcome: bool, amount: TokenAmount) -> str:
         raise NotImplementedError("Subclasses must implement this method")
 
     @staticmethod
@@ -263,8 +215,8 @@ class AgentMarket(BaseModel):
         """
         raise NotImplementedError("Subclasses must implement this method")
 
-    @classmethod
-    def get_trade_balance(cls, api_keys: APIKeys) -> USD:
+    @staticmethod
+    def get_trade_balance(api_keys: APIKeys) -> float:
         """
         Return balance that can be used to trade on the given market.
         """
@@ -320,11 +272,11 @@ class AgentMarket(BaseModel):
     def is_resolved(self) -> bool:
         return self.resolution is not None
 
-    def get_liquidity(self) -> Token:
+    def get_liquidity(self) -> TokenAmount:
         raise NotImplementedError("Subclasses must implement this method")
 
     def has_liquidity(self) -> bool:
-        return self.get_liquidity() > 0
+        return self.get_liquidity().amount > 0
 
     def has_successful_resolution(self) -> bool:
         return self.resolution in [Resolution.YES, Resolution.NO]
@@ -335,7 +287,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) -> OutcomeStr:
+    def get_outcome_str(self, outcome_index: int) -> str:
         try:
             return self.outcomes[outcome_index]
         except IndexError:
@@ -349,19 +301,16 @@ 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) -> OutcomeToken:
+    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) -> ExistingPosition | None:
+    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: OutcomeToken = OutcomeToken(0),
-    ) -> t.Sequence[Position]:
+        cls, user_id: str, liquid_only: bool = False, larger_than: float = 0
+    ) -> list[Position]:
         """
         Get all non-zero positions a user has in any market.
 
@@ -372,6 +321,13 @@ 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
@@ -384,7 +340,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) -> OutcomeToken:
+    def get_pool_tokens(self, outcome: str) -> float:
         if not self.outcome_token_pool:
             raise ValueError("Outcome token pool is not available.")
 

prediction_market_agent_tooling/markets/blockchain_utils.py

@@ -2,7 +2,13 @@ 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 HexBytes, HexStr
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    HexBytes,
+    HexStr,
+    xDai,
+    xdai_type,
+)
 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 (
@@ -12,11 +18,31 @@ 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,18 +1,19 @@
 from enum import Enum
-from typing import Annotated
+from typing import Annotated, TypeAlias
 
 from pydantic import BaseModel, BeforeValidator, computed_field
 
-from prediction_market_agent_tooling.gtypes import (
-    USD,
-    OutcomeStr,
-    OutcomeToken,
-    Probability,
-    Token,
-)
+from prediction_market_agent_tooling.gtypes import OutcomeStr, Probability
 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"
@@ -24,9 +25,21 @@ 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: Token
+    amount: BetAmount
     outcome: bool
     created_time: DatetimeUTC
     market_question: str
@@ -39,7 +52,7 @@ class Bet(BaseModel):
 class ResolvedBet(Bet):
     market_outcome: bool
     resolved_time: DatetimeUTC
-    profit: Token
+    profit: ProfitAmount
 
     @computed_field  # type: ignore[prop-decorator]
     @property
@@ -50,6 +63,10 @@ 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
@@ -85,36 +102,23 @@ class ProbabilisticAnswer(BaseModel):
 
 class Position(BaseModel):
     market_id: str
-    # This is for how much we could buy or sell the position right now.
-    amounts_current: dict[OutcomeStr, USD]
+    amounts: dict[OutcomeStr, TokenAmount]
 
     @property
-    def total_amount_current(self) -> USD:
-        return sum(self.amounts_current.values(), start=USD(0))
+    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 __str__(self) -> str:
         amounts_str = ", ".join(
-            f"{amount} USD of '{outcome}' tokens"
-            for outcome, amount in self.amounts_current.items()
+            f"{amount.amount} '{outcome}' tokens"
+            for outcome, amount in self.amounts.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"
@@ -123,7 +127,7 @@ class TradeType(str, Enum):
 class Trade(BaseModel):
     trade_type: TradeType
     outcome: bool
-    amount: USD
+    amount: TokenAmount
 
 
 class PlacedTrade(Trade):
@@ -145,12 +149,12 @@ class SimulatedBetDetail(BaseModel):
     market_p_yes: float
     agent_p_yes: float
     agent_conf: float
-    org_bet: Token
-    sim_bet: Token
+    org_bet: float
+    sim_bet: float
     org_dir: bool
     sim_dir: bool
-    org_profit: Token
-    sim_profit: Token
+    org_profit: float
+    sim_profit: float
     timestamp: DatetimeUTC
 
 
@@ -162,10 +166,10 @@ class SharpeOutput(BaseModel):
 
 class SimulatedLifetimeDetail(BaseModel):
     p_yes_mse: float
-    total_bet_amount: Token
-    total_bet_profit: Token
-    total_simulated_amount: Token
-    total_simulated_profit: Token
+    total_bet_amount: float
+    total_bet_profit: float
+    total_simulated_amount: float
+    total_simulated_profit: float
     roi: float
     simulated_roi: float
     sharpe_output_original: SharpeOutput

prediction_market_agent_tooling/markets/manifold/api.py

@@ -5,7 +5,11 @@ 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 ResolvedBet
+from prediction_market_agent_tooling.markets.data_models import (
+    BetAmount,
+    Currency,
+    ResolvedBet,
+)
 from prediction_market_agent_tooling.markets.manifold.data_models import (
     FullManifoldMarket,
     ManifoldBet,
@@ -207,7 +211,7 @@ def manifold_to_generic_resolved_bet(
     market_outcome = market.get_resolved_boolean_outcome()
     return ResolvedBet(
         id=bet.id,
-        amount=bet.amount,
+        amount=BetAmount(amount=bet.amount, currency=Currency.Mana),
         outcome=bet.get_resolved_boolean_outcome(),
         created_time=bet.createdTime,
         market_question=market.question,

prediction_market_agent_tooling/markets/manifold/data_models.py

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

prediction_market_agent_tooling/markets/manifold/manifold.py

@@ -2,13 +2,14 @@ import typing as t
 from math import ceil
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import USD, Mana, Probability, Token
+from prediction_market_agent_tooling.gtypes import Mana, Probability, mana_type
 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,
@@ -18,7 +19,6 @@ 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,6 +31,7 @@ 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.
@@ -48,17 +49,19 @@ 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
 
-    def get_tiny_bet_amount(self) -> Token:
-        return Token(1)
+    @classmethod
+    def get_tiny_bet_amount(cls) -> BetAmount:
+        return BetAmount(amount=1, currency=cls.currency)
 
     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(ceil(minimum_bet_to_win(answer, amount_to_win, self)))
+        return mana_type(ceil(minimum_bet_to_win(answer, amount_to_win, self)))
 
-    def place_bet(self, outcome: bool, amount: USD) -> str:
-        self.get_usd_in_token(amount)
+    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}.")
         bet = place_bet(
-            amount=usd_to_mana(amount),
+            amount=Mana(amount.amount),
             market_id=self.id,
             outcome=outcome,
             manifold_api_key=APIKeys().manifold_api_key,