deltadefi 0.0.10__py3-none-any.whl → 0.1.0__py3-none-any.whl

deltadefi/__init__.py

@@ -1,2 +1,2 @@
 # flake8: noqa
-from .clients import ApiClient
+from .clients import ApiClient, WebSocketClient

deltadefi/api.py

@@ -6,7 +6,7 @@ from deltadefi.error import ClientError, ServerError
 from deltadefi.lib.utils import clean_none_value, encoded_string
 
 
-class API(object):
+class API:
     def __init__(self, base_url=None, api_key=None, timeout=None, **kwargs):
         self.base_url = base_url
         self.api_key = api_key
@@ -73,10 +73,10 @@ class API(object):
         if 400 <= status_code < 500:
             try:
                 err = json.loads(response.text)
-            except json.JSONDecodeError:
+            except json.JSONDecodeError as e:
                 raise ClientError(
                     status_code, None, response.text, response.headers, None
-                )
+                ) from e
             error_data = None
             if "data" in err:
                 error_data = err["data"]

deltadefi/api_resources/auth.py

@@ -1,16 +1,15 @@
 from dataclasses import dataclass
-from typing import Optional
 
 
 @dataclass
 class AuthHeaders:
     jwt: str
-    apiKey: str
+    api_key: str
 
 
 class ApiHeaders:
     __annotations__ = {
         "Content-Type": str,
-        "Authorization": Optional[str],
-        "X-API-KEY": Optional[str],
+        "Authorization": str | None,
+        "X-API-KEY": str | None,
     }

deltadefi/clients/__init__.py

@@ -1,2 +1,3 @@
 # flake8: noqa
 from .client import *
+from .websocket import WebSocketClient

deltadefi/clients/accounts.py

@@ -1,5 +1,4 @@
 #
-from typing import List
 
 from sidan_gin import Asset, UTxO
 
@@ -12,12 +11,17 @@ from deltadefi.responses import (
     CreateNewAPIKeyResponse,
     GetAccountBalanceResponse,
     GetDepositRecordsResponse,
-    GetOrderRecordResponse,
     GetWithdrawalRecordsResponse,
     SubmitDepositTransactionResponse,
     SubmitWithdrawalTransactionResponse,
 )
-from deltadefi.responses.accounts import GetOperationKeyResponse
+from deltadefi.responses.accounts import (
+    BuildTransferalTransactionResponse,
+    GetOperationKeyResponse,
+    GetOrderRecordResponse,
+    GetOrderRecordsResponse,
+    SubmitTransferalTransactionResponse,
+)
 
 
 class Accounts(API):
@@ -74,7 +78,7 @@ class Accounts(API):
 
     def get_order_records(
         self, status: OrderStatusType, **kwargs
-    ) -> GetOrderRecordResponse:
+    ) -> GetOrderRecordsResponse:
         """
         Get order records.
 
@@ -85,7 +89,7 @@ class Accounts(API):
             page: Optional; The page number for pagination. Defaults to 1.
 
         Returns:
-            A GetOrderRecordResponse object containing the order records.
+            A GetOrderRecordsResponse object containing the order records.
         """
         check_required_parameter(status, "status")
         payload = {"status": status, **kwargs}
@@ -93,6 +97,21 @@ class Accounts(API):
         url_path = "/order-records"
         return self.send_request("GET", self.group_url_path + url_path, payload)
 
+    def get_order_record(self, order_id: str, **kwargs) -> GetOrderRecordResponse:
+        """
+        Get a single order record by order ID.
+
+        Args:
+            order_id: The ID of the order to retrieve.
+
+        Returns:
+            A GetOrderRecordResponse object containing the order record.
+        """
+        check_required_parameter(order_id, "order_id")
+
+        url_path = f"/order/{order_id}"
+        return self.send_request("GET", self.group_url_path + url_path, kwargs)
+
     def get_account_balance(self, **kwargs) -> GetAccountBalanceResponse:
         """
         Get account balance.
@@ -104,7 +123,7 @@ class Accounts(API):
         return self.send_request("GET", self.group_url_path + url_path, kwargs)
 
     def build_deposit_transaction(
-        self, deposit_amount: List[Asset], input_utxos: List[UTxO], **kwargs
+        self, deposit_amount: list[Asset], input_utxos: list[UTxO], **kwargs
     ) -> BuildDepositTransactionResponse:
         """
         Build a deposit transaction.
@@ -129,7 +148,7 @@ class Accounts(API):
         return self.send_request("POST", self.group_url_path + url_path, payload)
 
     def build_withdrawal_transaction(
-        self, withdrawal_amount: List[Asset], **kwargs
+        self, withdrawal_amount: list[Asset], **kwargs
     ) -> BuildWithdrawalTransactionResponse:
         """
         Build a withdrawal transaction.
@@ -147,6 +166,31 @@ class Accounts(API):
         url_path = "/withdrawal/build"
         return self.send_request("POST", self.group_url_path + url_path, payload)
 
+    def build_transferal_transaction(
+        self, transferal_amount: list[Asset], to_address: str, **kwargs
+    ) -> BuildTransferalTransactionResponse:
+        """
+        Build a transferal transaction.
+
+        Args:
+            data: A BuildTransferalTransactionRequest object containing the transferal transaction details.
+
+        Returns:
+            A BuildTransferalTransactionResponse object containing the built transferal transaction.
+        """
+
+        check_required_parameter(
+            transferal_amount, "transferal_amount", to_address, "to_address"
+        )
+        payload = {
+            "transferal_amount": transferal_amount,
+            "to_address": to_address,
+            **kwargs,
+        }
+
+        url_path = "/transferal/build"
+        return self.send_request("POST", self.group_url_path + url_path, payload)
+
     def submit_deposit_transaction(
         self, signed_tx: str, **kwargs
     ) -> SubmitDepositTransactionResponse:
@@ -184,3 +228,22 @@ class Accounts(API):
 
         url_path = "/withdrawal/submit"
         return self.send_request("POST", self.group_url_path + url_path, payload)
+
+    def submit_transferal_transaction(
+        self, signed_tx: str, **kwargs
+    ) -> SubmitTransferalTransactionResponse:
+        """
+        Submit a transferal transaction.
+
+        Args:
+            data: A SubmitTransferalTransactionRequest object containing the transferal transaction details.
+
+        Returns:
+            A SubmitTransferalTransactionResponse object containing the submitted transferal transaction.
+        """
+
+        check_required_parameter(signed_tx, "signed_tx")
+        payload = {"signed_tx": signed_tx, **kwargs}
+
+        url_path = "/transferal/submit"
+        return self.send_request("POST", self.group_url_path + url_path, payload)

deltadefi/clients/client.py

@@ -1,10 +1,9 @@
-# flake8: noqa: E501
 from sidan_gin import Wallet, decrypt_with_cipher
 
 from deltadefi.clients.accounts import Accounts
-from deltadefi.clients.app import App
 from deltadefi.clients.markets import Market
 from deltadefi.clients.orders import Order
+from deltadefi.clients.websocket import WebSocketClient
 from deltadefi.models.models import OrderSide, OrderType
 from deltadefi.responses import PostOrderResponse
 
@@ -17,9 +16,9 @@ class ApiClient:
     def __init__(
         self,
         network: str = "preprod",
-        api_key: str = None,
-        base_url: str = None,
-        master_wallet: Wallet = None,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        master_wallet: Wallet | None = None,
     ):
         """
         Initialize the ApiClient.
@@ -43,10 +42,19 @@ class ApiClient:
         self.master_wallet = master_wallet
 
         self.accounts = Accounts(base_url=self.base_url, api_key=api_key)
-        self.app = App(base_url=self.base_url, api_key=api_key)
         self.orders = Order(base_url=self.base_url, api_key=api_key)
         self.markets = Market(base_url=self.base_url, api_key=api_key)
 
+        # Initialize WebSocket client with correct stream URL
+        if network == "mainnet":
+            ws_base_url = (
+                "wss://stream.deltadefi.io"  # TODO: Update when mainnet is available
+            )
+        else:
+            ws_base_url = "wss://stream-staging.deltadefi.io"
+
+        self.websocket = WebSocketClient(base_url=ws_base_url, api_key=api_key)
+
     def load_operation_key(self, password: str):
         """
         Load the operation key from the wallet using the provided password.

deltadefi/clients/markets.py

@@ -1,14 +1,8 @@
-# flake8: noqa: E501
-
 from typing import Literal
 
 from deltadefi.api import API
 from deltadefi.lib.utils import check_required_parameter, check_required_parameters
-from deltadefi.responses import (
-    GetAggregatedPriceResponse,
-    GetMarketDepthResponse,
-    GetMarketPriceResponse,
-)
+from deltadefi.responses import GetAggregatedPriceResponse, GetMarketPriceResponse
 
 
 class Market(API):
@@ -21,23 +15,6 @@ class Market(API):
     def __init__(self, api_key=None, base_url=None, **kwargs):
         super().__init__(api_key=api_key, base_url=base_url, **kwargs)
 
-    def get_depth(self, symbol: str, **kwargs) -> GetMarketDepthResponse:
-        """
-        Get market depth.
-
-        Args:
-            data: A GetMarketDepthRequest object containing the market pair.
-
-        Returns:
-            A GetMarketDepthResponse object containing the market depth.
-        """
-
-        check_required_parameter(symbol, "symbol")
-        payload = {"symbol": symbol, **kwargs}
-        url_path = "/depth"
-
-        return self.send_request("GET", self.group_url_path + url_path, payload)
-
     def get_market_price(self, symbol: str, **kwargs) -> GetMarketPriceResponse:
         """
         Get market price.
@@ -78,7 +55,7 @@ class Market(API):
                 [end, "end"],
             ]
         )
-        url_path = f"/aggregated-trade/{symbol}"
+        url_path = f"/graph/{symbol}"
         return self.send_request(
             "GET",
             self.group_url_path + url_path,

deltadefi/clients/websocket.py

@@ -0,0 +1,355 @@
+import asyncio
+from collections.abc import Callable
+import json
+import logging
+from typing import Any
+
+import websockets
+
+from deltadefi.error import ClientError
+
+
+class WebSocketClient:
+    """
+    WebSocket client for DeltaDeFi real-time data streams.
+
+    Supports:
+    - Recent trades
+    - Account streams
+    - Market price streams
+    - Market depth streams
+    """
+
+    def __init__(
+        self,
+        base_url: str = "wss://stream-staging.deltadefi.io",
+        api_key: str | None = None,
+        auto_reconnect: bool = True,
+        reconnect_interval: int = 5,
+        ping_interval: int = 20,
+        ping_timeout: int = 10,
+    ):
+        """
+        Initialize the WebSocket client.
+
+        Args:
+            base_url: WebSocket base URL
+            api_key: API key for authentication
+            auto_reconnect: Whether to automatically reconnect on disconnect
+            reconnect_interval: Seconds to wait before reconnection attempt
+            ping_interval: Seconds between ping frames
+            ping_timeout: Timeout for pong response
+        """
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.auto_reconnect = auto_reconnect
+        self.reconnect_interval = reconnect_interval
+        self.ping_interval = ping_interval
+        self.ping_timeout = ping_timeout
+
+        self.websocket: websockets.WebSocketServerProtocol | None = None
+        self.subscriptions: dict[str, dict[str, Any]] = {}
+        self.message_handlers: dict[str, Callable] = {}
+        self.is_connected = False
+        self.should_stop = False
+
+        self.logger = logging.getLogger(__name__)
+
+    async def connect(self, endpoint_path: str = "") -> None:
+        """
+        Establish WebSocket connection.
+
+        Args:
+            endpoint_path: Specific endpoint path for the connection
+        """
+        try:
+            # Build the full WebSocket URL
+            if endpoint_path:
+                url = f"{self.base_url}{endpoint_path}"
+            else:
+                url = f"{self.base_url}/ws"
+
+            # Add API key as query parameter if provided
+            if self.api_key:
+                separator = "&" if "?" in url else "?"
+                url = f"{url}{separator}api_key={self.api_key}"
+
+            self.websocket = await websockets.connect(
+                url,
+                ping_interval=self.ping_interval,
+                ping_timeout=self.ping_timeout,
+            )
+            self.is_connected = True
+            self.logger.info(f"WebSocket connected successfully to {url}")
+
+            # Start message listening loop
+            self._listen_task = asyncio.create_task(self._listen_messages())
+
+        except Exception as e:
+            self.logger.error(f"Failed to connect to WebSocket: {e}")
+            raise ClientError(0, "WS_CONNECTION_ERROR", str(e), {}, None) from e
+
+    async def disconnect(self) -> None:
+        """Close WebSocket connection."""
+        self.should_stop = True
+        if self.websocket:
+            await self.websocket.close()
+            self.is_connected = False
+            self.logger.info("WebSocket disconnected")
+
+    async def _listen_messages(self) -> None:
+        """Listen for incoming WebSocket messages."""
+        if not self.websocket:
+            return
+
+        try:
+            async for message in self.websocket:
+                if self.should_stop:
+                    break
+
+                await self._handle_message(message)
+
+        except websockets.exceptions.ConnectionClosed:
+            self.is_connected = False
+            self.logger.warning("WebSocket connection closed")
+
+            if self.auto_reconnect and not self.should_stop:
+                await self._reconnect()
+
+        except Exception as e:
+            self.logger.error(f"Error in message listener: {e}")
+
+    async def _handle_message(self, message: str) -> None:
+        """Handle incoming WebSocket message."""
+        try:
+            data = json.loads(message)
+
+            # Determine message type based on structure
+            if isinstance(data, list) and len(data) > 0 and "timestamp" in data[0]:
+                # This is a trade stream message (array format)
+                if "trade" in self.message_handlers:
+                    await self.message_handlers["trade"](data)
+                else:
+                    self.logger.debug("No handler for trade stream")
+
+            elif isinstance(data, dict) and "type" in data:
+                # Handle typed messages (account, price, etc.)
+                msg_type = data.get("type", "unknown").lower()
+                sub_type = data.get("sub_type", "").lower()
+
+                if msg_type == "account":
+                    # Account stream message
+                    if "account" in self.message_handlers:
+                        await self.message_handlers["account"](data)
+                    else:
+                        self.logger.debug("No handler for account stream")
+
+                elif msg_type == "market" and sub_type == "market_price":
+                    # Price stream message
+                    if "price" in self.message_handlers:
+                        await self.message_handlers["price"](data)
+                    else:
+                        self.logger.debug("No handler for price stream")
+
+                else:
+                    self.logger.debug(
+                        f"Unknown message type: {msg_type}, sub_type: {sub_type}"
+                    )
+
+            elif (
+                isinstance(data, dict)
+                and "timestamp" in data
+                and ("bids" in data or "asks" in data)
+            ):
+                # This is a depth stream message
+                if "depth" in self.message_handlers:
+                    await self.message_handlers["depth"](data)
+                else:
+                    self.logger.debug("No handler for depth stream")
+
+            else:
+                self.logger.debug(f"Unknown message format: {data}")
+
+        except json.JSONDecodeError:
+            self.logger.error(f"Failed to parse message: {message}")
+        except Exception as e:
+            self.logger.error(f"Error handling message: {e}")
+
+    async def _reconnect(self) -> None:
+        """Attempt to reconnect WebSocket."""
+        self.logger.info(
+            f"Attempting to reconnect in {self.reconnect_interval} seconds"
+        )
+        await asyncio.sleep(self.reconnect_interval)
+
+        try:
+            # For now, just reconnect to the first subscription if any exist
+            # In a more complex implementation, you'd want to handle multiple concurrent subscriptions
+            if self.subscriptions:
+                first_sub = next(iter(self.subscriptions.values()))
+                if first_sub.get("type") == "trade":
+                    await self.connect(first_sub["endpoint"])
+                else:
+                    await self.connect()
+            else:
+                await self.connect()
+
+        except Exception as e:
+            self.logger.error(f"Reconnection failed: {e}")
+            if self.auto_reconnect and not self.should_stop:
+                await self._reconnect()
+
+    async def _send_message(self, message: dict[str, Any]) -> None:
+        """Send message to WebSocket server."""
+        if not self.websocket or not self.is_connected:
+            raise ClientError(
+                0, "WS_NOT_CONNECTED", "WebSocket not connected", {}, None
+            )
+
+        try:
+            await self.websocket.send(json.dumps(message))
+        except Exception as e:
+            self.logger.error(f"Failed to send message: {e}")
+            raise ClientError(0, "WS_SEND_ERROR", str(e), {}, None) from e
+
+    def register_handler(self, stream_type: str, handler: Callable) -> None:
+        """
+        Register a message handler for a specific stream type.
+
+        Args:
+            stream_type: Type of stream (e.g., 'trade', 'depth', 'price', 'account')
+            handler: Async function to handle messages
+        """
+        self.message_handlers[stream_type] = handler
+
+    async def subscribe_trades(self, symbol: str) -> None:
+        """
+        Subscribe to recent trades for a symbol using DeltaDeFi's specific endpoint.
+
+        Args:
+            symbol: Trading pair symbol (e.g., "ADAUSDM")
+        """
+        if not self.api_key:
+            raise ClientError(
+                0, "API_KEY_REQUIRED", "API key required for trade streams", {}, None
+            )
+
+        # Close existing connection if any
+        if self.websocket:
+            await self.disconnect()
+
+        # Connect to the specific trades endpoint
+        endpoint_path = f"/market/recent-trades/{symbol}?limit=50"
+        await self.connect(endpoint_path)
+
+        # Store subscription info
+        self.subscriptions[f"trade_{symbol}"] = {
+            "type": "trade",
+            "symbol": symbol,
+            "endpoint": endpoint_path,
+        }
+        self.logger.info(f"Subscribed to trades for {symbol}")
+
+    async def subscribe_depth(self, symbol: str) -> None:
+        """
+        Subscribe to market depth for a symbol using DeltaDeFi's specific endpoint.
+
+        Args:
+            symbol: Trading pair symbol (e.g., "ADAUSDM")
+        """
+        if not self.api_key:
+            raise ClientError(
+                0, "API_KEY_REQUIRED", "API key required for depth streams", {}, None
+            )
+
+        # Close existing connection if any
+        if self.websocket:
+            await self.disconnect()
+
+        # Connect to the specific depth endpoint
+        endpoint_path = f"/market/depth/{symbol}"
+        await self.connect(endpoint_path)
+
+        # Store subscription info
+        self.subscriptions[f"depth_{symbol}"] = {
+            "type": "depth",
+            "symbol": symbol,
+            "endpoint": endpoint_path,
+        }
+        self.logger.info(f"Subscribed to depth for {symbol}")
+
+    async def subscribe_price(self, symbol: str) -> None:
+        """
+        Subscribe to price streams for a symbol using DeltaDeFi's specific endpoint.
+
+        Args:
+            symbol: Trading pair symbol (e.g., "ADAUSDM")
+        """
+        if not self.api_key:
+            raise ClientError(
+                0, "API_KEY_REQUIRED", "API key required for price streams", {}, None
+            )
+
+        # Close existing connection if any
+        if self.websocket:
+            await self.disconnect()
+
+        # Connect to the specific price endpoint
+        endpoint_path = f"/market/market-price/{symbol}"
+        await self.connect(endpoint_path)
+
+        # Store subscription info
+        self.subscriptions[f"price_{symbol}"] = {
+            "type": "price",
+            "symbol": symbol,
+            "endpoint": endpoint_path,
+        }
+        self.logger.info(f"Subscribed to price for {symbol}")
+
+    async def subscribe_account(self) -> None:
+        """
+        Subscribe to account streams using DeltaDeFi's specific endpoint.
+        Provides balance updates and order status updates.
+        """
+        if not self.api_key:
+            raise ClientError(
+                0, "API_KEY_REQUIRED", "API key required for account streams", {}, None
+            )
+
+        # Close existing connection if any
+        if self.websocket:
+            await self.disconnect()
+
+        # Connect to the account stream endpoint
+        endpoint_path = "/accounts/stream"
+        await self.connect(endpoint_path)
+
+        # Store subscription info
+        self.subscriptions["account"] = {"type": "account", "endpoint": endpoint_path}
+        self.logger.info("Subscribed to account streams")
+
+    async def unsubscribe(self, subscription_key: str) -> None:
+        """
+        Unsubscribe from a stream.
+
+        Args:
+            subscription_key: Key of the subscription to cancel
+        """
+        if subscription_key not in self.subscriptions:
+            return
+
+        sub_data = self.subscriptions[subscription_key]
+        message = {
+            "method": "UNSUBSCRIBE",
+            "params": sub_data["params"],
+            "id": sub_data["id"],
+        }
+
+        await self._send_message(message)
+        del self.subscriptions[subscription_key]
+        self.logger.info(f"Unsubscribed from {subscription_key}")
+
+    async def unsubscribe_all(self) -> None:
+        """Unsubscribe from all streams."""
+        for sub_key in list(self.subscriptions.keys()):
+            await self.unsubscribe(sub_key)

deltadefi/error.py

@@ -27,7 +27,7 @@ class ParameterRequiredError(Error):
         self.params = params
 
     def __str__(self):
-        return "%s is mandatory, but received empty." % (", ".join(self.params))
+        return "{} is mandatory, but received empty.".format(", ".join(self.params))
 
 
 class ParameterValueError(Error):
@@ -35,7 +35,7 @@ class ParameterValueError(Error):
         self.params = params
 
     def __str__(self):
-        return "the enum value %s is invalid." % (", ".join(self.params))
+        return "the enum value {} is invalid.".format(", ".join(self.params))
 
 
 class ParameterTypeError(Error):

deltadefi/models/models.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import List, Literal
+from typing import Literal
 
 OrderStatusType = Literal["openOrder", "orderHistory", "tradingHistory"]
 
@@ -59,7 +59,7 @@ class OrderJSON:
 class DepositRecord:
     created_at: str
     status: TransactionStatus
-    assets: List[AssetRecord]
+    assets: list[AssetRecord]
     tx_hash: str
 
 
@@ -67,7 +67,7 @@ class DepositRecord:
 class WithdrawalRecord:
     created_at: str
     status: TransactionStatus
-    assets: List[AssetRecord]
+    assets: list[AssetRecord]
 
 
 @dataclass

deltadefi/responses/accounts.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import List, TypedDict
+from typing import TypedDict
 
 from deltadefi.models.models import (
     AssetBalance,
@@ -32,19 +32,31 @@ class SubmitDepositTransactionResponse(TypedDict):
 
 
 @dataclass
-class GetDepositRecordsResponse(List[DepositRecord]):
+class GetDepositRecordsResponse(list[DepositRecord]):
     pass
 
 
 @dataclass
-class GetWithdrawalRecordsResponse(List[WithdrawalRecord]):
+class GetWithdrawalRecordsResponse(list[WithdrawalRecord]):
     pass
 
 
+@dataclass
+class OrderRecordsData(TypedDict):
+    orders: list[OrderJSON]
+    order_filling_records: list[OrderFillingRecordJSON]
+
+
+@dataclass
+class GetOrderRecordsResponse(TypedDict):
+    data: list[OrderRecordsData]
+    total_count: int
+    total_page: int
+
+
 @dataclass
 class GetOrderRecordResponse(TypedDict):
-    orders: List[OrderJSON]
-    order_filling_records: List[OrderFillingRecordJSON]
+    order_json: OrderJSON
 
 
 @dataclass
@@ -52,11 +64,21 @@ class BuildWithdrawalTransactionResponse(TypedDict):
     tx_hex: str
 
 
+@dataclass
+class BuildTransferalTransactionResponse(TypedDict):
+    tx_hex: str
+
+
 @dataclass
 class SubmitWithdrawalTransactionResponse(TypedDict):
     tx_hash: str
 
 
+@dataclass
+class SubmitTransferalTransactionResponse(TypedDict):
+    tx_hash: str
+
+
 @dataclass
 class GetAccountInfoResponse(TypedDict):
     api_key: str
@@ -66,5 +88,5 @@ class GetAccountInfoResponse(TypedDict):
 
 
 @dataclass
-class GetAccountBalanceResponse(List[AssetBalance]):
+class GetAccountBalanceResponse(list[AssetBalance]):
     pass

deltadefi/responses/responses.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import List, TypedDict
+from typing import TypedDict
 
 from deltadefi.models import OrderJSON
 
@@ -17,8 +17,8 @@ class MarketDepth(TypedDict):
 
 @dataclass
 class GetMarketDepthResponse(TypedDict):
-    bids: List[MarketDepth]
-    asks: List[MarketDepth]
+    bids: list[MarketDepth]
+    asks: list[MarketDepth]
 
 
 @dataclass
@@ -38,7 +38,7 @@ class Trade(TypedDict):
 
 
 @dataclass
-class GetAggregatedPriceResponse(List[Trade]):
+class GetAggregatedPriceResponse(list[Trade]):
     pass
 
 

{deltadefi-0.0.10.dist-info → deltadefi-0.1.0.dist-info}/METADATA

@@ -1,29 +1,30 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: deltadefi
-Version: 0.0.10
+Version: 0.1.0
 Summary: Python SDK for DeltaDeFi protocol.
-License: Apache-2.0
-Keywords: cardano
-Author: HinsonSIDAN
-Author-email: wongkahinhinson@gmail.com
-Requires-Python: >3.11,<4.0.0
+Author-email: HinsonSIDAN <wongkahinhinson@gmail.com>
+License-Expression: Apache-2.0
+Keywords: cardano,defi,sdk,trading
+Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: certifi (==2024.8.30)
-Requires-Dist: charset-normalizer (==3.4.0)
-Requires-Dist: dotenv (>=0.9.9,<0.10.0)
-Requires-Dist: idna (==3.10)
-Requires-Dist: pycardano (>=0.12.3,<0.13.0)
-Requires-Dist: requests (>=2.25,<3.0)
-Requires-Dist: sidan-gin (==0.1.6)
-Requires-Dist: urllib3 (==2.2.3)
-Project-URL: Documentation, https://github.com/deltadefi-protocol/python-sdk
-Project-URL: Homepage, https://github.com/deltadefi-protocol/python-sdk
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4.0.0,>3.11
+Requires-Dist: certifi>=2024.8.30
+Requires-Dist: charset-normalizer>=3.4.0
+Requires-Dist: idna>=3.10
+Requires-Dist: pycardano>=0.12.3
+Requires-Dist: python-dotenv>=0.9.9
+Requires-Dist: requests>=2.25.0
+Requires-Dist: sidan-gin>=0.1.6
+Requires-Dist: urllib3>=2.2.3
+Requires-Dist: websockets>=12.0
 Description-Content-Type: text/markdown
 
 # DeltaDeFi Python SDK
@@ -56,11 +57,8 @@ from sidan_gin import HDWallet
 network="preprod",
 api_key="your_api_key",
 
-# Initialize HDWallet
-wallet = HDWallet("your_wallet_mnemonic")
-
 # Initialize ApiClient
-api = ApiClient(network=network, api_key=api_key, wallet=wallet)
+api = ApiClient(network=network, api_key=api_key)
 ```
 
 ### Accounts
@@ -73,33 +71,40 @@ account_balance = api.accounts.get_account_balance()
 print(account_balance)
 ```
 
-### Market
+### Markets
 
 The Market client allows you to interact with market-related endpoints.
 
 ```python
 # Get market depth
-market_depth = api.market.get_depth("ADAUSDM")
+market_depth = api.markets.get_depth("ADAUSDM")
 print(market_depth_response)
 
 # Get market price
-market_price_response = api.market.get_market_price("ADAUSDM")
+market_price_response = api.markets.get_market_price("ADAUSDM")
 print(market_price_response)
 ```
 
-### Order
+### Orders
 
 The Order client allows you to interact with order-related endpoints.
 
 ```python
-# Build place order transaction
-place_order_request = BuildPlaceOrderTransactionRequest(pair="BTC/USD", amount=1, price=50000)
-place_order_response = api.order.build_place_order_transaction(symbol="ADAUSDM", amount=50, price=0.75, type="limit")
-print(place_order_response)
-
-# Submit place order transaction
-submit_order_response = api.order.submit_place_order_transaction(signed_tx="<signed_tx>", order_id="<order_id>")
-print(submit_order_response)
+api_key = os.environ.get("DELTADEFI_API_KEY")
+password = os.environ.get("TRADING_PASSWORD")
+
+api = ApiClient(api_key=api_key)
+api.load_operation_key(password)
+
+res = api.post_order(
+    symbol="ADAUSDM",
+    side="sell",
+    type="limit",
+    quantity=51,
+    price=15,
+)
+
+print("Order submitted successfully.", res)
 ```
 
 ## Development
@@ -115,4 +120,3 @@ DELTADEFI_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx make test
 ## License
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at <http://www.apache.org/licenses/LICENSE-2.0>
-

deltadefi-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+deltadefi/__init__.py,sha256=pKZHfRdXT3f3kncxAKamtk5V3EDQB8Ocy8xBmjhsJ4A,63
+deltadefi/api.py,sha256=g5N7O_xzrl5hsQuw-ZhJ9lQi5rKzgr3_-C9FViRlOuw,2724
+deltadefi/error.py,sha256=zDMx5ukb5zs0AOeGAHjXiIMDZ0LbEcaGyVi45WFJfmI,1658
+deltadefi/api_resources/__init__.py,sha256=_SGHTpaQTIBvh9Rm868IT5pXpvvGBPqz3bxkY6YapZ4,61
+deltadefi/api_resources/auth.py,sha256=4QCEI4P4UlQPQYctqY9Oat4hn7lsI95QihHTD_0PZKg,245
+deltadefi/api_resources/validation.py,sha256=vz-hovpLy9SMOIFGcBHC8vWZH8CJRlQP8rcbbTSM-PM,1375
+deltadefi/clients/__init__.py,sha256=4hyPuk6_bcJGXUElOvkgZ7ARlQ6QwKLp-nFgCXTbFVI,76
+deltadefi/clients/accounts.py,sha256=3bOHKYIBJYsOgb97rw57u9aJV9VyHb1U8l_rGXBOwp4,8411
+deltadefi/clients/client.py,sha256=2hLOsxqBc8eu_6ovuYLRoK2popdI1_t3pGcEP8Keu9A,4619
+deltadefi/clients/markets.py,sha256=JQUj3duj1dLEA36NW4Rk44_ALAMLrlK37ylxnu5kTCc,1989
+deltadefi/clients/orders.py,sha256=gnh8AcXWI1QQK9riJtsu_1BqzuOml5OGf4bFP6yfy9g,3890
+deltadefi/clients/websocket.py,sha256=0454RunoE9eHqmQ0wrywEwxqrie1qEXq2ObxyKXopck,12424
+deltadefi/constants/__init__.py,sha256=7LkrzfLTJsCCUl5IgZYrl-AbY_cf1fftcLklgnBYDTs,40
+deltadefi/constants/constants.py,sha256=4bkY4kfNcsgoCe1xU8n2We7w-vxZXyzVw5rQvAsx4j8,168
+deltadefi/models/__init__.py,sha256=oDJj6Y4gXN6C7Oz_t2fq8hej-D0G9OqfXjL4Jaeq8z8,37
+deltadefi/models/models.py,sha256=kiRpCdzUh3WmyuFOaxlZ1rjsQ2cxLWjVFBCqsHXMtBc,1633
+deltadefi/responses/__init__.py,sha256=JKSIUQu6qI_XhbAR2mVMCKNvR6x_vFZdyLGOuQTVrVY,64
+deltadefi/responses/accounts.py,sha256=o-It4vyNsiDeCmHa-XQl77KuCVtJi7qlPdn059fgwcI,1590
+deltadefi/responses/responses.py,sha256=Kz5PtDnx_AgKrV7NhZqrSMnS1wPlLbu13J2BKNzN0ME,1012
+deltadefi-0.1.0.dist-info/METADATA,sha256=lkvqD6KUiekc--8-QROKHZ7G7HKCah8cwJfanmMJjo4,3075
+deltadefi-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+deltadefi-0.1.0.dist-info/RECORD,,

{deltadefi-0.0.10.dist-info → deltadefi-0.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

deltadefi/clients/app.py

@@ -1,23 +0,0 @@
-from deltadefi.api import API
-from deltadefi.responses import GetTermsAndConditionResponse
-
-
-class App(API):
-    """
-    App client for interacting with the DeltaDeFi API.
-    """
-
-    group_url_path = "/app"
-
-    def __init__(self, api_key=None, base_url=None, **kwargs):
-        super().__init__(api_key=api_key, base_url=base_url, **kwargs)
-
-    def get_terms_and_condition(self, **kwargs) -> GetTermsAndConditionResponse:
-        """
-        Get terms and conditions.
-
-        Returns:
-            A GetTermsAndConditionResponse object containing the terms and conditions.
-        """
-        url_path = "/terms-and-conditions"
-        return self.send_request("GET", self.group_url_path + url_path, kwargs)

deltadefi/lib/utils.py

@@ -1,46 +0,0 @@
-from urllib.parse import urlencode
-
-from deltadefi.error import (
-    ParameterRequiredError,
-    ParameterTypeError,
-    ParameterValueError,
-)
-
-
-def clean_none_value(d) -> dict:
-    out = {}
-    for k in d.keys():
-        if d[k] is not None:
-            out[k] = d[k]
-    return out
-
-
-def check_required_parameter(value, name):
-    if not value and value != 0:
-        raise ParameterRequiredError([name])
-
-
-def check_required_parameters(params):
-    """Validate multiple parameters
-    params = [
-        ['btcusdt', 'symbol'],
-        [10, 'price']
-    ]
-
-    """
-    for p in params:
-        check_required_parameter(p[0], p[1])
-
-
-def check_enum_parameter(value, enum_class):
-    if value not in set(item.value for item in enum_class):
-        raise ParameterValueError([value])
-
-
-def check_type_parameter(value, name, data_type):
-    if value is not None and not isinstance(value, data_type):
-        raise ParameterTypeError([name, data_type])
-
-
-def encoded_string(query):
-    return urlencode(query, True).replace("%40", "@")

deltadefi-0.0.10.dist-info/RECORD

@@ -1,24 +0,0 @@
-deltadefi/__init__.py,sha256=_dbB-toNXZvwZxj5DnEY0nW5noDnDpF4QsJNEwGO_IA,46
-deltadefi/api.py,sha256=XSdOFwq9s2HFxKxiv7ljaCgUhwXVAkkq19dPSRhwlek,2720
-deltadefi/api_resources/__init__.py,sha256=_SGHTpaQTIBvh9Rm868IT5pXpvvGBPqz3bxkY6YapZ4,61
-deltadefi/api_resources/auth.py,sha256=Mpl4Dbh_d_gGhwLo2CtBSKxZ21DC74x-qjVhlczZCDE,278
-deltadefi/api_resources/validation.py,sha256=vz-hovpLy9SMOIFGcBHC8vWZH8CJRlQP8rcbbTSM-PM,1375
-deltadefi/clients/__init__.py,sha256=GEEsW2Sl-fPq0ilDsNyztoCDO7JSed14uMN2gOurIOI,37
-deltadefi/clients/accounts.py,sha256=ZuzPjobGk-bk4SPC8mqDAxChCfv5vj7y96k38G84uj0,6302
-deltadefi/clients/app.py,sha256=TOgRlP83p91r7oS4ez8Gfm8soQzFHrJAmOHZJoGZ4SM,712
-deltadefi/clients/client.py,sha256=khtgJYE4m6VFPLylVUe5a52SWu6kzdtHdse7XXy0LoE,4284
-deltadefi/clients/markets.py,sha256=v8hK06oXC73qS3IjvWDempHq_-9T6OW2pckIcDR7P2M,2580
-deltadefi/clients/orders.py,sha256=gnh8AcXWI1QQK9riJtsu_1BqzuOml5OGf4bFP6yfy9g,3890
-deltadefi/constants/__init__.py,sha256=7LkrzfLTJsCCUl5IgZYrl-AbY_cf1fftcLklgnBYDTs,40
-deltadefi/constants/constants.py,sha256=4bkY4kfNcsgoCe1xU8n2We7w-vxZXyzVw5rQvAsx4j8,168
-deltadefi/error.py,sha256=Pq55p7FQbVn1GTih7NQBI7ZcVUUrlkaFKn-SwZUxBA8,1650
-deltadefi/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltadefi/lib/utils.py,sha256=zuQFAKQphbGxDdPzBURw4A2n3AkRSbzmjMLHPLm9Ed4,1035
-deltadefi/models/__init__.py,sha256=oDJj6Y4gXN6C7Oz_t2fq8hej-D0G9OqfXjL4Jaeq8z8,37
-deltadefi/models/models.py,sha256=Fgk3W6Ps1tibnE3cJTaBt5OPfVKl70nIDxDFsu1m5bk,1639
-deltadefi/responses/__init__.py,sha256=JKSIUQu6qI_XhbAR2mVMCKNvR6x_vFZdyLGOuQTVrVY,64
-deltadefi/responses/accounts.py,sha256=tDjJPb_Xk0_-aEX8pNHINrhurCljEZQfI-TikCIO_D4,1227
-deltadefi/responses/responses.py,sha256=JZrnBWZZGM_yyulrcgYNdJyw-8bOhlsmMTK3xZbuBKM,1018
-deltadefi-0.0.10.dist-info/METADATA,sha256=s434ECRVm3WNTikx0lNU5LfkNiU8OVfev3HO7YjbRwo,3235
-deltadefi-0.0.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-deltadefi-0.0.10.dist-info/RECORD,,