x10-python-trading-starknet 0.0.2__tar.gz → 0.0.5__tar.gz

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: x10-python-trading-starknet
-Version: 0.0.2
+Version: 0.0.5
 Summary: Python client for X10 API
 Home-page: https://github.com/x10xchange/python_sdk
 Author: X10

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "x10-python-trading-starknet"
-version = "0.0.2"
+version = "0.0.5"
 description = "Python client for X10 API"
 authors = ["X10 <tech@ex10.org>"]
 repository = "https://github.com/x10xchange/python_sdk"

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/candles.py

@@ -1,5 +1,5 @@
 from decimal import Decimal
-from typing import Literal
+from typing import Literal, Optional
 
 from pydantic import AliasChoices, Field
 
@@ -14,5 +14,7 @@ class CandleModel(X10BaseModel):
     low: Decimal = Field(validation_alias=AliasChoices("low", "l"), serialization_alias="l")
     high: Decimal = Field(validation_alias=AliasChoices("high", "h"), serialization_alias="h")
     close: Decimal = Field(validation_alias=AliasChoices("close", "c"), serialization_alias="c")
-    volume: Decimal = Field(validation_alias=AliasChoices("volume", "v"), serialization_alias="v")
+    volume: Optional[Decimal] = Field(
+        validation_alias=AliasChoices("volume", "v"), serialization_alias="v", default=None
+    )
     timestamp: int = Field(validation_alias=AliasChoices("timestamp", "T"), serialization_alias="T")

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/configuration.py

@@ -74,7 +74,7 @@ MAINNET_CONFIG_LEGACY_SIGNING_DOMAIN = EndpointConfig(
 STARKNET_TESTNET_CONFIG = EndpointConfig(
     chain_rpc_url="https://rpc.sepolia.org",
     api_base_url="https://api.starknet.sepolia.extended.exchange/api/v1",
-    stream_url="wss://api.starknet.sepolia.extended.exchange/stream.extended.exchange/v1",
+    stream_url="wss://starknet.sepolia.extended.exchange/stream.extended.exchange/v1",
     onboarding_url="https://api.starknet.sepolia.extended.exchange",
     signing_domain="starknet.sepolia.extended.exchange",
     collateral_asset_contract="0x0C9165046063B7bCD05C6924Bbe05ed535c140a1",

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/markets.py

@@ -76,6 +76,9 @@ class TradingConfigModel(X10BaseModel):
         else:
             return Decimal(0)
 
+    def round_price(self, price: Decimal, rounding_direction: str = ROUND_CEILING) -> Decimal:
+        return self.price_precision * (price / self.price_precision).to_integral_exact(rounding_direction)
+
 
 class L2ConfigModel(X10BaseModel):
     type: str

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/order_object.py

@@ -38,7 +38,7 @@ def create_order_object(
     side: OrderSide,
     starknet_domain: StarknetDomain,
     post_only: bool = False,
-    previous_order_id: Optional[str] = None,
+    previous_order_external_id: Optional[str] = None,
     expire_time: Optional[datetime] = None,
     order_external_id: Optional[str] = None,
     time_in_force: TimeInForce = TimeInForce.GTT,
@@ -66,7 +66,7 @@ def create_order_object(
         exact_only=False,
         expire_time=expire_time,
         post_only=post_only,
-        previous_order_external_id=previous_order_id,
+        previous_order_external_id=previous_order_external_id,
         order_external_id=order_external_id,
         time_in_force=time_in_force,
         self_trade_protection_level=self_trade_protection_level,

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/orderbook.py

@@ -31,9 +31,10 @@ class OrderBook:
     async def create(
         endpoint_config: EndpointConfig,
         market_name: str,
-        best_ask_change_callback: Callable[[OrderBookEntry], None] | None = None,
-        best_bid_change_callback: Callable[[OrderBookEntry], None] | None = None,
+        best_ask_change_callback: Callable[[OrderBookEntry | None], None] | None = None,
+        best_bid_change_callback: Callable[[OrderBookEntry | None], None] | None = None,
         start=False,
+        depth_1: bool = False,
     ) -> "OrderBook":
         ob = OrderBook(
             endpoint_config,
@@ -49,8 +50,8 @@ class OrderBook:
         self,
         endpoint_config: EndpointConfig,
         market_name: str,
-        best_ask_change_callback: Callable[[OrderBookEntry], None] | None = None,
-        best_bid_change_callback: Callable[[OrderBookEntry], None] | None = None,
+        best_ask_change_callback: Callable[[OrderBookEntry | None], None] | None = None,
+        best_bid_change_callback: Callable[[OrderBookEntry | None], None] | None = None,
     ) -> None:
         self.__stream_client = PerpetualStreamClient(api_url=endpoint_config.stream_url)
         self.__market_name = market_name
@@ -64,7 +65,7 @@ class OrderBook:
         best_bid_before_update = self.best_bid()
         for bid in data.bid:
             if bid.price in self._bid_prices:
-                existing_bid_entry: OrderBookEntry = self._bid_prices.get(bid.price)
+                existing_bid_entry: OrderBookEntry = self._bid_prices[bid.price]
                 existing_bid_entry.amount = existing_bid_entry.amount + bid.qty
                 if existing_bid_entry.amount == 0:
                     del self._bid_prices[bid.price]
@@ -74,14 +75,14 @@ class OrderBook:
                     amount=bid.qty,
                 )
         now_best_bid = self.best_bid()
-        if now_best_bid and best_bid_before_update != now_best_bid:
+        if best_bid_before_update != now_best_bid:
             if self.best_bid_change_callback:
                 self.best_bid_change_callback(now_best_bid)
 
         best_ask_before_update = self.best_ask()
         for ask in data.ask:
             if ask.price in self._ask_prices:
-                existing_ask_entry: OrderBookEntry = self._ask_prices.get(ask.price)
+                existing_ask_entry: OrderBookEntry = self._ask_prices[ask.price]
                 existing_ask_entry.amount = existing_ask_entry.amount + ask.qty
                 if existing_ask_entry.amount == 0:
                     del self._ask_prices[ask.price]
@@ -91,7 +92,7 @@ class OrderBook:
                     amount=ask.qty,
                 )
         now_best_ask = self.best_ask()
-        if now_best_ask and best_ask_before_update != now_best_ask:
+        if best_ask_before_update != now_best_ask:
             if self.best_ask_change_callback:
                 self.best_ask_change_callback(now_best_ask)
 
@@ -111,12 +112,20 @@ class OrderBook:
         loop = asyncio.get_running_loop()
 
         async def inner():
-            async with self.__stream_client.subscribe_to_orderbooks(self.__market_name) as stream:
-                async for event in stream:
-                    if event.type == StreamDataType.SNAPSHOT.value:
-                        self.init_orderbook(event.data)
-                    elif event.type == StreamDataType.DELTA.value:
-                        self.update_orderbook(event.data)
+            while True:
+                print(f"Connecting to orderbook stream for market: {self.__market_name}")
+                async with self.__stream_client.subscribe_to_orderbooks(self.__market_name) as stream:
+                    async for event in stream:
+                        if event.type == StreamDataType.SNAPSHOT.value:
+                            if not event.data:
+                                continue
+                            self.init_orderbook(event.data)
+                        elif event.type == StreamDataType.DELTA.value:
+                            if not event.data:
+                                continue
+                            self.update_orderbook(event.data)
+                print("Orderbook stream disconnected, reconnecting...")
+                await asyncio.sleep(1)
 
         self.__task = loop.create_task(inner())
         return self.__task

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/positions.py

@@ -44,8 +44,8 @@ class PositionHistoryModel(X10BaseModel):
     leverage: Decimal
     size: Decimal
     open_price: Decimal
-    exit_type: Optional[ExitType]
-    exit_price: Optional[Decimal]
+    exit_type: Optional[ExitType] = None
+    exit_price: Optional[Decimal] = None
     realised_pnl: Decimal
     created_time: int
-    closed_time: Optional[int]
+    closed_time: Optional[int] = None

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/simple_client/simple_trading_client.py

@@ -25,12 +25,12 @@ from x10.perpetual.trading_client.order_management_module import OrderManagement
 from x10.utils.http import WrappedStreamResponse
 
 
-async def condition_to_awaitable(condition: asyncio.Condition) -> Awaitable:
+def condition_to_awaitable(condition: asyncio.Condition) -> Awaitable:
     async def __inner():
         async with condition:
             await condition.wait()
 
-    return await __inner()
+    return __inner()
 
 
 class TimedOpenOrderModel(OpenOrderModel):
@@ -74,6 +74,10 @@ class CancelWaiter:
 
 class BlockingTradingClient:
     def __init__(self, endpoint_config: EndpointConfig, account: StarkPerpetualAccount):
+        if not asyncio.get_event_loop().is_running():
+            raise RuntimeError(
+                "BlockingTradingClient must be initialized from an async function, use BlockingTradingClient.create()"
+            )
         self.__endpoint_config = endpoint_config
         self.__account = account
         self.__market_module = MarketsInformationModule(endpoint_config, api_key=account.api_key)
@@ -85,14 +89,19 @@ class BlockingTradingClient:
             PerpetualStreamConnection[WrappedStreamResponse[AccountStreamDataModel]],
         ] = None
         self.__order_waiters: Dict[str, OrderWaiter] = {}
-        self.__cancel_waiters: Dict[int, CancelWaiter] = {}
-        self.__orders_task: Union[None, asyncio.Task] = None
-        self.__stream_lock = asyncio.Lock()
+        self.__cancel_waiters: Dict[str, CancelWaiter] = {}
+        self.__stream_task = asyncio.create_task(self.___order_stream())
+
+    @staticmethod
+    async def create(endpoint_config: EndpointConfig, account: StarkPerpetualAccount) -> "BlockingTradingClient":
+        client = BlockingTradingClient(endpoint_config, account)
+        await client.__stream_client.subscribe_to_account_updates(account.api_key)
+        return client
 
-    async def handle_cancel(self, order_id: int):
-        if order_id not in self.__cancel_waiters:
+    async def __handle_cancel(self, order_external_id: str):
+        if order_external_id not in self.__cancel_waiters:
             return
-        cancel_waiter = self.__cancel_waiters.get(order_id)
+        cancel_waiter = self.__cancel_waiters.get(order_external_id)
         if not cancel_waiter:
             return
         if cancel_waiter.condition:
@@ -100,57 +109,61 @@ class BlockingTradingClient:
                 cancel_waiter.end_nanos = time.time_ns()
                 cancel_waiter.condition.notify_all()
 
-    async def handle_update(self, order: OpenOrderModel):
-        if order.external_id not in self.__order_waiters:
-            return
-        order_waiter = self.__order_waiters.get(order.external_id)
-        if not order_waiter:
-            return
-        if order_waiter.condition:
-            async with order_waiter.condition:
-                order_waiter.open_order = TimedOpenOrderModel(
-                    start_nanos=order_waiter.start_nanos,
-                    end_nanos=time.time_ns(),
-                    open_order=order,
-                )
-                order_waiter.condition.notify_all()
-
-    async def handle_order(self, order: OpenOrderModel):
+    async def __handle_update(self, order: OpenOrderModel):
+        if order.status == OrderStatus.NEW.value:
+            if order.external_id not in self.__order_waiters:
+                return
+            order_waiter = self.__order_waiters.get(order.external_id)
+            if not order_waiter:
+                return
+            if order_waiter.condition:
+                async with order_waiter.condition:
+                    order_waiter.open_order = TimedOpenOrderModel(
+                        start_nanos=order_waiter.start_nanos,
+                        end_nanos=time.time_ns(),
+                        open_order=order,
+                    )
+                    order_waiter.condition.notify_all()
+
+    async def __handle_order(self, order: OpenOrderModel):
         if order.status == OrderStatus.CANCELLED.value:
-            await self.handle_cancel(order.id)
+            await self.__handle_cancel(order.external_id)
         else:
-            await self.handle_update(order)
+            await self.__handle_update(order)
 
     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):
                 continue
             for order in event.data.orders:
-                await self.handle_order(order)
+                await self.__handle_order(order)
+        print("Order stream closed, reconnecting...")
+        await self.___order_stream()
 
-    async def cancel_order(self, order_id: int) -> TimedCancel:
+    async def cancel_order(self, order_external_id: str) -> TimedCancel:
         awaitable: Awaitable
-        if order_id in self.__cancel_waiters:
-            awaitable = condition_to_awaitable(self.__cancel_waiters[order_id].condition)
+        if order_external_id in self.__cancel_waiters:
+            awaitable = condition_to_awaitable(self.__cancel_waiters[order_external_id].condition)
         else:
-            self.__cancel_waiters[order_id] = CancelWaiter(
+            self.__cancel_waiters[order_external_id] = CancelWaiter(
                 asyncio.Condition(), start_nanos=time.time_ns(), end_nanos=None
             )
-            cancel_task = asyncio.create_task(self.__orders_module.cancel_order(order_id))
+            cancel_task = asyncio.create_task(self.__orders_module.cancel_order_by_external_id(order_external_id))
             awaitable = asyncio.gather(
                 cancel_task,
-                asyncio.wait_for(condition_to_awaitable(self.__cancel_waiters[order_id].condition), 5),
+                asyncio.wait_for(condition_to_awaitable(self.__cancel_waiters[order_external_id].condition), 5),
                 return_exceptions=False,
             )
 
-        cancel_waiter = self.__cancel_waiters[order_id]
+        cancel_waiter = self.__cancel_waiters[order_external_id]
         end_nanos = None
         if cancel_waiter.end_nanos:
             end_nanos = cancel_waiter.end_nanos
         else:
             await awaitable
-            end_nanos = self.__cancel_waiters[order_id].end_nanos
-        del self.__cancel_waiters[order_id]
+            end_nanos = self.__cancel_waiters[order_external_id].end_nanos
+        del self.__cancel_waiters[order_external_id]
         end_nanos = cast(int, end_nanos)
         return TimedCancel(
             start_nanos=cancel_waiter.start_nanos,
@@ -161,9 +174,26 @@ class BlockingTradingClient:
     async def get_markets(self) -> Dict[str, MarketModel]:
         if not self.__markets:
             markets = await self.__market_module.get_markets()
-            self.__markets = {m.name: m for m in markets.data}
+            market_data = markets.data
+            if not market_data:
+                raise ValueError("Core market data is empty, check your connection or API key.")
+            self.__markets = {m.name: m for m in market_data}
         return self.__markets
 
+    async def mass_cancel(
+        self,
+        order_ids: list[int] | None = None,
+        external_order_ids: list[str] | None = None,
+        markets: list[str] | None = None,
+        cancel_all: bool = False,
+    ) -> None:
+        await self.__orders_module.mass_cancel(
+            order_ids=order_ids,
+            external_order_ids=external_order_ids,
+            markets=markets,
+            cancel_all=cancel_all,
+        )
+
     async def create_and_place_order(
         self,
         market_name: str,
@@ -171,19 +201,13 @@ class BlockingTradingClient:
         price: Decimal,
         side: OrderSide,
         post_only: bool = False,
-        previous_order_id: str | None = None,
+        previous_order_external_id: str | None = None,
+        external_id: str | None = None,
     ) -> TimedOpenOrderModel:
         market = (await self.get_markets()).get(market_name)
         if not market:
             raise ValueError(f"Market '{market_name}' not found.")
 
-        if not self.__account_stream:
-            await self.__stream_lock.acquire()
-            if not self.__account_stream:
-                self.__account_stream = await self.__stream_client.subscribe_to_account_updates(self.__account.api_key)
-                self.__orders_task = asyncio.create_task(self.___order_stream())
-            self.__stream_lock.release()
-
         order: PerpetualOrderModel = create_order_object(
             account=self.__account,
             market=market,
@@ -191,8 +215,9 @@ class BlockingTradingClient:
             price=price,
             side=side,
             post_only=post_only,
-            previous_order_id=previous_order_id,
+            previous_order_external_id=previous_order_external_id,
             starknet_domain=self.__endpoint_config.starknet_domain,
+            order_external_id=external_id,
         )
 
         if order.id in self.__order_waiters:

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/stream_client/perpetual_stream_connection.py

@@ -43,10 +43,8 @@ class PerpetualStreamConnection(Generic[StreamMsgResponseType]):
 
     async def close(self):
         assert self.__websocket is not None
-        assert not self.__websocket.closed
-
-        await self.__websocket.close()
-
+        if not self.__websocket.closed:
+            await self.__websocket.close()
         LOGGER.debug("Stream closed: %s", self.__stream_url)
 
     @property
@@ -67,8 +65,10 @@ class PerpetualStreamConnection(Generic[StreamMsgResponseType]):
 
         if self.__websocket.closed:
             raise StopAsyncIteration
-
-        return await self.__receive()
+        try:
+            return await self.__receive()
+        except websockets.ConnectionClosed:
+            raise StopAsyncIteration from None
 
     async def __receive(self) -> StreamMsgResponseType:
         assert self.__websocket is not None

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/stream_client/stream_client.py

@@ -24,12 +24,12 @@ class PerpetualStreamClient:
 
         self.__api_url = api_url
 
-    def subscribe_to_orderbooks(self, market_name: Optional[str] = None):
+    def subscribe_to_orderbooks(self, market_name: Optional[str] = None, depth: int | None = None):
         """
         https://api.docs.extended.exchange/#orderbooks-stream
         """
 
-        url = self.__get_url("/orderbooks/<market?>", market=market_name)
+        url = self.__get_url("/orderbooks/<market?>" + (f"?depth={depth}" if depth else ""), market=market_name)
         return self.__connect(url, WrappedStreamResponse[OrderbookUpdateModel])
 
     def subscribe_to_public_trades(self, market_name: Optional[str] = None):

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/trading_client/order_management_module.py

@@ -10,10 +10,10 @@ LOGGER = get_logger(__name__)
 
 
 class _MassCancelRequestModel(X10BaseModel):
-    order_ids: Optional[List[int]]
-    external_order_ids: Optional[List[str]]
-    markets: Optional[List[str]]
-    cancel_all: Optional[bool]
+    order_ids: Optional[List[int]] = None
+    external_order_ids: Optional[List[str]] = None
+    markets: Optional[List[str]] = None
+    cancel_all: Optional[bool] = None
 
 
 class OrderManagementModule(BaseModule):

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/trading_client/trading_client.py

@@ -52,6 +52,7 @@ class PerpetualTradingClient:
         expire_time: Optional[datetime] = None,
         time_in_force: TimeInForce = TimeInForce.GTT,
         self_trade_protection_level: SelfTradeProtectionLevel = SelfTradeProtectionLevel.ACCOUNT,
+        external_id: Optional[str] = None,
     ) -> WrappedApiResponse[PlacedOrderModel]:
         if not self.__stark_account:
             raise ValueError("Stark account is not set")
@@ -74,11 +75,12 @@ class PerpetualTradingClient:
             price=price,
             side=side,
             post_only=post_only,
-            previous_order_id=previous_order_id,
+            previous_order_external_id=previous_order_id,
             expire_time=expire_time,
             time_in_force=time_in_force,
             self_trade_protection_level=self_trade_protection_level,
             starknet_domain=self.__config.starknet_domain,
+            order_external_id=external_id,
         )
         return await self.__order_management_module.place_order(order)
 

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/transfer_object.py

@@ -55,13 +55,13 @@ def create_transfer_object(
         domain_version=starknet_domain.version,
         domain_chain_id=starknet_domain.chain_id,
         domain_revision=starknet_domain.revision,
-        collateral_id=1,
+        collateral_id=int(config.collateral_asset_on_chain_id, base=16),
     )
 
     (transfer_signature_r, transfer_signature_s) = stark_account.sign(transfer_hash)
     settlement = StarkTransferSettlement(
         amount=int(stark_amount),
-        asset_id=int(config.collateral_asset_id, base=16),
+        asset_id=int(config.collateral_asset_on_chain_id, base=16),
         expiration_timestamp=expiration_timestamp,
         nonce=nonce,
         receiver_position_id=to_vault,

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/user_client/onboarding.py

@@ -39,6 +39,7 @@ class AccountRegistration:
     tos_accepted: bool
     time: datetime
     action: str
+    host: str
 
     def __post_init__(self):
         self.time_string = self.time.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
@@ -52,6 +53,7 @@ class AccountRegistration:
             "tosAccepted": self.tos_accepted,
             "time": self.time_string,
             "action": self.action,
+            "host": self.host,
         }
         types = {
             "EIP712Domain": [
@@ -63,6 +65,7 @@ class AccountRegistration:
                 {"name": "tosAccepted", "type": "bool"},
                 {"name": "time", "type": "string"},
                 {"name": "action", "type": "string"},
+                {"name": "host", "type": "string"},
             ],
         }
         primary_type = "AccountRegistration"
@@ -81,6 +84,7 @@ class AccountRegistration:
             "tosAccepted": self.tos_accepted,
             "time": self.time_string,
             "action": self.action,
+            "host": self.host,
         }
 
 
@@ -127,7 +131,7 @@ class OnboardingPayLoad:
 
 
 def get_registration_struct_to_sign(
-    account_index: int, address: str, timestamp: datetime, action: str
+    account_index: int, address: str, timestamp: datetime, action: str, host: str
 ) -> AccountRegistration:
     return AccountRegistration(
         account_index=account_index,
@@ -135,6 +139,7 @@ def get_registration_struct_to_sign(
         tos_accepted=True,
         time=timestamp,
         action=action,
+        host=host,
     )
 
 
@@ -180,6 +185,7 @@ def get_onboarding_payload(
     account: LocalAccount,
     signing_domain: str,
     key_pair: StarkKeyPair,
+    host: str,
     time: datetime | None = None,
     referral_code: str | None = None,
 ) -> OnboardingPayLoad:
@@ -187,11 +193,11 @@ def get_onboarding_payload(
         time = datetime.now(timezone.utc)
 
     registration_payload = get_registration_struct_to_sign(
-        account_index=0, address=account.address, timestamp=time, action=register_action
+        account_index=0, address=account.address, timestamp=time, action=register_action, host=host
     )
-    l1_signature = account.sign_message(
-        registration_payload.to_signable_message(signing_domain=signing_domain)
-    ).signature.hex()
+    payload = registration_payload.to_signable_message(signing_domain=signing_domain)
+    l1_signature = account.sign_message(payload).signature.hex()
+
     l2_message = pedersen_hash(int(account.address, 16), key_pair.public)
     l2_r, l2_s = stark_sign(msg_hash=l2_message, private_key=key_pair.private)
 
@@ -207,16 +213,18 @@ def get_onboarding_payload(
 
 
 def get_sub_account_creation_payload(
-    account_index: int, l1_address: str, key_pair: StarkKeyPair, description: str, time: datetime | None = None
+    account_index: int,
+    l1_address: str,
+    key_pair: StarkKeyPair,
+    description: str,
+    host: str,
+    time: datetime | None = None,
 ):
     if time is None:
         time = datetime.now(timezone.utc)
 
     registration_payload = get_registration_struct_to_sign(
-        account_index=account_index,
-        address=l1_address,
-        timestamp=time,
-        action=sub_account_action,
+        account_index=account_index, address=l1_address, timestamp=time, action=sub_account_action, host=host
     )
 
     l2_message = pedersen_hash(int(l1_address, 16), key_pair.public)

{x10_python_trading_starknet-0.0.2 → x10_python_trading_starknet-0.0.5}/x10/perpetual/user_client/user_client.py

@@ -78,6 +78,7 @@ class UserClient:
             signing_domain=self.__endpoint_config.signing_domain,
             key_pair=key_pair,
             referral_code=referral_code,
+            host=self.__endpoint_config.onboarding_url,
         )
         url = self._get_url(self.__endpoint_config.onboarding_url, path="/auth/onboard")
         onboarding_response = await send_post_request(
@@ -111,6 +112,7 @@ class UserClient:
             l1_address=signing_account.address,
             key_pair=key_pair,
             description=description,
+            host=self.__endpoint_config.onboarding_url,
         )
         headers = {
             L1_AUTH_SIGNATURE_HEADER: l1_signature.signature.hex(),