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

ddx/common/transactions/partial_fill.py

@@ -0,0 +1,125 @@
+"""
+PartialFill module
+"""
+
+from attrs import define, field
+from ddx.common.transactions.cancel import Cancel
+from ddx.common.transactions.event import Event
+from ddx.common.transactions.inner.outcome import Outcome
+from ddx.common.transactions.inner.trade_fill import TradeFill
+from ddx.common.transactions.post import Post
+from ddx._rust.common import ProductSymbol
+from ddx._rust.common.enums import OrderSide
+from ddx._rust.common.state import DerivadexSMT
+from ddx._rust.decimal import Decimal
+
+
+@define
+class PartialFill(Event):
+    """
+    Defines an PartialFill
+
+    A PartialFill is a scenario where the taker order has been partially filled
+    across 1 or more maker orders and thus has a remaining order that enters the
+    book along with any canceled maker orders.
+
+    Attributes:
+        post (Post): A Post object
+        trade_outcomes (list[TradeFill | Cancel]): A list of trade outcome objects
+        request_index (int): Sequenced request index of transaction
+    """
+
+    post: Post
+    trade_outcomes: list[TradeFill | Cancel] = field(eq=set)
+    request_index: int = field(default=-1, eq=False)
+
+    @classmethod
+    def decode_value_into_cls(cls, raw_tx_log_event: dict):
+        """
+        Decode a raw transaction log event (dict) into a PartialFill
+        instance.
+
+        Parameters
+        ----------
+        raw_tx_log_event : dict
+            Raw transaction log event being processed
+        """
+
+        event = raw_tx_log_event["event"]["c"]
+        trade_outcomes_tx_event = event["tradeOutcomes"]
+
+        return cls(
+            Post(
+                ProductSymbol(event["symbol"]),
+                event["orderHash"],
+                OrderSide(event["side"]),
+                Decimal(event["amount"]),
+                Decimal(event["price"]),
+                event["traderAddress"],
+                event["strategyIdHash"],
+                event["bookOrdinal"],
+                # NOTE 3503: This is logically identical to the time value in BookOrder, so not repeating it.
+                raw_tx_log_event["timeValue"],
+                raw_tx_log_event["requestIndex"],
+            ),
+            [
+                (
+                    TradeFill(
+                        ProductSymbol(trade_outcome["Fill"]["symbol"]),
+                        trade_outcome["Fill"]["takerOrderHash"],
+                        trade_outcome["Fill"]["makerOrderHash"],
+                        Decimal(trade_outcome["Fill"]["makerOrderRemainingAmount"]),
+                        Decimal(trade_outcome["Fill"]["amount"]),
+                        Decimal(trade_outcome["Fill"]["price"]),
+                        OrderSide(trade_outcome["Fill"]["takerSide"]),
+                        Outcome(
+                            trade_outcome["Fill"]["makerOutcome"]["trader"],
+                            trade_outcome["Fill"]["makerOutcome"]["strategyIdHash"],
+                        ),
+                        Outcome(
+                            trade_outcome["Fill"]["takerOutcome"]["trader"],
+                            trade_outcome["Fill"]["takerOutcome"]["strategyIdHash"],
+                        ),
+                        raw_tx_log_event["timeValue"],
+                        raw_tx_log_event["requestIndex"],
+                    )
+                    if "Fill" in trade_outcome
+                    else Cancel(
+                        ProductSymbol(trade_outcome["Cancel"]["symbol"]),
+                        trade_outcome["Cancel"]["orderHash"],
+                        Decimal(trade_outcome["Cancel"]["amount"]),
+                        raw_tx_log_event["requestIndex"],
+                    )
+                )
+                for trade_outcome in trade_outcomes_tx_event
+            ],
+            raw_tx_log_event["requestIndex"],
+        )
+
+    def process_tx(
+        self,
+        smt: DerivadexSMT,
+        **kwargs,
+    ):
+        """
+        Process a PartialFill transaction. A PartialFill consists of
+        Fill objects, which will adjust the maker BookOrder leaf in the
+        SMT, while also adjusting the Strategy, Position, and Trader
+        leaves corresponding to both the maker and the taker. It also
+        consists of a Post object, which will be a BookOrder consisting
+        of what's left of the partially matched order.
+
+        Parameters
+        ----------
+        smt: DerivadexSMT
+            DerivaDEX Sparse Merkle Tree
+        **kwargs
+            Additional args specific to PartialFill transactions
+        """
+
+        # Loop through each trade outcome event and process them individually
+        for trade_outcome in self.trade_outcomes:
+            trade_outcome.process_tx(smt, **kwargs)
+
+        # Process the remaining post event
+        self.post.process_tx(smt, **kwargs)

ddx/common/transactions/pnl_realization.py

@@ -0,0 +1,122 @@
+"""
+PnlRealization module
+"""
+
+from attrs import define, field
+from ddx.common.item_utils import update_avail_collateral
+from ddx.common.logging import auditor_logger
+from ddx.common.transactions.event import Event
+from ddx._rust.common import TokenSymbol
+from ddx._rust.common.state import DerivadexSMT, Position
+from ddx._rust.common.state.keys import PositionKey, StrategyKey
+from ddx._rust.decimal import Decimal
+
+logger = auditor_logger(__name__)
+
+
+@define
+class PnlRealization(Event):
+    """
+    Defines a PnlRealization
+
+    A PnlRealization is when unrealized pnl is settled/realized for all
+    traders' strategies. This will result in a credit/debit for all
+    strategies.
+
+    Attributes:
+        settlement_epoch_id (int): Settlement epoch id
+        time_value (int): Time value
+        request_index (int): Sequenced request index of transaction
+    """
+
+    settlement_epoch_id: int
+    time_value: int
+    request_index: int = field(default=-1, eq=False)
+
+    @classmethod
+    def decode_value_into_cls(cls, raw_tx_log_event: dict):
+        """
+        Decode a raw transaction log event (dict) into a PnlRealization
+        instance.
+
+        Parameters
+        ----------
+        raw_tx_log_event : dict
+            Raw transaction log event being processed
+        """
+
+        event = raw_tx_log_event["event"]["c"]
+
+        return cls(
+            event["settlementEpochId"],
+            raw_tx_log_event["timeValue"],
+            raw_tx_log_event["requestIndex"],
+        )
+
+    def process_tx(
+        self,
+        smt: DerivadexSMT,
+        **kwargs,
+    ):
+        """
+        Process a PnlRealization transaction. A PnlRealization event
+        consists of information relating to when unrealized pnl is
+        settled/realized for all traders' strategies. This will result
+        in a credit/debit for all strategies. Furthermore, the
+        average entry price for any open positions will be set to the
+        current mark price.
+
+        Parameters
+        ----------
+        smt: DerivadexSMT
+            DerivaDEX Sparse Merkle Tree
+        **kwargs
+            Additional args specific to PnlRealization transactions
+        """
+
+        for (
+            position_key,
+            position,
+        ) in sorted(
+            smt.all_positions(),
+            key=lambda item: item[0].symbol,
+        ):
+            mark_price = kwargs["latest_price_leaves"][position_key.symbol][
+                1
+            ].mark_price
+            unrealized_pnl = position.unrealized_pnl(
+                mark_price,
+            )
+
+            # Construct a StrategyKey and corresponding encoded
+            # key
+            strategy_key: StrategyKey = position_key.as_strategy_key()
+
+            # Get the Strategy leaf given the key from above
+            strategy = smt.strategy(strategy_key)
+
+            old_balance = strategy.avail_collateral[TokenSymbol.USDC]
+            # Credit/debit the trader's Strategy leaf by the
+            # unrealized PNL to settle
+            update_avail_collateral(
+                strategy,
+                TokenSymbol.USDC,
+                strategy.avail_collateral[TokenSymbol.USDC] + unrealized_pnl,
+            )
+            logger.info(
+                f"Calculated realized pnl:\n\told balance: {old_balance}\n\tnew balance: {strategy.avail_collateral[TokenSymbol.USDC]}\n\tpnl realized: {strategy.avail_collateral[TokenSymbol.USDC] - old_balance}"
+            )
+
+            smt.store_strategy(
+                strategy_key,
+                strategy,
+            )
+
+            # Set the Position's average entry price to the mark price
+            # since settlement has just taken place
+            position.avg_entry_price = mark_price
+
+            smt.store_position(
+                position_key,
+                position,
+            )

ddx/common/transactions/post.py

@@ -0,0 +1,72 @@
+"""
+Post module
+"""
+
+from attrs import define, field
+from ddx.common.transactions.event import Event
+from ddx._rust.common import ProductSymbol
+from ddx._rust.common.enums import OrderSide
+from ddx._rust.common.state import BookOrder, DerivadexSMT
+from ddx._rust.common.state.keys import BookOrderKey, StrategyKey
+from ddx._rust.decimal import Decimal
+
+
+@define
+class Post(Event):
+    """
+    Defines a Post
+
+    A Post is an order that enters the order book.
+
+    Attributes:
+        symbol (ProductSymbol): The symbol for the market this order is for.
+        order_hash (str): Hexstr representation of the EIP-712 hash of the order
+        side (str): Side of order ('Bid', 'Ask')
+        amount (Decimal): Amount/size of order
+        price (Decimal): Price the order has been placed at
+        trader_address (str): The order creator's Ethereum address
+        strategy_id_hash (str): The cross-margined strategy ID for which this order belongs
+        book_ordinal (int): The numerical sequence-identifying value for an order's insertion into the book
+        time_value (int): Time value
+        request_index (int): Sequenced request index of transaction
+    """
+
+    symbol: ProductSymbol
+    order_hash: str = field(eq=str.lower)
+    side: OrderSide
+    amount: Decimal
+    price: Decimal
+    trader_address: str = field(eq=str.lower)
+    strategy_id_hash: str = field(eq=str.lower)
+    book_ordinal: int
+    time_value: int
+    request_index: int = field(default=-1, eq=False)
+
+    def process_tx(
+        self,
+        smt: DerivadexSMT,
+        **kwargs,
+    ):
+        """
+        Process a Post transaction. We will need to create a new
+        BookOrder leaf with this information.
+
+        Parameters
+        ----------
+        smt: DerivadexSMT
+            DerivaDEX Sparse Merkle Tree
+        **kwargs
+            Additional args specific to PostOrder transactions
+        """
+
+        book_order = BookOrder(
+            self.side,
+            self.amount,
+            self.price,
+            self.trader_address,
+            self.strategy_id_hash,
+            self.book_ordinal,
+            self.time_value,
+        )
+
+        smt.store_book_order(BookOrderKey(self.symbol, self.order_hash), book_order)

ddx/common/transactions/post_order.py

@@ -0,0 +1,95 @@
+"""
+PostOrder module
+"""
+
+from attrs import define, field
+from ddx.common.transactions.cancel import Cancel
+from ddx.common.transactions.event import Event
+from ddx.common.transactions.post import Post
+from ddx._rust.common import ProductSymbol
+from ddx._rust.common.enums import OrderSide
+from ddx._rust.common.state import DerivadexSMT
+from ddx._rust.decimal import Decimal
+
+
+@define
+class PostOrder(Event):
+    """
+    Defines a PostOrder
+
+    A PostOrder is an order that enters the order book along with any
+    canceled maker orders.
+
+    Attributes:
+        post (Post): The posted order.
+        canceled_orders (list[Cancel]): Canceled maker orders as a result of the posted order
+        request_index (int): Sequenced request index of transaction
+    """
+
+    post: Post
+    canceled_orders: list[Cancel] = field(eq=set)
+    request_index: int = field(default=-1, eq=False)
+
+    @classmethod
+    def decode_value_into_cls(cls, raw_tx_log_event: dict):
+        """
+        Decode a raw transaction log event (dict) into a PostOrder
+        instance.
+
+        Parameters
+        ----------
+        raw_tx_log_event : dict
+            Raw transaction log event being processed
+        """
+
+        post_tx_event = raw_tx_log_event["event"]["c"]
+        cancel_orders_tx_event = post_tx_event["tradeOutcomes"]
+
+        return cls(
+            Post(
+                ProductSymbol(post_tx_event["symbol"]),
+                post_tx_event["orderHash"],
+                OrderSide(post_tx_event["side"]),
+                Decimal(post_tx_event["amount"]),
+                Decimal(post_tx_event["price"]),
+                post_tx_event["traderAddress"],
+                post_tx_event["strategyIdHash"],
+                post_tx_event["bookOrdinal"],
+                raw_tx_log_event["timeValue"],
+                raw_tx_log_event["requestIndex"],
+            ),
+            [
+                Cancel(
+                    ProductSymbol(canceled_order["Cancel"]["symbol"]),
+                    canceled_order["Cancel"]["orderHash"],
+                    Decimal(canceled_order["Cancel"]["amount"]),
+                    raw_tx_log_event["requestIndex"],
+                )
+                for canceled_order in cancel_orders_tx_event
+            ],
+            raw_tx_log_event["requestIndex"],
+        )
+
+    def process_tx(
+        self,
+        smt: DerivadexSMT,
+        **kwargs,
+    ):
+        """
+        Process a PostOrder transaction. We will need to create a new
+        BookOrder leaf with this information.
+
+        Parameters
+        ----------
+        smt: DerivadexSMT
+            DerivaDEX Sparse Merkle Tree
+        **kwargs
+            Additional args specific to PostOrder transactions
+        """
+
+        # Loop through each cancel event and process them individually
+        for canceled_order in self.canceled_orders:
+            canceled_order.process_tx(smt, **kwargs)
+
+        # Process the post event
+        self.post.process_tx(smt, **kwargs)

ddx/common/transactions/price_checkpoint.py

@@ -0,0 +1,96 @@
+"""
+PriceCheckpoint module
+"""
+
+from attrs import define, field
+from ddx.common.transactions.event import Event
+from ddx._rust.common import ProductSymbol
+from ddx._rust.common.accounting import MarkPriceMetadata
+from ddx._rust.common.state import DerivadexSMT, Price
+from ddx._rust.common.state.keys import PriceKey
+from ddx._rust.decimal import Decimal
+
+
+@define(hash=True)
+class PriceCheckpoint(Event):
+    """
+    Defines a PriceCheckpoint
+
+    A PriceCheckpoint is when a market registers an update to the
+    composite index price a perpetual is tracking along with the mark
+    price metadata component.
+
+    Attributes:
+        symbol (ProductSymbol): The symbol for the market this price update is for.
+        mark_price_metadata (MarkPriceMetadata): Mark price metadata used for calculating mark price
+        index_price_hash (str): Index price hash
+        index_price (Decimal): Composite index price (a weighted average across several price feed sources)
+        ordinal (int): The numerical sequence-identifying value for a PriceCheckpoint
+        time_value (int): Time value
+        request_index (int): Sequenced request index of transaction
+    """
+
+    symbol: ProductSymbol
+    mark_price_metadata: MarkPriceMetadata = field(hash=False)
+    index_price_hash: str = field(eq=str.lower)
+    index_price: Decimal = field(hash=False)
+    ordinal: int = field(hash=False)
+    time_value: int
+    request_index: int = field(default=-1, eq=False, hash=False)
+
+    def is_void(self):
+        return self.index_price == Decimal("0")
+
+    @property
+    def mark_price(self) -> Decimal:
+        if isinstance(self.mark_price_metadata, MarkPriceMetadata.Ema):
+            mark_price = min(
+                self.index_price * Decimal("1.005"),
+                max(
+                    self.index_price * Decimal("0.995"),
+                    self.index_price + self.mark_price_metadata.ema,
+                ),
+            ).recorded_amount()
+        elif (
+            isinstance(self.mark_price_metadata, MarkPriceMetadata.Average) is not None
+        ):
+            mark_price = (self.index_price + self.mark_price_metadata.accum) / (
+                self.mark_price_metadata.count + 1
+            )
+        else:
+            raise ValueError("Invalid MarkPriceMetadata type")
+        return mark_price.recorded_amount()
+
+    def process_tx(
+        self,
+        smt: DerivadexSMT,
+        **kwargs,
+    ):
+        """
+        Process a PriceCheckpoint transaction. A PriceCheckpoint
+        consists of information relating to a new price checkpoint,
+        such as the symbol, composite index price, and mark price
+        metadata. This will update the Price leaf in the SMT.
+
+        Parameters
+        ----------
+        smt: DerivadexSMT
+            DerivaDEX Sparse Merkle Tree
+        **kwargs
+            Additional args specific to PriceCheckpoint transactions
+        """
+        price_key = PriceKey(self.symbol, self.index_price_hash)
+        price = Price(
+            self.index_price,
+            self.mark_price_metadata,
+            self.ordinal,
+            self.time_value,
+        )
+        smt.store_price(price_key, price)
+
+        # Update latest price leaves abstraction with the new price
+        # checkpoint data
+        kwargs["latest_price_leaves"][self.symbol] = (
+            price_key,
+            price,
+        )

ddx/common/transactions/signer_registered.py

@@ -0,0 +1,62 @@
+"""
+Signer Registered module
+"""
+
+from attrs import define, field
+from ddx.common.transactions.event import Event
+from ddx._rust.common.state import DerivadexSMT, Signer
+from ddx._rust.common.state.keys import SignerKey
+
+
+@define
+class SignerRegistered(Event):
+    """
+    Defines a SignerRegistered
+
+    A SignerRegistered is when a new enclave signer registers with the smart contract
+
+    Attributes:
+        signer_address (str): The signer address component of the signer key pertaining to the SignerRegistered tx.
+        release_hash (str): The release hash component of the signer key pertaining to the SignerRegistered tx.
+    """
+
+    signer_address: str = field(eq=str.lower)
+    release_hash: str = field(eq=str.lower)
+
+    @classmethod
+    def decode_value_into_cls(cls, raw_tx_log_event: dict):
+        """
+        Decode a raw transaction log event (dict) into a SignerRegistered
+        instance.
+
+        Parameters
+        ----------
+        raw_tx_log_event : dict
+            Raw transaction log event being processed
+        """
+
+        event = raw_tx_log_event["event"]["c"]
+
+        return cls(
+            event["signerAddress"],
+            event["releaseHash"],
+        )
+
+    def process_tx(
+        self,
+        smt: DerivadexSMT,
+        **kwargs,
+    ):
+        """
+        Process a SignerRegistered, inserting the signer into the tree
+
+        Parameters
+        ----------
+        smt: DerivadexSMT
+            DerivaDEX Sparse Merkle Tree
+        **kwargs
+            Additional args specific to SignerRegistered transactions
+        """
+        signer = Signer(self.release_hash)
+
+        smt.store_signer(SignerKey(self.signer_address), signer)

ddx/common/transactions/specs_update.py

@@ -0,0 +1,61 @@
+"""
+SpecsUpdate module
+"""
+
+from attrs import define, field
+from ddx.common.transactions.event import Event
+from ddx._rust.common import ProductSymbol
+from ddx._rust.common.specs import SpecsKind
+from ddx._rust.common.state import Specs
+from ddx._rust.common.state.keys import SpecsKey
+from ddx._rust.decimal import Decimal
+
+
+# TODO: test usage
+@define
+class SpecsUpdate(Event):
+    """
+    Defines an SpecsUpdate
+
+    An SpecsUpdate is a transaction that updates the market specs
+
+    Attributes:
+        key (SpecsKey): The key of the specs being updated
+        expr (Specs): The expression of the specs being updated
+        block_number (int): Block number of transaction
+        tx_hash (str): Transaction hash of on-chain action
+        request_index (int): Sequenced request index of transaction
+    """
+
+    key: SpecsKey
+    expr: Specs
+    block_number: int
+    tx_hash: str = field(eq=str.lower)
+    request_index: int = field(default=-1, eq=False)
+
+    @classmethod
+    def decode_value_into_cls(cls, raw_tx_log_event: dict):
+        """
+        Decode a raw transaction log event (dict) into a
+        SpecsUpdate instance.
+
+        Parameters
+        ----------
+        raw_tx_log_event : dict
+            Raw transaction log event being processed
+        """
+
+        specs_update_tx_event = raw_tx_log_event["event"]["c"]
+
+        return cls(
+            SpecsKey(
+                SpecsKind(specs_update_tx_event["key"]["kind"]),
+                specs_update_tx_event["key"]["name"],
+            ),
+            Specs(specs_update_tx_event["expr"]),
+            specs_update_tx_event["blockNumber"],
+            specs_update_tx_event["txHash"],
+            raw_tx_log_event["requestIndex"],
+        )
+
+    # TODO: process_tx