ctrader-api-client 0.8.1__tar.gz → 0.9.0__tar.gz

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ctrader-api-client
-Version: 0.8.1
+Version: 0.9.0
 Summary: API Client to interact with the cTrader Open API spec
 Author-email: Elio <elioachukri@pm.me>
 License-File: LICENSE
@@ -303,6 +303,10 @@ results = await client.symbols.search(account_id, "EUR")
 # Get specific symbol
 symbol = await client.symbols.get_by_id(account_id, symbol_id)
 
+# The commission rate comes with the type that says what the rate counts
+commission = symbol.commission
+print(f"{commission.rate} ({commission.type.value}), min {commission.minimum}")
+
 # Trading hours arrive with the symbol, so this costs no extra request
 hours = symbol.trading_hours
 if hours.is_open():

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/README.md

@@ -283,6 +283,10 @@ results = await client.symbols.search(account_id, "EUR")
 # Get specific symbol
 symbol = await client.symbols.get_by_id(account_id, symbol_id)
 
+# The commission rate comes with the type that says what the rate counts
+commission = symbol.commission
+print(f"{commission.rate} ({commission.type.value}), min {commission.minimum}")
+
 # Trading hours arrive with the symbol, so this costs no extra request
 hours = symbol.trading_hours
 if hours.is_open():

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/docs/api/enums.md

@@ -69,6 +69,16 @@ from ctrader_api_client import ExecutionType, OrderSide, OrderType
       show_source: false
       members: true
 
+::: ctrader_api_client.enums.CommissionType
+    options:
+      show_source: false
+      members: true
+
+::: ctrader_api_client.enums.MinCommissionType
+    options:
+      show_source: false
+      members: true
+
 ## Market Data Enums
 
 ::: ctrader_api_client.enums.TrendbarPeriod

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/docs/api/models.md

@@ -130,6 +130,66 @@ partial_close = ClosePositionRequest(
       show_source: false
 
 
+::: ctrader_api_client.models.Commission
+    options:
+      show_source: false
+
+**Example:**
+
+A broker states a commission as a rate and a type. The type says what the rate counts, so
+you must read the two together. The rate alone is meaningless: `2.5` is 2.50 USD per lot
+under one type and 2.5% of the traded value under another.
+
+```python
+from decimal import Decimal
+
+from ctrader_api_client import CommissionType, Symbol
+
+
+def commission_per_side(symbol: Symbol, lots: Decimal, price: Decimal) -> Decimal:
+    """Commission for one side of a trade.
+
+    The result is in USD for the two USD types, and in the symbol's quote currency
+    for QUOTE_CCY_PER_LOT.
+    """
+    # lot_size counts hundredths of a base unit, so 100 gives the contract size.
+    notional = lots * symbol.lot_size / 100 * price
+
+    match symbol.commission.type:
+        case CommissionType.USD_PER_MILLION_USD:
+            return symbol.commission.rate * notional / 1_000_000
+        case CommissionType.USD_PER_LOT | CommissionType.QUOTE_CCY_PER_LOT:
+            return symbol.commission.rate * lots
+        case CommissionType.PERCENTAGE_OF_VALUE:
+            return symbol.commission.rate / 100 * notional
+
+
+# Symbol IDs belong to the broker's server, so look yours up with symbols.search().
+gold = await client.symbols.get_by_id(account_id, 41)
+
+# 0.0007 (PERCENTAGE_OF_VALUE), a lot of 100 ounces
+print(gold.commission.rate, gold.commission.type.value)
+
+# 3.07689900 USD for 1 lot at 4395.57, which the broker charges as 3.08
+print(commission_per_side(gold, Decimal(1), Decimal("4395.57")))
+```
+
+These rates come from one live broker, and show how far the types differ:
+
+| Symbol | Type | Rate | Charge per side, for one lot |
+|--------|------|------|------------------------------|
+| EURUSD | `USD_PER_LOT` | 2.5 | 2.50 USD, at any price |
+| XAUUSD | `PERCENTAGE_OF_VALUE` | 0.0007 | 3.08 USD, at a price of 4395.57 |
+| BTCUSD | `PERCENTAGE_OF_VALUE` | 0.0325 | 20.89 USD, at a price of 64286.15 |
+
+The broker charges the commission per side, so a round turn costs twice as much.
+
+`minimum` is the smallest commission the broker charges for one trade. Apply it only when
+its currency matches your charge: `minimum_type` tells you whether `minimum` is in the
+symbol's quote currency, or in the currency that `minimum_asset` names. A `minimum` of 0
+means the broker sets no minimum.
+
+
 ::: ctrader_api_client.models.TradingHours
     options:
       show_source: false

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/docs/api/symbols.md

@@ -58,6 +58,35 @@ for sym in eur_pairs:
     print(sym.name)
 ```
 
+## Commission
+
+A broker states a commission as a rate and a type. The type says what the rate counts, so
+you must read the two together. The same rate of `35` is 35 USD per million USD of volume
+for one symbol, and 35 USD per lot for another.
+
+```python
+from ctrader_api_client import CommissionType
+
+symbol = await client.symbols.get_by_id(account_id, 270)
+commission = symbol.commission
+
+print(f"{commission.rate} ({commission.type.value})")
+print(f"Minimum: {commission.minimum} {commission.minimum_asset}")
+```
+
+| Type | Meaning of the rate |
+|------|---------------------|
+| `USD_PER_MILLION_USD` | USD per million USD of traded volume. Usual for forex. |
+| `USD_PER_LOT` | USD per lot. Usual for commodity and index CFDs and futures. |
+| `PERCENTAGE_OF_VALUE` | Percent of the traded value. Usual for equities. |
+| `QUOTE_CCY_PER_LOT` | The symbol's quote currency per lot. |
+
+The broker charges the commission per side, so a round turn costs twice the rate. The
+charge lands in USD for the first two types, and in the symbol's quote currency for
+`QUOTE_CCY_PER_LOT`. Convert to your deposit currency yourself. See
+[Models](models.md#ctrader_api_client.models.Commission) for the arithmetic of each type,
+and for how to apply `minimum`.
+
 ## Trading Hours
 
 Every `Symbol` arrives with its trading calendar attached, so asking when a symbol is open

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrader-api-client"
-version = "0.8.1"
+version = "0.9.0"
 description = "API Client to interact with the cTrader Open API spec"
 readme = "README.md"
 authors = [

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/src/ctrader_api_client/__init__.py

@@ -50,8 +50,10 @@ from .enums import (
     AccessRights,
     AccountType,
     AuthTrigger,
+    CommissionType,
     DealStatus,
     ExecutionType,
+    MinCommissionType,
     OrderSide,
     OrderStatus,
     OrderType,
@@ -108,6 +110,7 @@ from .models import (
     AmendPositionRequest,
     CloseDetail,
     ClosePositionRequest,
+    Commission,
     Deal,
     Holiday,
     NewOrderRequest,
@@ -150,6 +153,8 @@ __all__ = [
     "ClientDisconnectEvent",
     "CloseDetail",
     "ClosePositionRequest",
+    "Commission",
+    "CommissionType",
     "Deal",
     "DealStatus",
     "DepthEvent",
@@ -162,6 +167,7 @@ __all__ = [
     "Holiday",
     "MarginCallTriggerEvent",
     "MarginChangeEvent",
+    "MinCommissionType",
     "NewOrderRequest",
     "Order",
     "OrderErrorEvent",

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/src/ctrader_api_client/enums.py

@@ -117,6 +117,35 @@ class TradingMode(Enum):
     CLOSE_ONLY = "CLOSE_ONLY"
 
 
+class CommissionType(Enum):
+    """Unit a symbol's commission rate is expressed in.
+
+    The rate is a plain number. This type tells you what the number counts.
+    """
+
+    USD_PER_MILLION_USD = "USD_PER_MILLION_USD"
+    """USD per million USD of traded volume. Usual for forex."""
+
+    USD_PER_LOT = "USD_PER_LOT"
+    """USD per lot. Usual for commodity and index CFDs and futures."""
+
+    PERCENTAGE_OF_VALUE = "PERCENTAGE_OF_VALUE"
+    """Percent of the traded value. Usual for equities."""
+
+    QUOTE_CCY_PER_LOT = "QUOTE_CCY_PER_LOT"
+    """The symbol's quote currency per lot."""
+
+
+class MinCommissionType(Enum):
+    """Currency a symbol's minimum commission is expressed in."""
+
+    CURRENCY = "CURRENCY"
+    """The currency named by the minimum commission asset."""
+
+    QUOTE_CURRENCY = "QUOTE_CURRENCY"
+    """The symbol's quote currency."""
+
+
 class TrendbarPeriod(Enum):
     """Trendbar/candle period."""
 

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/src/ctrader_api_client/models/__init__.py

@@ -24,6 +24,7 @@ Example:
 """
 
 from .account import Account, AccountSummary
+from .commission import Commission
 from .deal import CloseDetail, Deal
 from .market_data import TickData, Trendbar
 from .order import Order
@@ -40,6 +41,7 @@ __all__ = [
     "AmendPositionRequest",
     "CloseDetail",
     "ClosePositionRequest",
+    "Commission",
     "Deal",
     "Holiday",
     "NewOrderRequest",

ctrader_api_client-0.9.0/src/ctrader_api_client/models/commission.py

@@ -0,0 +1,148 @@
+"""What a broker charges to trade a symbol.
+
+The server sends a commission as a number and a type, and the type decides what
+the number means. The same rate of ``35`` is 35 USD per million USD of volume for
+one symbol and 35 USD per lot for another. A rate read without its type is
+meaningless, so both travel together here.
+
+The server sends each amount twice: once in a deprecated field, and once in a
+scaled ``precise`` field that carries more decimal places. The precise field wins
+where the broker sets it. Brokers that still publish only the deprecated fields
+keep working.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+from .._internal.proto import ProtoOACommissionType, ProtoOAMinCommissionType
+from ..enums import CommissionType, MinCommissionType
+from ._base import FrozenModel
+
+
+if TYPE_CHECKING:
+    from .._internal.proto import ProtoOASymbol
+
+
+_COMMISSION_TYPE_MAP: dict[int, CommissionType] = {
+    ProtoOACommissionType.USD_PER_MILLION_USD: CommissionType.USD_PER_MILLION_USD,
+    ProtoOACommissionType.USD_PER_LOT: CommissionType.USD_PER_LOT,
+    ProtoOACommissionType.PERCENTAGE_OF_VALUE: CommissionType.PERCENTAGE_OF_VALUE,
+    ProtoOACommissionType.QUOTE_CCY_PER_LOT: CommissionType.QUOTE_CCY_PER_LOT,
+}
+
+_MIN_COMMISSION_TYPE_MAP: dict[int, MinCommissionType] = {
+    ProtoOAMinCommissionType.CURRENCY: MinCommissionType.CURRENCY,
+    ProtoOAMinCommissionType.QUOTE_CURRENCY: MinCommissionType.QUOTE_CURRENCY,
+}
+
+# Every amount is an integer scaled by a fixed power of ten. A money amount is
+# scaled by 10^8 in the precise fields and by 10^2 in the deprecated ones, which is
+# why the two differ by 10^6 on the wire. A percentage rate keeps one scale of 10^5
+# in both fields.
+_PRECISE_SCALE = Decimal(10) ** 8
+_DEPRECATED_SCALE = Decimal(10) ** 2
+_PERCENTAGE_SCALE = Decimal(10) ** 5
+
+# The wire format leaves an unset field at 0, and no commission enum has a member
+# there, so 0 means "the broker said nothing" rather than a value.
+_UNSET = 0
+
+# What the server applies when the broker omits the field.
+_DEFAULT_MIN_COMMISSION_ASSET = "USD"
+
+
+class Commission(FrozenModel):
+    """The commission a broker charges to trade one symbol.
+
+    A commission is charged per side, so a round turn costs twice ``rate`` unless
+    the broker states otherwise.
+
+    Attributes:
+        type: What ``rate`` counts. See CommissionType.
+        rate: The commission rate, in the unit its type names. A
+            PERCENTAGE_OF_VALUE rate is a percent, so ``Decimal("0.005")`` means
+            0.005% of the traded value.
+        minimum: The smallest commission the broker charges for one trade, in the
+            currency its type names. 0 means the broker sets no minimum.
+        minimum_type: The currency ``minimum`` is expressed in. See
+            MinCommissionType.
+        minimum_asset: The currency ``minimum`` is expressed in when
+            ``minimum_type`` is CURRENCY.
+
+    Example:
+        ```python
+        from ctrader_api_client import CommissionType
+
+        symbol = await client.symbols.get_by_id(account_id, 270)
+        commission = symbol.commission
+
+        if commission.type is CommissionType.USD_PER_MILLION_USD:
+            charge = commission.rate * notional_usd / 1_000_000
+            print(f"{max(charge, commission.minimum)} USD per side")
+        ```
+    """
+
+    type: CommissionType = CommissionType.USD_PER_MILLION_USD
+    rate: Decimal = Decimal(0)
+    minimum: Decimal = Decimal(0)
+    minimum_type: MinCommissionType = MinCommissionType.CURRENCY
+    minimum_asset: str = _DEFAULT_MIN_COMMISSION_ASSET
+
+    @classmethod
+    def from_proto(cls, proto: ProtoOASymbol) -> Commission:
+        """Create a Commission from a symbol proto message.
+
+        Args:
+            proto: The proto message to read the commission fields from.
+
+        Returns:
+            A new Commission instance.
+        """
+        commission_type = _COMMISSION_TYPE_MAP.get(proto.commission_type, CommissionType.USD_PER_MILLION_USD)
+        return cls(
+            type=commission_type,
+            rate=_rate(proto, commission_type),
+            minimum=_minimum(proto),
+            minimum_type=_MIN_COMMISSION_TYPE_MAP.get(proto.min_commission_type, MinCommissionType.CURRENCY),
+            minimum_asset=proto.min_commission_asset or _DEFAULT_MIN_COMMISSION_ASSET,
+        )
+
+
+def _rate(proto: ProtoOASymbol, commission_type: CommissionType) -> Decimal:
+    """Descale the commission rate, preferring the precise field over the deprecated one.
+
+    A percentage rate is scaled by 10^5 in both fields. Every other rate is money,
+    so it is scaled by 10^8 in the precise field and by 10^2 in the deprecated one.
+
+    Args:
+        proto: The proto message to read the rate from.
+        commission_type: The type the rate is expressed in.
+
+    Returns:
+        The rate in the unit its type names.
+    """
+    if commission_type is CommissionType.PERCENTAGE_OF_VALUE:
+        scaled = proto.precise_trading_commission_rate or proto.commission
+        return Decimal(scaled) / _PERCENTAGE_SCALE
+    if proto.precise_trading_commission_rate != _UNSET:
+        return Decimal(proto.precise_trading_commission_rate) / _PRECISE_SCALE
+    return Decimal(proto.commission) / _DEPRECATED_SCALE
+
+
+def _minimum(proto: ProtoOASymbol) -> Decimal:
+    """Descale the minimum commission, preferring the precise field over the deprecated one.
+
+    A minimum is always money, so it carries the money scales: 10^8 in the precise
+    field and 10^2 in the deprecated one.
+
+    Args:
+        proto: The proto message to read the minimum from.
+
+    Returns:
+        The minimum commission per trade.
+    """
+    if proto.precise_min_commission != _UNSET:
+        return Decimal(proto.precise_min_commission) / _PRECISE_SCALE
+    return Decimal(proto.min_commission) / _DEPRECATED_SCALE

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/src/ctrader_api_client/models/symbol.py

@@ -8,6 +8,7 @@ from pydantic import Field
 from .._internal.proto import ProtoOATradingMode
 from ..enums import TradingMode
 from ._base import FrozenModel
+from .commission import Commission
 from .trading_hours import TradingHours
 
 
@@ -78,14 +79,15 @@ class Symbol(FrozenModel):
         symbol_id: The unique symbol identifier.
         digits: Price decimal places.
         pip_position: Position of pip in price (e.g., 4 means 0.0001).
-        lot_size: Contract size in base units (e.g., 100000 for forex).
+        lot_size: Contract size in hundredths of a base unit. A forex lot of
+            100000 units reads as 10000000, and a 100 ounce gold lot as 10000.
         min_volume: Minimum order volume in cents.
         max_volume: Maximum order volume in cents.
         step_volume: Volume step in cents.
         trading_mode: Current trading mode.
         swap_long: Swap rate for long positions.
         swap_short: Swap rate for short positions.
-        commission: Commission rate.
+        commission: What the broker charges to trade the symbol.
         max_exposure: Maximum allowed exposure.
         leverage_id: ID of dynamic leverage profile, if any.
         enable_short_selling: Whether short selling is allowed.
@@ -108,9 +110,9 @@ class Symbol(FrozenModel):
     trading_mode: TradingMode
     swap_long: Decimal
     swap_short: Decimal
+    commission: Commission = Field(default_factory=Commission)
 
     # Optional fields
-    commission: int = 0
     max_exposure: int | None = None
     leverage_id: int | None = None
     enable_short_selling: bool = True
@@ -176,7 +178,7 @@ class Symbol(FrozenModel):
             trading_mode=_TRADING_MODE_MAP.get(proto.trading_mode, TradingMode.ENABLED),
             swap_long=Decimal(str(proto.swap_long)),
             swap_short=Decimal(str(proto.swap_short)),
-            commission=proto.commission if proto.commission else 0,
+            commission=Commission.from_proto(proto),
             max_exposure=proto.max_exposure if proto.max_exposure else None,
             leverage_id=proto.leverage_id if proto.leverage_id else None,
             enable_short_selling=proto.enable_short_selling,

ctrader_api_client-0.9.0/tests/unit/test_commission_conversion.py

@@ -0,0 +1,187 @@
+"""The translation of the commission a broker charges to trade a symbol."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+import pytest
+
+from ctrader_api_client._internal.proto import (
+    ProtoOACommissionType,
+    ProtoOAMinCommissionType,
+    ProtoOASymbol,
+)
+from ctrader_api_client.enums import CommissionType, MinCommissionType
+from ctrader_api_client.models import Symbol
+
+
+@pytest.mark.parametrize(
+    ("proto_type", "expected"),
+    [
+        (ProtoOACommissionType.USD_PER_MILLION_USD, CommissionType.USD_PER_MILLION_USD),
+        (ProtoOACommissionType.USD_PER_LOT, CommissionType.USD_PER_LOT),
+        (ProtoOACommissionType.PERCENTAGE_OF_VALUE, CommissionType.PERCENTAGE_OF_VALUE),
+        (ProtoOACommissionType.QUOTE_CCY_PER_LOT, CommissionType.QUOTE_CCY_PER_LOT),
+    ],
+)
+def test_the_commission_type_is_translated(proto_type: ProtoOACommissionType, expected: CommissionType) -> None:
+    symbol = Symbol.from_proto(ProtoOASymbol(symbol_id=1, commission_type=proto_type))
+
+    assert symbol.commission.type == expected
+
+
+def test_a_commission_type_the_broker_omits_falls_back_to_the_server_default() -> None:
+    """The wire format leaves an unset enum at 0, which no commission type uses."""
+    symbol = Symbol.from_proto(ProtoOASymbol(symbol_id=1))
+
+    assert symbol.commission.type == CommissionType.USD_PER_MILLION_USD
+    assert symbol.commission.minimum_type == MinCommissionType.CURRENCY
+    assert symbol.commission.minimum_asset == "USD"
+
+
+def test_a_symbol_without_a_commission_reports_no_charge() -> None:
+    symbol = Symbol.from_proto(ProtoOASymbol(symbol_id=1))
+
+    assert symbol.commission.rate == Decimal(0)
+    assert symbol.commission.minimum == Decimal(0)
+
+
+def test_a_rate_per_million_is_descaled() -> None:
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=270,
+            commission_type=ProtoOACommissionType.USD_PER_MILLION_USD,
+            precise_trading_commission_rate=3_500_000_000,
+        )
+    )
+
+    assert symbol.commission.rate == Decimal(35)
+
+
+def test_a_rate_per_lot_keeps_its_fractional_part() -> None:
+    """The precise field exists to carry the decimals the deprecated one cannot."""
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=270,
+            commission_type=ProtoOACommissionType.USD_PER_LOT,
+            precise_trading_commission_rate=350_000_000,
+        )
+    )
+
+    assert symbol.commission.rate == Decimal("3.5")
+
+
+def test_a_percentage_rate_is_reported_as_a_percent() -> None:
+    """A percentage rate is scaled by 10^5, not by the 10^8 the other types use."""
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=270,
+            commission_type=ProtoOACommissionType.PERCENTAGE_OF_VALUE,
+            precise_trading_commission_rate=500,
+        )
+    )
+
+    assert symbol.commission.rate == Decimal("0.005")
+
+
+def test_a_broker_that_sends_only_the_deprecated_rate_is_read() -> None:
+    """A deprecated money rate counts hundredths, so 250 is 2.50 USD per lot."""
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=270,
+            commission_type=ProtoOACommissionType.USD_PER_LOT,
+            commission=250,
+        )
+    )
+
+    assert symbol.commission.rate == Decimal("2.5")
+
+
+def test_a_deprecated_percentage_rate_carries_the_percentage_scale() -> None:
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=270,
+            commission_type=ProtoOACommissionType.PERCENTAGE_OF_VALUE,
+            commission=500,
+        )
+    )
+
+    assert symbol.commission.rate == Decimal("0.005")
+
+
+def test_the_precise_rate_wins_over_the_deprecated_one() -> None:
+    """Brokers send both, and only the precise field carries the smaller decimals."""
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=270,
+            commission_type=ProtoOACommissionType.USD_PER_LOT,
+            commission=355,
+            precise_trading_commission_rate=355_500_000,
+        )
+    )
+
+    assert symbol.commission.rate == Decimal("3.555")
+
+
+def test_the_two_rate_fields_agree_on_what_a_live_broker_sends() -> None:
+    """A live broker publishes 2.50 USD per lot as 250 and as 250000000.
+
+    The two scales differ by 10^6, and both readings must give the same money.
+    """
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=270,
+            commission_type=ProtoOACommissionType.USD_PER_LOT,
+            commission=250,
+            precise_trading_commission_rate=250_000_000,
+        )
+    )
+
+    assert symbol.commission.rate == Decimal("2.5")
+
+
+def test_a_live_percentage_rate_reads_as_a_fraction_of_a_percent() -> None:
+    """A live broker publishes 0.0007% on gold as 70 in both rate fields."""
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=41,
+            commission_type=ProtoOACommissionType.PERCENTAGE_OF_VALUE,
+            commission=70,
+            precise_trading_commission_rate=70,
+        )
+    )
+
+    assert symbol.commission.rate == Decimal("0.0007")
+
+
+def test_the_minimum_commission_is_descaled() -> None:
+    symbol = Symbol.from_proto(ProtoOASymbol(symbol_id=270, precise_min_commission=250_000_000))
+
+    assert symbol.commission.minimum == Decimal("2.5")
+
+
+def test_a_broker_that_sends_only_the_deprecated_minimum_is_read() -> None:
+    """A minimum is money, so the deprecated field counts hundredths as the rate does."""
+    symbol = Symbol.from_proto(ProtoOASymbol(symbol_id=270, min_commission=250))
+
+    assert symbol.commission.minimum == Decimal("2.5")
+
+
+def test_the_precise_minimum_wins_over_the_deprecated_one() -> None:
+    symbol = Symbol.from_proto(ProtoOASymbol(symbol_id=270, min_commission=200, precise_min_commission=250_000_000))
+
+    assert symbol.commission.minimum == Decimal("2.5")
+
+
+def test_the_minimum_commission_keeps_the_currency_it_is_charged_in() -> None:
+    symbol = Symbol.from_proto(
+        ProtoOASymbol(
+            symbol_id=270,
+            precise_min_commission=250_000_000,
+            min_commission_type=ProtoOAMinCommissionType.QUOTE_CURRENCY,
+            min_commission_asset="EUR",
+        )
+    )
+
+    assert symbol.commission.minimum_type == MinCommissionType.QUOTE_CURRENCY
+    assert symbol.commission.minimum_asset == "EUR"

{ctrader_api_client-0.8.1 → ctrader_api_client-0.9.0}/uv.lock

@@ -270,7 +270,7 @@ wheels = [
 
 [[package]]
 name = "ctrader-api-client"
-version = "0.8.1"
+version = "0.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },