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

prediction_market_agent_tooling/deploy/agent.py

@@ -40,8 +40,8 @@ from prediction_market_agent_tooling.markets.agent_market import (
     SortBy,
 )
 from prediction_market_agent_tooling.markets.data_models import (
-    ExistingPosition,
     PlacedTrade,
+    Position,
     ProbabilisticAnswer,
     Trade,
 )
@@ -582,9 +582,9 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         """
         user_id = market.get_user_id(api_keys=APIKeys())
 
-        total_amount = market.get_in_usd(market.get_tiny_bet_amount())
+        total_amount = market.get_tiny_bet_amount().amount
         if existing_position := market.get_position(user_id=user_id):
-            total_amount += existing_position.total_amount_current
+            total_amount += existing_position.total_amount.amount
 
         return MaxAccuracyBettingStrategy(bet_amount=total_amount)
 
@@ -592,10 +592,11 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         self,
         market: AgentMarket,
         answer: ProbabilisticAnswer,
-        existing_position: ExistingPosition | None,
+        existing_position: Position | None,
     ) -> list[Trade]:
         strategy = self.get_betting_strategy(market=market)
         trades = strategy.calculate_trades(existing_position, answer, market)
+        BettingStrategy.assert_trades_currency_match_markets(market, trades)
         return trades
 
     def before_process_market(

prediction_market_agent_tooling/deploy/betting_strategy.py

@@ -2,13 +2,14 @@ from abc import ABC, abstractmethod
 
 from scipy.optimize import minimize_scalar
 
-from prediction_market_agent_tooling.gtypes import USD, OutcomeToken, Token
+from prediction_market_agent_tooling.gtypes import xDai
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import AgentMarket, MarketFees
 from prediction_market_agent_tooling.markets.data_models import (
-    ExistingPosition,
+    Currency,
     Position,
     ProbabilisticAnswer,
+    TokenAmount,
     Trade,
     TradeType,
 )
@@ -30,7 +31,7 @@ class BettingStrategy(ABC):
     @abstractmethod
     def calculate_trades(
         self,
-        existing_position: ExistingPosition | None,
+        existing_position: Position | None,
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
@@ -38,11 +39,21 @@ class BettingStrategy(ABC):
 
     @property
     @abstractmethod
-    def maximum_possible_bet_amount(self) -> USD:
+    def maximum_possible_bet_amount(self) -> float:
         raise NotImplementedError("Subclass should implement this.")
 
-    def build_zero_usd_amount(self) -> USD:
-        return USD(0)
+    def build_zero_token_amount(self, currency: Currency) -> TokenAmount:
+        return TokenAmount(amount=0, currency=currency)
+
+    @staticmethod
+    def assert_trades_currency_match_markets(
+        market: AgentMarket, trades: list[Trade]
+    ) -> None:
+        currencies_match = all([t.amount.currency == market.currency for t in trades])
+        if not currencies_match:
+            raise ValueError(
+                "Cannot handle trades with currencies that deviate from market's currency"
+            )
 
     @staticmethod
     def assert_buy_trade_wont_be_guaranteed_loss(
@@ -53,21 +64,20 @@ class BettingStrategy(ABC):
                 outcome_tokens_to_get = market.get_buy_token_amount(
                     trade.amount, trade.outcome
                 )
-                outcome_tokens_to_get_in_usd = market.get_token_in_usd(
-                    outcome_tokens_to_get.as_token
-                )
-                if outcome_tokens_to_get_in_usd <= trade.amount:
+
+                if outcome_tokens_to_get.amount < trade.amount.amount:
                     raise GuaranteedLossError(
                         f"Trade {trade=} would result in guaranteed loss by getting only {outcome_tokens_to_get=}."
                     )
 
     @staticmethod
     def check_trades(market: AgentMarket, trades: list[Trade]) -> None:
+        BettingStrategy.assert_trades_currency_match_markets(market, trades)
         BettingStrategy.assert_buy_trade_wont_be_guaranteed_loss(market, trades)
 
     def _build_rebalance_trades_from_positions(
         self,
-        existing_position: ExistingPosition | None,
+        existing_position: Position | None,
         target_position: Position,
         market: AgentMarket,
     ) -> list[Trade]:
@@ -85,20 +95,23 @@ class BettingStrategy(ABC):
         trades = []
         for outcome_bool in [True, False]:
             outcome = market.get_outcome_str_from_bool(outcome_bool)
-            prev_amount = (
-                existing_position.amounts_current[outcome]
-                if existing_position and outcome in existing_position.amounts_current
-                else self.build_zero_usd_amount()
+            prev_amount: TokenAmount = (
+                existing_position.amounts[outcome]
+                if existing_position and outcome in existing_position.amounts
+                else self.build_zero_token_amount(currency=market.currency)
             )
-            new_amount = target_position.amounts_current.get(
-                outcome, self.build_zero_usd_amount()
+            new_amount: TokenAmount = target_position.amounts.get(
+                outcome, self.build_zero_token_amount(currency=market.currency)
             )
-            diff_amount = new_amount - prev_amount
+
+            if prev_amount.currency != new_amount.currency:
+                raise ValueError("Cannot handle positions with different currencies")
+            diff_amount = new_amount.amount - prev_amount.amount
             if diff_amount == 0:
                 continue
             trade_type = TradeType.SELL if diff_amount < 0 else TradeType.BUY
             trade = Trade(
-                amount=abs(diff_amount),
+                amount=TokenAmount(amount=abs(diff_amount), currency=market.currency),
                 outcome=outcome_bool,
                 trade_type=trade_type,
             )
@@ -115,25 +128,28 @@ class BettingStrategy(ABC):
 
 
 class MaxAccuracyBettingStrategy(BettingStrategy):
-    def __init__(self, bet_amount: USD):
+    def __init__(self, bet_amount: float):
         self.bet_amount = bet_amount
 
     @property
-    def maximum_possible_bet_amount(self) -> USD:
+    def maximum_possible_bet_amount(self) -> float:
         return self.bet_amount
 
     def calculate_trades(
         self,
-        existing_position: ExistingPosition | None,
+        existing_position: Position | None,
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
         direction = self.calculate_direction(market.current_p_yes, answer.p_yes)
 
         amounts = {
-            market.get_outcome_str_from_bool(direction): self.bet_amount,
+            market.get_outcome_str_from_bool(direction): TokenAmount(
+                amount=self.bet_amount,
+                currency=market.currency,
+            ),
         }
-        target_position = Position(market_id=market.id, amounts_current=amounts)
+        target_position = Position(market_id=market.id, amounts=amounts)
         trades = self._build_rebalance_trades_from_positions(
             existing_position, target_position, market=market
         )
@@ -157,17 +173,17 @@ class MaxExpectedValueBettingStrategy(MaxAccuracyBettingStrategy):
 
 
 class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD, max_price_impact: float | None = None):
+    def __init__(self, max_bet_amount: float, max_price_impact: float | None = None):
         self.max_bet_amount = max_bet_amount
         self.max_price_impact = max_price_impact
 
     @property
-    def maximum_possible_bet_amount(self) -> USD:
+    def maximum_possible_bet_amount(self) -> float:
         return self.max_bet_amount
 
     def calculate_trades(
         self,
-        existing_position: ExistingPosition | None,
+        existing_position: Position | None,
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
@@ -180,7 +196,7 @@ class KellyBettingStrategy(BettingStrategy):
                 market.get_outcome_str_from_bool(False)
             ],
             estimated_p_yes=answer.p_yes,
-            max_bet=market.get_usd_in_token(self.max_bet_amount),
+            max_bet=self.max_bet_amount,
             confidence=answer.confidence,
             fees=market.fees,
         )
@@ -196,11 +212,11 @@ class KellyBettingStrategy(BettingStrategy):
             kelly_bet_size = min(kelly_bet.size, max_price_impact_bet_amount)
 
         amounts = {
-            market.get_outcome_str_from_bool(
-                kelly_bet.direction
-            ): market.get_token_in_usd(kelly_bet_size),
+            market.get_outcome_str_from_bool(kelly_bet.direction): TokenAmount(
+                amount=kelly_bet_size, currency=market.currency
+            ),
         }
-        target_position = Position(market_id=market.id, amounts_current=amounts)
+        target_position = Position(market_id=market.id, amounts=amounts)
         trades = self._build_rebalance_trades_from_positions(
             existing_position, target_position, market=market
         )
@@ -209,9 +225,9 @@ class KellyBettingStrategy(BettingStrategy):
     def calculate_price_impact_for_bet_amount(
         self,
         buy_direction: bool,
-        bet_amount: Token,
-        yes: OutcomeToken,
-        no: OutcomeToken,
+        bet_amount: float,
+        yes: float,
+        no: float,
         fees: MarketFees,
     ) -> float:
         total_outcome_tokens = yes + no
@@ -223,7 +239,7 @@ class KellyBettingStrategy(BettingStrategy):
             bet_amount, buy_direction, yes, no, fees
         )
 
-        actual_price = bet_amount.value / tokens_to_buy.value
+        actual_price = bet_amount / tokens_to_buy
         # price_impact should always be > 0
         price_impact = (actual_price - expected_price) / expected_price
         return price_impact
@@ -232,13 +248,13 @@ class KellyBettingStrategy(BettingStrategy):
         self,
         market: AgentMarket,
         kelly_bet: SimpleBet,
-    ) -> Token:
+    ) -> float:
         def calculate_price_impact_deviation_from_target_price_impact(
-            bet_amount_usd: float,  # Needs to be float because it's used in minimize_scalar internally.
+            bet_amount: xDai,
         ) -> float:
             price_impact = self.calculate_price_impact_for_bet_amount(
                 kelly_bet.direction,
-                market.get_usd_in_token(USD(bet_amount_usd)),
+                bet_amount,
                 yes_outcome_pool_size,
                 no_outcome_pool_size,
                 market.fees,
@@ -264,41 +280,40 @@ class KellyBettingStrategy(BettingStrategy):
         # The bounds below have been found to work heuristically.
         optimized_bet_amount = minimize_scalar(
             calculate_price_impact_deviation_from_target_price_impact,
-            bounds=(0, 1000 * (yes_outcome_pool_size + no_outcome_pool_size).value),
+            bounds=(0, 1000 * (yes_outcome_pool_size + no_outcome_pool_size)),
             method="bounded",
             tol=1e-11,
             options={"maxiter": 10000},
         )
-        return Token(optimized_bet_amount.x)
+        return float(optimized_bet_amount.x)
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(max_bet_amount={self.max_bet_amount}, max_price_impact={self.max_price_impact})"
 
 
 class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: USD):
+    def __init__(self, max_bet_amount: float = 10):
         self.max_bet_amount = max_bet_amount
 
     @property
-    def maximum_possible_bet_amount(self) -> USD:
+    def maximum_possible_bet_amount(self) -> float:
         return self.max_bet_amount
 
     def adjust_bet_amount(
-        self, existing_position: ExistingPosition | None, market: AgentMarket
-    ) -> USD:
+        self, existing_position: Position | None, market: AgentMarket
+    ) -> float:
         existing_position_total_amount = (
-            existing_position.total_amount_current if existing_position else USD(0)
+            existing_position.total_amount.amount if existing_position else 0
         )
         return self.max_bet_amount + existing_position_total_amount
 
     def calculate_trades(
         self,
-        existing_position: ExistingPosition | None,
+        existing_position: Position | None,
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
-        adjusted_bet_amount_usd = self.adjust_bet_amount(existing_position, market)
-        adjusted_bet_amount_token = market.get_usd_in_token(adjusted_bet_amount_usd)
+        adjusted_bet_amount = self.adjust_bet_amount(existing_position, market)
         outcome_token_pool = check_not_none(market.outcome_token_pool)
 
         # Fixed direction of bet, only use Kelly to adjust the bet size based on market's outcome pool size.
@@ -313,16 +328,17 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
                 market.get_outcome_str_from_bool(False)
             ],
             estimated_p_yes=estimated_p_yes,
-            max_bet=adjusted_bet_amount_token,
+            max_bet=adjusted_bet_amount,
             confidence=confidence,
             fees=market.fees,
         )
-        kelly_bet_size_usd = market.get_token_in_usd(kelly_bet.size)
 
         amounts = {
-            market.get_outcome_str_from_bool(kelly_bet.direction): kelly_bet_size_usd,
+            market.get_outcome_str_from_bool(kelly_bet.direction): TokenAmount(
+                amount=kelly_bet.size, currency=market.currency
+            ),
         }
-        target_position = Position(market_id=market.id, amounts_current=amounts)
+        target_position = Position(market_id=market.id, amounts=amounts)
         trades = self._build_rebalance_trades_from_positions(
             existing_position, target_position, market=market
         )

prediction_market_agent_tooling/gtypes.py

@@ -1,6 +1,5 @@
 import typing as t
-from decimal import Decimal
-from typing import NewType
+from typing import NewType, Union
 
 from eth_typing.evm import (  # noqa: F401  # Import for the sake of easy importing with others from here.
     Address,
@@ -10,15 +9,13 @@ from eth_typing.evm import (  # noqa: F401  # Import for the sake of easy import
 )
 from pydantic.types import SecretStr
 from pydantic.v1.types import SecretStr as SecretStrV1
-from web3 import Web3
 from web3.types import (  # noqa: F401  # Import for the sake of easy importing with others from here.
     Nonce,
     TxParams,
     TxReceipt,
+    Wei,
 )
-from web3.types import Wei as Web3Wei
 
-from prediction_market_agent_tooling.tools._generic_value import _GenericValue
 from prediction_market_agent_tooling.tools.datetime_utc import (  # noqa: F401  # Import for the sake of easy importing with others from here.
     DatetimeUTC,
 )
@@ -26,118 +23,43 @@ from prediction_market_agent_tooling.tools.hexbytes_custom import (  # noqa: F40
     HexBytes,
 )
 
+Wad = Wei  # Wei tends to be referred to as `wad` variable in contracts.
+USD = NewType("USD", float)
+PrivateKey = NewType("PrivateKey", SecretStr)
+xDai = NewType("xDai", float)
+GNO = NewType("GNO", float)
+ABI = NewType("ABI", str)
+OmenOutcomeToken = NewType("OmenOutcomeToken", Wei)
+OutcomeStr = NewType("OutcomeStr", str)
+Probability = NewType("Probability", float)
+Mana = NewType("Mana", float)  # Manifold's "currency"
+USDC = NewType("USDC", float)
+ChainID = NewType("ChainID", int)
+IPFSCIDVersion0 = NewType("IPFSCIDVersion0", str)
 
-class Token(_GenericValue[int | float | str | Decimal, float], parser=float):
-    """
-    Represents any token in its decimal form, it could be 1.1 GNO, WXDAI, XDAI, Mana, whatever. We don't know the currency, just that it's in the decimal form.
-    """
-
-    @property
-    def as_wei(self) -> "Wei":
-        return Wei(Web3.to_wei(self.value, "ether"))
-
-
-class OutcomeToken(_GenericValue[int | float | str | Decimal, float], parser=float):
-    """
-    Represents outcome tokens in market in decimal form.
-    After you redeem the outcome tokens, 1 OutcomeToken equals to 1 Token, but before, it's important to distinguish between them.
-    For example, it's a big difference if you are going to sell 1 OutcomeToken, or 1 (collateral) Token.
-    But still, Token and OutcomeToken needs to be handled together in many cases, use available properties to convert between them explicitly.
-    """
-
-    @staticmethod
-    def from_token(token: Token) -> "OutcomeToken":
-        return OutcomeToken(token.value)
-
-    @property
-    def as_outcome_wei(self) -> "OutcomeWei":
-        return OutcomeWei(Web3.to_wei(self.value, "ether"))
-
-    @property
-    def as_token(self) -> Token:
-        """
-        OutcomeToken is essentialy Token as well, when you know you really need to convert it, you can convert it explicitly using this.
-        """
-        return Token(self.value)
-
-
-class USD(_GenericValue[int | float | str | Decimal, float], parser=float):
-    """Represents values in USD."""
-
-
-class xDai(_GenericValue[int | float | str | Decimal, float], parser=float):
-    """Represents values in xDai."""
-
-    @property
-    def as_token(self) -> Token:
-        """
-        xDai is essentialy Token as well, when you know you need to pass it, you can convert it using this.
-        """
-        return Token(self.value)
-
-    @property
-    def as_xdai_wei(self) -> "xDaiWei":
-        return xDaiWei(Web3.to_wei(self.value, "ether"))
-
-
-class Mana(_GenericValue[int | float | str | Decimal, float], parser=float):
-    """Represents values in Manifold's Mana."""
-
-
-class USDC(_GenericValue[int | float | str | Decimal, float], parser=float):
-    """Represents values in USDC."""
-
-
-class Wei(_GenericValue[Web3Wei | int | str, Web3Wei], parser=int):
-    """Represents values in Wei. We don't know what currency, but in its integer form called Wei."""
-
-    @property
-    def as_token(self) -> Token:
-        return Token(Web3.from_wei(self.value, "ether"))
 
+def usd_type(amount: Union[str, int, float]) -> USD:
+    return USD(float(amount))
 
-class OutcomeWei(_GenericValue[Web3Wei | int | str, Web3Wei], parser=int):
-    """
-    Similar to OutcomeToken, but in Wei units.
-    """
 
-    @staticmethod
-    def from_wei(wei: Wei) -> "OutcomeWei":
-        return OutcomeWei(wei.value)
+def wei_type(amount: Union[str, int, float]) -> Wei:
+    return Wei(int(amount))
 
-    @property
-    def as_outcome_token(self) -> OutcomeToken:
-        return OutcomeToken(Web3.from_wei(self.value, "ether"))
 
-    @property
-    def as_wei(self) -> Wei:
-        """
-        OutcomeWei is essentialy Wei as well, when you know you need to pass it, you can convert it using this.
-        """
-        return Wei(self.value)
+def omen_outcome_type(amount: Union[str, int, Wei]) -> OmenOutcomeToken:
+    return OmenOutcomeToken(wei_type(amount))
 
 
-class xDaiWei(_GenericValue[Web3Wei | int | str, Web3Wei], parser=int):
-    """Represents xDai in Wei, like 1.9 xDai is 1.9 * 10**18 Wei. In contrast to just `Wei`, we don't know what unit Wei is (Wei of GNO, sDai, or whatever), but xDaiWei is xDai converted to Wei."""
+def xdai_type(amount: Union[str, int, float]) -> xDai:
+    return xDai(float(amount))
 
-    @property
-    def as_xdai(self) -> xDai:
-        return xDai(Web3.from_wei(self.value, "ether"))
 
-    @property
-    def as_wei(self) -> Wei:
-        """
-        xDaiWei is essentialy Wei as well, when you know you need to pass it, you can convert it using this.
-        """
-        return Wei(self.value)
+def mana_type(amount: Union[str, int, float]) -> Mana:
+    return Mana(float(amount))
 
 
-PrivateKey = NewType("PrivateKey", SecretStr)
-ABI = NewType("ABI", str)
-OutcomeStr = NewType("OutcomeStr", str)
-Probability = NewType("Probability", float)
-ChainID = NewType("ChainID", int)
-IPFSCIDVersion0 = NewType("IPFSCIDVersion0", str)
+def usdc_type(amount: Union[str, int, float]) -> USDC:
+    return USDC(float(amount))
 
 
 def private_key_type(k: str) -> PrivateKey:

prediction_market_agent_tooling/jobs/jobs_models.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from pydantic import BaseModel
 
 from prediction_market_agent_tooling.deploy.betting_strategy import ProbabilisticAnswer
-from prediction_market_agent_tooling.gtypes import USD, Probability
+from prediction_market_agent_tooling.gtypes import Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     ProcessedTradedMarket,
@@ -19,7 +19,8 @@ from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 class SimpleJob(BaseModel):
     id: str
     job: str
-    reward: USD
+    reward: float
+    currency: str
     deadline: DatetimeUTC
 
 
@@ -37,7 +38,7 @@ class JobAgentMarket(AgentMarket, ABC):
         """Deadline for the job completion."""
 
     @abstractmethod
-    def get_reward(self, max_bond: USD) -> USD:
+    def get_reward(self, max_bond: float) -> float:
         """Reward for completing this job."""
 
     @classmethod
@@ -57,15 +58,16 @@ class JobAgentMarket(AgentMarket, ABC):
 
     @abstractmethod
     def submit_job_result(
-        self, agent_name: str, max_bond: USD, result: str
+        self, agent_name: str, max_bond: float, result: str
     ) -> ProcessedTradedMarket:
         """Submit the completed result for this job."""
 
-    def to_simple_job(self, max_bond: USD) -> SimpleJob:
+    def to_simple_job(self, max_bond: float) -> SimpleJob:
         return SimpleJob(
             id=self.id,
             job=self.job,
             reward=self.get_reward(max_bond),
+            currency=self.currency.value,
             deadline=self.deadline,
         )
 

prediction_market_agent_tooling/jobs/omen/omen_jobs.py

@@ -2,14 +2,15 @@ import typing as t
 
 from prediction_market_agent_tooling.config import APIKeys
 from prediction_market_agent_tooling.deploy.betting_strategy import (
+    Currency,
     KellyBettingStrategy,
     TradeType,
 )
-from prediction_market_agent_tooling.gtypes import USD
 from prediction_market_agent_tooling.jobs.jobs_models import JobAgentMarket
 from prediction_market_agent_tooling.markets.agent_market import ProcessedTradedMarket
 from prediction_market_agent_tooling.markets.data_models import PlacedTrade, Trade
 from prediction_market_agent_tooling.markets.omen.omen import (
+    BetAmount,
     OmenAgentMarket,
     OmenMarket,
 )
@@ -33,21 +34,21 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
     def deadline(self) -> DatetimeUTC:
         return self.close_time
 
-    def get_reward(self, max_bond: USD) -> USD:
+    def get_reward(self, max_bond: float) -> float:
         trade = self.get_job_trade(
             max_bond,
             result="",  # Pass empty result, as we are computing only potential reward at this point.
         )
-        reward_usd = (
-            self.get_token_in_usd(
-                self.get_buy_token_amount(
-                    bet_amount=trade.amount,
-                    direction=trade.outcome,
-                ).as_token
-            )
-            - trade.amount
+        reward = (
+            self.get_buy_token_amount(
+                bet_amount=BetAmount(
+                    amount=trade.amount.amount, currency=trade.amount.currency
+                ),
+                direction=trade.outcome,
+            ).amount
+            - trade.amount.amount
         )
-        return reward_usd
+        return reward
 
     @classmethod
     def get_jobs(
@@ -71,7 +72,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         )
 
     def submit_job_result(
-        self, agent_name: str, max_bond: USD, result: str
+        self, agent_name: str, max_bond: float, result: str
     ) -> ProcessedTradedMarket:
         if not APIKeys().enable_ipfs_upload:
             raise RuntimeError(
@@ -91,7 +92,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
         return processed_traded_market
 
-    def get_job_trade(self, max_bond: USD, result: str) -> Trade:
+    def get_job_trade(self, max_bond: float, result: str) -> Trade:
         # Because jobs are powered by prediction markets, potentional reward depends on job's liquidity and our will to bond (bet) our xDai into our job completion.
         strategy = KellyBettingStrategy(max_bet_amount=max_bond)
         required_trades = strategy.calculate_trades(
@@ -105,6 +106,9 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         trade = required_trades[0]
         assert trade.trade_type == TradeType.BUY, "Should only buy on job markets."
         assert trade.outcome, "Should buy only YES on job markets."
+        assert (
+            trade.amount.currency == Currency.xDai
+        ), "Should work only on real-money markets."
         return required_trades[0]
 
     @staticmethod