Add StarkNet order signing functionality

Makefile

@@ -3,25 +3,6 @@ format:
 	black --target-version py310 --line-length 120 ./examples ./tests ./x10
 
 lint:
-	safety check \
-		-i 51457 \
-		-i 64227 \
-		-i 64396 \
-		-i 64459 \
-		-i 64642 \
-		-i 65693 \
-		-i 66742 \
-		-i 67599 \
-		-i 67895 \
-		-i 70612 \
-		-i 70630 \
-		-i 71064 \
-		-i 71545 \
-		-i 71591 \
-		-i 71608 \
-		-i 73456 \
-		-i 74251 \
-		-i 76752
 	black --check --diff --target-version py310 --line-length 120 ./examples ./tests ./x10
 	flake8 ./examples ./tests ./x10
 	mypy

README.md

@@ -7,7 +7,7 @@ Minimum Python version required to use this library is `3.10` (you can use [pyen
 ## Installation 
 
 ```shell
-pip install x10-python-trading
+pip install x10-python-trading-starknet
 ```
 
 Our SDK makes use of a [Rust Library](https://github.com/x10xchange/stark-crypto-wrapper) to accelerate signing and hashing of stark components. Currently this library supports the following environments
@@ -19,7 +19,7 @@ Our SDK makes use of a [Rust Library](https://github.com/x10xchange/stark-crypto
 | linux (glibc) - arm64 |   ✅   |   ✅   |   ✅   |   ✅   |
 | linux (musl) - arm64  |   ✅   |   ✅   |   ✅   |   ✅   |
 | OSX - arm64           |   ✅   |   ✅   |   ✅   |   ✅   |
-| windows - x86         |   ⚠️   |   ⚠️   |   ⚠️   |   ⚠️   |
+| windows - x86         |   ✅   |   ✅   |   ✅   |   ✅   |
 | windows - arm64       |   ⚠️   |   ⚠️   |   ⚠️   |   ⚠️   |
 
 

examples/market_maker_example.py

@@ -0,0 +1,117 @@
+import asyncio
+import math
+from decimal import Decimal
+
+from eth_account import Account
+from eth_account.signers.local import LocalAccount
+
+from x10.perpetual.accounts import StarkPerpetualAccount
+from x10.perpetual.configuration import STARKNET_TESTNET_CONFIG
+from x10.perpetual.orders import OrderSide
+from x10.perpetual.trading_client.trading_client import PerpetualTradingClient
+from x10.perpetual.user_client.user_client import UserClient
+
+
+async def build_markets_cache(trading_client: PerpetualTradingClient):
+    markets = await trading_client.markets_info.get_markets()
+    assert markets.data is not None
+    return {m.name: m for m in markets.data}
+
+
+# flake8: noqa
+async def on_board_example():
+    environment_config = STARKNET_TESTNET_CONFIG
+    eth_account_1: LocalAccount = Account.from_key("<YOUR_ETH_PRIVATE_KEY>")
+    onboarding_client = UserClient(endpoint_config=environment_config, l1_private_key=eth_account_1.key.hex)
+    root_account = await onboarding_client.onboard()
+
+    trading_key = await onboarding_client.create_account_api_key(root_account.account, "trading_key")
+
+    root_trading_client = PerpetualTradingClient(
+        environment_config,
+        StarkPerpetualAccount(
+            vault=root_account.account.l2_vault,
+            private_key=root_account.l2_key_pair.private_hex,
+            public_key=root_account.l2_key_pair.public_hex,
+            api_key=trading_key,
+        ),
+    )
+
+    print(f"User 1 v: {root_account.account.l2_vault}")
+    print(f"User 1 pub: {root_account.l2_key_pair.public_hex}")
+    print(f"User 1 priv: {root_account.l2_key_pair.private_hex}")
+
+    while True:
+        markets = await build_markets_cache(root_trading_client)
+        try:
+            for market in markets.values():
+                print(f"Market: {market.name}")
+                price_offset = (Decimal(hash(market.name) % 3 - 1) / Decimal(100)) * Decimal(1)
+                await root_trading_client.orders.mass_cancel(
+                    markets=[market.name],
+                )
+
+                if "BTC" not in market.name:  # Example for a specific market
+                    print(f"Skipping {market.name} market")
+                    continue
+
+                mark_price = market.market_stats.mark_price
+                print(f"Mark Price: {mark_price}")
+                print(f"price offset: {price_offset}")
+                print(f"Min order size: {market.trading_config.min_order_size}")
+                base_target = market.trading_config.max_position_value / Decimal(1000)
+                sell_prices = [
+                    (
+                        Decimal(base_target * (i + 1)),
+                        round(
+                            mark_price + mark_price * Decimal((i * 0.2) / 100.0) + price_offset * mark_price,
+                            market.trading_config.price_precision,
+                        ),
+                    )
+                    for i in range(10)
+                ]
+                buy_prices = [
+                    (
+                        Decimal(base_target * (i + 1)),
+                        round(
+                            mark_price - mark_price * Decimal((i * 0.2) / 100.0) + price_offset * mark_price,
+                            market.trading_config.price_precision,
+                        ),
+                    )
+                    for i in range(10)
+                ]
+
+                for target_value, sell_price in sell_prices:
+                    order_size = order_size = market.trading_config.calculate_order_size_from_value(
+                        order_value=target_value, order_price=sell_price
+                    )
+                    print(f"Sell Price: {sell_price}, order size: {order_size}")
+                    try:
+                        order_response_1 = await root_trading_client.place_order(
+                            market_name=market.name,
+                            amount_of_synthetic=order_size,
+                            price=sell_price,
+                            side=OrderSide.SELL,
+                        )
+                    except Exception as e:
+                        print(f"Error: {e}")
+                for target_value, buy_price in buy_prices:
+                    order_size = market.trading_config.calculate_order_size_from_value(
+                        order_value=target_value, order_price=buy_price
+                    )
+                    print(f"Buy Price: {buy_price}, order size: {order_size}")
+                    try:
+                        order_response_2 = await root_trading_client.place_order(
+                            market_name=market.name,
+                            amount_of_synthetic=order_size,
+                            price=buy_price,
+                            side=OrderSide.BUY,
+                        )
+                    except Exception as e:
+                        print(f"Error: {e}")
+                await asyncio.sleep(30)
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+asyncio.run(on_board_example())

examples/onboarding_example.py

@@ -1,79 +1,41 @@
 import asyncio
-from decimal import Decimal
 
 from eth_account import Account
 from eth_account.signers.local import LocalAccount
 
 from x10.perpetual.accounts import StarkPerpetualAccount
-from x10.perpetual.assets import AssetOperationType
-from x10.perpetual.configuration import TESTNET_CONFIG
-from x10.perpetual.contract import call_erc20_approve, call_stark_perpetual_deposit
+from x10.perpetual.configuration import STARKNET_TESTNET_CONFIG
 from x10.perpetual.trading_client.trading_client import PerpetualTradingClient
 from x10.perpetual.user_client.user_client import UserClient
 
 
-# flake8: noqa
 async def on_board_example():
-    environment_config = TESTNET_CONFIG
-    eth_account: LocalAccount = Account.from_key("<your private key>")
-    user_client = UserClient(endpoint_config=environment_config, l1_private_key=eth_account.key.hex)
-    onboarded_user = await user_client.onboard()
-    sub_account_1 = await user_client.onboard_subaccount(1, "sub account 1")
+    environment_config = STARKNET_TESTNET_CONFIG
+    eth_account_1: LocalAccount = Account.from_key("YOUR_ETH_PRIVATE_KEY")
+    onboarding_client = UserClient(endpoint_config=environment_config, l1_private_key=eth_account_1.key.hex)
+    root_account = await onboarding_client.onboard()
 
-    default_api_key = await user_client.create_account_api_key(onboarded_user.account, "trading api key")
-    account_1_api_key = await user_client.create_account_api_key(sub_account_1.account, "sub account 1 api key")
+    trading_key = await onboarding_client.create_account_api_key(root_account.account, "trading_key")
 
-    default_account_trading_client = PerpetualTradingClient(
+    root_trading_client = PerpetualTradingClient(
         environment_config,
         StarkPerpetualAccount(
-            vault=onboarded_user.account.l2_vault,
-            private_key=onboarded_user.l2_key_pair.private_hex,
-            public_key=onboarded_user.l2_key_pair.public_hex,
-            api_key=default_api_key,
+            vault=root_account.account.l2_vault,
+            private_key=root_account.l2_key_pair.private_hex,
+            public_key=root_account.l2_key_pair.public_hex,
+            api_key=trading_key,
         ),
     )
 
-    sub_account_1_trading_client = PerpetualTradingClient(
-        environment_config,
-        StarkPerpetualAccount(
-            vault=sub_account_1.account.l2_vault,
-            private_key=sub_account_1.l2_key_pair.private_hex,
-            public_key=sub_account_1.l2_key_pair.public_hex,
-            api_key=account_1_api_key,
-        ),
-    )
-
-    call_erc20_approve(
-        human_readable_amount=Decimal("1000"), get_eth_private_key=eth_account.key.hex, config=environment_config
-    )
-
-    await default_account_trading_client.account.deposit(
-        human_readable_amount=Decimal("1000"),
-        get_eth_private_key=eth_account.key.hex,
-    )
-
-    default_account_trading_client.account.transfer(
-        to_vault=int(sub_account_1.account.l2_vault),
-        to_l2_key=sub_account_1.l2_key_pair.public_hex,
-        amount=Decimal("10"),
-    )
-
-    created_withdrawal_id = await default_account_trading_client.account.slow_withdrawal(
-        amount=Decimal("10"),
-        eth_address=eth_account.address,
-    )
-
-    withdrawals = await default_account_trading_client.account.asset_operations(
-        operations_type=[AssetOperationType.SLOW_WITHDRAWAL],
-    )
-
-    #### wait until withdrawal is in status READY_FOR_CLAIM
-
-    available_withdrawal_balance = await user_client.available_l1_withdrawal_balance()
-
-    withdrawal_tx_hash = await user_client.perform_l1_withdrawal()
+    print(f"User 1 v: {root_account.account.l2_vault}")
+    print(f"User 1 pub: {root_account.l2_key_pair.public_hex}")
+    print(f"User 1 priv: {root_account.l2_key_pair.private_hex}")
+    claim_response = await root_trading_client.testnet.claim_testing_funds()
+    claim_id = claim_response.data.id if claim_response.data else None
+    print(f"Claim ID: {claim_id}")
 
-    print()
+    resp = await root_trading_client.account.asset_operations(id=claim_id)
+    print(f"Asset Operations: {resp.data}")
 
 
 asyncio.run(on_board_example())

examples/placed_order_example_advanced.py

@@ -105,7 +105,9 @@ async def place_order(
     price = Decimal("0.660") - Decimal("0.00" + str(i)) if should_buy else Decimal("0.6601") + Decimal("0.00" + str(i))
     order_side = OrderSide.BUY if should_buy else OrderSide.SELL
     market = markets_cache[ADA_USD_MARKET]
-    new_order = create_order_object(stark_account, market, Decimal("100"), price, order_side)
+    new_order = create_order_object(
+        stark_account, market, Decimal("100"), price, order_side, starknet_domain=TESTNET_CONFIG.starknet_domain
+    )
     order_condtions[new_order.id] = asyncio.Condition()
     return new_order.id, await trading_client.orders.place_order(order=new_order)
 

examples/simple_client_example.py

@@ -20,19 +20,20 @@ async def setup_and_run():
         api_key=api_key,
     )
 
-    client = BlockingTradingClient(endpoint_config=TESTNET_CONFIG, account=stark_account)
+    client = await BlockingTradingClient.create(endpoint_config=TESTNET_CONFIG, account=stark_account)
 
     placed_order = await client.create_and_place_order(
         amount_of_synthetic=Decimal("1"),
         price=Decimal("62133.6"),
         market_name="BTC-USD",
         side=OrderSide.BUY,
         post_only=False,
+        external_id="test_order_123",
     )
 
     print(placed_order)
 
-    await client.cancel_order(placed_order.id)
+    await client.cancel_order(order_external_id=placed_order.external_id)
 
 
 if __name__ == "__main__":