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

ddx/rest_client/models/signed.py

@@ -0,0 +1,61 @@
+from typing import Optional, Dict, Union, Any, Literal
+from ddx.models.base import CamelModel, HexStr
+from pydantic import Field, field_validator, ConfigDict
+from ddx._rust.common.requests import SafetyFailure
+
+
+class SequencedReceiptContent(CamelModel):
+    """Content of a successful sequenced receipt."""
+
+    nonce: HexStr
+    request_hash: HexStr
+    request_index: int = Field(..., ge=0)
+    sender: HexStr
+    enclave_signature: HexStr
+
+
+class ErrorReceiptContent(CamelModel):
+    """Content of an error receipt."""
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    message: str
+    inner: SafetyFailure
+
+    @field_validator("inner", mode="before")
+    def _parse_safety_failure(cls, v):
+        if isinstance(v, SafetyFailure):
+            return v
+        return SafetyFailure[v] if isinstance(v, str) else SafetyFailure(v)
+
+
+class TradeReceipt(CamelModel):
+    """Model for trade request receipts."""
+
+    t: Literal["Sequenced", "SafetyFailure"]
+    c: Union[SequencedReceiptContent, ErrorReceiptContent, Dict[str, Any]]
+
+    @property
+    def is_success(self) -> bool:
+        """Check if the receipt indicates success."""
+
+        return self.t == "Sequenced"
+
+    @property
+    def is_error(self) -> bool:
+        """Check if the receipt indicates an error."""
+
+        return self.t in ("Error", "SafetyFailure")
+
+    @property
+    def error_message(self) -> Optional[str]:
+        """Get the error message if this is an error receipt."""
+
+        if self.is_error and isinstance(self.c, ErrorReceiptContent):
+            return self.c.message
+        return None
+
+    @property
+    def error(self) -> Optional[SafetyFailure]:
+        if self.is_error and isinstance(self.c, ErrorReceiptContent):
+            return self.c.inner
+        return None

ddx/rest_client/models/system.py

@@ -0,0 +1,311 @@
+from datetime import datetime
+from typing import List, Optional
+from pydantic import Field, ConfigDict, field_validator
+from ddx.models.base import CamelModel
+
+
+class SettlementInfo(CamelModel):
+    """Settlement information model."""
+
+    type: str
+    duration_value: str
+    duration_unit: str
+
+
+class SymbolInfo(CamelModel):
+    """Symbol information model."""
+
+    symbol: str
+    tick_size: str
+    max_order_notional: str
+    max_taker_price_deviation: str
+    min_order_size: str
+    kind: str  # SingleNamePerpetual, IndexFundPerpetual, FixedExpiryFuture
+
+
+class ExchangeInfo(CamelModel):
+    """Exchange information model."""
+
+    settlements_info: List[SettlementInfo]
+    assets: List[str]
+    symbols: List[SymbolInfo]
+
+
+class ExchangeInfoResponse(CamelModel):
+    """Response model for exchange info endpoint."""
+
+    value: ExchangeInfo
+    success: bool
+    timestamp: int
+
+
+class PingResponse(CamelModel):
+    """Response model for ping endpoint."""
+
+    model_config = CamelModel.model_config | ConfigDict(extra="allow")
+
+    # The ping endpoint returns an empty object on success
+    # We'll allow extra fields in case the response changes in the future
+
+
+class Symbol(CamelModel):
+    """Tradable product symbol model."""
+
+    kind: int  # 0: Perpetual Market, 2: Index Market, 4: Futures Market
+    symbol: str
+    name: str
+    is_active: bool
+    created_at: datetime
+
+
+class SymbolsResponse(CamelModel):
+    """Response model for symbols endpoint."""
+
+    value: List[Symbol]
+    success: bool
+    timestamp: int
+
+
+class ServerTimeResponse(CamelModel):
+    """Response model for server time endpoint."""
+
+    server_time: int
+
+
+class Epoch(CamelModel):
+    """Epoch data model."""
+
+    epoch_id: int
+    start_time: datetime
+    end_time: Optional[datetime] = None
+
+
+class EpochHistoryResponse(CamelModel):
+    """Response model for epoch history endpoint."""
+
+    value: List[Epoch]
+    success: bool
+    timestamp: int
+
+
+class InsuranceFund(CamelModel):
+    """Insurance fund update data model."""
+
+    epoch_id: int
+    tx_ordinal: int
+    symbol: str
+    total_capitalization: Optional[str] = None
+    kind: int  # 0: fill, 1: liquidation, 2: deposit, 3: withdrawal
+    created_at: datetime
+
+
+class InsuranceFundHistoryResponse(CamelModel):
+    """Response model for insurance fund history endpoint with cursor pagination."""
+
+    value: List[InsuranceFund]
+    next_epoch: Optional[int] = Field(None, ge=0)
+    next_tx_ordinal: Optional[int] = Field(None, ge=0)
+    next_ordinal: Optional[int] = Field(None, ge=0)
+    success: bool
+    timestamp: int
+
+
+class SpecValue(CamelModel):
+    """Spec value model."""
+
+    model_config = CamelModel.model_config | ConfigDict(extra="allow")
+
+    # This is a flexible model that can contain various fields
+    # based on the kind of spec
+
+
+class Spec(CamelModel):
+    """Spec data model."""
+
+    kind: int = Field(..., description="0: Market, 1: SpotGateway")
+    name: str
+    expr: str
+    value: Optional[SpecValue] = None
+
+
+class SpecsResponse(CamelModel):
+    """Response model for specs endpoint."""
+
+    value: List[Spec]
+    success: bool
+    timestamp: int
+
+
+class OnChainCheckpoint(CamelModel):
+    """On-chain checkpoint information model."""
+
+    latest_on_chain_checkpoint: int
+    latest_checkpoint_transaction_link: Optional[str] = None
+
+
+class ExchangeStatus(CamelModel):
+    """Exchange status information model."""
+
+    current_epoch: str
+    latest_on_chain_checkpoint: Optional[OnChainCheckpoint] = None
+    active_addresses: str
+
+
+class ExchangeStatusResponse(CamelModel):
+    """Response model for exchange status endpoint."""
+
+    value: ExchangeStatus
+    success: bool
+    timestamp: int
+
+
+class DDXSupply(CamelModel):
+    """DDX supply information model."""
+
+    circulating_supply: str
+
+
+class DDXSupplyResponse(CamelModel):
+    """Response model for DDX supply endpoint."""
+
+    value: DDXSupply
+    success: bool
+    timestamp: int
+
+
+class TradableProduct(CamelModel):
+    """Tradable product data model."""
+
+    kind: int  # 0: Perpetual Market, 2: Index Market, 4: Futures Market
+    symbol: str
+    name: str
+    is_active: bool
+    created_at: datetime
+
+
+class TradableProductsResponse(CamelModel):
+    """Response model for tradable products endpoint."""
+
+    value: List[TradableProduct]
+    success: bool
+    timestamp: int
+
+
+class CollateralAggregation(CamelModel):
+    """Collateral aggregation data model."""
+
+    model_config = CamelModel.model_config | ConfigDict(extra="allow")
+
+    timestamp: int
+    # Dynamic fields will be handled with extra='allow'
+    # Fields like collateral_deposits, collateral_withdrawals, etc.
+
+    # Add method to access dynamic fields
+    def get_value(self, field_name: str) -> Optional[str]:
+        """Get value for a specific collateral field."""
+        return getattr(self, f"collateral_{field_name}", None)
+
+
+class CollateralAggregationResponse(CamelModel):
+    """Response model for collateral aggregation endpoint."""
+
+    value: List[CollateralAggregation]
+    next_starting_value: Optional[str] = None
+    success: bool
+    timestamp: int
+
+
+class DDXAggregation(CamelModel):
+    """DDX aggregation data model."""
+
+    model_config = CamelModel.model_config | ConfigDict(extra="allow")
+
+    timestamp: int
+    # Dynamic fields will be available through extra="allow"
+    # Fields like ddx_deposits, ddx_withdrawals, etc.
+
+    # Add method to get DDX value by type
+    def get_ddx_value(self, value_type: str) -> Optional[str]:
+        """Get DDX value for a specific type."""
+        return getattr(self, f"ddx_{value_type}", None)
+
+
+class DDXAggregationResponse(CamelModel):
+    """Response model for DDX aggregation endpoint."""
+
+    value: List[DDXAggregation]
+    next_starting_value: Optional[str] = None
+    success: bool
+    timestamp: int
+
+
+class InsuranceFundAggregation(CamelModel):
+    """Insurance fund aggregation data model."""
+
+    model_config = CamelModel.model_config | ConfigDict(extra="allow")
+
+    timestamp: int
+    # Dynamic fields will be handled with extra='allow'
+    # Fields like insurance-fund_fees, insurance-fund_overall, etc.
+
+    def get_value(self, field: str) -> Optional[str]:
+        """Get a specific field value."""
+        return getattr(self, field, None)
+
+
+class InsuranceFundAggregationResponse(CamelModel):
+    """Response model for insurance fund aggregation endpoint."""
+
+    value: List[InsuranceFundAggregation]
+    next_starting_value: Optional[str] = None
+    success: bool
+    timestamp: int
+
+
+class DeploymentAddresses(CamelModel):
+    """Model for contract deployment addresses."""
+
+    ddx_address: str
+    ddx_wallet_cloneable_address: str
+    derivadex_address: str = Field(alias="derivaDEXAddress")  # Custom alias
+    di_fund_token_factory_address: str
+    governance_address: str
+    governance_dip12_address: str
+    gas_consumer_address: str
+    insurance_fund_address: str
+    pause_address: str
+    trader_address: str
+    usdt_address: str
+    ausdt_address: str
+    cusdt_address: str
+    usdc_address: str
+    cusdc_address: str
+    ausdc_address: str
+    husd_address: str
+    gusd_address: str
+    gnosis_safe_address: str
+    gnosis_safe_proxy_factory_address: str
+    gnosis_safe_proxy_address: str
+    create_call_address: str
+    banner_address: str
+    funded_insurance_fund_address: str
+    funded_insurance_fund_dip12_address: str
+    checkpoint_address: str
+    registration_address: str
+    initialize_app_address: str
+    specs_address: str
+    collateral_address: str
+    collateral_dip12_address: str
+    custodian_address: str
+    reject_address: str
+    stake_address: str
+    stake_dip12_address: str
+    pilot_reset_address: str
+
+
+class DeploymentInfo(CamelModel):
+    """Model for deployment information."""
+
+    addresses: DeploymentAddresses
+    chain_id: int
+    eth_rpc_url: str

ddx/rest_client/models/trade.py

@@ -0,0 +1,185 @@
+from datetime import datetime
+from typing import List, Literal, Optional
+from pydantic import Field, field_validator
+from ddx.models.base import (
+    CamelModel,
+    HexStr,
+    validate_decimal_str,
+    PositionSide,
+)
+
+from ddx._rust.decimal import Decimal
+from ddx._rust.common.state import (
+    Strategy as SMTStrategy,
+    Balance,
+    Trader as SMTTrader,
+    Position as SMTPosition,
+)
+from ddx._rust.common import TokenSymbol
+
+
+# Strategy Fees History Models
+class Fee(CamelModel):
+    """Strategy fee data model."""
+
+    epoch_id: int = Field(..., ge=0)
+    tx_ordinal: int = Field(..., ge=0)
+    ordinal: int = Field(..., ge=0)
+    amount: str
+    fee_symbol: str
+    symbol: str
+    created_at: datetime
+
+    @field_validator("amount")
+    @classmethod
+    def validate_nonnegative_decimals(cls, v, info):
+        return validate_decimal_str(v, f"StrategyFee.{info.field_name}", nonnegative=True)
+
+
+class FeesHistoryResponse(CamelModel):
+    """Response model for strategy fees history endpoint."""
+
+    value: List[Fee]
+    next_epoch: Optional[int] = Field(None, ge=0)
+    next_tx_ordinal: Optional[int] = Field(None, ge=0)
+    next_ordinal: Optional[int] = Field(None, ge=0)
+    success: bool
+    timestamp: int
+
+
+# Strategy Positions Models
+class Position(CamelModel):
+    """Position data model."""
+
+    trader: HexStr
+    symbol: str
+    strategy_id_hash: HexStr
+    strategy_id: str
+    side: PositionSide
+    balance: str
+    avg_entry_price: str
+    last_modified_in_epoch: Optional[int] = Field(None, ge=0)
+
+    @field_validator("balance", "avg_entry_price")
+    @classmethod
+    def validate_nonnegative_decimals(cls, v, info):
+        return validate_decimal_str(v, f"Position.{info.field_name}", nonnegative=True)
+
+    def raw_position(self) -> SMTPosition:
+        return SMTPosition(
+            self.side.raw_position_side(),
+            Decimal(self.balance),
+            Decimal(self.avg_entry_price),
+        )
+
+
+class PositionsResponse(CamelModel):
+    """Response model for strategy positions endpoint."""
+
+    value: List[Position]
+    success: bool
+    timestamp: int
+
+
+# Strategy Models
+class Strategy(CamelModel):
+    """Srategy data model."""
+
+    trader: HexStr
+    strategy_id_hash: HexStr
+    strategy_id: str
+    max_leverage: int = Field(..., ge=1)
+    avail_collateral: str
+    locked_collateral: str
+    frozen: bool
+
+    @field_validator("avail_collateral", "locked_collateral")
+    @classmethod
+    def validate_nonnegative_decimals(cls, v, info):
+        return validate_decimal_str(v, f"Strategy.{info.field_name}", nonnegative=True)
+
+    def raw_strategy(self) -> SMTStrategy:
+        return SMTStrategy(
+            Balance(
+                Decimal(self.avail_collateral),
+                TokenSymbol.USDC,
+            ),
+            Balance(
+                Decimal(self.locked_collateral),
+                TokenSymbol.USDC,
+            ),
+            self.max_leverage,
+            self.frozen,
+        )
+
+
+class StrategyResponse(CamelModel):
+    """Response model for strategy endpoint."""
+
+    value: Optional[Strategy] = None
+    success: bool
+    timestamp: int
+
+
+# Strategies Models
+class StrategiesResponse(CamelModel):
+    """Response model for strategies endpoint."""
+
+    value: List[Strategy]
+    success: bool
+    timestamp: int
+
+
+# Strategy Metrics Models
+class StrategyMetrics(CamelModel):
+    """Strategy metrics data model."""
+
+    margin_fraction: str
+    mmr: str
+    leverage: str
+    strategy_margin: str
+    strategy_value: str
+
+    @field_validator("margin_fraction", "mmr", "leverage", "strategy_margin", "strategy_value")
+    @classmethod
+    def validate_nonnegative_decimals(cls, v, info):
+        return validate_decimal_str(v, f"StrategyMetrics.{info.field_name}", nonnegative=True)
+
+
+class StrategyMetricsResponse(CamelModel):
+    """Response model for strategy metrics endpoint."""
+
+    value: StrategyMetrics
+    success: bool
+    timestamp: int
+
+
+# Trader Models
+class Trader(CamelModel):
+    """Trader data model."""
+
+    trader: str
+    avail_ddx: str
+    locked_ddx: str
+    pay_fees_in_ddx: bool
+    referral_address: Optional[HexStr] = None
+
+    @field_validator("avail_ddx", "locked_ddx")
+    @classmethod
+    def validate_nonnegative_decimals(cls, v, info):
+        return validate_decimal_str(v, f"TraderProfile.{info.field_name}", nonnegative=True)
+
+    def raw_trader(self) -> SMTTrader:
+        return SMTTrader(
+            Decimal(self.avail_ddx),
+            Decimal(self.locked_ddx),
+            self.pay_fees_in_ddx,
+        )
+
+
+class TraderResponse(CamelModel):
+    """Response model for trader profile endpoint."""
+
+    value: Optional[Trader] = None
+    success: bool
+    timestamp: int

ddx/rest_client/utils/encryption_utils.py

@@ -0,0 +1,26 @@
+"""
+DerivaDEX signature utils
+"""
+from coincurve import PublicKey, PrivateKey
+from Crypto.Cipher import AES
+from Crypto.Random import get_random_bytes
+from Crypto.Hash import keccak
+
+
+def encrypt_with_nonce(encryption_key: str, msg: str) -> bytes:
+    network_public_key = PublicKey(bytes.fromhex(encryption_key[2:]))
+    my_secret_key = PrivateKey(get_random_bytes(32))
+    my_public_key = my_secret_key.public_key
+    shared_pub = network_public_key.multiply(my_secret_key.secret)
+    keccak_256 = keccak.new(digest_bits=256)
+    keccak_256.update(shared_pub.format())
+    derived_key = keccak_256.digest()[:16]
+    nonce = get_random_bytes(12)
+
+    cipher = AES.new(derived_key, AES.MODE_GCM, nonce=nonce)
+    encoded_message = msg.encode("utf8")
+    ciphertext, tag = cipher.encrypt_and_digest(
+        len(encoded_message).to_bytes(4, byteorder="big") + encoded_message
+    )
+
+    return ciphertext + tag + nonce + my_public_key.format()

ddx_python-1.0.4.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: ddx-python
+Version: 1.0.4
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: POSIX :: Linux
+Requires-Dist: maturin>=1.5.0,<1.6.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: websockets>=12.0,<13
+Requires-Dist: 0x-contract-wrappers>=2.0.0,<3
+Requires-Dist: aiohttp>=3.10.3,<4
+Requires-Dist: asyncpg>=0.30.0,<1
+Requires-Dist: attrs>=24.2.0,<25
+Requires-Dist: cattrs>=23.2.3,<24
+Requires-Dist: coloredlogs>=15.0.1,<16
+Requires-Dist: configargparse>=1.7,<2
+Requires-Dist: numpy>=2.2.6,<3
+Requires-Dist: pandas>=2.2.2,<3
+Requires-Dist: path>=17.0.0,<18
+Requires-Dist: pathlib>=1.0.1,<2
+Requires-Dist: plotly>=5.23.0,<6
+Requires-Dist: psutil>=6.0.0,<7
+Requires-Dist: requests>=2.32.3,<3
+Requires-Dist: simplejson>=3.19.2,<4
+Requires-Dist: sphinx>=8.0.2,<9
+Requires-Dist: verboselogs>=1.7,<2
+Requires-Dist: btrees>=6.0,<7
+Requires-Dist: ccxt>=4.3.79,<5
+Requires-Dist: coincurve>=20.0.0,<21
+Requires-Dist: dash-bootstrap-components>=1.6.0,<2
+Requires-Dist: python-dotenv>=1.0.1,<2
+Requires-Dist: sexpdata>=1.0.2,<2
+Requires-Dist: web3>=6.20.1,<7
+Requires-Dist: werkzeug>=3.0.3,<4
+Requires-Dist: gevent>=24.2.1,<25
+Requires-Dist: sortedcontainers>=2.4.0,<3
+Requires-Dist: aioresponses>=0.7.6,<0.8
+Requires-Dist: colorama>=0.4.6,<0.5
+Requires-Dist: loguru
+Requires-Dist: black>=24.4.2,<25 ; extra == 'dev'
+Requires-Dist: basedpyright ; extra == 'dev'
+Requires-Dist: pipdeptree ; extra == 'dev'
+Requires-Dist: jupyter-book>=0.6.5,<0.7 ; extra == 'notebook'
+Requires-Dist: jupyter-dash>=0.4.2,<0.5 ; extra == 'notebook'
+Requires-Dist: jupyterlab-lsp>=5.1.0,<6 ; extra == 'notebook'
+Requires-Dist: jupyter>=1.0.0,<2 ; extra == 'notebook'
+Requires-Dist: jupyterlab ; extra == 'notebook'
+Requires-Dist: matplotlib>=3.9.1,<4 ; extra == 'notebook'
+Requires-Dist: pytest>=8.3.5,<9 ; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.26.0,<0.27 ; extra == 'test'
+Requires-Dist: pytest-pretty>=1.2.0,<2 ; extra == 'test'
+Provides-Extra: dev
+Provides-Extra: notebook
+Provides-Extra: test
+Requires-Python: >=3.10