lighter-sdk 0.1.0__py3-none-any.whl

lighter/signer_client.py

@@ -0,0 +1,440 @@
+import ctypes
+import platform
+import logging
+import os
+import time
+
+from eth_account import Account
+import lighter
+from lighter.configuration import Configuration
+from lighter.models import TxHash
+from lighter.transactions import CreateOrder, CancelOrder, Withdraw
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+class SignerClient:
+    USDC_TICKER_SCALE = 1e6
+
+    TX_TYPE_CREATE_SUB_ACCOUNT = 9
+    TX_TYPE_CREATE_PUBLIC_POOL = 10
+    TX_TYPE_UPDATE_PUBLIC_POOL = 11
+    TX_TYPE_TRANSFER = 12
+    TX_TYPE_WITHDRAW = 13
+    TX_TYPE_CREATE_ORDER = 14
+    TX_TYPE_CANCEL_ORDER = 15
+    TX_TYPE_CANCEL_ALL_ORDERS = 16
+    TX_TYPE_MODIFY_ORDER = 17
+    TX_TYPE_MINT_SHARES = 18
+    TX_TYPE_BURN_SHARES = 19
+
+    ORDER_TYPE_LIMIT = 0
+    ORDER_TYPE_MARKET = 1
+    ORDER_TYPE_STOP_LOSS = 2
+    ORDER_TYPE_STOP_LOSS_LIMIT = 3
+    ORDER_TYPE_TAKE_PROFIT = 4
+    ORDER_TYPE_TAKE_PROFIT_LIMIT = 5
+    ORDER_TYPE_TWAP = 6
+
+    ORDER_TIME_IN_FORCE_IMMEDIATE_OR_CANCEL = 0
+    ORDER_TIME_IN_FORCE_GOOD_TILL_TIME = 1
+    ORDER_TIME_IN_FORCE_POST_ONLY = 2
+
+    NIL_TRIGGER_PRICE = 0
+    DEFAULT_28_DAY_ORDER_EXPIRY = -1
+    DEFAULT_10_MIN_AUTH_EXPIRY = -1
+    MINUTE = 60
+
+    def __init__(
+        self, url, private_key, chain_id=300, api_key_index=0, account_index=-1
+    ):
+        if private_key.startswith("0x"):
+            private_key = private_key[2:]
+        self.url = url
+        self.private_key = private_key
+        self.chain_id = chain_id
+        self.api_key_index = api_key_index
+        self.account_index = account_index
+        self.signer = self._initialize_signer()
+        self.api_client = lighter.ApiClient(configuration=Configuration(host=url))
+        self.tx_api = lighter.TransactionApi(self.api_client)
+        self.create_client()
+        self.l1_address = Account.from_key(private_key).address
+
+    def _initialize_signer(self):
+        is_linux = platform.system() == "Linux"
+        is_mac = platform.system() == "Darwin"
+        is_x64 = platform.machine().lower() in ("amd64", "x86_64")
+        is_arm = platform.machine().lower() == "arm64"
+
+        current_file_directory = os.path.dirname(os.path.abspath(__file__))
+        path_to_signer_folders = os.path.join(current_file_directory, "signers")
+
+        if is_arm and is_mac:
+            logging.debug("Detected ARM architecture on macOS.")
+            return ctypes.CDLL(
+                os.path.join(path_to_signer_folders, "signer-arm64.dylib")
+            )
+        elif is_linux and is_x64:
+            logging.debug("Detected x64/amd architecture on Linux.")
+            return ctypes.CDLL(os.path.join(path_to_signer_folders, "signer-amd64.so"))
+        else:
+            raise Exception(
+                f"Unsupported platform/architecture: {platform.system()}/{platform.machine()} only supports Linux(x86) and Darwin(arm64)"
+            )
+
+    async def set_account_index(self) -> int:
+        if self.account_index != -1:
+            return self.account_index
+
+        accounts = await lighter.AccountApi(self.api_client).accounts_by_l1_address(
+            l1_address=self.l1_address
+        )
+        if len(accounts.sub_accounts) > 0:
+            self.account_index = min(acc.index for acc in accounts.sub_accounts)
+            return self.account_index
+
+        return -1
+
+    def create_client(self):
+        self.signer.CreateClient.argtypes = [
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_longlong,
+        ]
+        self.signer.CreateClient.restype = ctypes.c_void_p
+        self.signer.CreateClient(
+            self.url.encode("utf-8"),
+            self.private_key.encode("utf-8"),
+            self.chain_id,
+            self.api_key_index,
+            self.account_index,
+        )
+
+    def sign_create_order(
+        self,
+        market_index,
+        client_order_index,
+        base_amount,
+        price,
+        is_ask,
+        order_type,
+        time_in_force,
+        reduce_only,
+        trigger_price,
+        order_expiry=DEFAULT_28_DAY_ORDER_EXPIRY,
+        nonce=-1,
+    ):
+        self.signer.SignCreateOrder.argtypes = [
+            ctypes.c_int,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignCreateOrder.restype = ctypes.c_char_p
+        return self.signer.SignCreateOrder(
+            market_index,
+            client_order_index,
+            base_amount,
+            price,
+            int(is_ask),
+            order_type,
+            time_in_force,
+            reduce_only,
+            trigger_price,
+            order_expiry,
+            nonce,
+        ).decode("utf-8")
+
+    def sign_cancel_order(self, market_index, order_index, nonce=-1):
+        self.signer.SignCancelOrder.argtypes = [
+            ctypes.c_int,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignCancelOrder.restype = ctypes.c_char_p
+        return self.signer.SignCancelOrder(market_index, order_index, nonce).decode(
+            "utf-8"
+        )
+
+    def sign_withdraw(self, usdc_amount, nonce=-1):
+        self.signer.SignWithdraw.argtypes = [ctypes.c_longlong, ctypes.c_longlong]
+        self.signer.SignWithdraw.restype = ctypes.c_char_p
+        return self.signer.SignWithdraw(usdc_amount, nonce).decode("utf-8")
+
+    def sign_create_sub_account(self, nonce=-1):
+        self.signer.SignCreateSubAccount.argtypes = [ctypes.c_longlong]
+        self.signer.SignCreateSubAccount.restype = ctypes.c_char_p
+        return self.signer.SignCreateSubAccount(nonce).decode("utf-8")
+
+    def sign_cancel_all_orders(self, time_in_force, time, nonce=-1):
+        self.signer.SignCancelAllOrders.argtypes = [
+            ctypes.c_int,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignCancelAllOrders.restype = ctypes.c_char_p
+        return self.signer.SignCancelAllOrders(time_in_force, time, nonce).decode(
+            "utf-8"
+        )
+
+    def sign_modify_order(
+        self, market_index, order_index, base_amount, price, trigger_price, nonce=-1
+    ):
+        self.signer.SignModifyOrder.argtypes = [
+            ctypes.c_int,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignModifyOrder.restype = ctypes.c_char_p
+        return self.signer.SignModifyOrder(
+            market_index, order_index, base_amount, price, trigger_price, nonce
+        ).decode("utf-8")
+
+    def sign_transfer(self, to_account_index, usdc_amount, nonce=-1):
+        self.signer.SignTransfer.argtypes = [
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignTransfer.restype = ctypes.c_char_p
+        return self.signer.SignTransfer(to_account_index, usdc_amount, nonce).decode(
+            "utf-8"
+        )
+
+    def sign_create_public_pool(
+        self, operator_fee, initial_total_shares, min_operator_share_rate, nonce=-1
+    ):
+        self.signer.SignCreatePublicPool.argtypes = [
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignCreatePublicPool.restype = ctypes.c_char_p
+        return self.signer.SignCreatePublicPool(
+            operator_fee, initial_total_shares, min_operator_share_rate, nonce
+        ).decode("utf-8")
+
+    def sign_update_public_pool(
+        self, public_pool_index, status, operator_fee, min_operator_share_rate, nonce=-1
+    ):
+        self.signer.SignUpdatePublicPool.argtypes = [
+            ctypes.c_longlong,
+            ctypes.c_int,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignUpdatePublicPool.restype = ctypes.c_char_p
+        return self.signer.SignUpdatePublicPool(
+            public_pool_index, status, operator_fee, min_operator_share_rate, nonce
+        ).decode("utf-8")
+
+    def sign_mint_shares(self, public_pool_index, share_amount, nonce=-1):
+        self.signer.SignMintShares.argtypes = [
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignMintShares.restype = ctypes.c_char_p
+        return self.signer.SignMintShares(
+            public_pool_index, share_amount, nonce
+        ).decode("utf-8")
+
+    def sign_burn_shares(self, public_pool_index, share_amount, nonce=-1):
+        self.signer.SignBurnShares.argtypes = [
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignBurnShares.restype = ctypes.c_char_p
+        return self.signer.SignBurnShares(
+            public_pool_index, share_amount, nonce
+        ).decode("utf-8")
+
+    def sign_update_leverage(self, market_index, leverage, nonce=-1):
+        self.signer.SignUpdateLeverage.argtypes = [
+            ctypes.c_int,
+            ctypes.c_int,
+            ctypes.c_longlong,
+        ]
+        self.signer.SignUpdateLeverage.restype = ctypes.c_char_p
+        return self.signer.SignUpdateLeverage(market_index, leverage, nonce).decode(
+            "utf-8"
+        )
+
+    def create_auth_token_with_expiry(self, deadline: int=DEFAULT_10_MIN_AUTH_EXPIRY):
+        if deadline == SignerClient.DEFAULT_10_MIN_AUTH_EXPIRY:
+            deadline = int(time.time() + 10 * SignerClient.MINUTE)
+        self.signer.CreateAuthToken.argtypes = [ctypes.c_longlong]
+        self.signer.CreateAuthToken.restype = ctypes.c_char_p
+        return self.signer.CreateAuthToken(deadline).decode("utf-8")
+
+    async def create_order(
+        self,
+        market_index,
+        client_order_index,
+        base_amount,
+        price,
+        is_ask,
+        order_type,
+        time_in_force,
+        reduce_only=False,
+        trigger_price=NIL_TRIGGER_PRICE,
+        order_expiry=-1,
+        nonce=-1,
+    ) -> (CreateOrder, TxHash):
+        tx_info = self.sign_create_order(
+            market_index,
+            client_order_index,
+            base_amount,
+            price,
+            int(is_ask),
+            order_type,
+            time_in_force,
+            int(reduce_only),
+            trigger_price,
+            order_expiry,
+            nonce,
+        )
+        logging.debug(f"Create Order Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_CREATE_ORDER, tx_info=tx_info
+        )
+        logging.debug(f"Create Order Send Tx Response: {api_response}")
+        return CreateOrder.from_json(tx_info), api_response
+
+    async def cancel_order(
+        self, market_index, order_index, nonce=-1
+    ) -> (CancelOrder, TxHash):
+        tx_info = self.sign_cancel_order(market_index, order_index, nonce)
+        logging.debug(f"Cancel Order Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_CANCEL_ORDER, tx_info=tx_info
+        )
+        logging.debug(f"Cancel Order Send Tx Response: {api_response}")
+        return CancelOrder.from_json(tx_info), api_response
+
+    async def withdraw(self, usdc_amount, nonce=-1) -> (Withdraw, TxHash):
+        usdc_amount = int(usdc_amount * self.USDC_TICKER_SCALE)
+
+        tx_info = self.sign_withdraw(usdc_amount, nonce)
+        logging.debug(f"Withdraw Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_WITHDRAW, tx_info=tx_info
+        )
+        logging.debug(f"Withdraw Send Tx Response: {api_response}")
+        return Withdraw.from_json(tx_info), api_response
+
+    async def create_sub_account(self, nonce=-1):
+        tx_info = self.sign_create_sub_account(nonce)
+        logging.debug(f"Create Sub Account Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_CREATE_SUB_ACCOUNT, tx_info=tx_info
+        )
+        logging.debug(f"Create Sub Account Send Tx Response: {api_response}")
+        return api_response
+
+    async def cancel_all_orders(self, time_in_force, time, nonce=-1):
+        tx_info = self.sign_cancel_all_orders(time_in_force, time, nonce)
+        logging.debug(f"Cancel All Orders Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_CANCEL_ALL_ORDERS, tx_info=tx_info
+        )
+        logging.debug(f"Cancel All Orders Send Tx Response: {api_response}")
+        return api_response
+
+    async def modify_order(
+        self, market_index, order_index, base_amount, price, trigger_price, nonce=-1
+    ):
+        tx_info = self.sign_modify_order(
+            market_index, order_index, base_amount, price, trigger_price, nonce
+        )
+        logging.debug(f"Modify Order Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_MODIFY_ORDER, tx_info=tx_info
+        )
+        logging.debug(f"Modify Order Send Tx Response: {api_response}")
+        return api_response
+
+    async def transfer(self, to_account_index, usdc_amount, nonce=-1):
+        usdc_amount = int(usdc_amount * self.USDC_TICKER_SCALE)
+
+        tx_info = self.sign_transfer(to_account_index, usdc_amount, nonce)
+        logging.debug(f"Transfer Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_TRANSFER, tx_info=tx_info
+        )
+        logging.debug(f"Transfer Send Tx Response: {api_response}")
+        return api_response
+
+    async def create_public_pool(
+        self, operator_fee, initial_total_shares, min_operator_share_rate, nonce=-1
+    ):
+        tx_info = self.sign_create_public_pool(
+            operator_fee, initial_total_shares, min_operator_share_rate, nonce
+        )
+        logging.debug(f"Create Public Pool Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_CREATE_PUBLIC_POOL, tx_info=tx_info
+        )
+        logging.debug(f"Create Public Pool Send Tx Response: {api_response}")
+        return api_response
+
+    async def update_public_pool(
+        self, public_pool_index, status, operator_fee, min_operator_share_rate, nonce=-1
+    ):
+        tx_info = self.sign_update_public_pool(
+            public_pool_index, status, operator_fee, min_operator_share_rate, nonce
+        )
+        logging.debug(f"Update Public Pool Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_UPDATE_PUBLIC_POOL, tx_info=tx_info
+        )
+        logging.debug(f"Update Public Pool Send Tx Response: {api_response}")
+        return api_response
+
+    async def mint_shares(self, public_pool_index, share_amount, nonce=-1):
+        tx_info = self.sign_mint_shares(public_pool_index, share_amount, nonce)
+        logging.debug(f"Mint Shares Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_MINT_SHARES, tx_info=tx_info
+        )
+        logging.debug(f"Mint Shares Send Tx Response: {api_response}")
+        return api_response
+
+    async def burn_shares(self, public_pool_index, share_amount, nonce=-1):
+        tx_info = self.sign_burn_shares(public_pool_index, share_amount, nonce)
+        logging.debug(f"Burn Shares Tx Info: {tx_info}")
+
+        api_response = await self.tx_api.send_tx(
+            tx_type=self.TX_TYPE_BURN_SHARES, tx_info=tx_info
+        )
+        logging.debug(f"Burn Shares Send Tx Response: {api_response}")
+        return api_response
+
+    async def close(self):
+        await self.api_client.close()

lighter/transactions/__init__.py

@@ -0,0 +1,3 @@
+from lighter.transactions.cancel_order import CancelOrder
+from lighter.transactions.create_order import CreateOrder
+from lighter.transactions.withdraw import Withdraw

lighter/transactions/cancel_order.py

@@ -0,0 +1,27 @@
+import json
+from typing import Optional
+
+
+class CancelOrder:
+    def __init__(self):
+        self.account_index: Optional[int] = None
+        self.order_book_index: Optional[int] = None
+        self.order_nonce: Optional[int] = None
+        self.expired_at: Optional[int] = None
+        self.nonce: Optional[int] = None
+        self.sig: Optional[str] = None
+
+    @classmethod
+    def from_json(cls, json_str: str) -> 'CancelOrder':
+        params = json.loads(json_str)
+        self = cls()
+        self.account_index = params.get('AccountIndex')
+        self.order_book_index = params.get('OrderBookIndex')
+        self.order_nonce = params.get('OrderNonce')
+        self.expired_at = params.get('ExpiredAt')
+        self.nonce = params.get('Nonce')
+        self.sig = params.get('Sig')
+        return self
+
+    def to_json(self) -> str:
+        return json.dumps(self.__dict__, default=str)

lighter/transactions/create_order.py

@@ -0,0 +1,33 @@
+import json
+from typing import Optional
+
+
+class CreateOrder:
+    def __init__(self):
+        self.account_index: Optional[int] = None
+        self.order_book_index: Optional[int] = None
+        self.base_amount: Optional[int] = None
+        self.price: Optional[int] = None
+        self.is_ask: Optional[int] = None
+        self.order_type: Optional[int] = None
+        self.expired_at: Optional[int] = None
+        self.nonce: Optional[int] = None
+        self.sig: Optional[str] = None
+
+    @classmethod
+    def from_json(cls, json_str: str) -> 'CreateOrder':
+        params = json.loads(json_str)
+        self = cls()
+        self.account_index = params.get('AccountIndex')
+        self.order_book_index = params.get('OrderBookIndex')
+        self.base_amount = params.get('BaseAmount')
+        self.price = params.get('Price')
+        self.is_ask = params.get('IsAsk')
+        self.order_type = params.get('OrderType')
+        self.expired_at = params.get('ExpiredAt')
+        self.nonce = params.get('Nonce')
+        self.sig = params.get('Sig')
+        return self
+
+    def to_json(self) -> str:
+        return json.dumps(self.__dict__, default=str)

lighter/transactions/withdraw.py

@@ -0,0 +1,25 @@
+import json
+from typing import Optional
+
+
+class Withdraw:
+    def __init__(self):
+        self.from_account_index: Optional[int] = None
+        self.collateral_amount: Optional[int] = None
+        self.expired_at: Optional[int] = None
+        self.nonce: Optional[int] = None
+        self.sig: Optional[str] = None
+
+    @classmethod
+    def from_json(cls, json_str: str) -> 'Withdraw':
+        params = json.loads(json_str)
+        instance = cls()
+        instance.from_account_index = params.get('FromAccountIndex')
+        instance.collateral_amount = params.get('CollateralAmount')
+        instance.expired_at = params.get('ExpiredAt')
+        instance.nonce = params.get('Nonce')
+        instance.sig = params.get('Sig')
+        return instance
+
+    def to_json(self) -> str:
+        return json.dumps(self.__dict__, default=str)

lighter/ws_client.py

@@ -0,0 +1,160 @@
+import json
+from websockets.sync.client import connect
+from websockets.client import connect as connect_async
+from lighter.configuration import Configuration
+
+
+class WsClient:
+    def __init__(
+        self,
+        host=None,
+        path="/stream",
+        order_book_ids=[],
+        account_ids=[],
+        on_order_book_update=print,
+        on_account_update=print,
+    ):
+        if host is None:
+            host = Configuration.get_default().host.replace("https://", "")
+
+        self.base_url = f"wss://{host}{path}"
+
+        self.subscriptions = {
+            "order_books": order_book_ids,
+            "accounts": account_ids,
+        }
+
+        if len(order_book_ids) == 0 and len(account_ids) == 0:
+            raise Exception("No subscriptions provided.")
+
+        self.order_book_states = {}
+        self.account_states = {}
+
+        self.on_order_book_update = on_order_book_update
+        self.on_account_update = on_account_update
+
+        self.ws = None
+
+    def on_message(self, ws, message):
+        if isinstance(message, str):
+            message = json.loads(message)
+
+        message_type = message.get("type")
+
+        if message_type == "connected":
+            self.handle_connected(ws)
+        elif message_type == "subscribed/order_book":
+            self.handle_subscribed_order_book(message)
+        elif message_type == "update/order_book":
+            self.handle_update_order_book(message)
+        elif message_type == "subscribed/account_all":
+            self.handle_subscribed_account(message)
+        elif message_type == "update/account_all":
+            self.handle_update_account(message)
+        else:
+            self.handle_unhandled_message(message)
+
+    async def on_message_async(self, ws, message):
+        message = json.loads(message)
+        message_type = message.get("type")
+
+        if message_type == "connected":
+            await self.handle_connected_async(ws)
+        else:
+            self.on_message(ws, message)
+
+    def handle_connected(self, ws):
+        for market_id in self.subscriptions["order_books"]:
+            ws.send(
+                json.dumps({"type": "subscribe", "channel": f"order_book/{market_id}"})
+            )
+        for account_id in self.subscriptions["accounts"]:
+            ws.send(
+                json.dumps(
+                    {"type": "subscribe", "channel": f"account_all/{account_id}"}
+                )
+            )
+
+    async def handle_connected_async(self, ws):
+        for market_id in self.subscriptions["order_books"]:
+            await ws.send(
+                json.dumps({"type": "subscribe", "channel": f"order_book/{market_id}"})
+            )
+        for account_id in self.subscriptions["accounts"]:
+            await ws.send(
+                json.dumps(
+                    {"type": "subscribe", "channel": f"account_all/{account_id}"}
+                )
+            )
+
+    def handle_subscribed_order_book(self, message):
+        market_id = message["channel"].split(":")[1]
+        self.order_book_states[market_id] = message["order_book"]
+        if self.on_order_book_update:
+            self.on_order_book_update(market_id, self.order_book_states[market_id])
+
+    def handle_update_order_book(self, message):
+        market_id = message["channel"].split(":")[1]
+        self.update_order_book_state(market_id, message["order_book"])
+        if self.on_order_book_update:
+            self.on_order_book_update(market_id, self.order_book_states[market_id])
+
+    def update_order_book_state(self, market_id, order_book):
+        self.update_orders(
+            order_book["asks"], self.order_book_states[market_id]["asks"]
+        )
+        self.update_orders(
+            order_book["bids"], self.order_book_states[market_id]["bids"]
+        )
+
+    def update_orders(self, new_orders, existing_orders):
+        for new_order in new_orders:
+            is_new_order = True
+            for existing_order in existing_orders:
+                if new_order["price"] == existing_order["price"]:
+                    is_new_order = False
+                    existing_order["size"] = new_order["size"]
+                    if float(new_order["size"]) == 0:
+                        existing_orders.remove(existing_order)
+                    break
+            if is_new_order:
+                existing_orders.append(new_order)
+
+        existing_orders = [
+            order for order in existing_orders if float(order["size"]) > 0
+        ]
+
+    def handle_subscribed_account(self, message):
+        account_id = message["channel"].split(":")[1]
+        self.account_states[account_id] = message
+        if self.on_account_update:
+            self.on_account_update(account_id, self.account_states[account_id])
+
+    def handle_update_account(self, message):
+        account_id = message["channel"].split(":")[1]
+        self.account_states[account_id] = message
+        if self.on_account_update:
+            self.on_account_update(account_id, self.account_states[account_id])
+
+    def handle_unhandled_message(self, message):
+        raise Exception(f"Unhandled message: {message}")
+
+    def on_error(self, ws, error):
+        raise Exception(f"Error: {error}")
+
+    def on_close(self, ws, close_status_code, close_msg):
+        raise Exception(f"Closed: {close_status_code} {close_msg}")
+
+    def run(self):
+        ws = connect(self.base_url)
+        self.ws = ws
+
+        for message in ws:
+            self.on_message(ws, message)
+
+    async def run_async(self):
+        ws = await connect_async(self.base_url)
+        self.ws = ws
+
+        async for message in ws:
+            await self.on_message_async(ws, message)