siglab-py 0.1.9__tar.gz → 0.1.10__tar.gz

{siglab_py-0.1.9 → siglab_py-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siglab_py
-Version: 0.1.9
+Version: 0.1.10
 Summary: Market data fetches, TA calculations and generic order gateway.
 Author: r0bbarh00d
 Author-email: r0bbarh00d <r0bbarh00d@gmail.com>

{siglab_py-0.1.9 → siglab_py-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "siglab_py"
-version = "0.1.9"
+version = "0.1.10"
 description = "Market data fetches, TA calculations and generic order gateway."
 authors = [{name = "r0bbarh00d", email = "r0bbarh00d@gmail.com"}]
 license = {text = "MIT"}

{siglab_py-0.1.9 → siglab_py-0.1.10}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = siglab_py
-version = 0.1.9
+version = 0.1.10
 description = Market data fetches, TA calculations and generic order gateway.
 author = r0bbarh00d
 author_email = r0bbarh00d@gmail.com

{siglab_py-0.1.9 → siglab_py-0.1.10}/siglab_py/market_data_providers/aggregated_orderbook_provider.py

@@ -12,6 +12,8 @@ import numpy as np
 from redis import StrictRedis
 
 '''
+https://medium.com/@norman-lm-fung/aggregated-orderbooks-using-ccxt-and-rest-calls-to-cexes-7bfdc8400d05
+
 From command prompt:
     python aggregated_orderbook.py --normalized_symbol BTC/USDT:USDT --sliding_window_num_intervals 1200 --update_imabalce_csv_intervals 100 --dump_imbalance_to_disk Y --publish_imbalance_to_redis N
     or

{siglab_py-0.1.9 → siglab_py-0.1.10}/siglab_py/market_data_providers/deribit_options_expiry_provider.py

@@ -14,7 +14,9 @@ from redis import StrictRedis
 import pandas as pd
 
 from util.market_data_util import timestamp_to_datetime_cols, fetch_deribit_btc_option_expiries, fetch_ohlcv_one_candle
-
+'''
+https://medium.com/@norman-lm-fung/monitoring-incoming-deribit-open-interest-fd8c8d596ca0
+'''
 param : Dict = {
     'market' : 'BTC',
 

{siglab_py-0.1.9 → siglab_py-0.1.10}/siglab_py/ordergateway/client.py

@@ -123,7 +123,51 @@ class DivisiblePosition(Order):
         return filled_amount
 
     def get_average_cost(self) -> float:
-        average_cost = sum([ self.executions[order_id]['average'] * self.executions[order_id]['amount'] for order_id in self.executions ])
+        '''
+        Example hyperliquid don't have 'average' in response JSON:
+
+        {
+            'info': {
+                'order': {
+                        'coin': 'SUSHI', 
+                        'side': 'B', 
+                        'limitPx': '0.79252', 
+                        'sz': '0.0', 
+                        'oid': xxx, 
+                        'timestamp': xxx, 
+                        'origSz': '30.0'
+                    }, 
+                    'status': 'filled', 
+                    'statusTimestamp': xxx}, 
+                    'id': 'xxx', 
+                    'clientOrderId': None, 
+                    'timestamp': xxx, 
+                    'datetime': '2025-02-26T01:00:00.522Z', 
+                    'lastTradeTimestamp': None, 
+                    'lastUpdateTimestamp': xxx, 
+                    'symbol': 'SUSHI/USDC:USDC', 
+                    'type': None, 
+                    'timeInForce': None, 
+                    'postOnly': None, 
+                    'reduceOnly': None, 
+                    'side': 'buy', 
+                    'price': 0.79252, 
+                    'triggerPrice': None, 
+                    'amount': 30.0, 
+                    'cost': 23.7756, 
+                    'average': None, <-- No average cost?
+                    'filled': 30.0, 
+                    'remaining': 0.0, 
+                    'status': 'closed', 
+                    'fee': None, 
+                    'trades': [], 
+                    'fees': [], 
+                    'stopPrice': None, 
+                    'takeProfitPrice': None, 
+                    'stopLossPrice': None
+                }
+        '''
+        average_cost = sum([ (self.executions[order_id]['average'] if self.executions[order_id]['average'] else self.executions[order_id]['price']) * self.executions[order_id]['amount'] for order_id in self.executions ])
         average_cost = average_cost / sum([ self.executions[order_id]['amount'] for order_id in self.executions ])
         return average_cost
 

{siglab_py-0.1.9 → siglab_py-0.1.10}/siglab_py/ordergateway/gateway.py

@@ -12,6 +12,7 @@ import hashlib
 from collections import deque
 import logging
 import json
+import uuid
 from io import StringIO
 import re
 from re import Pattern
@@ -178,11 +179,12 @@ class LogLevel(Enum):
 
 param : Dict = {
     'gateway_id' : '---',
+    'dry_run' : False,
 
     "incoming_orders_topic_regex" : r"ordergateway_pending_orders_$GATEWAY_ID$", 
     "executions_publish_topic" : r"ordergateway_executions_$GATEWAY_ID$",
 
-    "fetch_order_status_poll_freq_ms" : 500,
+    "loop_freq_ms" : 500,
 
     'mds' : {
         'topics' : {
@@ -207,6 +209,39 @@ sh = logging.StreamHandler()
 sh.setLevel(log_level)
 sh.setFormatter(formatter)
 logger.addHandler(sh)
+fh = logging.FileHandler(f"ordergateway.log")
+fh.setLevel(log_level)
+fh.setFormatter(formatter)     
+logger.addHandler(fh)
+
+DUMMY_EXECUTION : Dict[str, Any] = {
+    "clientOrderId": None,
+    "timestamp": None,
+    "datetime": None,
+    "symbol": None,
+    "type": None,
+    "side": None,
+    "price": None,
+    "average": None,
+    "cost": None,
+    "amount": None,
+    "filled": None,
+    "remaining": None,
+    "status": "closed",
+    "fee": {
+        "cost": None,
+        "currency": "USDT"
+    },
+    "trades": [],
+    "reduceOnly": False,
+    "fees": [
+        {
+            "cost": 0,
+            "currency": "USDT"
+        }
+    ],
+    "multiplier": None
+}
 
 def log(message : str, log_level : LogLevel = LogLevel.INFO):
     if log_level.value<LogLevel.WARNING.value:
@@ -222,6 +257,7 @@ def parse_args():
     parser = argparse.ArgumentParser() # type: ignore
 
     parser.add_argument("--gateway_id", help="gateway_id: Where are you sending your order?", default=None)
+    parser.add_argument("--dry_run", help="Y or N (default, for testing). If Y, orders won't be dispatched to exchange, gateway will fake reply.", default='N')
     parser.add_argument("--default_type", help="default_type: spot, linear, inverse, futures ...etc", default='linear')
     parser.add_argument("--rate_limit_ms", help="rate_limit_ms: Check your exchange rules", default=100)
 
@@ -233,6 +269,15 @@ def parse_args():
 
     args = parser.parse_args()
     param['gateway_id'] = args.gateway_id
+
+    if args.dry_run:
+        if args.dry_run=='Y':
+            param['dry_run'] = True
+        else:
+            param['dry_run'] = False
+    else:
+        param['dry_run'] = False
+
     param['default_type'] = args.default_type
     param['rate_limit_ms'] = int(args.rate_limit_ms)
 
@@ -264,7 +309,7 @@ def init_redis_client() -> StrictRedis:
     
     return redis_client
 
-def instantiate_exchange(
+async def instantiate_exchange(
     gateway_id : str,
     api_key : str,
     secret : str,
@@ -306,12 +351,58 @@ def instantiate_exchange(
         # https://github.com/ccxt/ccxt/blob/master/python/ccxt/deribit.py#L360
         exchange = ccxtpro.deribit(exchange_params)  # type: ignore
     elif exchange_name=='hyperliquid':
-        # swap
-        # https://github.com/ccxt/ccxt/blob/master/python/ccxt/hyperliquid.py#L225
-        exchange = ccxtpro.hyperliquid(exchange_params)  # type: ignore
+        '''
+        https://app.hyperliquid.xyz/API
+        
+        defaultType from ccxt: swap
+            https://github.com/ccxt/ccxt/blob/master/python/ccxt/hyperliquid.py#L225
+        
+        How to integrate? You can skip first 6 min: https://www.youtube.com/watch?v=UuBr331wxr4&t=363s
+
+        Example, 
+            API credentials created under "\ More \ API":
+                    Ledger Arbitrum Wallet Address: 0xAAAAA <-- This is your Ledger Arbitrum wallet address with which you connect to Hyperliquid. 
+                    API Wallet Address 0xBBBBB <-- Generated
+                    privateKey 0xCCCCC
+
+        Basic connection via CCXT:
+            import asyncio
+            import ccxt.pro as ccxtpro
+
+            async def main():
+                rate_limit_ms = 100
+                exchange_params = {
+                    "walletAddress" : "0xAAAAA", # Ledger Arbitrum Wallet Address here! Not the generated address.
+                    "privateKey" : "0xCCCCC"
+                }
+                exchange = ccxtpro.hyperliquid(exchange_params) 
+                balances = await exchange.fetch_balance()
+                print(balances)
+
+            asyncio.run(main())
+        '''
+        exchange = ccxtpro.hyperliquid(
+            {
+                "walletAddress" : api_key,
+                "privateKey" : secret,
+                'enableRateLimit'  : True,
+                'rateLimit' : rate_limit_ms
+            }
+        )  # type: ignore
     else:
         raise ArgumentError(f"Unsupported exchange {exchange_name}, check gateway_id {gateway_id}.")
 
+    await exchange.load_markets() # type: ignore
+
+    '''
+    Is this necessary? The added trouble is for example bybit.authenticate requires arg 'url'. binance doesn't. And fetch_balance already test credentials.
+
+    try:
+        await exchange.authenticate() # type: ignore
+    except Exception as swallow_this_error:
+        pass
+    '''
+
     return exchange
 
 async def watch_orders_task(
@@ -329,7 +420,7 @@ async def watch_orders_task(
         except Exception as loop_err:
             print(f"watch_orders_task error: {loop_err}")
         
-        await asyncio.sleep(int(param['fetch_order_status_poll_freq_ms']/1000))
+        await asyncio.sleep(int(param['loop_freq_ms']/1000))
 
 async def execute_one_position(
     exchange : AnyExchange,
@@ -337,17 +428,11 @@ async def execute_one_position(
     param : Dict,
     executions : Dict[str, Dict[str, Any]]
 ):
-    await exchange.load_markets() # type: ignore
-    try:
-        await exchange.authenticate() # type: ignore
-    except Exception as swallow_this_error:
-        pass # @todo, perhaps a better way for handling this?
-
     market : Dict[str, Any] = exchange.markets[position.ticker] if position.ticker in exchange.markets else None # type: ignore
     if not market:
         raise ArgumentError(f"Market not found for {position.ticker} under {exchange.name}") # type: ignore
 
-    min_amount = float(market['limits']['amount']['min']) # type: ignore
+    min_amount = float(market['limits']['amount']['min']) if market['limits']['amount']['min'] else 0 # type: ignore
     multiplier = market['contractSize'] if 'contractSize' in market and market['contractSize'] else 1
     position.multiplier = multiplier
 
@@ -355,43 +440,77 @@ async def execute_one_position(
     i = 0
     for slice in slices:
         try:
+            dt_now : datetime = datetime.now()
+
             slice_amount_in_base_ccy : float = slice.amount
             rounded_slice_amount_in_base_ccy = slice_amount_in_base_ccy / multiplier # After devided by multiplier, rounded_slice_amount_in_base_ccy in number of contracts actually (Not in base ccy).
             rounded_slice_amount_in_base_ccy = exchange.amount_to_precision(position.ticker, rounded_slice_amount_in_base_ccy) # type: ignore
             rounded_slice_amount_in_base_ccy = float(rounded_slice_amount_in_base_ccy)
             rounded_slice_amount_in_base_ccy = rounded_slice_amount_in_base_ccy if rounded_slice_amount_in_base_ccy>min_amount else min_amount
 
-            limit_price : float = 0
-            rounded_limit_price : float = 0
+            orderbook = await exchange.fetch_order_book(symbol=position.ticker, limit=3) # type: ignore
+            if position.side=='buy':
+                asks = [ ask[0] for ask in orderbook['asks'] ]
+                best_asks = min(asks)
+                limit_price : float= best_asks * (1 + position.leg_room_bps/10000)
+            else:
+                bids = [ bid[0] for bid in orderbook['bids'] ]
+                best_bid = max(bids)
+                limit_price : float = best_bid * (1 - position.leg_room_bps/10000)
+                
+            rounded_limit_price : float = exchange.price_to_precision(position.ticker, limit_price) # type: ignore
+            rounded_limit_price = float(rounded_limit_price)
+            
             if position.order_type=='limit':
-                orderbook = await exchange.fetch_order_book(symbol=position.ticker, limit=3) # type: ignore
-                if position.side=='buy':
-                    asks = [ ask[0] for ask in orderbook['asks'] ]
-                    best_asks = min(asks)
-                    limit_price = best_asks * (1 + position.leg_room_bps/10000)
+                if not param['dry_run']:
+                    executed_order = await exchange.create_order( # type: ignore
+                        symbol = position.ticker,
+                        type = position.order_type,
+                        amount = rounded_slice_amount_in_base_ccy,
+                        price = rounded_limit_price,
+                        side = position.side
+                    )
                 else:
-                    bids = [ bid[0] for bid in orderbook['bids'] ]
-                    best_bid = max(bids)
-                    limit_price = best_bid * (1 - position.leg_room_bps/10000)
-                    
-                rounded_limit_price = exchange.price_to_precision(position.ticker, limit_price) # type: ignore
-                rounded_limit_price = float(rounded_limit_price)
-
-                executed_order = await exchange.create_order( # type: ignore
-                    symbol = position.ticker,
-                    type = position.order_type,
-                    amount = rounded_slice_amount_in_base_ccy,
-                    price = rounded_limit_price,
-                    side = position.side
-                )
+                    executed_order = DUMMY_EXECUTION.copy()
+                    executed_order['clientOrderId'] = str(uuid.uuid4())
+                    executed_order['timestamp'] = dt_now.timestamp()
+                    executed_order['datetime'] = dt_now
+                    executed_order['symbol'] = position.ticker
+                    executed_order['type'] = position.order_type
+                    executed_order['side'] = position.side
+                    executed_order['price'] = rounded_limit_price
+                    executed_order['average'] = rounded_limit_price
+                    executed_order['cost'] = 0
+                    executed_order['amount'] = rounded_slice_amount_in_base_ccy
+                    executed_order['filled'] = rounded_slice_amount_in_base_ccy
+                    executed_order['remaining'] = 0
+                    executed_order['status'] = 'closed'
+                    executed_order['multiplier'] = position.multiplier
 
             else:
-                executed_order = await exchange.create_order( # type: ignore
-                    symbol = position.ticker,
-                    type = position.order_type,
-                    amount = rounded_slice_amount_in_base_ccy,
-                    side = position.side
-                )
+                if not param['dry_run']:
+                    executed_order = await exchange.create_order( # type: ignore
+                        symbol = position.ticker,
+                        type = position.order_type,
+                        amount = rounded_slice_amount_in_base_ccy,
+                        side = position.side
+                    )
+                else:
+                    executed_order = DUMMY_EXECUTION.copy()
+                    executed_order['clientOrderId'] = str(uuid.uuid4())
+                    executed_order['timestamp'] = dt_now.timestamp()
+                    executed_order['datetime'] = dt_now
+                    executed_order['symbol'] = position.ticker
+                    executed_order['type'] = position.order_type
+                    executed_order['side'] = position.side
+                    executed_order['price'] = rounded_limit_price
+                    executed_order['average'] = rounded_limit_price
+                    executed_order['cost'] = 0
+                    executed_order['amount'] = rounded_slice_amount_in_base_ccy
+                    executed_order['filled'] = rounded_slice_amount_in_base_ccy
+                    executed_order['remaining'] = 0
+                    executed_order['status'] = 'closed'
+                    executed_order['multiplier'] = position.multiplier
 
             executed_order['slice_id'] = i
 
@@ -459,7 +578,7 @@ async def execute_one_position(
                             log(f"Limit order fully filled: {order_id}", log_level=LogLevel.INFO)
                             break
 
-                    await asyncio.sleep(int(param['fetch_order_status_poll_freq_ms']/1000))
+                    await asyncio.sleep(int(param['loop_freq_ms']/1000))
             
             
 
@@ -511,7 +630,7 @@ async def execute_one_position(
 
                             log(f"Waiting for resent market order to close {order_id} ...")
 
-                            await asyncio.sleep(int(param['fetch_order_status_poll_freq_ms']/1000))
+                            await asyncio.sleep(int(param['loop_freq_ms']/1000))
 
                         log(f"Resent market order{order_id} filled. status: {order_status}, filled_amount: {filled_amount}, remaining_amount: {remaining_amount}")
 
@@ -618,6 +737,8 @@ async def work(
 
         except Exception as loop_error:
             log(f"Error: {loop_error} {str(sys.exc_info()[0])} {str(sys.exc_info()[1])} {traceback.format_exc()}")
+        finally:
+            await asyncio.sleep(int(param['loop_freq_ms']/1000))
 
 async def main():
     parse_args()
@@ -652,7 +773,7 @@ async def main():
     
     redis_client : StrictRedis = init_redis_client()
 
-    exchange : Union[AnyExchange, None] = instantiate_exchange(
+    exchange : Union[AnyExchange, None] = await instantiate_exchange(
         gateway_id=param['gateway_id'],
         api_key=api_key,
         secret=secret,

{siglab_py-0.1.9 → siglab_py-0.1.10}/siglab_py/ordergateway/test_ordergateway.py

@@ -77,12 +77,12 @@ if __name__ == '__main__':
 
     positions_2 : List[DivisiblePosition] = [
         DivisiblePosition(
-            ticker = 'SUSHI/USDT:USDT',
+            ticker = 'SUSHI/USDC:USDC',
             side = 'buy',
-            amount = 10,
+            amount = 60,
             leg_room_bps = 5,
             order_type = 'limit',
-            slices=5,
+            slices=2,
             wait_fill_threshold_ms=15000
         ),
     ]

{siglab_py-0.1.9 → siglab_py-0.1.10}/siglab_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siglab-py
-Version: 0.1.9
+Version: 0.1.10
 Summary: Market data fetches, TA calculations and generic order gateway.
 Author: r0bbarh00d
 Author-email: r0bbarh00d <r0bbarh00d@gmail.com>