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

ddx/common/utils.py

@@ -0,0 +1,176 @@
+"""
+Utils module
+"""
+
+from decimal import Decimal as PyDecimal
+import simplejson as json
+
+from ddx._rust.common.enums import OrderSide
+from ddx._rust.decimal import Decimal
+
+
+def round_to_unit(val: Decimal) -> Decimal:
+    """
+    Round a decimal value down to 6 units of precision.
+
+    Parameters
+    ----------
+    val : Decimal
+        Value to be rounded
+    """
+
+    return val.quantize(6)
+
+
+def to_base_unit_amount(val: Decimal, decimals: int) -> int:
+    """
+    Convert a value to grains format (e.g. DDX grains would be
+    multiplying by 10 ** 18).
+
+    Parameters
+    ----------
+    val : Decimal
+        Value to be scaled up
+    decimals : int
+        Number of decimal places to scale up to
+    """
+
+    return int(round_to_unit(val) * 10**decimals)
+
+
+def to_unit_amount(val: int, decimals: int) -> Decimal:
+    """
+    Convert a value from grains format (e.g. from DDX grains would be
+    dividing by 10 ** 18).
+
+    Parameters
+    ----------
+    val : Decimal
+        Value to be scaled down
+    decimals : int
+        Number of decimal places to scale down by
+    """
+
+    return Decimal(str(val)) / 10**decimals
+
+
+def to_base_unit_amount_list(vals: list[Decimal], decimals: int) -> list[int]:
+    """
+    Convert values to grains format (e.g. DDX grains would be
+    multiplying by 10 ** 18).
+
+    Parameters
+    ----------
+    vals : list[Decimal]
+        Values to be scaled up
+    decimals : int
+        Number of decimal places to scale up to
+    """
+
+    return [to_base_unit_amount(val, decimals) for val in vals]
+
+
+def to_unit_amount_list(vals: list[int], decimals: int):
+    """
+    Convert values from grains format (e.g. from DDX grains would be
+    dividing by 10 ** 18).
+
+    Parameters
+    ----------
+    vals : list[int]
+        Values to be scaled down
+    decimals : int
+        Number of decimal places to scale down by
+    """
+
+    return [to_unit_amount(val, decimals) for val in vals]
+
+
+def to_adjusted_encoding_for_negative_val(val: int):
+    """
+    Adjust encoding for a potentially negative value
+
+    Parameters
+    ----------
+    vals : int
+        Values to be adjusted
+    """
+
+    return 16**32 + abs(val) if val < 0 else val
+
+
+def to_adjusted_encoding_for_negative_val_list(vals: list[int]):
+    """
+    Adjust encoding for list of potentially negative values
+
+    Parameters
+    ----------
+    vals : list[int]
+        list of values to be adjusted
+    """
+
+    return [to_adjusted_encoding_for_negative_val(val) for val in vals]
+
+
+def from_adjusted_encoding_for_negative_val(val: int):
+    """
+    Adjust encoding for a potentially negative value
+
+    Parameters
+    ----------
+    vals : int
+        Values to be adjusted
+    """
+
+    return val if val < 16**32 else -(val - 16**32)
+
+
+def get_parsed_tx_log_entry(tx_log_entry: dict):
+    """
+    Parse an individual transaction log entry into a format
+    suitable for the Auditor. This format was selected so
+    that the Auditor can be reused as-is by the integration
+    tests with no changes needed.
+
+    Parameters
+    ----------
+    tx_log_entry : dict
+        Transaction log message
+    """
+    return {
+        "event": tx_log_entry["event"],
+        "requestIndex": int(tx_log_entry["requestIndex"]),
+        "epochId": int(tx_log_entry["epochId"]),
+        "txOrdinal": int(tx_log_entry["ordinal"]),
+        "batchId": int(tx_log_entry["batchId"]),
+        "timeValue": int(tx_log_entry["time"]["value"]),
+        "timestamp": int(tx_log_entry["time"]["timestamp"]),
+        "stateRootHash": tx_log_entry["stateRootHash"],
+    }
+
+
+def calculate_max_collateral(
+    collateral_tranches: list[tuple[Decimal, Decimal]], ddx_balance: Decimal
+) -> Decimal:
+    limit = Decimal("0")
+    for ddx_threshold, max_collateral in collateral_tranches:
+        limit = max_collateral
+        if ddx_balance < ddx_threshold:
+            break
+    return limit
+
+
+class ComplexOutputEncoder(json.JSONEncoder):
+    """
+    Custom JSON-encoder for serializing objects
+    """
+
+    def __init__(self, **kwargs):
+        super(ComplexOutputEncoder, self).__init__(**kwargs)
+
+    def default(self, o):
+        if hasattr(o, "repr_json"):
+            return o.repr_json()
+        elif type(o) == Decimal:
+            return PyDecimal(str(o))
+        return json.JSONEncoder.default(self, o)

ddx/config.py

@@ -0,0 +1,17 @@
+import os
+
+# from ddx._rust import common
+from ddx._rust.common import reinit_operator_context
+
+# FIXME: might need to change these environment variables to `DDX_CONTRACT_DEPLOYMENT` for better convention
+
+
+def load_mainnet():
+    os.environ["CONTRACT_DEPLOYMENT"] = "derivadex"
+    # common.reinit_operator_context()
+    reinit_operator_context()
+
+
+def load_testnet():
+    os.environ["CONTRACT_DEPLOYMENT"] = "testnet"
+    reinit_operator_context()

ddx/derivadex_client.py

@@ -0,0 +1,254 @@
+"""
+DerivaDEX Client
+"""
+
+from typing import Optional
+from web3 import Web3
+from web3.middleware import geth_poa_middleware
+
+from ddx.realtime_client import RealtimeClient
+from ddx.rest_client.clients.market_client import MarketClient
+from ddx.rest_client.clients.on_chain_client import OnChainClient
+from ddx.rest_client.clients.signed_client import SignedClient
+from ddx.rest_client.clients.system_client import SystemClient
+from ddx.rest_client.clients.trade_client import TradeClient
+from ddx.rest_client.http.http_client import HTTPClient
+
+
+class DerivaDEXClient:
+    """
+    Main client for interacting with the DerivaDEX API.
+
+    This client provides access to all DerivaDEX API endpoints through
+    various client objects and supports both REST and WebSocket APIs.
+    It can be used as an async context manager to ensure proper client cleanup.
+
+    Attributes
+    ----------
+    market : MarketClient
+        Access to market operations
+    on_chain : OnChainClient
+        Access to on-chain operations
+    signed : SignedClient
+        Access to signed operations
+    system : SystemClient
+        Access to system operations
+    trade : TradeClient
+        Access to trade operations
+    web3_account : Account
+        The Web3 account used for signing transactions
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        ws_url: str,
+        rpc_url: str,
+        contract_deployment: str,
+        private_key: str = None,
+        mnemonic: str = None,
+        timeout: int = 30,
+    ) -> None:
+        """
+        Initialize the client.
+
+        Parameters
+        ----------
+        base_url : str
+            Base URL for webserver
+        ws_url : str
+            WebSocket URL for real-time updates
+        rpc_url : str
+            RPC URL for webserver
+        contract_deployment : str
+            Type of contract deployment (e.g. "mainnet")
+        private_key : str, optional
+            Ethereum private key for user
+        mnemonic : str, optional
+            Ethereum mnemonic for user
+        timeout : int, default=30
+            Timeout in seconds for HTTP requests
+
+        Raises
+        ------
+        ValueError
+            If neither private_key nor mnemonic is provided
+        """
+
+        if not private_key and not mnemonic:
+            raise ValueError("Either private_key or mnemonic must be provided")
+
+        self._base_url = base_url
+        self._ws_url = ws_url
+
+        # Initialize HTTP client
+        self._http = HTTPClient(timeout)
+
+        self._contract_deployment = contract_deployment
+
+        # These will be initialized when needed
+        self._chain_id: Optional[int] = None
+        self._verifying_contract: Optional[str] = None
+
+        # Initialize web3 service
+        self.w3 = Web3(Web3.HTTPProvider(rpc_url, request_kwargs={"timeout": 60}))
+
+        if contract_deployment == "geth":
+            self.w3.middleware_onion.inject(geth_poa_middleware, layer=0)
+
+        # Initialize web3 account from private key or mnemonic
+        if private_key is not None:
+            self.web3_account = self.w3.eth.account.from_key(private_key)
+        else:
+            self.w3.eth.account.enable_unaudited_hdwallet_features()
+            self.web3_account = self.w3.eth.account.from_mnemonic(mnemonic)
+
+        # Set default account for send transactions
+        self.w3.eth.defaultAccount = self.web3_account.address
+
+        # Initialize clients (lazy loading)
+        self._market: Optional[MarketClient] = None
+        self._on_chain: Optional[OnChainClient] = None
+        self._signed: Optional[SignedClient] = None
+        self._system: Optional[SystemClient] = None
+        self._trade: Optional[TradeClient] = None
+
+    async def __aenter__(self) -> "DerivaDEXClient":
+        await self._http.__aenter__()
+
+        # Get deployment configuration
+        deployment_info = await self.system.get_deployment_info(
+            self._contract_deployment
+        )
+        self._chain_id = deployment_info.chain_id
+        self._verifying_contract = deployment_info.addresses.derivadex_address
+
+        # Initialize and start WebSocket client
+        # We do this here rather than lazy loading because we want
+        # to ensure the connection is established when using the context manager
+        self._ws = RealtimeClient(self._ws_url)
+        await self._ws.connect()
+
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        # Stop WebSocket client if it was started
+        if self._ws is not None:
+            await self._ws.disconnect()
+        await self._http.__aexit__(exc_type, exc_val, exc_tb)
+
+    @property
+    def ws(self) -> RealtimeClient:
+        """
+        Access WebSocket functionality.
+
+        Returns
+        -------
+        RealtimeClient
+            The WebSocket Realtime API client instance
+
+        Raises
+        ------
+        RuntimeError
+            If accessed outside of context manager
+        """
+
+        if not hasattr(self, "_ws"):
+            raise RuntimeError("WebSocket client must be used within context manager")
+
+        return self._ws
+
+    @property
+    def market(self) -> MarketClient:
+        """
+        Access to market operations.
+
+        Returns
+        -------
+        MarketClient
+            The market client instance, initialized on first access
+        """
+
+        if self._market is None:
+            self._market = MarketClient(self._http, self._base_url)
+
+        return self._market
+
+    @property
+    def on_chain(self) -> OnChainClient:
+        """
+        Access on-chain operations.
+
+        Returns
+        -------
+        OnChainClient
+            The on-chain client instance, initialized on first access
+        """
+
+        if self._on_chain is None:
+            self._on_chain = OnChainClient(
+                self._http,
+                self._base_url,
+                self.web3_account,
+                self.w3,
+                self._verifying_contract,
+            )
+
+        return self._on_chain
+
+    @property
+    def signed(self) -> SignedClient:
+        """
+        Access to signed operations
+
+        Returns
+        -------
+        SignedClient
+            The signed client instance, initialized on first access
+        """
+
+        if self._signed is None:
+            self._signed = SignedClient(
+                self._http,
+                self._base_url,
+                self.web3_account,
+                self._chain_id,
+                self._verifying_contract,
+            )
+
+        return self._signed
+
+    @property
+    def system(self) -> SystemClient:
+        """
+        Access to system operations.
+
+        Returns
+        -------
+        SystemClient
+            The system client instance, initialized on first access
+        """
+
+        if self._system is None:
+            self._system = SystemClient(self._http, self._base_url)
+
+        return self._system
+
+    @property
+    def trade(self) -> TradeClient:
+        """
+        Access to trade operations
+
+        Returns
+        -------
+        TradeClient
+            The trade client instance, initialized on first access
+        """
+
+        if self._trade is None:
+            self._trade = TradeClient(
+                self._http,
+                self._base_url,
+            )
+
+        return self._trade

ddx/realtime_client/__init__.py

@@ -0,0 +1,2 @@
+from .realtime_client import RealtimeClient
+from .models import *

ddx/realtime_client/config.py

@@ -0,0 +1,2 @@
+DEFAULT_RETRY_DELAY = 1
+MAX_RETRY_DELAY = 60