prediction-market-agent-tooling 0.61.2.dev479__py3-none-any.whl → 0.62.0__py3-none-any.whl

prediction_market_agent_tooling/markets/seer/seer.py

@@ -4,15 +4,16 @@ from eth_typing import ChecksumAddress
 from web3 import Web3
 from web3.types import TxReceipt
 
-from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.config import APIKeys, RPCConfig
 from prediction_market_agent_tooling.gtypes import (
+    USD,
+    CollateralToken,
     HexAddress,
     HexBytes,
     OutcomeStr,
-    Wei,
-    wei_type,
+    OutcomeToken,
+    OutcomeWei,
     xDai,
-    xdai_type,
 )
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.agent_market import (
@@ -23,15 +24,9 @@ from prediction_market_agent_tooling.markets.agent_market import (
     SortBy,
 )
 from prediction_market_agent_tooling.markets.blockchain_utils import store_trades
-from prediction_market_agent_tooling.markets.data_models import (
-    BetAmount,
-    Currency,
-    Position,
-    TokenAmount,
-)
+from prediction_market_agent_tooling.markets.data_models import ExistingPosition
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
-from prediction_market_agent_tooling.markets.omen.omen_contracts import sDaiContract
 from prediction_market_agent_tooling.markets.seer.data_models import (
     NewMarketEvent,
     SeerMarket,
@@ -43,7 +38,6 @@ from prediction_market_agent_tooling.markets.seer.seer_contracts import (
 from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
     SeerSubgraphHandler,
 )
-from prediction_market_agent_tooling.tools.balances import get_balances
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
@@ -57,14 +51,16 @@ from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
     auto_deposit_collateral_token,
 )
-from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai, xdai_to_wei
+from prediction_market_agent_tooling.tools.tokens.usd import (
+    get_token_in_usd,
+    get_usd_in_token,
+)
 
 # We place a larger bet amount by default than Omen so that cow presents valid quotes.
-SEER_TINY_BET_AMOUNT = xdai_type(0.1)
+SEER_TINY_BET_AMOUNT = USD(0.1)
 
 
 class SeerAgentMarket(AgentMarket):
-    currency = Currency.sDai
     wrapped_tokens: list[ChecksumAddress]
     creator: HexAddress
     collateral_token_contract_address_checksummed: ChecksumAddress
@@ -74,6 +70,16 @@ class SeerAgentMarket(AgentMarket):
         None  # Seer markets don't have a description, so just default to None.
     )
 
+    def get_collateral_token_contract(
+        self, web3: Web3 | None = None
+    ) -> ContractERC20OnGnosisChain:
+        web3 = web3 or RPCConfig().get_web3()
+        return to_gnosis_chain_contract(
+            init_collateral_token_contract(
+                self.collateral_token_contract_address_checksummed, web3
+            )
+        )
+
     def store_prediction(
         self,
         processed_market: ProcessedMarket | None,
@@ -95,29 +101,28 @@ class SeerAgentMarket(AgentMarket):
             agent_name=agent_name,
         )
 
-    def _convert_bet_amount_into_wei(self, bet_amount: BetAmount) -> Wei:
-        if bet_amount.currency == self.currency:
-            return xdai_to_wei(xdai_type(bet_amount.amount))
-        raise ValueError(
-            f"Currencies don't match. Currency bet amount {bet_amount.currency} currency market: {self.currency}"
-        )
+    def get_token_in_usd(self, x: CollateralToken) -> USD:
+        return get_token_in_usd(x, self.collateral_token_contract_address_checksummed)
+
+    def get_usd_in_token(self, x: USD) -> CollateralToken:
+        return get_usd_in_token(x, self.collateral_token_contract_address_checksummed)
 
     def get_buy_token_amount(
-        self, bet_amount: BetAmount, direction: bool
-    ) -> TokenAmount:
+        self, bet_amount: USD | CollateralToken, direction: bool
+    ) -> OutcomeToken:
         """Returns number of outcome tokens returned for a given bet expressed in collateral units."""
 
         outcome_token = self.get_wrapped_token_for_outcome(direction)
-
-        bet_amount_in_wei = self._convert_bet_amount_into_wei(bet_amount=bet_amount)
+        bet_amount_in_tokens = self.get_in_token(bet_amount)
+        bet_amount_in_wei = bet_amount_in_tokens.as_wei
 
         quote = CowManager().get_quote(
             buy_token=outcome_token,
             sell_amount=bet_amount_in_wei,
             collateral_token=self.collateral_token_contract_address_checksummed,
         )
-        sell_amount = wei_to_xdai(wei_type(quote.quote.buyAmount.root))
-        return TokenAmount(amount=sell_amount, currency=bet_amount.currency)
+        sell_amount = OutcomeWei(quote.quote.buyAmount.root).as_outcome_token
+        return sell_amount
 
     def get_outcome_str_from_bool(self, outcome: bool) -> OutcomeStr:
         outcome_translated = SeerOutcomeEnum.from_bool(outcome)
@@ -125,33 +130,46 @@ class SeerAgentMarket(AgentMarket):
         return OutcomeStr(self.outcomes[idx])
 
     @staticmethod
-    def get_trade_balance(api_keys: APIKeys) -> float:
+    def get_trade_balance(api_keys: APIKeys) -> USD:
         return OmenAgentMarket.get_trade_balance(api_keys=api_keys)
 
-    @classmethod
-    def get_tiny_bet_amount(cls) -> BetAmount:
-        return BetAmount(amount=SEER_TINY_BET_AMOUNT, currency=cls.currency)
+    def get_tiny_bet_amount(self) -> CollateralToken:
+        return self.get_in_token(SEER_TINY_BET_AMOUNT)
 
-    def get_position(self, user_id: str, web3: Web3 | None = None) -> Position | None:
+    def get_position(
+        self, user_id: str, web3: Web3 | None = None
+    ) -> ExistingPosition | None:
         """
         Fetches position from the user in a given market.
         We ignore the INVALID balances since we are only interested in binary outcomes.
         """
 
-        amounts = {}
+        amounts_ot: dict[OutcomeStr, OutcomeToken] = {}
 
         for outcome in [True, False]:
             wrapped_token = self.get_wrapped_token_for_outcome(outcome)
 
-            outcome_token_balance = ContractERC20OnGnosisChain(
-                address=wrapped_token
-            ).balanceOf(for_address=Web3.to_checksum_address(user_id), web3=web3)
-            outcome_str = self.get_outcome_str_from_bool(outcome=outcome)
-            amounts[outcome_str] = TokenAmount(
-                amount=wei_to_xdai(outcome_token_balance), currency=self.currency
+            outcome_token_balance_wei = OutcomeWei.from_wei(
+                ContractERC20OnGnosisChain(address=wrapped_token).balanceOf(
+                    for_address=Web3.to_checksum_address(user_id), web3=web3
+                )
             )
-
-        return Position(market_id=self.id, amounts=amounts)
+            outcome_str = self.get_outcome_str_from_bool(outcome=outcome)
+            amounts_ot[outcome_str] = outcome_token_balance_wei.as_outcome_token
+
+        amounts_current = {
+            k: self.get_token_in_usd(self.get_sell_value_of_outcome_token(k, v))
+            for k, v in amounts_ot.items()
+        }
+        amounts_potential = {
+            k: self.get_token_in_usd(v.as_token) for k, v in amounts_ot.items()
+        }
+        return ExistingPosition(
+            market_id=self.id,
+            amounts_current=amounts_current,
+            amounts_potential=amounts_potential,
+            amounts_ot=amounts_ot,
+        )
 
     @staticmethod
     def get_user_id(api_keys: APIKeys) -> str:
@@ -210,9 +228,9 @@ class SeerAgentMarket(AgentMarket):
             CowManager().get_quote(
                 collateral_token=self.collateral_token_contract_address_checksummed,
                 buy_token=outcome_token,
-                sell_amount=xdai_to_wei(
-                    xdai_type(1)
-                ),  # we take 1 xDai as a baseline value for common trades the agents take.
+                sell_amount=CollateralToken(
+                    1
+                ).as_wei,  # we take 1 as a baseline value for common trades the agents take.
             )
             return True
         except NoLiquidityAvailableOnCowException:
@@ -236,7 +254,7 @@ class SeerAgentMarket(AgentMarket):
     def place_bet(
         self,
         outcome: bool,
-        amount: BetAmount,
+        amount: USD,
         auto_deposit: bool = True,
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
@@ -247,32 +265,27 @@ class SeerAgentMarket(AgentMarket):
                 f"Market {self.id} is not open for trading. Cannot place bet."
             )
 
-        if amount.currency != self.currency:
-            raise ValueError(f"Seer bets are made in xDai. Got {amount.currency}.")
+        amount_in_token = self.get_usd_in_token(amount)
+        amount_wei = amount_in_token.as_wei
+        collateral_contract = self.get_collateral_token_contract()
 
-        collateral_contract = sDaiContract()
         if auto_deposit:
-            # We convert the deposit amount (in sDai) to assets in order to convert.
-            asset_amount = collateral_contract.convertToAssets(
-                xdai_to_wei(xdai_type(amount.amount))
-            )
             auto_deposit_collateral_token(
-                collateral_contract, asset_amount, api_keys, web3
+                collateral_contract, amount_wei, api_keys, web3
             )
 
-        # We require that amount is given in sDAI.
-        collateral_balance = get_balances(address=api_keys.bet_from_address, web3=web3)
-        if collateral_balance.sdai < amount.amount:
+        collateral_balance = collateral_contract.balanceOf(api_keys.bet_from_address)
+        if collateral_balance < amount_wei:
             raise ValueError(
-                f"Balance {collateral_balance.sdai} not enough for bet size {amount.amount}"
+                f"Balance {collateral_balance} not enough for bet size {amount}"
             )
 
         outcome_token = self.get_wrapped_token_for_outcome(outcome)
-        #  Sell sDAI using token address
+        # Sell using token address
         order_metadata = CowManager().swap(
-            amount=xdai_type(amount.amount),
+            amount=amount_in_token,
             sell_token=collateral_contract.address,
-            buy_token=Web3.to_checksum_address(outcome_token),
+            buy_token=outcome_token,
             api_keys=api_keys,
             web3=web3,
         )
@@ -282,18 +295,17 @@ class SeerAgentMarket(AgentMarket):
 
 def seer_create_market_tx(
     api_keys: APIKeys,
-    initial_funds: xDai,
+    initial_funds: USD | CollateralToken,
     question: str,
     opening_time: DatetimeUTC,
     language: str,
-    outcomes: list[str],
+    outcomes: t.Sequence[OutcomeStr],
     auto_deposit: bool,
     category: str,
     min_bond_xdai: xDai,
     web3: Web3 | None = None,
 ) -> ChecksumAddress:
     web3 = web3 or SeerMarketFactory.get_web3()  # Default to Gnosis web3.
-    initial_funds_wei = xdai_to_wei(initial_funds)
 
     factory_contract = SeerMarketFactory()
     collateral_token_address = factory_contract.collateral_token(web3=web3)
@@ -301,24 +313,26 @@ def seer_create_market_tx(
         init_collateral_token_contract(collateral_token_address, web3)
     )
 
+    initial_funds_in_collateral = (
+        get_usd_in_token(initial_funds, collateral_token_address)
+        if isinstance(initial_funds, USD)
+        else initial_funds
+    )
+    initial_funds_in_collateral_wei = initial_funds_in_collateral.as_wei
+
     if auto_deposit:
         auto_deposit_collateral_token(
             collateral_token_contract=collateral_token_contract,
             api_keys=api_keys,
-            amount_wei=initial_funds_wei,
+            collateral_amount_wei_or_usd=initial_funds_in_collateral_wei,
             web3=web3,
         )
 
-    # In case of ERC4626, obtained (for example) sDai out of xDai could be lower than the `amount_wei`, so we need to handle it.
-    initial_funds_in_shares = collateral_token_contract.get_in_shares(
-        amount=initial_funds_wei, web3=web3
-    )
-
     # Approve the market maker to withdraw our collateral token.
     collateral_token_contract.approve(
         api_keys=api_keys,
         for_address=factory_contract.address,
-        amount_wei=initial_funds_in_shares,
+        amount_wei=initial_funds_in_collateral_wei,
         web3=web3,
     )
 
@@ -329,7 +343,7 @@ def seer_create_market_tx(
         opening_time=opening_time,
         language=language,
         category=category,
-        min_bond_xdai=min_bond_xdai,
+        min_bond=min_bond_xdai,
     )
     tx_receipt = factory_contract.create_categorical_market(
         api_keys=api_keys, params=params, web3=web3

prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -1,10 +1,16 @@
 import os
+import typing as t
 
 from web3 import Web3
 from web3.types import TxReceipt
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ABI, ChecksumAddress, xDai
+from prediction_market_agent_tooling.gtypes import (
+    ABI,
+    ChecksumAddress,
+    OutcomeStr,
+    xDai,
+)
 from prediction_market_agent_tooling.markets.seer.data_models import (
     CreateCategoricalMarketsParams,
 )
@@ -13,7 +19,6 @@ from prediction_market_agent_tooling.tools.contract import (
     abi_field_validator,
 )
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
-from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
 
 
 class SeerMarketFactory(ContractOnGnosisChain):
@@ -31,9 +36,9 @@ class SeerMarketFactory(ContractOnGnosisChain):
     @staticmethod
     def build_market_params(
         market_question: str,
-        outcomes: list[str],
+        outcomes: t.Sequence[OutcomeStr],
         opening_time: DatetimeUTC,
-        min_bond_xdai: xDai,
+        min_bond: xDai,
         language: str = "en_US",
         category: str = "misc",
     ) -> CreateCategoricalMarketsParams:
@@ -42,7 +47,7 @@ class SeerMarketFactory(ContractOnGnosisChain):
             token_names=[
                 o.upper() for o in outcomes
             ],  # Following usual token names on Seer (YES,NO).
-            min_bond=xdai_to_wei(min_bond_xdai),
+            min_bond=min_bond.as_xdai_wei.value,
             opening_time=int(opening_time.timestamp()),
             outcomes=outcomes,
             lang=language,

prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py

@@ -15,6 +15,7 @@ from prediction_market_agent_tooling.markets.seer.data_models import (
 )
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
 from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
+from prediction_market_agent_tooling.tools.web3_utils import unwrap_generic_value
 
 
 class SeerSubgraphHandler(BaseSubgraphHandler):
@@ -158,7 +159,7 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
             first=(
                 limit if limit else sys.maxsize
             ),  # if not limit, we fetch all possible markets,
-            where=where_stms,
+            where=unwrap_generic_value(where_stms),
             **optional_params,
         )
         fields = self._get_fields_for_markets(markets_field)
@@ -219,7 +220,9 @@ class SeerSubgraphHandler(BaseSubgraphHandler):
                     {"token1": wrapped_token.lower()},
                 ]
             )
-        pools_field = self.swapr_algebra_subgraph.Query.pools(where={"or": wheres})
+        pools_field = self.swapr_algebra_subgraph.Query.pools(
+            where=unwrap_generic_value({"or": wheres})
+        )
         fields = self._get_fields_for_pools(pools_field)
         pools = self.do_query(fields=fields, pydantic_model=SeerPool)
         return pools

prediction_market_agent_tooling/monitor/monitor.py

@@ -186,12 +186,12 @@ def monitor_agent(agent: DeployedAgent) -> None:
         return
     bets_info = {
         "Market Question": [bet.market_question for bet in agent_bets],
-        "Bet Amount": [bet.amount.amount for bet in agent_bets],
+        "Bet Amount": [bet.amount for bet in agent_bets],
         "Bet Outcome": [bet.outcome for bet in agent_bets],
         "Created Time": [bet.created_time for bet in agent_bets],
         "Resolved Time": [bet.resolved_time for bet in agent_bets],
         "Is Correct": [bet.is_correct for bet in agent_bets],
-        "Profit": [round(bet.profit.amount, 2) for bet in agent_bets],
+        "Profit": [round(bet.profit, 2) for bet in agent_bets],
     }
 
     # Time column to use for x-axes and sorting

prediction_market_agent_tooling/tools/_generic_value.py

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