ddx-python 1.0.4__cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

ddx/auditor/websocket_message.py

@@ -0,0 +1,54 @@
+"""
+WebsocketMessage module
+"""
+
+from enum import Enum
+from typing import Dict, Union
+
+from attrs import define
+
+
+class WebsocketMessageType(str, Enum):
+    GET = "Get"
+    SUBSCRIBE = "Subscribe"
+    REQUEST = "Request"
+    INFO = "Info"
+    SEQUENCED = "Sequenced"
+    SAFETY_FAILURE = "SafetyFailure"
+
+
+class WebsocketEventType(str, Enum):
+    PARTIAL = "Partial"
+    UPDATE = "Update"
+    SNAPSHOT = "Snapshot"
+    HEAD = "Head"
+    TAIL = "Tail"
+
+
+@define
+class WebsocketMessage:
+    """
+    Defines a WebsocketMessage.
+    """
+
+    message_type: Union[WebsocketMessageType, str]
+    message_content: str
+
+    @classmethod
+    def decode_value_into_cls(cls, raw_websocket_message: Dict):
+        """
+        Decode a raw websocket message into class
+
+        Parameters
+        ----------
+        raw_websocket_message : Dict
+            Raw websocket message
+        """
+
+        return cls(
+            raw_websocket_message["t"],
+            raw_websocket_message["c"],
+        )
+
+    def repr_json(self):
+        return {"t": self.message_type, "c": self.message_content}

ddx/common/epoch_params.py

@@ -0,0 +1,28 @@
+from attrs import define
+from ddx._rust.common import ProductSymbol
+from ddx._rust.common.requests import SettlementAction
+
+
+@define
+class EpochParams:
+    """
+    Defines the epoch parameters
+    """
+
+    epoch_size: int
+    price_checkpoint_size: int
+    settlement_epoch_length: int
+    pnl_realization_period: int
+    funding_period: int
+    trade_mining_period: int
+    expiry_price_leaves_duration: int
+
+    @property
+    def settlement_action_periods(self):
+        res = {
+            SettlementAction.TradeMining: self.trade_mining_period,
+            SettlementAction.PnlRealization: self.pnl_realization_period,
+            SettlementAction.FundingDistribution: self.funding_period,
+        }
+
+        return res

ddx/common/fill_context.py

@@ -0,0 +1,141 @@
+"""
+Fill module.
+"""
+
+import logging
+from typing import Optional
+
+from attrs import define, field
+from ddx.common.transactions.inner.outcome import Outcome
+from ddx._rust.common import TokenSymbol
+from ddx._rust.common.enums import OrderSide, PositionSide, TradeSide
+from ddx._rust.common.state import Position, Strategy, Trader
+from ddx._rust.decimal import Decimal
+
+logger = logging.getLogger(__name__)
+
+MAX_DDX_PRICE_CHECKPOINT_AGE_IN_TICKS = 40000
+DDX_FEE_DISCOUNT = 0.5
+
+
+def apply_trade(
+    position: Position, amount: Decimal, price: Decimal, side: OrderSide
+) -> (Position, Decimal):
+    logger.debug(
+        f"Applying trade of {amount} at {price} on {side} to position {position}"
+    )
+    if side == OrderSide.Bid:
+        if position.side == PositionSide.Long:
+            logger.info("Trade side matches position side, increasing position balance")
+            return position.increase(price, amount)
+        if position.side == PositionSide.Short:
+            logger.info(
+                "Trade side does not match position side, decreasing position balance"
+            )
+            if amount > position.balance:
+                return position.cross_over(price, amount)
+            return position.decrease(price, amount)
+        logger.info(
+            "Position side not set, setting to Long and increasing position balance"
+        )
+        position.side = PositionSide.Long
+        return position.increase(price, amount)
+    else:
+        if position.side == PositionSide.Short:
+            logger.info("Trade side matches position side, increasing position balance")
+            return position.increase(price, amount)
+        if position.side == PositionSide.Long:
+            logger.info(
+                "Trade side does not match position side, decreasing position balance"
+            )
+            if amount > position.balance:
+                return position.cross_over(price, amount)
+            return position.decrease(price, amount)
+        logger.info(
+            "Position side not set, setting to Short and increasing position balance"
+        )
+        position.side = PositionSide.Short
+        return position.increase(price, amount)
+
+
+@define
+class FillContext:
+    """
+    Defines a FillContext.
+    """
+
+    outcome: Outcome
+    realized_pnl: Optional[Decimal] = field(init=False)
+
+    def apply_fill(
+        self,
+        position: Optional[Position],
+        side: OrderSide,
+        trade_side: TradeSide,
+        fill_amount: Decimal,
+        fill_price: Decimal,
+    ) -> Position:
+        if position is None:
+            position = Position(
+                PositionSide.Long if side == OrderSide.Bid else PositionSide.Short,
+                Decimal("0"),
+                Decimal("0"),
+            )
+            logger.info(f"New {position.side} position")
+        old_balance = position.balance
+
+        fee = trade_side.trading_fee(fill_amount, fill_price)
+        updated_position, realized_pnl = apply_trade(
+            position, fill_amount, fill_price, side
+        )
+
+        self.realized_pnl = realized_pnl
+        logger.info(f"Realized pnl: {self.realized_pnl}")
+        logger.info(f"Fee: {fee}")
+
+        # Note that, again, we're never reading the fee from the txlog, and instead
+        # we calulate it from the fill amount and price and set it in the outcome.
+        self.outcome.fee = fee
+
+        return updated_position
+
+    def apply_ddx_fee_and_mutate_trader(
+        self,
+        trader: Trader,
+        ddx_price: Decimal,
+    ) -> bool:
+        if self.outcome.fee == Decimal("0"):
+            logger.info("Base fee of 0, no fees to pay")
+            return False
+        fee_in_ddx = (self.outcome.fee / ddx_price) * (Decimal("1") - DDX_FEE_DISCOUNT)
+        if fee_in_ddx.recorded_amount() == Decimal("0"):
+            logger.info(
+                "Fee in DDX is 0 after conversion and discount, no fees to pay in DDX"
+            )
+            return False
+        if trader.avail_ddx_balance < fee_in_ddx:
+            # TODO 3825: this should be caught by the sequencer
+            logger.warn("Not enough DDX to pay fee")
+            return False
+        old_balance = trader.avail_ddx_balance
+        trader.avail_ddx_balance = (old_balance - fee_in_ddx).recorded_amount()
+        self.outcome.fee = (old_balance - trader.avail_ddx_balance).recorded_amount()
+        self.outcome.pay_fee_in_ddx = True
+        return True
+
+    def realize_trade_and_mutate_strategy(self, strategy: Strategy):
+        if strategy.frozen:
+            raise Exception("Cannot realize pnl from a frozen strategy")
+        strategy.set_avail_collateral(
+            TokenSymbol.USDC,
+            strategy.avail_collateral[TokenSymbol.USDC] + self.realized_pnl,
+        )
+        if not self.outcome.pay_fee_in_ddx and self.outcome.fee > Decimal("0"):
+            old_balance = strategy.avail_collateral[TokenSymbol.USDC]
+            strategy.set_avail_collateral(
+                TokenSymbol.USDC,
+                strategy.avail_collateral[TokenSymbol.USDC] - self.outcome.fee,
+            )
+            self.outcome.fee = (
+                old_balance - strategy.avail_collateral[TokenSymbol.USDC]
+            ).recorded_amount()

ddx/common/logging.py

@@ -0,0 +1,184 @@
+import inspect
+import logging
+
+from colorama import Back, Fore, Style
+from verboselogs import VerboseLogger
+
+logging.setLoggerClass(VerboseLogger)
+
+CHECKMARK = f"{Style.BRIGHT}{Back.GREEN}\u2713{Style.NORMAL}{Back.RESET}"
+
+
+def freeze_logging(func):
+    """Decorator to set the logging pathname, filename, and lineno based on the caller of the decorated function."""
+
+    class CustomLogRecord(logging.LogRecord):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            # Capture the stack frame of the caller outside the current module and not from __init__.py
+            for f in inspect.stack():
+                if (
+                    f[1] != inspect.getfile(inspect.currentframe())
+                    and "__init__.py" not in f[1]
+                    and "utils.py" not in f[1]
+                ):
+                    self.pathname = f[1]
+                    self.filename = f[1].split("/")[-1]
+                    self.lineno = f[2]
+                    break
+            else:
+                self.pathname = "unknown_path"
+                self.lineno = 0
+
+    def wrapper(*args, **kwargs):
+        # Temporarily replace the LogRecord class for the logger
+        original_factory = logging.getLogRecordFactory()
+        logging.setLogRecordFactory(CustomLogRecord)
+
+        try:
+            return func(*args, **kwargs)
+        finally:
+            # Restore the original LogRecord class
+            logging.setLogRecordFactory(original_factory)
+
+    return wrapper
+
+
+def auditor_logger(name: str):
+    logger = logging.getLogger(name)
+    logger = AuditorAdapter(logger)
+    return logger
+
+
+def local_logger(name: str):
+    logger = logging.getLogger(name)
+    logger = LocalAdapter(logger)
+    return logger
+
+
+def assert_logger(name: str):
+    logger = logging.getLogger(name)
+    logger = AssertAdapter(logger)
+    return logger
+
+
+def data_logger(name: str):
+    logger = logging.getLogger(name)
+    logger = DataAdapter(logger)
+    return logger
+
+
+class DataAdapter(logging.LoggerAdapter):
+    """
+    Wrap all messages with "data: " and make the message green.
+    """
+
+    def process(self, msg, kwargs):
+        return f"{Fore.GREEN}data: {msg}{Style.RESET_ALL}", kwargs
+
+    @freeze_logging
+    def verbose(self, msg, *args, **kwargs):
+        self.log(logging.VERBOSE, msg, *args, **kwargs)
+
+    @freeze_logging
+    def notice(self, msg, *args, **kwargs):
+        self.log(logging.NOTICE, msg, *args, **kwargs)
+
+    @freeze_logging
+    def success(self, msg, *args, **kwargs):
+        self.log(logging.SUCCESS, msg, *args, **kwargs)
+
+    @freeze_logging
+    def spam(self, msg, *args, **kwargs):
+        self.log(logging.SPAM, msg, *args, **kwargs)
+
+    @freeze_logging
+    def failure(self, msg, *args, **kwargs):
+        self.log(logging.FAILURE, msg, *args, **kwargs)
+
+
+class AssertAdapter(logging.LoggerAdapter):
+    """
+    Wrap all messages with "assert: " and make the message yellow.
+    """
+
+    def process(self, msg, kwargs):
+        return f"{Fore.YELLOW}assert: {msg}{Style.RESET_ALL}", kwargs
+
+    @freeze_logging
+    def verbose(self, msg, *args, **kwargs):
+        self.log(logging.VERBOSE, msg, *args, **kwargs)
+
+    @freeze_logging
+    def notice(self, msg, *args, **kwargs):
+        self.log(logging.NOTICE, msg, *args, **kwargs)
+
+    @freeze_logging
+    def success(self, msg, *args, **kwargs):
+        self.log(logging.SUCCESS, msg, *args, **kwargs)
+
+    @freeze_logging
+    def spam(self, msg, *args, **kwargs):
+        self.log(logging.SPAM, msg, *args, **kwargs)
+
+    @freeze_logging
+    def failure(self, msg, *args, **kwargs):
+        self.log(logging.FAILURE, msg, *args, **kwargs)
+
+
+class AuditorAdapter(logging.LoggerAdapter):
+    """
+    Wrap all messages with "auditor: " and make the message magenta.
+    """
+
+    def process(self, msg, kwargs):
+        return f"{Fore.MAGENTA}auditor: {msg}{Style.RESET_ALL}", kwargs
+
+    @freeze_logging
+    def verbose(self, msg, *args, **kwargs):
+        self.log(logging.VERBOSE, msg, *args, **kwargs)
+
+    @freeze_logging
+    def notice(self, msg, *args, **kwargs):
+        self.log(logging.NOTICE, msg, *args, **kwargs)
+
+    @freeze_logging
+    def success(self, msg, *args, **kwargs):
+        self.log(logging.SUCCESS, msg, *args, **kwargs)
+
+    @freeze_logging
+    def spam(self, msg, *args, **kwargs):
+        self.log(logging.SPAM, msg, *args, **kwargs)
+
+    @freeze_logging
+    def failure(self, msg, *args, **kwargs):
+        self.log(logging.FAILURE, msg, *args, **kwargs)
+
+
+class LocalAdapter(logging.LoggerAdapter):
+    """
+    Wrap all messages with "local: " and make the message blue.
+    """
+
+    def process(self, msg, kwargs):
+        return f"{Fore.BLUE}local: {msg}{Style.RESET_ALL}", kwargs
+
+    @freeze_logging
+    def verbose(self, msg, *args, **kwargs):
+        self.log(logging.VERBOSE, msg, *args, **kwargs)
+
+    @freeze_logging
+    def notice(self, msg, *args, **kwargs):
+        self.log(logging.NOTICE, msg, *args, **kwargs)
+
+    @freeze_logging
+    def success(self, msg, *args, **kwargs):
+        self.log(logging.SUCCESS, msg, *args, **kwargs)
+
+    @freeze_logging
+    def spam(self, msg, *args, **kwargs):
+        self.log(logging.SPAM, msg, *args, **kwargs)
+
+    @freeze_logging
+    def failure(self, msg, *args, **kwargs):
+        self.log(logging.FAILURE, msg, *args, **kwargs)

ddx/common/market_aware_account.py

@@ -0,0 +1,259 @@
+"""
+MarketAwareAccount module.
+"""
+
+import copy
+import logging
+
+from attrs import define
+from ddx.common.transactions.price_checkpoint import PriceCheckpoint
+from ddx._rust.common import ProductSymbol, TokenSymbol
+from ddx._rust.common.enums import OrderSide, PositionSide
+from ddx._rust.common.state import Position, Strategy
+from ddx._rust.decimal import Decimal
+
+logger = logging.getLogger(__name__)
+
+MMR_FRACTION = Decimal("0.15")
+
+
+# Designed to mimic ddxenclave::StrategyMetrics
+@define
+class MarketAwareAccount:
+    avail_collateral: Decimal
+    max_leverage: int
+    positions: dict[ProductSymbol, tuple[Position, Decimal]]
+
+    # must be initialize with a nonempty strategy
+    def __init__(
+        self,
+        strategy: Strategy,
+        positions: dict[ProductSymbol, tuple[Position, Decimal]],
+    ):
+        return self.__attrs_init__(
+            strategy.avail_collateral[TokenSymbol.USDC],
+            strategy.max_leverage,
+            positions,
+        )
+
+    @property
+    def notional_value(self):
+        notional = Decimal("0")
+        for symbol, (position, mark_price) in self.positions.items():
+            notional += position.balance * mark_price
+        logger.debug(f"Notional value: {notional}")
+        return notional
+
+    @property
+    def unrealized_pnl(self):
+        unrealized_pnl = Decimal("0")
+        for symbol, (position, mark_price) in self.positions.items():
+            unrealized_pnl += position.unrealized_pnl(mark_price)
+        logger.debug(f"Unrealized pnl: {unrealized_pnl}")
+        return unrealized_pnl
+
+    @property
+    def total_value(self):
+        res = self.avail_collateral + self.unrealized_pnl
+        logger.debug(f"Total value: {res}")
+        return res
+
+    @property
+    def margin_fraction(self):
+        total_value = self.total_value
+        notional_value = self.notional_value
+        if notional_value == Decimal("0"):
+            if total_value < Decimal("0"):
+                return Decimal("-1_000_000")
+            return Decimal("1_000_000")
+
+        mf = total_value / notional_value
+        logger.debug(f"Margin fraction: {mf}")
+        return mf
+
+    @property
+    def maintenance_margin_fraction(self):
+        mmf = MMR_FRACTION / self.max_leverage
+        logger.debug(f"Maintenance margin fraction: {mmf}")
+        return mmf
+
+    @property
+    def maximum_withdrawal_amount(self):
+        res = self.total_value - self.maintenance_margin_fraction * self.notional_value
+        logger.debug(f"Max withdrawal amount: {res}")
+        return res
+
+    def maximum_fill_amount_increasing(
+        self,
+        fee_percentage: Decimal,
+        mark_price: Decimal,
+        side: OrderSide,
+        price: Decimal,
+        amount: Decimal,
+    ):
+        logger.debug(
+            f"Max fill amount increasing current position {self.avail_collateral} {self.notional_value}"
+        )
+        if self.avail_collateral == Decimal("0") and self.notional_value == Decimal(
+            "0"
+        ):
+            return Decimal("0")
+
+        side = Decimal("1") if side == OrderSide.Bid else Decimal("-1")
+        gamma = Decimal("1") / self.max_leverage
+        if self.margin_fraction <= gamma:
+            derivative_numerator = (
+                self.notional_value
+                * (side * (mark_price - price) - fee_percentage * price)
+                - mark_price * self.total_value
+            )
+            return min(
+                (
+                    Decimal("0")
+                    if derivative_numerator < Decimal("0")
+                    else Decimal("1_000_000")
+                ),
+                amount,
+            )
+        else:
+            denominator = (
+                side * (price - mark_price)
+                + fee_percentage * price
+                + gamma * mark_price
+            )
+            return min(
+                (
+                    (self.total_value - gamma * self.notional_value) / denominator
+                    if denominator > Decimal("0")
+                    else Decimal("1_000_000")
+                ),
+                amount,
+            )
+
+    def maximum_fill_amount_decreasing(
+        self,
+        fee_percentage: Decimal,
+        mark_price: Decimal,
+        position: Position,
+        side: OrderSide,
+        price: Decimal,
+        amount: Decimal,
+    ):
+        logger.debug(f"Max fill amount decreasing current position")
+        side = Decimal("-1") if side == OrderSide.Bid else Decimal("1")
+        gamma = Decimal("1") / self.max_leverage
+        if self.margin_fraction <= gamma:
+            derivative_numerator = (
+                self.notional_value
+                * (side * (price - mark_price) - fee_percentage * price)
+                + mark_price * self.total_value
+            )
+            theoretical_fill_amount = (
+                Decimal("0")
+                if derivative_numerator < Decimal("0")
+                else Decimal("1_000_000")
+            )
+        else:
+            denominator = (
+                side * (mark_price - price)
+                + fee_percentage * price
+                - gamma * mark_price
+            )
+            theoretical_fill_amount = (
+                (self.total_value - gamma * self.notional_value) / denominator
+                if denominator > Decimal("0")
+                else Decimal("1_000_000")
+            )
+
+        return min(
+            theoretical_fill_amount,
+            amount,
+            position.balance,
+        )
+
+    def maximum_fill_amount_cross_over(
+        self,
+        symbol: ProductSymbol,
+        fee_percentage: Decimal,
+        mark_price: Decimal,
+        position: Position,
+        side: OrderSide,
+        price: Decimal,
+        amount: Decimal,
+    ):
+        logger.debug(f"Max fill amount crossing over current position")
+        decreasing_amount = self.maximum_fill_amount_decreasing(
+            fee_percentage, mark_price, position, side, price, amount
+        )
+
+        if decreasing_amount == position.balance:
+            # copy account so as to not modify anything
+            copy_account = copy.deepcopy(self)
+            copy_account.avail_collateral = (
+                copy_account.avail_collateral
+                + position.avg_pnl(price) * decreasing_amount
+                - fee_percentage * price * decreasing_amount
+            ).recorded_amount()
+            del copy_account.positions[symbol]
+
+            increasing_amount = copy_account.maximum_fill_amount_increasing(
+                fee_percentage, mark_price, side, price, amount - decreasing_amount
+            )
+            return decreasing_amount + increasing_amount
+        else:
+            return decreasing_amount
+
+    def maximum_fill_amount(
+        self,
+        symbol: ProductSymbol,
+        fee_percentage: Decimal,
+        mark_price: Decimal,
+        side: OrderSide,
+        price: Decimal,
+        amount: Decimal,
+        min_order_size: Decimal,
+    ):
+        logger.debug(f"Calculating max fill amount")
+        if symbol in self.positions:
+            logger.debug(f"Position already exists")
+            p = self.positions[symbol][0]
+
+            if (
+                (p.side == PositionSide.Long and side == OrderSide.Bid)
+                or (p.side == PositionSide.Short and side == OrderSide.Ask)
+                or p.side == PositionSide.Empty
+            ):
+                fill_amount = self.maximum_fill_amount_increasing(
+                    fee_percentage, mark_price, side, price, amount
+                )
+            else:
+                fill_amount = self.maximum_fill_amount_cross_over(
+                    symbol, fee_percentage, mark_price, p, side, price, amount
+                )
+        else:
+            logger.debug(f"Position does not exist, auto increase")
+            fill_amount = self.maximum_fill_amount_increasing(
+                fee_percentage,
+                mark_price,
+                side,
+                price,
+                amount,
+            )
+        return (
+            fill_amount
+            if min_order_size == Decimal("0")
+            else fill_amount - (fill_amount % min_order_size)
+        )
+
+    def assess_solvency(self):
+        res = 0 if self.margin_fraction < self.maintenance_margin_fraction else 1
+        logger.info(
+            f"solvent? {bool(res)}; margin fraction is {self.margin_fraction} and maintenance margin fraction is {self.maintenance_margin_fraction}"
+        )
+        return res
+
+    def sorted_positions_by_unrealized_pnl(self):
+        return sorted(
+            self.positions.items(),
+            key=lambda item: item[1][0].unrealized_pnl(item[1][1]),
+        )