deltadefi 0.0.1__tar.gz → 0.0.2__tar.gz

{deltadefi-0.0.1 → deltadefi-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: deltadefi
-Version: 0.0.1
+Version: 0.0.2
 Summary: Python SDK for DeltaDeFi protocol.
 License: Apache-2.0
 Keywords: cardano
@@ -34,7 +34,7 @@ The DeltaDeFi Python SDK provides a convenient way to interact with the DeltaDeF
 To install the SDK, use `pip`:
 
 ```sh
-pip install deltadefi-python-sdk
+pip install deltadefi
 ```
 
 ## Requirements
@@ -48,19 +48,18 @@ pip install deltadefi-python-sdk
 To use the SDK, you need to initialize the ApiClient with your API configuration and wallet.
 
 ```python
-from deltadefi.api_resources.api_config import ApiConfig
-from deltadefi.clients.clients import ApiClient
+from deltadefi.clients import ApiClient
 from sidan_gin import HDWallet
 
 # Initialize API configuration
-network="mainnet",
+network="preprod",
 api_key="your_api_key",
 
 # Initialize HDWallet
 wallet = HDWallet("your_wallet_mnemonic")
 
 # Initialize ApiClient
-api_client = ApiClient(network=network, api_key=api_key, wallet=wallet)
+api = ApiClient(network=network, api_key=api_key, wallet=wallet)
 ```
 
 ### Accounts
@@ -68,17 +67,8 @@ api_client = ApiClient(network=network, api_key=api_key, wallet=wallet)
 The Accounts client allows you to interact with account-related endpoints.
 
 ```python
-from deltadefi.clients.accounts import Accounts
-
-accounts_client = api_client.accounts
-
-# Sign in
-sign_in_request = SignInRequest(auth_key="your_auth_key", wallet_address="your_wallet_address")
-sign_in_response = accounts_client.sign_in(sign_in_request)
-print(sign_in_response)
-
 # Get account balance
-account_balance = accounts_client.get_account_balance()
+account_balance = api.accounts.get_account_balance()
 print(account_balance)
 ```
 
@@ -87,46 +77,31 @@ print(account_balance)
 The Markets client allows you to interact with market-related endpoints.
 
 ```python
-from deltadefi.clients.markets import Markets
-
-markets_client = api_client.markets
-
 # Get market depth
-market_depth_request = GetMarketDepthRequest(pair="BTC/USD")
-market_depth_response = markets_client.getDepth(market_depth_request)
+market_depth = api.markets.get_depth("ADAUSDX")
 print(market_depth_response)
 
 # Get market price
-market_price_request = GetMarketPriceRequest(pair="BTC/USD")
-market_price_response = markets_client.getMarketPrice(market_price_request)
+market_price_response = api.markets.get_market_price("ADAUSDX")
 print(market_price_response)
 ```
 
-### Orders
+### Order
 
-The Orders client allows you to interact with order-related endpoints.
+The Order client allows you to interact with order-related endpoints.
 
 ```python
-from deltadefi.clients.orders import Orders
-
-orders_client = api_client.orders
-
 # Build place order transaction
 place_order_request = BuildPlaceOrderTransactionRequest(pair="BTC/USD", amount=1, price=50000)
-place_order_response = orders_client.build_place_order_transaction(place_order_request)
+place_order_response = api.order.build_place_order_transaction(symbol="ADAUSDX", amount=50, price=0.75, type="limit")
 print(place_order_response)
 
 # Submit place order transaction
-submit_order_request = SubmitPlaceOrderTransactionRequest(order_id="order_id")
-submit_order_response = orders_client.submit_place_order_transaction(submit_order_request)
+submit_order_response = api.order.submit_place_order_transaction(signed_tx="<signed_tx>", order_id="<order_id>")
 print(submit_order_response)
 ```
 
 ## 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
-```
+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.0.2/README.md

@@ -0,0 +1,79 @@
+# DeltaDeFi Python SDK
+
+The DeltaDeFi Python SDK provides a convenient way to interact with the DeltaDeFi API. This SDK allows developers to easily integrate DeltaDeFi's features into their Python applications.
+
+## Installation
+
+To install the SDK, use `pip`:
+
+```sh
+pip install deltadefi
+```
+
+## Requirements
+
+- Python 3.11 or higher
+
+## Usage
+
+### Initialization
+
+To use the SDK, you need to initialize the ApiClient with your API configuration and wallet.
+
+```python
+from deltadefi.clients import ApiClient
+from sidan_gin import HDWallet
+
+# Initialize API configuration
+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)
+```
+
+### Accounts
+
+The Accounts client allows you to interact with account-related endpoints.
+
+```python
+# Get account balance
+account_balance = api.accounts.get_account_balance()
+print(account_balance)
+```
+
+### Markets
+
+The Markets client allows you to interact with market-related endpoints.
+
+```python
+# Get market depth
+market_depth = api.markets.get_depth("ADAUSDX")
+print(market_depth_response)
+
+# Get market price
+market_price_response = api.markets.get_market_price("ADAUSDX")
+print(market_price_response)
+```
+
+### Order
+
+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="ADAUSDX", 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)
+```
+
+## 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.0.1 → deltadefi-0.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "deltadefi"
-version = "0.0.1"
+version = "0.0.2"
 classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: Apache Software License",

deltadefi-0.0.2/src/deltadefi/api.py

@@ -0,0 +1,77 @@
+import json
+
+import requests
+
+from deltadefi.error import ClientError, ServerError
+from deltadefi.lib.utils import clean_none_value, encoded_string
+
+
+class API(object):
+    def __init__(self, base_url=None, api_key=None, timeout=None, **kwargs):
+        self.base_url = base_url
+        self.api_key = api_key
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Content-Type": "application/json;charset=utf-8",
+                "X-API-KEY": api_key if api_key is not None else "",
+            }
+        )
+
+    def send_request(self, http_method, url_path, payload=None):
+        if payload is None:
+            payload = {}
+        url = self.base_url + url_path
+        params = clean_none_value(
+            {
+                "url": url,
+                "params": self._prepare_params(payload),
+                "timeout": self.timeout,
+            }
+        )
+        response = self._dispatch_request(http_method)(**params)
+        self._handle_exception(response)
+
+        try:
+            data = response.json()
+        except ValueError:
+            data = response.text
+        result = {}
+
+        if len(result) != 0:
+            result["data"] = data
+            return result
+
+        return data
+
+    def _dispatch_request(self, http_method):
+        return {
+            "GET": self.session.get,
+            "DELETE": self.session.delete,
+            "PUT": self.session.put,
+            "POST": self.session.post,
+        }.get(http_method, "GET")
+
+    def _prepare_params(self, params):
+        return encoded_string(clean_none_value(params))
+
+    def _handle_exception(self, response):
+        status_code = response.status_code
+        if status_code < 400:
+            return
+        if 400 <= status_code < 500:
+            try:
+                err = json.loads(response.text)
+            except json.JSONDecodeError:
+                raise ClientError(
+                    status_code, None, response.text, response.headers, None
+                )
+            error_data = None
+            if "data" in err:
+                error_data = err["data"]
+            print("Error?", err)
+            raise ClientError(
+                status_code, err["code"], err["msg"], response.headers, error_data
+            )
+        raise ServerError(status_code, response.text)

deltadefi-0.0.2/src/deltadefi/clients/__init__.py

@@ -0,0 +1,2 @@
+# flake8: noqa
+from .clients import *

deltadefi-0.0.2/src/deltadefi/clients/accounts.py

@@ -0,0 +1,162 @@
+#
+from typing import List
+
+from sidan_gin import Asset, UTxO
+
+from deltadefi.api import API
+from deltadefi.lib.utils import check_required_parameter, check_required_parameters
+from deltadefi.responses import (
+    BuildDepositTransactionResponse,
+    BuildWithdrawalTransactionResponse,
+    CreateNewAPIKeyResponse,
+    GetAccountBalanceResponse,
+    GetDepositRecordsResponse,
+    GetOrderRecordResponse,
+    GetWithdrawalRecordsResponse,
+    SubmitDepositTransactionResponse,
+    SubmitWithdrawalTransactionResponse,
+)
+
+
+class Accounts(API):
+    """
+    Accounts client for interacting with the DeltaDeFi API.
+    """
+
+    group_url_path = "/accounts"
+
+    def __init__(self, api_key=None, base_url=None, **kwargs):
+        super().__init__(api_key=api_key, base_url=base_url, **kwargs)
+
+    def create_new_api_key(self, **kwargs) -> CreateNewAPIKeyResponse:
+        """
+        Create a new API key.
+
+        Returns:
+            A CreateNewAPIKeyResponse object containing the new API key.
+        """
+
+        url_path = "/new-api-key"
+        return self.send_request("GET", self.group_url_path + url_path, kwargs)
+
+    def get_deposit_records(self, **kwargs) -> GetDepositRecordsResponse:
+        """
+        Get deposit records.
+
+        Returns:
+            A GetDepositRecordsResponse object containing the deposit records.
+        """
+        url_path = "/deposit-records"
+        return self.send_request("GET", self.group_url_path + url_path, kwargs)
+
+    def get_withdrawal_records(self, **kwargs) -> GetWithdrawalRecordsResponse:
+        """
+        Get withdrawal records.
+
+        Returns:
+            A GetWithdrawalRecordsResponse object containing the withdrawal records.
+        """
+        url_path = "/withdrawal-records"
+        return self.send_request("GET", self.group_url_path + url_path, kwargs)
+
+    def get_order_records(self, **kwargs) -> GetOrderRecordResponse:
+        """
+        Get order records.
+
+        Returns:
+            A GetOrderRecordResponse object containing the order records.
+        """
+        url_path = "/order-records"
+        return self.send_request("GET", self.group_url_path + url_path, kwargs)
+
+    def get_account_balance(self, **kwargs) -> GetAccountBalanceResponse:
+        """
+        Get account balance.
+
+        Returns:
+            A GetAccountBalanceResponse object containing the account balance.
+        """
+        url_path = "/balance"
+        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
+    ) -> BuildDepositTransactionResponse:
+        """
+        Build a deposit transaction.
+
+        Args:
+            data: A BuildDepositTransactionRequest object containing the deposit transaction details.
+
+        Returns:
+            A BuildDepositTransactionResponse object containing the built deposit transaction.
+        """
+
+        check_required_parameters(
+            [[deposit_amount, "deposit_amount"], [input_utxos, "input_utxos"]]
+        )
+        payload = {
+            "deposit_amount": deposit_amount,
+            "input_utxos": input_utxos,
+            **kwargs,
+        }
+
+        url_path = "/deposit/build"
+        return self.send_request("POST", self.group_url_path + url_path, payload)
+
+    def build_withdrawal_transaction(
+        self, withdrawal_amount: List[Asset], **kwargs
+    ) -> BuildWithdrawalTransactionResponse:
+        """
+        Build a withdrawal transaction.
+
+        Args:
+            data: A BuildWithdrawalTransactionRequest object containing the withdrawal transaction details.
+
+        Returns:
+            A BuildWithdrawalTransactionResponse object containing the built withdrawal transaction.
+        """
+
+        check_required_parameter(withdrawal_amount, "withdrawal_amount")
+        payload = {"withdrawal_amount": withdrawal_amount, **kwargs}
+
+        url_path = "/withdrawal/build"
+        return self.send_request("POST", self.group_url_path + url_path, payload)
+
+    def submit_deposit_transaction(
+        self, signed_tx: str, **kwargs
+    ) -> SubmitDepositTransactionResponse:
+        """
+        Submit a deposit transaction.
+
+        Args:
+            data: A SubmitDepositTransactionRequest object containing the deposit transaction details.
+
+        Returns:
+            A SubmitDepositTransactionResponse object containing the submitted deposit transaction.
+        """
+
+        check_required_parameter(signed_tx, "signed_tx")
+        payload = {"signed_tx": signed_tx, **kwargs}
+
+        url_path = "/deposit/submit"
+        return self.send_request("POST", self.group_url_path + url_path, payload)
+
+    def submit_withdrawal_transaction(
+        self, signed_tx: str, **kwargs
+    ) -> SubmitWithdrawalTransactionResponse:
+        """
+        Submit a withdrawal transaction.
+
+        Args:
+            data: A SubmitWithdrawalTransactionRequest object containing the withdrawal transaction details.
+
+        Returns:
+            A SubmitWithdrawalTransactionResponse object containing the submitted withdrawal transaction.
+        """
+
+        check_required_parameter(signed_tx, "signed_tx")
+        payload = {"signed_tx": signed_tx, **kwargs}
+
+        url_path = "/withdrawal/submit"
+        return self.send_request("POST", self.group_url_path + url_path, payload)

deltadefi-0.0.2/src/deltadefi/clients/app.py

@@ -0,0 +1,23 @@
+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-0.0.1 → deltadefi-0.0.2}/src/deltadefi/clients/clients.py

@@ -3,9 +3,9 @@ from sidan_gin import HDWallet
 
 from deltadefi.api_resources.auth import ApiHeaders
 from deltadefi.clients.accounts import Accounts
+from deltadefi.clients.app import App
 from deltadefi.clients.markets import Markets
-from deltadefi.clients.orders import Orders
-from deltadefi.requests import PostOrderRequest
+from deltadefi.clients.order import Order
 from deltadefi.responses import PostOrderResponse
 
 
@@ -17,7 +17,6 @@ class ApiClient:
     def __init__(
         self,
         network: str = "preprod",
-        jwt: str = None,
         api_key: str = None,
         wallet: HDWallet = None,
         base_url: str = None,
@@ -30,11 +29,6 @@ class ApiClient:
             wallet: An instance of HDWallet for signing transactions.
             base_url: Optional; The base URL for the API. Defaults to "https://api-dev.deltadefi.io".
         """
-        self.base_url = base_url or "https://api-dev.deltadefi.io"
-        headers: ApiHeaders = {
-            "Content-Type": "application/json",
-        }
-
         if network == "mainnet":
             self.network_id = 1
             base_url = "https://api-dev.deltadefi.io"  # TODO: input production link once available
@@ -42,20 +36,16 @@ class ApiClient:
             self.network_id = 0
             base_url = "https://api-dev.deltadefi.io"
 
-        if jwt is not None:
-            headers["Authorization"] = jwt
-
-        if api_key is not None:
-            headers["X-API-KEY"] = api_key
-
-        if wallet is not None:
-            self.wallet = wallet.signing_key
+        self.api_key = api_key
+        self.wallet = wallet
+        self.base_url = base_url
 
-        self.accounts = Accounts(self)
-        self.orders = Orders(self)
-        self.markets = Markets(self)
+        self.accounts = Accounts(base_url=base_url, api_key=api_key)
+        self.app = App(base_url=base_url, api_key=api_key)
+        self.order = Order(base_url=base_url, api_key=api_key)
+        self.markets = Markets(base_url=base_url, api_key=api_key)
 
-    async def post_order(self, data: PostOrderRequest) -> PostOrderResponse:
+    async def post_order(self, **kwargs) -> PostOrderResponse:
         """
         Post an order to the DeltaDeFi API.
 

deltadefi-0.0.2/src/deltadefi/clients/markets.py

@@ -0,0 +1,90 @@
+# 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,
+)
+
+
+class Markets(API):
+    """
+    Markets client for interacting with the DeltaDeFi API.
+    """
+
+    group_url_path = "/market"
+
+    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.
+
+        Args:
+            data: A GetMarketPriceRequest object containing the market pair.
+
+        Returns:
+            A GetMarketPriceResponse object containing the market price.
+        """
+        check_required_parameter(symbol, "symbol")
+        payload = {"symbol": symbol, **kwargs}
+        url_path = "/market-price"
+        return self.send_request("GET", self.group_url_path + url_path, payload)
+
+    def get_aggregated_price(
+        self,
+        symbol: str,
+        interval: Literal["15m", "30m", "1h", "1d", "1w", "1M"],
+        start: int,
+        end: int,
+    ) -> GetAggregatedPriceResponse:
+        """
+        Get aggregated price.
+
+        Args:
+            data: A GetAggregatedPriceRequest object containing the market pair, interval, start, and end time.
+
+        Returns:
+            A GetAggregatedPriceResponse object containing the aggregated price.
+        """
+
+        check_required_parameters(
+            [
+                [symbol, "symbol"],
+                [interval, "interval"],
+                [start, "start"],
+                [end, "end"],
+            ]
+        )
+        url_path = f"/aggregated-trade/{symbol}"
+        return self.send_request(
+            "GET",
+            self.group_url_path + url_path,
+            {
+                "interval": interval,
+                "start": start,
+                "end": end,
+            },
+        )