x10-python-trading-starknet 1.4.0__tar.gz → 2.0.0__tar.gz

{x10_python_trading_starknet-1.4.0 → x10_python_trading_starknet-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: x10-python-trading-starknet
-Version: 1.4.0
+Version: 2.0.0
 Summary: Python client for X10 API
 Home-page: https://github.com/x10xchange/python_sdk
 Author: X10
@@ -20,9 +20,9 @@ Requires-Dist: fast-stark-crypto (==0.5.0)
 Requires-Dist: pydantic (>=2.9.0)
 Requires-Dist: pyyaml (>=6.0.1)
 Requires-Dist: sortedcontainers (>=2.4.0)
-Requires-Dist: strenum (>=0.4.15,<0.5.0)
-Requires-Dist: tenacity (>=9.1.2,<10.0.0)
-Requires-Dist: websockets (>=12.0,<14.0)
+Requires-Dist: strenum (>=0.4.15)
+Requires-Dist: tenacity (>=9.1.2)
+Requires-Dist: websockets (>=12.0)
 Project-URL: Documentation, https://api.docs.extended.exchange/
 Project-URL: Repository, https://github.com/x10xchange/python_sdk
 Description-Content-Type: text/markdown
@@ -286,7 +286,7 @@ All new accounts should use the `MAINNET_CONFIG` configuration bundle.
 
 ## OnBoarding via SDK (Since Version 0.3.0)
 
-To onboard to the Extended Exchange, the `UserClient` defined in [user_client.py](x10/perpetual/user_client/user_client.py) provides a way to use an Ethereum account to onboard onto the Extended Exchange. 
+To onboard to the Extended Exchange, the `UserClient` defined in [user_client.py](x10/perpetual/user_client/user_client.py) provides a way to use an Ethereum account to onboard onto the Extended Exchange.
 
 ### TLDR - Check out: [onboarding_example.py](examples/onboarding_example.py)
 

{x10_python_trading_starknet-1.4.0 → x10_python_trading_starknet-2.0.0}/README.md

@@ -257,7 +257,7 @@ All new accounts should use the `MAINNET_CONFIG` configuration bundle.
 
 ## OnBoarding via SDK (Since Version 0.3.0)
 
-To onboard to the Extended Exchange, the `UserClient` defined in [user_client.py](x10/perpetual/user_client/user_client.py) provides a way to use an Ethereum account to onboard onto the Extended Exchange. 
+To onboard to the Extended Exchange, the `UserClient` defined in [user_client.py](x10/perpetual/user_client/user_client.py) provides a way to use an Ethereum account to onboard onto the Extended Exchange.
 
 ### TLDR - Check out: [onboarding_example.py](examples/onboarding_example.py)
 

{x10_python_trading_starknet-1.4.0 → x10_python_trading_starknet-2.0.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "x10-python-trading-starknet"
-version = "1.4.0"
+version = "2.0.0"
 description = "Python client for X10 API"
 authors = ["X10 <tech@ex10.org>"]
 repository = "https://github.com/x10xchange/python_sdk"
@@ -29,9 +29,9 @@ pydantic = ">=2.9.0"
 python = "^3.10"
 pyyaml = ">=6.0.1"
 sortedcontainers = ">=2.4.0"
-strenum = "^0.4.15"
-tenacity = "^9.1.2"
-websockets = ">=12.0,<14.0"
+strenum = ">=0.4.15"
+tenacity = ">=9.1.2"
+websockets = ">=12.0"
 
 [tool.poetry.group.dev.dependencies]
 black = "==23.12.0"
@@ -52,7 +52,7 @@ python-dotenv = "==1.0.1"
 safety = "==3.5.1"
 tox = "==4.11.4"
 types-pyyaml = "==6.0.12.12"
-typing-extensions = ">=4.9.0"
+typing-extensions = "==4.15.0"
 
 
 [tool.mypy]

x10_python_trading_starknet-2.0.0/x10/clients/blocking/__init__.py

@@ -0,0 +1,3 @@
+from x10.clients.blocking.blocking_trading_client import (  # noqa: F401
+    BlockingTradingClient,
+)

x10_python_trading_starknet-1.4.0/x10/perpetual/simple_client/simple_trading_client.py → x10_python_trading_starknet-2.0.0/x10/clients/blocking/blocking_trading_client.py

@@ -1,12 +1,17 @@
 import asyncio
-import dataclasses
 import time
+from dataclasses import dataclass
 from decimal import Decimal
-from typing import Awaitable, Dict, Union, cast
+from typing import Awaitable, Dict, Optional, cast
 
+from x10.clients.rest.modules.info_module import InfoModule
+from x10.clients.rest.modules.order_management_module import OrderManagementModule
+from x10.clients.stream import StreamClient, StreamConnection
 from x10.config import Config
 from x10.core.stark_account import StarkPerpetualAccount
+from x10.errors import SdkError, ValidationError
 from x10.models.account import AccountStreamDataModel
+from x10.models.http import WrappedStreamResponseModel
 from x10.models.market import MarketModel
 from x10.models.order import (
     NewOrderModel,
@@ -16,14 +21,7 @@ from x10.models.order import (
     OrderType,
     TimeInForce,
 )
-from x10.perpetual.order_object import create_order_object
-from x10.perpetual.stream_client.perpetual_stream_connection import (
-    PerpetualStreamConnection,
-)
-from x10.perpetual.stream_client.stream_client import PerpetualStreamClient
-from x10.perpetual.trading_client.info_markets_module import InfoMarketsModule
-from x10.perpetual.trading_client.order_management_module import OrderManagementModule
-from x10.utils.http import WrappedStreamResponse
+from x10.signing.order_object import create_order_object
 
 
 def condition_to_awaitable(condition: asyncio.Condition) -> Awaitable:
@@ -52,21 +50,21 @@ class TimedOpenOrderModel(OpenOrderModel):
         )
 
 
-@dataclasses.dataclass
+@dataclass
 class TimedCancel:
     start_nanos: int
     end_nanos: int
     operation_ms: float
 
 
-@dataclasses.dataclass
+@dataclass
 class OrderWaiter:
     condition: asyncio.Condition
     open_order: None | TimedOpenOrderModel
     start_nanos: int
 
 
-@dataclasses.dataclass
+@dataclass
 class CancelWaiter:
     condition: asyncio.Condition
     start_nanos: int
@@ -74,24 +72,27 @@ class CancelWaiter:
 
 
 class BlockingTradingClient:
+    """
+    A client for placing orders and receiving updates in a blocking manner.
+    Waits for the confirmation from the WS stream after placing or canceling an order.
+    """
+
     def __init__(self, config: Config, account: StarkPerpetualAccount):
         if not asyncio.get_event_loop().is_running():
-            raise RuntimeError(
+            raise SdkError(
                 "BlockingTradingClient must be initialized from an async function, use BlockingTradingClient.create()"
             )
+
         self.__config = config
         self.__account = account
-        self.__market_module = InfoMarketsModule(config, api_key=account.api_key)
+        self.__info_module = InfoModule(config, api_key=account.api_key)
         self.__orders_module = OrderManagementModule(config, api_key=account.api_key)
-        self.__markets: Union[None, Dict[str, MarketModel]] = None
-        self.__stream_client: PerpetualStreamClient = PerpetualStreamClient(api_url=config.endpoints.stream_url)
-        self.__account_stream: Union[
-            None,
-            PerpetualStreamConnection[WrappedStreamResponse[AccountStreamDataModel]],
-        ] = None
+        self.__markets: Optional[Dict[str, MarketModel]] = None
+        self.__stream_client: StreamClient = StreamClient(api_url=config.endpoints.stream_url)
+        self.__account_stream: Optional[StreamConnection[WrappedStreamResponseModel[AccountStreamDataModel]]] = None
         self.__order_waiters: Dict[str, OrderWaiter] = {}
         self.__cancel_waiters: Dict[str, CancelWaiter] = {}
-        self.__stream_task = asyncio.create_task(self.___order_stream())
+        self.__stream_task = asyncio.create_task(self.__order_stream())
 
     @staticmethod
     async def create(config: Config, account: StarkPerpetualAccount) -> "BlockingTradingClient":
@@ -128,7 +129,7 @@ class BlockingTradingClient:
         else:
             await self.__handle_update(order)
 
-    async def ___order_stream(self):
+    async def __order_stream(self):
         self.__account_stream = await self.__stream_client.subscribe_to_account_updates(self.__account.api_key)
         async for event in self.__account_stream:
             if not (event.data and event.data.orders):
@@ -136,7 +137,7 @@ class BlockingTradingClient:
             for order in event.data.orders:
                 await self.__handle_order(order)
         print("Order stream closed, reconnecting...")
-        await self.___order_stream()
+        await self.__order_stream()
 
     async def cancel_order(self, order_external_id: str) -> TimedCancel:
         awaitable: Awaitable
@@ -170,10 +171,10 @@ class BlockingTradingClient:
 
     async def get_markets(self) -> Dict[str, MarketModel]:
         if not self.__markets:
-            markets = await self.__market_module.get_markets()
+            markets = await self.__info_module.get_markets()
             market_data = markets.data
             if not market_data:
-                raise ValueError("Core market data is empty, check your connection or API key.")
+                raise ValidationError("Core market data is empty, check your connection or API key.")
             self.__markets = {m.name: m for m in market_data}
         return self.__markets
 
@@ -209,7 +210,7 @@ class BlockingTradingClient:
     ) -> TimedOpenOrderModel:
         market = (await self.get_markets()).get(market_name)
         if not market:
-            raise ValueError(f"Market '{market_name}' not found.")
+            raise ValidationError(f"Market '{market_name}' not found.")
 
         order: NewOrderModel = create_order_object(
             account=self.__account,
@@ -230,7 +231,7 @@ class BlockingTradingClient:
         )
 
         if order.id in self.__order_waiters:
-            raise ValueError(f"order with {order.id} hash already placed")
+            raise ValidationError(f"order with {order.id} hash already placed")
 
         self.__order_waiters[order.id] = OrderWaiter(asyncio.Condition(), None, start_nanos=time.time_ns())
         placed_order_task = asyncio.create_task(self.__orders_module.place_order(order))
@@ -246,7 +247,7 @@ class BlockingTradingClient:
             open_model = self.__order_waiters[order.id].open_order
             del self.__order_waiters[order.id]
             if not open_model:
-                raise ValueError("No Fill or Placement received for order")
+                raise ValidationError("No Fill or Placement received for order")
             return open_model
 
     async def close(self):

x10_python_trading_starknet-2.0.0/x10/clients/onboarding/__init__.py

@@ -0,0 +1 @@
+from x10.clients.onboarding.onboarding_client import OnboardingClient  # noqa: F401

x10_python_trading_starknet-2.0.0/x10/clients/onboarding/modules/account_module.py

@@ -0,0 +1,32 @@
+from x10.clients.onboarding.modules.base_module import BaseModule
+from x10.errors import ValidationError
+from x10.models.account import ApiKeyRequestModel, ApiKeyResponseModel
+from x10.signing.onboarding import sign_api_request
+from x10.utils.http import RequestHeader, send_post_request
+
+
+class AccountModule(BaseModule):
+    async def create_api_key(self, *, account_id: int, description: str) -> str:
+        request_path = "/api/v1/user/account/api-key"
+        signature = sign_api_request(request_path, self._sign_message)
+        headers: dict[str, str] = {
+            RequestHeader.AUTH_L1_SIGNATURE: signature.value,
+            RequestHeader.AUTH_L1_MESSAGE_TIME: signature.time,
+            RequestHeader.AUTH_ACTIVE_ACCOUNT: str(account_id),
+        }
+
+        payload = ApiKeyRequestModel(description=description)
+        url = self._get_url(request_path)
+        response = await send_post_request(
+            await self._get_session(),
+            url,
+            ApiKeyResponseModel,
+            json=payload.to_api_request_json(),
+            request_headers=headers,
+        )
+        response_data = response.data
+
+        if response_data is None:
+            raise ValidationError("No API key data returned from onboarding")
+
+        return response_data.key

x10_python_trading_starknet-2.0.0/x10/clients/onboarding/modules/auth_module.py

@@ -0,0 +1,89 @@
+from aiohttp.web_exceptions import HTTPConflict
+
+from x10.clients.onboarding.modules.base_module import BaseModule
+from x10.errors import SdkError, ValidationError
+from x10.models.account import AccountModel
+from x10.models.client import OnboardedClientModel
+from x10.signing.onboarding import (
+    OnBoardedAccount,
+    get_l2_keys_from_l1_account,
+    get_onboarding_payload,
+    get_sub_account_creation_payload,
+    sign_api_request,
+)
+from x10.utils.http import RequestHeader, send_post_request
+
+
+class SubAccountExists(SdkError):
+    pass
+
+
+class AuthModule(BaseModule):
+    async def onboard_client(self, *, referral_code: str | None = None) -> OnBoardedAccount:
+        l2_key_pair = get_l2_keys_from_l1_account(
+            account_index=0,
+            account_address=self._get_account_address(),
+            signing_domain=self._get_config().signing.signing_domain,
+            sign_message=self._sign_message,
+        )
+        payload = get_onboarding_payload(
+            account_address=self._get_account_address(),
+            signing_domain=self._get_config().signing.signing_domain,
+            key_pair=l2_key_pair,
+            referral_code=referral_code,
+            host=self._get_config().endpoints.onboarding_url,
+            sign_message=self._sign_message,
+        )
+
+        url = self._get_url("/auth/onboard")
+        onboarding_response = await send_post_request(
+            await self._get_session(), url, OnboardedClientModel, json=payload.to_json()
+        )
+
+        onboarded_client = onboarding_response.data
+
+        if onboarded_client is None:
+            raise ValidationError("No account data returned from onboarding")
+
+        return OnBoardedAccount(account=onboarded_client.default_account, l2_key_pair=l2_key_pair)
+
+    async def onboard_subaccount(self, *, account_index: int, description: str):
+        request_path = "/auth/onboard/subaccount"
+        signature = sign_api_request(request_path, self._sign_message)
+        headers: dict[str, str] = {
+            RequestHeader.AUTH_L1_SIGNATURE: signature.value,
+            RequestHeader.AUTH_L1_MESSAGE_TIME: signature.time,
+        }
+
+        key_pair = get_l2_keys_from_l1_account(
+            account_index=account_index,
+            account_address=self._get_account_address(),
+            signing_domain=self._get_config().signing.signing_domain,
+            sign_message=self._sign_message,
+        )
+        payload = get_sub_account_creation_payload(
+            account_index=account_index,
+            l1_address=self._get_account_address(),
+            key_pair=key_pair,
+            description=description,
+            host=self._get_config().endpoints.onboarding_url,
+        )
+        url = self._get_url(request_path)
+
+        try:
+            onboarding_response = await send_post_request(
+                await self._get_session(),
+                url,
+                AccountModel,
+                json=payload.to_json(),
+                request_headers=headers,
+                response_code_to_exception={HTTPConflict.status_code: SubAccountExists},
+            )
+            onboarded_account = onboarding_response.data
+        except SubAccountExists:
+            raise ValidationError("Subaccount already exists")
+
+        if onboarded_account is None:
+            raise ValidationError("No account data returned from onboarding")
+
+        return OnBoardedAccount(account=onboarded_account, l2_key_pair=key_pair)

x10_python_trading_starknet-2.0.0/x10/clients/onboarding/modules/base_module.py

@@ -0,0 +1,51 @@
+from typing import Dict, Optional
+
+import aiohttp
+from aiohttp import ClientTimeout
+from eth_account.messages import SignableMessage
+from eth_typing import ChecksumAddress
+
+from x10.config import Config
+from x10.signing.onboarding import SignMessageCallback
+from x10.utils.http import get_url
+
+
+class BaseModule:
+    __config: Config
+    __account_address: ChecksumAddress
+    __sign_message: SignMessageCallback
+    __session: Optional[aiohttp.ClientSession]
+
+    def __init__(self, config: Config, *, account_address: ChecksumAddress, sign_message: SignMessageCallback):
+        super().__init__()
+
+        self.__config = config
+        self.__account_address = account_address
+        self.__sign_message = sign_message
+        self.__session = None
+
+    def _get_url(self, path: str, *, query: Optional[Dict] = None, **path_params) -> str:
+        return get_url(f"{self.__config.endpoints.onboarding_url}{path}", query=query, **path_params)
+
+    def _get_config(self) -> Config:
+        return self.__config
+
+    def _get_account_address(self) -> ChecksumAddress:
+        return self.__account_address
+
+    def _sign_message(self, msg: SignableMessage) -> str:
+        return self.__sign_message(msg)
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self.__session is None:
+            created_session = aiohttp.ClientSession(
+                timeout=ClientTimeout(total=self.__config.defaults.request_timeout_seconds)
+            )
+            self.__session = created_session
+
+        return self.__session
+
+    async def close_session(self):
+        if self.__session:
+            await self.__session.close()
+            self.__session = None

x10_python_trading_starknet-2.0.0/x10/clients/onboarding/onboarding_client.py

@@ -0,0 +1,33 @@
+from eth_typing import ChecksumAddress
+
+from x10.clients.onboarding.modules.account_module import AccountModule
+from x10.clients.onboarding.modules.auth_module import AuthModule
+from x10.config import Config
+from x10.signing.onboarding import SignMessageCallback
+
+
+class OnboardingClient:
+    __account_module: AccountModule
+    __auth_module: AuthModule
+
+    async def close(self):
+        await self.__account_module.close_session()
+        await self.__auth_module.close_session()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.close()
+
+    def __init__(self, config: Config, *, account_address: ChecksumAddress, sign_message: SignMessageCallback):
+        self.__account_module = AccountModule(config, account_address=account_address, sign_message=sign_message)
+        self.__auth_module = AuthModule(config, account_address=account_address, sign_message=sign_message)
+
+    @property
+    def account(self):
+        return self.__account_module
+
+    @property
+    def auth(self):
+        return self.__auth_module

x10_python_trading_starknet-2.0.0/x10/clients/rest/__init__.py

@@ -0,0 +1 @@
+from x10.clients.rest.rest_api_client import RestApiClient  # noqa: F401