prediction-market-agent-tooling 0.61.1.dev489__py3-none-any.whl → 0.62.0__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_tiny_bet_amount().amount
+        total_amount = market.get_in_usd(market.get_tiny_bet_amount())
         if existing_position := market.get_position(user_id=user_id):
-            total_amount += existing_position.total_amount.amount
+            total_amount += existing_position.total_amount_current
 
         return MaxAccuracyBettingStrategy(bet_amount=total_amount)
 
@@ -592,11 +592,10 @@ class DeployableTraderAgent(DeployablePredictionAgent):
         self,
         market: AgentMarket,
         answer: ProbabilisticAnswer,
-        existing_position: Position | None,
+        existing_position: ExistingPosition | 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,14 +2,13 @@ from abc import ABC, abstractmethod
 
 from scipy.optimize import minimize_scalar
 
-from prediction_market_agent_tooling.gtypes import xDai
+from prediction_market_agent_tooling.gtypes import USD, CollateralToken, OutcomeToken
 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 (
-    Currency,
+    ExistingPosition,
     Position,
     ProbabilisticAnswer,
-    TokenAmount,
     Trade,
     TradeType,
 )
@@ -31,7 +30,7 @@ class BettingStrategy(ABC):
     @abstractmethod
     def calculate_trades(
         self,
-        existing_position: Position | None,
+        existing_position: ExistingPosition | None,
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
@@ -39,21 +38,11 @@ class BettingStrategy(ABC):
 
     @property
     @abstractmethod
-    def maximum_possible_bet_amount(self) -> float:
+    def maximum_possible_bet_amount(self) -> USD:
         raise NotImplementedError("Subclass should implement this.")
 
-    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"
-            )
+    def build_zero_usd_amount(self) -> USD:
+        return USD(0)
 
     @staticmethod
     def assert_buy_trade_wont_be_guaranteed_loss(
@@ -64,20 +53,21 @@ class BettingStrategy(ABC):
                 outcome_tokens_to_get = market.get_buy_token_amount(
                     trade.amount, trade.outcome
                 )
-
-                if outcome_tokens_to_get.amount < trade.amount.amount:
+                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:
                     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: Position | None,
+        existing_position: ExistingPosition | None,
         target_position: Position,
         market: AgentMarket,
     ) -> list[Trade]:
@@ -95,23 +85,20 @@ class BettingStrategy(ABC):
         trades = []
         for outcome_bool in [True, False]:
             outcome = market.get_outcome_str_from_bool(outcome_bool)
-            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)
+            prev_amount = (
+                existing_position.amounts_current[outcome]
+                if existing_position and outcome in existing_position.amounts_current
+                else self.build_zero_usd_amount()
             )
-            new_amount: TokenAmount = target_position.amounts.get(
-                outcome, self.build_zero_token_amount(currency=market.currency)
+            new_amount = target_position.amounts_current.get(
+                outcome, self.build_zero_usd_amount()
             )
-
-            if prev_amount.currency != new_amount.currency:
-                raise ValueError("Cannot handle positions with different currencies")
-            diff_amount = new_amount.amount - prev_amount.amount
+            diff_amount = new_amount - prev_amount
             if diff_amount == 0:
                 continue
             trade_type = TradeType.SELL if diff_amount < 0 else TradeType.BUY
             trade = Trade(
-                amount=TokenAmount(amount=abs(diff_amount), currency=market.currency),
+                amount=abs(diff_amount),
                 outcome=outcome_bool,
                 trade_type=trade_type,
             )
@@ -128,28 +115,25 @@ class BettingStrategy(ABC):
 
 
 class MaxAccuracyBettingStrategy(BettingStrategy):
-    def __init__(self, bet_amount: float):
+    def __init__(self, bet_amount: USD):
         self.bet_amount = bet_amount
 
     @property
-    def maximum_possible_bet_amount(self) -> float:
+    def maximum_possible_bet_amount(self) -> USD:
         return self.bet_amount
 
     def calculate_trades(
         self,
-        existing_position: Position | None,
+        existing_position: ExistingPosition | 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): TokenAmount(
-                amount=self.bet_amount,
-                currency=market.currency,
-            ),
+            market.get_outcome_str_from_bool(direction): self.bet_amount,
         }
-        target_position = Position(market_id=market.id, amounts=amounts)
+        target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(
             existing_position, target_position, market=market
         )
@@ -173,17 +157,17 @@ class MaxExpectedValueBettingStrategy(MaxAccuracyBettingStrategy):
 
 
 class KellyBettingStrategy(BettingStrategy):
-    def __init__(self, max_bet_amount: float, max_price_impact: float | None = None):
+    def __init__(self, max_bet_amount: USD, 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) -> float:
+    def maximum_possible_bet_amount(self) -> USD:
         return self.max_bet_amount
 
     def calculate_trades(
         self,
-        existing_position: Position | None,
+        existing_position: ExistingPosition | None,
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
@@ -196,7 +180,7 @@ class KellyBettingStrategy(BettingStrategy):
                 market.get_outcome_str_from_bool(False)
             ],
             estimated_p_yes=answer.p_yes,
-            max_bet=self.max_bet_amount,
+            max_bet=market.get_usd_in_token(self.max_bet_amount),
             confidence=answer.confidence,
             fees=market.fees,
         )
@@ -212,11 +196,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): TokenAmount(
-                amount=kelly_bet_size, currency=market.currency
-            ),
+            market.get_outcome_str_from_bool(
+                kelly_bet.direction
+            ): market.get_token_in_usd(kelly_bet_size),
         }
-        target_position = Position(market_id=market.id, amounts=amounts)
+        target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(
             existing_position, target_position, market=market
         )
@@ -225,9 +209,9 @@ class KellyBettingStrategy(BettingStrategy):
     def calculate_price_impact_for_bet_amount(
         self,
         buy_direction: bool,
-        bet_amount: float,
-        yes: float,
-        no: float,
+        bet_amount: CollateralToken,
+        yes: OutcomeToken,
+        no: OutcomeToken,
         fees: MarketFees,
     ) -> float:
         total_outcome_tokens = yes + no
@@ -239,7 +223,7 @@ class KellyBettingStrategy(BettingStrategy):
             bet_amount, buy_direction, yes, no, fees
         )
 
-        actual_price = bet_amount / tokens_to_buy
+        actual_price = bet_amount.value / tokens_to_buy.value
         # price_impact should always be > 0
         price_impact = (actual_price - expected_price) / expected_price
         return price_impact
@@ -248,13 +232,13 @@ class KellyBettingStrategy(BettingStrategy):
         self,
         market: AgentMarket,
         kelly_bet: SimpleBet,
-    ) -> float:
+    ) -> CollateralToken:
         def calculate_price_impact_deviation_from_target_price_impact(
-            bet_amount: xDai,
+            bet_amount_usd: float,  # Needs to be float because it's used in minimize_scalar internally.
         ) -> float:
             price_impact = self.calculate_price_impact_for_bet_amount(
                 kelly_bet.direction,
-                bet_amount,
+                market.get_usd_in_token(USD(bet_amount_usd)),
                 yes_outcome_pool_size,
                 no_outcome_pool_size,
                 market.fees,
@@ -280,40 +264,41 @@ 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)),
+            bounds=(0, 1000 * (yes_outcome_pool_size + no_outcome_pool_size).value),
             method="bounded",
             tol=1e-11,
             options={"maxiter": 10000},
         )
-        return float(optimized_bet_amount.x)
+        return CollateralToken(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: float = 10):
+    def __init__(self, max_bet_amount: USD):
         self.max_bet_amount = max_bet_amount
 
     @property
-    def maximum_possible_bet_amount(self) -> float:
+    def maximum_possible_bet_amount(self) -> USD:
         return self.max_bet_amount
 
     def adjust_bet_amount(
-        self, existing_position: Position | None, market: AgentMarket
-    ) -> float:
+        self, existing_position: ExistingPosition | None, market: AgentMarket
+    ) -> USD:
         existing_position_total_amount = (
-            existing_position.total_amount.amount if existing_position else 0
+            existing_position.total_amount_current if existing_position else USD(0)
         )
         return self.max_bet_amount + existing_position_total_amount
 
     def calculate_trades(
         self,
-        existing_position: Position | None,
+        existing_position: ExistingPosition | None,
         answer: ProbabilisticAnswer,
         market: AgentMarket,
     ) -> list[Trade]:
-        adjusted_bet_amount = self.adjust_bet_amount(existing_position, market)
+        adjusted_bet_amount_usd = self.adjust_bet_amount(existing_position, market)
+        adjusted_bet_amount_token = market.get_usd_in_token(adjusted_bet_amount_usd)
         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.
@@ -328,17 +313,16 @@ class MaxAccuracyWithKellyScaledBetsStrategy(BettingStrategy):
                 market.get_outcome_str_from_bool(False)
             ],
             estimated_p_yes=estimated_p_yes,
-            max_bet=adjusted_bet_amount,
+            max_bet=adjusted_bet_amount_token,
             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): TokenAmount(
-                amount=kelly_bet.size, currency=market.currency
-            ),
+            market.get_outcome_str_from_bool(kelly_bet.direction): kelly_bet_size_usd,
         }
-        target_position = Position(market_id=market.id, amounts=amounts)
+        target_position = Position(market_id=market.id, amounts_current=amounts)
         trades = self._build_rebalance_trades_from_positions(
             existing_position, target_position, market=market
         )

prediction_market_agent_tooling/gtypes.py

@@ -1,5 +1,6 @@
 import typing as t
-from typing import NewType, Union
+from decimal import Decimal
+from typing import NewType
 
 from eth_typing.evm import (  # noqa: F401  # Import for the sake of easy importing with others from here.
     Address,
@@ -9,13 +10,15 @@ 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,
 )
@@ -23,43 +26,118 @@ 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 CollateralToken(_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: CollateralToken) -> "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) -> CollateralToken:
+        """
+        OutcomeToken is essentialy Token as well, when you know you really need to convert it, you can convert it explicitly using this.
+        """
+        return CollateralToken(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."""
 
-def usd_type(amount: Union[str, int, float]) -> USD:
-    return USD(float(amount))
+    @property
+    def as_token(self) -> CollateralToken:
+        """
+        xDai is essentialy Token as well, when you know you need to pass it, you can convert it using this.
+        """
+        return CollateralToken(self.value)
 
+    @property
+    def as_xdai_wei(self) -> "xDaiWei":
+        return xDaiWei(Web3.to_wei(self.value, "ether"))
 
-def wei_type(amount: Union[str, int, float]) -> Wei:
-    return Wei(int(amount))
 
+class Mana(_GenericValue[int | float | str | Decimal, float], parser=float):
+    """Represents values in Manifold's Mana."""
 
-def omen_outcome_type(amount: Union[str, int, Wei]) -> OmenOutcomeToken:
-    return OmenOutcomeToken(wei_type(amount))
 
+class USDC(_GenericValue[int | float | str | Decimal, float], parser=float):
+    """Represents values in USDC."""
 
-def xdai_type(amount: Union[str, int, float]) -> xDai:
-    return xDai(float(amount))
 
+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."""
 
-def mana_type(amount: Union[str, int, float]) -> Mana:
-    return Mana(float(amount))
+    @property
+    def as_token(self) -> CollateralToken:
+        return CollateralToken(Web3.from_wei(self.value, "ether"))
 
 
-def usdc_type(amount: Union[str, int, float]) -> USDC:
-    return USDC(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)
+
+    @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)
+
+
+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."""
+
+    @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)
+
+
+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 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 Probability
+from prediction_market_agent_tooling.gtypes import USD, Probability
 from prediction_market_agent_tooling.markets.agent_market import (
     AgentMarket,
     ProcessedTradedMarket,
@@ -19,8 +19,7 @@ from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 class SimpleJob(BaseModel):
     id: str
     job: str
-    reward: float
-    currency: str
+    reward: USD
     deadline: DatetimeUTC
 
 
@@ -38,7 +37,7 @@ class JobAgentMarket(AgentMarket, ABC):
         """Deadline for the job completion."""
 
     @abstractmethod
-    def get_reward(self, max_bond: float) -> float:
+    def get_reward(self, max_bond: USD) -> USD:
         """Reward for completing this job."""
 
     @classmethod
@@ -58,16 +57,15 @@ class JobAgentMarket(AgentMarket, ABC):
 
     @abstractmethod
     def submit_job_result(
-        self, agent_name: str, max_bond: float, result: str
+        self, agent_name: str, max_bond: USD, result: str
     ) -> ProcessedTradedMarket:
         """Submit the completed result for this job."""
 
-    def to_simple_job(self, max_bond: float) -> SimpleJob:
+    def to_simple_job(self, max_bond: USD) -> 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,15 +2,14 @@ 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,
 )
@@ -34,21 +33,21 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
     def deadline(self) -> DatetimeUTC:
         return self.close_time
 
-    def get_reward(self, max_bond: float) -> float:
+    def get_reward(self, max_bond: USD) -> USD:
         trade = self.get_job_trade(
             max_bond,
             result="",  # Pass empty result, as we are computing only potential reward at this point.
         )
-        reward = (
-            self.get_buy_token_amount(
-                bet_amount=BetAmount(
-                    amount=trade.amount.amount, currency=trade.amount.currency
-                ),
-                direction=trade.outcome,
-            ).amount
-            - trade.amount.amount
+        reward_usd = (
+            self.get_token_in_usd(
+                self.get_buy_token_amount(
+                    bet_amount=trade.amount,
+                    direction=trade.outcome,
+                ).as_token
+            )
+            - trade.amount
         )
-        return reward
+        return reward_usd
 
     @classmethod
     def get_jobs(
@@ -72,7 +71,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
         )
 
     def submit_job_result(
-        self, agent_name: str, max_bond: float, result: str
+        self, agent_name: str, max_bond: USD, result: str
     ) -> ProcessedTradedMarket:
         if not APIKeys().enable_ipfs_upload:
             raise RuntimeError(
@@ -92,7 +91,7 @@ class OmenJobAgentMarket(OmenAgentMarket, JobAgentMarket):
 
         return processed_traded_market
 
-    def get_job_trade(self, max_bond: float, result: str) -> Trade:
+    def get_job_trade(self, max_bond: USD, 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(
@@ -106,9 +105,6 @@ 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