x10-python-trading-starknet 1.2.0__tar.gz → 1.3.0__tar.gz

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: x10-python-trading-starknet
-Version: 1.2.0
+Version: 1.3.0
 Summary: Python client for X10 API
 Home-page: https://github.com/x10xchange/python_sdk
 Author: X10
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: aiohttp (>=3.10.11)
 Requires-Dist: eth-account (>=0.12.0)
-Requires-Dist: fast-stark-crypto (==0.3.8)
+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)

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "x10-python-trading-starknet"
-version = "1.2.0"
+version = "1.3.0"
 description = "Python client for X10 API"
 authors = ["X10 <tech@ex10.org>"]
 repository = "https://github.com/x10xchange/python_sdk"
@@ -24,7 +24,7 @@ packages = [{ include = "x10" }]
 [tool.poetry.dependencies]
 aiohttp = ">=3.10.11"
 eth-account = ">=0.12.0"
-fast-stark-crypto = "==0.3.8"
+fast-stark-crypto = "==0.5.0"
 pydantic = ">=2.9.0"
 python = "^3.10"
 pyyaml = ">=6.0.1"

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/assets.py

@@ -7,6 +7,21 @@ from strenum import StrEnum
 from x10.utils.model import HexValue, X10BaseModel
 
 
+class AssetModel(X10BaseModel):
+    id: int
+    name: str
+    symbol: str
+    precision: int
+    is_active: bool
+    is_collateral: bool
+    starkex_id: HexValue
+    starkex_resolution: int
+    l1_id: str
+    l1_resolution: int
+    version: int
+
+
+# FIXME: Replace with AssetModel
 @dataclass
 class Asset:
     id: int
@@ -37,6 +52,20 @@ class Asset:
             raise ValueError("Only collateral assets have an L1 representation")
         return int(internal * Decimal(self.l1_resolution))
 
+    @staticmethod
+    def from_model(model: AssetModel):
+        return Asset(
+            id=model.id,
+            name=model.name,
+            precision=model.precision,
+            active=model.is_active,
+            is_collateral=model.is_collateral,
+            settlement_external_id=hex(model.starkex_id),
+            settlement_resolution=model.starkex_resolution,
+            l1_external_id=model.l1_id,
+            l1_resolution=model.l1_resolution,
+        )
+
 
 class AssetOperationType(StrEnum):
     CLAIM = "CLAIM"

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/balances.py

@@ -13,3 +13,15 @@ class BalanceModel(X10BaseModel):
     initial_margin: Decimal
     margin_ratio: Decimal
     updated_time: int
+
+
+class SpotBalanceModel(X10BaseModel):
+    account_id: int
+    asset: str
+    balance: Decimal
+    index_price: Decimal
+    notional_value: Decimal
+    contribution_factor: Decimal
+    equity_contribution: Decimal
+    available_to_withdraw: Decimal
+    updated_at: int

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/configuration.py

@@ -13,6 +13,7 @@ class StarknetDomain:
 class EndpointConfig:
     """
     Attributes:
+        chain_rpc_url (str): Field is deprecated and will be removed.
         asset_operations_contract (str): Field is deprecated and will be removed.
         collateral_asset_contract (str): Field is deprecated and will be removed.
         collateral_asset_on_chain_id (str): Field is deprecated and will be removed.
@@ -33,6 +34,8 @@ class EndpointConfig:
     collateral_decimals: int
     collateral_asset_id: str
 
+    vault_asset_name: str
+
 
 TESTNET_CONFIG = EndpointConfig(
     chain_rpc_url="https://rpc.sepolia.org",
@@ -40,12 +43,13 @@ TESTNET_CONFIG = EndpointConfig(
     stream_url="wss://api.starknet.sepolia.extended.exchange/stream.extended.exchange/v1",
     onboarding_url="https://api.starknet.sepolia.extended.exchange",
     signing_domain="starknet.sepolia.extended.exchange",
+    starknet_domain=StarknetDomain(name="Perpetuals", version="v0", chain_id="SN_SEPOLIA", revision="1"),
     asset_operations_contract="",
-    collateral_asset_contract="0x31857064564ed0ff978e687456963cba09c2c6985d8f9300a1de4962fafa054",
+    collateral_asset_contract="0x05ba91db44b3e6a4485b5dbfcb17d791faa9cb6890a42731b66b3536b28b8ed5",
     collateral_asset_on_chain_id="0x1",
     collateral_decimals=6,
     collateral_asset_id="0x1",
-    starknet_domain=StarknetDomain(name="Perpetuals", version="v0", chain_id="SN_SEPOLIA", revision="1"),
+    vault_asset_name="XVS",
 )
 
 MAINNET_CONFIG = EndpointConfig(
@@ -54,10 +58,11 @@ MAINNET_CONFIG = EndpointConfig(
     stream_url="wss://api.starknet.extended.exchange/stream.extended.exchange/v1",
     onboarding_url="https://api.starknet.extended.exchange",
     signing_domain="extended.exchange",
+    starknet_domain=StarknetDomain(name="Perpetuals", version="v0", chain_id="SN_MAIN", revision="1"),
     asset_operations_contract="",
     collateral_asset_contract="",
     collateral_asset_on_chain_id="0x1",
     collateral_decimals=6,
     collateral_asset_id="0x1",
-    starknet_domain=StarknetDomain(name="Perpetuals", version="v0", chain_id="SN_MAIN", revision="1"),
+    vault_asset_name="XVS",
 )

x10_python_trading_starknet-1.3.0/x10/perpetual/limit_order_object_settlement.py

@@ -0,0 +1,72 @@
+import decimal
+from datetime import timedelta
+
+from x10.perpetual.accounts import StarkPerpetualAccount
+from x10.perpetual.amounts import HumanReadableAmount, StarkAmount
+from x10.perpetual.assets import Asset, AssetModel
+from x10.perpetual.configuration import StarknetDomain
+from x10.perpetual.order_object_settlement import (
+    calculate_order_settlement_expiration,
+    hash_limit_order,
+)
+from x10.perpetual.orders import LimitOrderSettlementModel
+from x10.utils.date import utc_now
+from x10.utils.model import SettlementSignatureModel
+from x10.utils.nonce import generate_nonce
+
+
+def create_order_settlement_data(
+    *,
+    quote_amount,
+    base_amount,
+    position_id,
+    quote_asset_model: AssetModel,
+    base_asset_model: AssetModel,
+    starknet_account: StarkPerpetualAccount,
+    starknet_domain: StarknetDomain,
+    is_buy: bool,
+):
+    quote_asset = Asset.from_model(quote_asset_model)
+    base_asset = Asset.from_model(base_asset_model)
+
+    quote_amount_human = HumanReadableAmount(
+        asset=quote_asset,
+        value=-quote_amount if is_buy else quote_amount,
+    )
+    base_amount_human = HumanReadableAmount(
+        asset=base_asset,
+        value=base_amount if is_buy else -base_amount,
+    )
+
+    quote_amount_stark = quote_amount_human.to_stark_amount(decimal.Context(rounding=decimal.ROUND_UP))
+    base_amount_stark = base_amount_human.to_stark_amount(decimal.Context(rounding=decimal.ROUND_UP))
+
+    nonce = generate_nonce()
+    expire_time = utc_now() + timedelta(hours=1)
+    order_hash = hash_limit_order(
+        amount_base=base_amount_stark,
+        amount_quote=quote_amount_stark,
+        max_fee=StarkAmount(0, quote_asset),
+        nonce=nonce,
+        position_id=position_id,
+        expiration_timestamp=expire_time,
+        public_key=starknet_account.public_key,
+        starknet_domain=starknet_domain,
+    )
+    order_signature = starknet_account.sign(order_hash)
+
+    settlement = LimitOrderSettlementModel(
+        base_amount=base_amount_stark.value,
+        quote_amount=quote_amount_stark.value,
+        fee_amount=0,
+        base_asset_id=int(base_asset.settlement_external_id, 16),
+        quote_asset_id=int(quote_asset.settlement_external_id, 16),
+        fee_asset_id=int(quote_asset.settlement_external_id, 16),
+        expiration_timestamp=calculate_order_settlement_expiration(expire_time),
+        nonce=nonce,
+        receiver_position_id=position_id,
+        sender_position_id=position_id,
+        signature=SettlementSignatureModel(r=order_signature[0], s=order_signature[1]),
+    )
+
+    return settlement, quote_amount_human, base_amount_human

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/order_object_settlement.py

@@ -4,7 +4,7 @@ from datetime import datetime, timedelta
 from decimal import Decimal
 from typing import Callable, Optional, Tuple
 
-from fast_stark_crypto import get_order_msg_hash
+from fast_stark_crypto import get_limit_order_msg_hash, get_order_msg_hash
 
 from x10.perpetual.amounts import (
     ROUNDING_BUY_CONTEXT,
@@ -45,13 +45,45 @@ class SettlementDataCtx:
     starknet_domain: StarknetDomain
 
 
-def __calc_settlement_expiration(expiration_timestamp: datetime):
+def calculate_order_settlement_expiration(expiration_timestamp: datetime):
     expire_time_with_buffer = expiration_timestamp + timedelta(days=14)
     expire_time_as_seconds = math.ceil(expire_time_with_buffer.timestamp())
 
     return expire_time_as_seconds
 
 
+def hash_limit_order(
+    amount_base: StarkAmount,
+    amount_quote: StarkAmount,
+    max_fee: StarkAmount,
+    nonce: int,
+    position_id: int,
+    expiration_timestamp: datetime,
+    public_key: int,
+    starknet_domain: StarknetDomain,
+) -> int:
+    synthetic_asset = amount_base.asset
+    collateral_asset = amount_quote.asset
+
+    return get_limit_order_msg_hash(
+        source_position_id=position_id,
+        receive_position_id=position_id,
+        base_asset_id=int(synthetic_asset.settlement_external_id, 16),
+        base_amount=amount_base.value,
+        quote_asset_id=int(collateral_asset.settlement_external_id, 16),
+        quote_amount=amount_quote.value,
+        fee_amount=max_fee.value,
+        fee_asset_id=int(collateral_asset.settlement_external_id, 16),
+        expiration=calculate_order_settlement_expiration(expiration_timestamp),
+        salt=nonce,
+        user_public_key=public_key,
+        domain_name=starknet_domain.name,
+        domain_version=starknet_domain.version,
+        domain_chain_id=starknet_domain.chain_id,
+        domain_revision=starknet_domain.revision,
+    )
+
+
 def hash_order(
     amount_synthetic: StarkAmount,
     amount_collateral: StarkAmount,
@@ -73,7 +105,7 @@ def hash_order(
         quote_amount=amount_collateral.value,
         fee_amount=max_fee.value,
         fee_asset_id=int(collateral_asset.settlement_external_id, 16),
-        expiration=__calc_settlement_expiration(expiration_timestamp),
+        expiration=calculate_order_settlement_expiration(expiration_timestamp),
         salt=nonce,
         user_public_key=public_key,
         domain_name=starknet_domain.name,

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/orders.py

@@ -109,6 +109,20 @@ class StarkSettlementModel(X10BaseModel):
     collateral_position: Decimal
 
 
+class LimitOrderSettlementModel(X10BaseModel):
+    base_amount: int
+    quote_amount: int
+    fee_amount: int
+    base_asset_id: HexValue
+    quote_asset_id: HexValue
+    fee_asset_id: HexValue
+    expiration_timestamp: int
+    nonce: int
+    receiver_position_id: int
+    sender_position_id: int
+    signature: SettlementSignatureModel
+
+
 class StarkDebuggingOrderAmountsModel(X10BaseModel):
     collateral_amount: Decimal
     fee_amount: Decimal

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/simple_client/simple_trading_client.py

@@ -13,15 +13,14 @@ from x10.perpetual.orders import (
     OpenOrderModel,
     OrderSide,
     OrderStatus,
+    OrderType,
     TimeInForce,
 )
 from x10.perpetual.stream_client.perpetual_stream_connection import (
     PerpetualStreamConnection,
 )
 from x10.perpetual.stream_client.stream_client import PerpetualStreamClient
-from x10.perpetual.trading_client.markets_information_module import (
-    MarketsInformationModule,
-)
+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
 
@@ -81,7 +80,7 @@ class BlockingTradingClient:
             )
         self.__endpoint_config = endpoint_config
         self.__account = account
-        self.__market_module = MarketsInformationModule(endpoint_config, api_key=account.api_key)
+        self.__market_module = InfoMarketsModule(endpoint_config, api_key=account.api_key)
         self.__orders_module = OrderManagementModule(endpoint_config, api_key=account.api_key)
         self.__markets: Union[None, Dict[str, MarketModel]] = None
         self.__stream_client: PerpetualStreamClient = PerpetualStreamClient(api_url=endpoint_config.stream_url)
@@ -203,6 +202,8 @@ class BlockingTradingClient:
         builder_fee: Decimal | None = None,
         builder_id: int | None = None,
         time_in_force: TimeInForce = TimeInForce.GTT,
+        reduce_only: bool = False,
+        order_type: OrderType = OrderType.LIMIT,
     ) -> TimedOpenOrderModel:
         market = (await self.get_markets()).get(market_name)
         if not market:
@@ -211,10 +212,12 @@ class BlockingTradingClient:
         order: NewOrderModel = create_order_object(
             account=self.__account,
             market=market,
+            order_type=order_type,
             amount_of_synthetic=amount_of_synthetic,
             price=price,
             side=side,
             post_only=post_only,
+            reduce_only=reduce_only,
             previous_order_external_id=previous_order_external_id,
             starknet_domain=self.__endpoint_config.starknet_domain,
             order_external_id=external_id,

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/trading_client/account_module.py

@@ -7,7 +7,7 @@ from x10.perpetual.assets import (
     AssetOperationStatus,
     AssetOperationType,
 )
-from x10.perpetual.balances import BalanceModel
+from x10.perpetual.balances import BalanceModel, SpotBalanceModel
 from x10.perpetual.bridges import BridgesConfig, Quote
 from x10.perpetual.clients import ClientModel
 from x10.perpetual.fees import TradingFeeModel
@@ -125,6 +125,16 @@ class AccountModule(BaseModule):
 
         return await send_get_request(await self.get_session(), url, list[OpenOrderModel], api_key=self._get_api_key())
 
+    async def get_spot_balances(self) -> WrappedApiResponse[List[SpotBalanceModel]]:
+        """
+        https://api.docs.extended.exchange/#get-spot-balance
+        """
+
+        url = self._get_url("/user/spot/balances")
+        return await send_get_request(
+            await self.get_session(), url, List[SpotBalanceModel], api_key=self._get_api_key()
+        )
+
     async def get_trades(
         self,
         market_names: Optional[List[str]] = None,

x10_python_trading_starknet-1.2.0/x10/perpetual/trading_client/markets_information_module.py → x10_python_trading_starknet-1.3.0/x10/perpetual/trading_client/info_markets_module.py

@@ -10,7 +10,7 @@ from x10.utils.date import to_epoch_millis
 from x10.utils.http import send_get_request
 
 
-class MarketsInformationModule(BaseModule):
+class InfoMarketsModule(BaseModule):
     async def get_markets(self, *, market_names: Optional[List[str]] = None):
         """
         https://api.docs.extended.exchange/#get-markets

x10_python_trading_starknet-1.3.0/x10/perpetual/trading_client/info_module.py

@@ -0,0 +1,29 @@
+from decimal import Decimal
+from typing import List
+
+from x10.perpetual.assets import AssetModel
+from x10.perpetual.trading_client.base_module import BaseModule
+from x10.utils.http import send_get_request
+from x10.utils.model import X10BaseModel
+
+
+class _SettingsModel(X10BaseModel):
+    stark_ex_contract_address: str
+
+
+class InfoModule(BaseModule):
+    async def get_settings(self):
+        url = self._get_url("/info/settings")
+        return await send_get_request(await self.get_session(), url, _SettingsModel)
+
+    async def get_assets(self):
+        url = self._get_url("/info/assets")
+        return await send_get_request(await self.get_session(), url, List[AssetModel])
+
+    async def get_assets_dict(self):
+        assets = await self.get_assets()
+        return {asset.name: asset for asset in assets.data}
+
+    async def get_asset_price(self, *, asset_name: str):
+        url = self._get_url("/info/assets/<asset_name>/price", asset_name=asset_name)
+        return await send_get_request(await self.get_session(), url, Decimal)

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/trading_client/trading_client.py

@@ -14,12 +14,11 @@ from x10.perpetual.orders import (
     TimeInForce,
 )
 from x10.perpetual.trading_client.account_module import AccountModule
+from x10.perpetual.trading_client.info_markets_module import InfoMarketsModule
 from x10.perpetual.trading_client.info_module import InfoModule
-from x10.perpetual.trading_client.markets_information_module import (
-    MarketsInformationModule,
-)
 from x10.perpetual.trading_client.order_management_module import OrderManagementModule
 from x10.perpetual.trading_client.testnet_module import TestnetModule
+from x10.perpetual.trading_client.vault_module import VaultModule
 from x10.utils.date import utc_now
 from x10.utils.http import WrappedApiResponse
 from x10.utils.log import get_logger
@@ -33,14 +32,16 @@ class PerpetualTradingClient:
     """
 
     __markets: Dict[str, MarketModel] | None
-    __stark_account: StarkPerpetualAccount
+
+    __config: EndpointConfig
+    __stark_account: StarkPerpetualAccount | None
 
     __info_module: InfoModule
-    __markets_info_module: MarketsInformationModule
+    __info_markets_module: InfoMarketsModule
     __account_module: AccountModule
     __order_management_module: OrderManagementModule
+    __vault_module: VaultModule
     __testnet_module: TestnetModule
-    __config: EndpointConfig
 
     async def place_order(
         self,
@@ -65,7 +66,7 @@ class PerpetualTradingClient:
             raise ValueError("Stark account is not set")
 
         if not self.__markets:
-            self.__markets = await self.__markets_info_module.get_markets_dict()
+            self.__markets = await self.__info_markets_module.get_markets_dict()
 
         market = self.__markets.get(market_name)
 
@@ -98,24 +99,43 @@ class PerpetualTradingClient:
         return await self.__order_management_module.place_order(order)
 
     async def close(self):
-        await self.__markets_info_module.close_session()
+        await self.__info_markets_module.close_session()
         await self.__account_module.close_session()
         await self.__order_management_module.close_session()
 
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.close()
+
     def __init__(self, endpoint_config: EndpointConfig, stark_account: StarkPerpetualAccount | None = None):
         api_key = stark_account.api_key if stark_account else None
 
+        self.__config = endpoint_config
         self.__markets = None
-
-        if stark_account:
-            self.__stark_account = stark_account
+        self.__stark_account = stark_account
 
         self.__info_module = InfoModule(endpoint_config)
-        self.__markets_info_module = MarketsInformationModule(endpoint_config, api_key=api_key)
+        self.__info_markets_module = InfoMarketsModule(endpoint_config, api_key=api_key)
         self.__account_module = AccountModule(endpoint_config, api_key=api_key, stark_account=stark_account)
         self.__order_management_module = OrderManagementModule(endpoint_config, api_key=api_key)
+        self.__vault_module = VaultModule(
+            endpoint_config,
+            info_module=self.__info_module,
+            account_module=self.__account_module,
+            account=stark_account,
+            api_key=api_key,
+        )
         self.__testnet_module = TestnetModule(endpoint_config, api_key=api_key, account_module=self.__account_module)
-        self.__config = endpoint_config
+
+    @property
+    def config(self):
+        return self.__config
+
+    @property
+    def stark_account(self):
+        return self.__stark_account
 
     @property
     def info(self):
@@ -123,7 +143,7 @@ class PerpetualTradingClient:
 
     @property
     def markets_info(self):
-        return self.__markets_info_module
+        return self.__info_markets_module
 
     @property
     def account(self):
@@ -136,3 +156,7 @@ class PerpetualTradingClient:
     @property
     def testnet(self):
         return self.__testnet_module
+
+    @property
+    def vault(self):
+        return self.__vault_module

x10_python_trading_starknet-1.3.0/x10/perpetual/trading_client/vault_module.py

@@ -0,0 +1,177 @@
+import decimal
+from decimal import Decimal
+from types import NoneType
+from typing import Optional
+
+from x10.errors import X10Error
+from x10.perpetual.accounts import StarkPerpetualAccount
+from x10.perpetual.configuration import EndpointConfig
+from x10.perpetual.limit_order_object_settlement import create_order_settlement_data
+from x10.perpetual.orders import LimitOrderSettlementModel
+from x10.perpetual.trading_client.account_module import AccountModule
+from x10.perpetual.trading_client.base_module import BaseModule
+from x10.perpetual.trading_client.info_module import InfoModule
+from x10.utils.http import send_post_request
+from x10.utils.model import X10BaseModel
+
+# Protects from an error on shares pricing fluctuations.
+VAULT_SHARES_SLIPPAGE_PCT = Decimal("0.65")
+COLLATERAL_ASSET_NAME = "USD"
+
+
+class DepositRequestModel(X10BaseModel):
+    from_account_id: int
+    to_account_id: int
+    collateral: Decimal
+    shares: Decimal
+    settlement: LimitOrderSettlementModel
+
+
+class WithdrawRequestModel(X10BaseModel):
+    from_account_id: int
+    to_account_id: int
+    collateral: Decimal
+    shares: Decimal
+    settlement: LimitOrderSettlementModel
+
+
+class VaultModule(BaseModule):
+    def __init__(
+        self,
+        endpoint_config: EndpointConfig,
+        *,
+        info_module: InfoModule,
+        account_module: AccountModule,
+        account: Optional[StarkPerpetualAccount] = None,
+        api_key: Optional[str] = None,
+    ):
+        super().__init__(endpoint_config, api_key=api_key)
+
+        self._info_module = info_module
+        self._account_module = account_module
+        self._account = account
+
+    async def get_vault_share_balance(self) -> Decimal:
+        spot_balances = (await self._account_module.get_spot_balances()).data
+        if spot_balances is None:
+            raise X10Error("Failed to get spot balances")
+        vault_asset_balances = filter(lambda b: b.asset == self._get_endpoint_config().vault_asset_name, spot_balances)
+        total_vault_asset_balance = sum(map(lambda b: b.balance, vault_asset_balances), Decimal(0))
+        return total_vault_asset_balance
+
+    async def deposit_to_vault(self, *, collateral_amount: Decimal) -> None:
+        if self._account is None:
+            raise X10Error("Stark account is required for vault operations")
+
+        account_info = (await self._account_module.get_account()).data
+        assets = await self._info_module.get_assets_dict()
+        vault_asset_price = (
+            await self._info_module.get_asset_price(asset_name=self._get_endpoint_config().vault_asset_name)
+        ).data
+
+        assert account_info is not None
+        assert vault_asset_price is not None
+
+        position_id = account_info.l2_vault
+        collateral_asset = assets[COLLATERAL_ASSET_NAME]
+        vault_asset = assets[self._get_endpoint_config().vault_asset_name]
+        vault_shares_expected = self.__calc_vault_shares_expected(
+            collateral_amount,
+            vault_asset_price,
+            vault_asset.precision,
+        )
+
+        settlement, collateral_amount_human, shares_amount_human = create_order_settlement_data(
+            quote_amount=collateral_amount,
+            base_amount=vault_shares_expected,
+            position_id=position_id,
+            quote_asset_model=collateral_asset,
+            base_asset_model=vault_asset,
+            starknet_account=self._account,
+            starknet_domain=self._get_endpoint_config().starknet_domain,
+            is_buy=True,
+        )
+        deposit_request = DepositRequestModel(
+            from_account_id=account_info.id,
+            to_account_id=account_info.id,
+            collateral=abs(collateral_amount_human.value),
+            shares=abs(shares_amount_human.value),
+            settlement=settlement,
+        )
+
+        url = self._get_url("/vault/user/deposits")
+        resp = await send_post_request(
+            await self.get_session(),
+            url,
+            NoneType,
+            json=deposit_request.to_api_request_json(exclude_none=True),
+            api_key=self._get_api_key(),
+        )
+
+        if resp.error is not None:
+            raise X10Error(f"Deposit error: {resp.error}")
+
+    async def withdraw_from_vault(self, *, shares_amount: Decimal) -> None:
+        if self._account is None:
+            raise X10Error("Stark account is required for vault operations")
+
+        assets = await self._info_module.get_assets_dict()
+        account_info = (await self._account_module.get_account()).data
+        vault_asset_price = (
+            await self._info_module.get_asset_price(asset_name=self._get_endpoint_config().vault_asset_name)
+        ).data
+
+        assert account_info is not None
+        assert vault_asset_price is not None
+
+        position_id = account_info.l2_vault
+        collateral_asset = assets[COLLATERAL_ASSET_NAME]
+        vault_asset = assets[self._get_endpoint_config().vault_asset_name]
+        collateral_amount_expected = self.__calc_collateral_amount_expected(
+            shares_amount,
+            vault_asset_price,
+            vault_asset.precision,
+        )
+
+        settlement, collateral_amount_human, shares_amount_human = create_order_settlement_data(
+            quote_amount=collateral_amount_expected,
+            base_amount=shares_amount,
+            position_id=position_id,
+            quote_asset_model=collateral_asset,
+            base_asset_model=vault_asset,
+            starknet_account=self._account,
+            starknet_domain=self._get_endpoint_config().starknet_domain,
+            is_buy=False,
+        )
+        withdraw_request = WithdrawRequestModel(
+            from_account_id=account_info.id,
+            to_account_id=account_info.id,
+            collateral=abs(collateral_amount_human.value),
+            shares=abs(shares_amount_human.value),
+            settlement=settlement,
+        )
+        url = self._get_url("/vault/user/withdrawals")
+        resp = await send_post_request(
+            await self.get_session(),
+            url,
+            NoneType,
+            json=withdraw_request.to_api_request_json(exclude_none=True),
+            api_key=self._get_api_key(),
+        )
+
+        if resp.error is not None:
+            raise X10Error(f"Withdraw error: {resp.error}")
+
+    @staticmethod
+    def __calc_vault_shares_expected(
+        collateral_amount: Decimal, vault_asset_price: Decimal, vault_asset_precision: int
+    ) -> Decimal:
+        shares = collateral_amount / vault_asset_price * VAULT_SHARES_SLIPPAGE_PCT
+        return shares.quantize(Decimal("10") ** -vault_asset_precision, rounding=decimal.ROUND_FLOOR)
+
+    @staticmethod
+    def __calc_collateral_amount_expected(
+        shares_amount: Decimal, vault_asset_price: Decimal, collateral_asset_precision: int
+    ) -> Decimal:
+        collateral_amount = shares_amount * vault_asset_price * VAULT_SHARES_SLIPPAGE_PCT
+        return collateral_amount.quantize(Decimal("10") ** -collateral_asset_precision, rounding=decimal.ROUND_FLOOR)

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/perpetual/transfer_object.py

@@ -29,6 +29,7 @@ def calc_expiration_timestamp():
     return expire_time_with_buffer_seconds
 
 
+# FIXME: Transfers are broken
 def create_transfer_object(
     from_vault: int,
     to_vault: int,
@@ -76,5 +77,5 @@ def create_transfer_object(
         to_vault=to_vault,
         amount=amount,
         settlement=settlement,
-        transferred_asset=config.collateral_asset_id,
+        transferred_asset=config.collateral_asset_on_chain_id,
     )

{x10_python_trading_starknet-1.2.0 → x10_python_trading_starknet-1.3.0}/x10/utils/http.py

@@ -1,5 +1,6 @@
 import itertools
 import re
+from types import NoneType
 from typing import Any, Dict, Generic, List, Optional, Sequence, Type, TypeVar, Union
 
 import aiohttp
@@ -16,7 +17,7 @@ from x10.utils.model import X10BaseModel
 LOGGER = get_logger(__name__)
 CLIENT_TIMEOUT = ClientTimeout(total=DEFAULT_REQUEST_TIMEOUT_SECONDS)
 
-ApiResponseType = TypeVar("ApiResponseType", bound=Union[int, X10BaseModel, Sequence[X10BaseModel]])
+ApiResponseType = TypeVar("ApiResponseType", bound=Union[int, X10BaseModel, Sequence[X10BaseModel], None])
 
 
 class RateLimitException(X10Error):
@@ -89,6 +90,13 @@ def parse_response_to_model(
 ) -> WrappedApiResponse[ApiResponseType]:
     # Read this to get more context re the type ignore:
     # https://github.com/python/mypy/issues/13619
+
+    if model_class == NoneType:
+        return WrappedApiResponse[None](
+            status=ResponseStatus.OK,
+            data=None,
+        )  # type: ignore
+
     return WrappedApiResponse[model_class].model_validate_json(response_text)  # type: ignore[valid-type]
 
 

x10_python_trading_starknet-1.2.0/x10/perpetual/trading_client/info_module.py

@@ -1,13 +0,0 @@
-from x10.perpetual.trading_client.base_module import BaseModule
-from x10.utils.http import send_get_request
-from x10.utils.model import X10BaseModel
-
-
-class _SettingsModel(X10BaseModel):
-    stark_ex_contract_address: str
-
-
-class InfoModule(BaseModule):
-    async def get_settings(self):
-        url = self._get_url("/info/settings")
-        return await send_get_request(await self.get_session(), url, _SettingsModel)