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

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,97 @@
+"""
+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 oracle 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

ddx/common/transactions/strategy_update.py

@@ -0,0 +1,158 @@
+"""
+Strategy Update module
+"""
+
+from typing import Optional
+
+from attrs import define, field
+from ddx.common.transactions.event import Event
+from ddx.common.utils import calculate_max_collateral
+from ddx._rust.common import TokenSymbol
+from ddx._rust.common.state import DerivadexSMT, Strategy, Trader
+from ddx._rust.common.state.keys import StrategyKey, TraderKey
+from ddx._rust.common.transactions import StrategyUpdateKind
+from ddx._rust.decimal import Decimal
+
+
+@define
+class StrategyUpdate(Event):
+    """
+    Defines a Strategy Update
+
+    A StrategyUpdate is an update to a trader's strategy (such as
+    depositing or withdrawing collateral).
+
+    Attributes:
+        trader_address (str): Trader's Ethereum address this strategy belongs to
+        collateral_address (str): Collateral's Ethereum address a deposit/withdrawal has been made with
+        strategy_id_hash (str): Strategy ID hash for the given trader this event belongs to
+        strategy_id (Optional[str]): Strategy ID for the given trader this event belongs to. Only deposits will fill this field
+        amount (Decimal): The amount of collateral deposited or withdrawn
+        update_kind (StrategyUpdateKind): Update kind (Deposit=0, Withdraw=1)
+        tx_hash (str): The Ethereum transaction's hash
+        request_index (int): Sequenced request index of transaction
+    """
+
+    trader_address: str = field(eq=str.lower)
+    collateral_address: str = field(eq=str.lower)
+    strategy_id_hash: str = field(eq=str.lower)
+    strategy_id: Optional[str]
+    amount: Decimal
+    update_kind: StrategyUpdateKind
+    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 StrategyUpdate
+        instance.
+
+        Parameters
+        ----------
+        raw_tx_log_event : dict
+            Raw transaction log event being processed
+        """
+
+        strategy_update_tx_event = raw_tx_log_event["event"]["c"]
+
+        return cls(
+            strategy_update_tx_event["trader"],
+            strategy_update_tx_event["collateralAddress"],
+            strategy_update_tx_event["strategyIdHash"],
+            strategy_update_tx_event.get("strategyId"),
+            Decimal(strategy_update_tx_event["amount"]),
+            StrategyUpdateKind(strategy_update_tx_event["updateKind"]),
+            strategy_update_tx_event["txHash"],
+            raw_tx_log_event["requestIndex"],
+        )
+
+    def process_tx(
+        self,
+        smt: DerivadexSMT,
+        **kwargs,
+    ):
+        """
+        Process a StrategyUpdate transaction. A StrategyUpdate consists
+        of information relating to updates for a trader's strategy, such
+        as when their free or frozen collateral has changed due to a
+        deposit or withdrawal. This will update the Strategy leaf in the
+        SMT.
+
+        Parameters
+        ----------
+        smt: DerivadexSMT
+            DerivaDEX Sparse Merkle Tree
+        **kwargs
+            Additional args specific to StrategyUpdate transactions
+        """
+
+        strategy_key: StrategyKey = StrategyKey(
+            self.trader_address, self.strategy_id_hash
+        )
+        strategy = smt.strategy(strategy_key)
+
+        symbol = TokenSymbol.from_address(self.collateral_address)
+        if self.update_kind == StrategyUpdateKind.Deposit:
+            # If StrategyUpdate is of deposit type
+
+            trader_key: TraderKey = TraderKey(self.trader_address)
+            trader = smt.trader(trader_key)
+
+            if strategy is None:
+                # If we haven't yet seen the Strategy leaf, create a new
+                # one
+                strategy = Strategy.default()
+
+                if trader is None:
+                    # Initialize a new Trader Leaf
+                    trader = Trader.default()
+
+                    smt.store_trader(trader_key, trader)
+
+            # Compute max allowable deposit given the collateral guard
+            # for the trader's DDX balance
+            max_allowable_deposit = max(
+                (
+                    calculate_max_collateral(
+                        kwargs["collateral_tranches"], trader.avail_ddx_balance
+                    )
+                    - strategy.avail_collateral.total_value()
+                ),
+                Decimal("0"),
+            )
+
+            # Compute how much of the attempted deposit will be added
+            # to the Strategy's free collateral
+            net = min(max_allowable_deposit, self.amount)
+
+            # Increment the Strategy's free collateral
+            strategy.set_avail_collateral(
+                symbol,
+                strategy.avail_collateral[symbol] + net,
+            )
+
+            # Compute how much of the attempted deposit will be added
+            # to the Strategy's frozen collateral
+            kickback = self.amount - net
+            if kickback != Decimal("0"):
+                # Increment the Strategy's frozen collateral
+                strategy.set_locked_collateral(
+                    symbol,
+                    strategy.locked_collateral[symbol] + kickback,
+                )
+        elif self.update_kind == StrategyUpdateKind.Withdraw:
+            # If StrategyUpdate is of withdrawal (claimed) type
+            if strategy is None or strategy.locked_collateral[symbol] < self.amount:
+                raise Exception(
+                    "Strategy leaf either non-existent or insufficiently capitalized to facilitate withdrawal"
+                )
+
+            # Adjust the existing strategy leaf by decrementing the
+            # free collateral by the amount in the withdrawal event
+            strategy.set_locked_collateral(
+                symbol,
+                strategy.locked_collateral[symbol] - self.amount,
+            )
+
+        smt.store_strategy(strategy_key, strategy)

ddx/common/transactions/tradable_product_update.py

@@ -0,0 +1,98 @@
+"""
+Tradable Product Update module
+"""
+
+from attrs import define, field
+from ddx.common.transactions.event import Event
+from ddx._rust.common.specs import SpecsKind
+from ddx._rust.common.state import (DerivadexSMT, TradableProduct,
+                                    TradableProductParameters)
+from ddx._rust.common.state.keys import SpecsKey, TradableProductKey
+
+
+@define
+class TradableProductUpdate(Event):
+    """
+    Defines a Tradable Product Update
+
+    A TradableProductUpdate is an update to a trader's strategy (such as depositing or withdrawing collateral).
+
+    Attributes:
+        additions (list[TradableProductKey]): List of tradable product keys that are marked tradable
+        removals (list[TradableProductKey]): List of tradable product keys that are marked untradable
+        request_index (int): Sequenced request index of transaction
+    """
+
+    additions: list[TradableProductKey]
+    removals: list[TradableProductKey]
+    request_index: int = field(default=-1, eq=False, hash=False)
+
+    @classmethod
+    def decode_value_into_cls(cls, raw_tx_log_event: dict):
+        """
+        Decode a raw transaction log event (dict) into a StrategyUpdate
+        instance.
+
+        Parameters
+        ----------
+        raw_tx_log_event : dict
+            Raw transaction log event being processed
+        """
+
+        tradable_product_update_tx_event = raw_tx_log_event["event"]["c"]
+
+        return cls(
+            [
+                TradableProductKey(
+                    SpecsKey(
+                        SpecsKind(tradable_product_key["specsKey"]["kind"]),
+                        tradable_product_key["specsKey"]["name"],
+                    ),
+                    TradableProductParameters.from_dict(
+                        tradable_product_key["parameters"]
+                    ),
+                )
+                for tradable_product_key in tradable_product_update_tx_event[
+                    "additions"
+                ]
+            ],
+            [
+                TradableProductKey(
+                    SpecsKey(
+                        SpecsKind(tradable_product_key["specsKey"]["kind"]),
+                        tradable_product_key["specsKey"]["name"],
+                    ),
+                    TradableProductParameters.from_dict(
+                        tradable_product_key["parameters"]
+                    ),
+                )
+                for tradable_product_key in tradable_product_update_tx_event["removals"]
+            ],
+            raw_tx_log_event["requestIndex"],
+        )
+
+    def process_tx(
+        self,
+        smt: DerivadexSMT,
+        **kwargs,
+    ):
+        """
+        Process a TradableProductUpdate transaction. A TradableProductUpdate consists
+        of information relating to updates of the list of tradable products.
+
+        Parameters
+        ----------
+        smt: DerivadexSMT
+            DerivaDEX Sparse Merkle Tree
+        **kwargs
+            Additional args specific to TradableProductUpdate transactions
+        """
+
+        for tradable_product_key in self.additions:
+            smt.store_tradable_product(
+                tradable_product_key,
+                TradableProduct(),
+            )
+
+        for tradable_product_key in self.removals:
+            smt.store_tradable_product(tradable_product_key, None)