siglab-py 0.1.0__py3-none-any.whl

siglab_py/ordergateway/client.py

@@ -0,0 +1,137 @@
+
+from typing import List, Dict, Any
+
+from ccxt.base.types import Position
+
+from constants import JSON_SERIALIZABLE_TYPES
+from exchanges.any_exchange import AnyExchange
+
+'''
+Example,
+    spot        'BTC/USDT'
+    perpetual   'BTC/USDT:USDT'
+In both cases, BTC is base ccy, and USDT is quote ccy.
+
+crypto/CCXT convention is, 
+    For spot, in base ccy. 
+    For perpetual contracts, this is in # contracts, not base ccy.
+Here, Order.amount is always in base ccy regardless whether you're trading spot or perpetual. 
+
+leg_room_bps: 
+    For limit orders, when order is executed, limit price be ...
+        buy order: best ask * (1 + leg_room_bps/10000) 
+        sell order: best bid * (1 - leg_room_bps/10000)
+    Thus a positive leg room means you're more aggressive to trying to get the order filled: Buy at higher price, Sell at lower price. 
+'''
+class Order:
+    def __init__(
+        self,
+        ticker : str,
+        side : str,  # buy/sell
+        amount : float,
+        order_type : str, # market/limit
+        leg_room_bps : float = 0
+    ) -> None:
+        self.ticker = ticker
+        self.side = side.strip().lower()
+        self.amount = amount
+        self.order_type = order_type.strip().lower()
+        self.leg_room_bps = leg_room_bps
+
+    def to_dict(self) -> Dict[JSON_SERIALIZABLE_TYPES, JSON_SERIALIZABLE_TYPES]:
+        return {
+            "ticker" : self.ticker,
+            "side" : self.side,
+            "amount" : self.amount,
+            "order_type" : self.order_type,
+            "leg_room_bps" : self.leg_room_bps
+        }
+
+'''
+For limit orders, if not filled within wait_fill_threshold_ms, we'd try cancel and resend un-filled amount as market order.
+wait_fill_threshold_ms default to -1: Means wait forever until fully filled.
+'''
+class DivisiblePosition(Order):
+    def __init__(
+        self,
+        ticker : str,
+        side : str,  # buy/sell
+        amount : float,
+        order_type : str, # market/limit
+        leg_room_bps : float,
+        slices : int = 1,
+        wait_fill_threshold_ms : float = -1
+    ) -> None:
+        super().__init__(ticker, side, amount, order_type, leg_room_bps)
+        self.slices = slices
+        self.wait_fill_threshold_ms = wait_fill_threshold_ms
+        self.multiplier = 1
+        self.filled_amount = 0
+        self.average_cost = 0
+
+        self.executions : Dict[str, Dict[str, Any]] = {}
+
+    def to_slices(self) -> List[Order]:
+        slices : List[Order] = []
+
+        remaining_amount_in_base_ccy : float = self.amount
+        slice_amount_in_base_ccy : float = self.amount / self.slices
+        for i in range(self.slices):
+            if remaining_amount_in_base_ccy>0:
+                if remaining_amount_in_base_ccy >= slice_amount_in_base_ccy:
+                    slice = Order(
+                        ticker=self.ticker, 
+                        side=self.side, 
+                        amount=slice_amount_in_base_ccy, 
+                        leg_room_bps=self.leg_room_bps, 
+                        order_type=self.order_type)
+                    
+                else:
+                    # Last slice
+                    slice = Order(
+                        ticker=self.ticker, 
+                        side=self.side, 
+                        amount=remaining_amount_in_base_ccy, 
+                        leg_room_bps=self.leg_room_bps, 
+                        order_type=self.order_type)
+
+                slices.append(slice)
+                    
+        return slices
+
+    def append_execution(
+        self,
+        order_id : str,
+        execution : Dict[str, Any]
+    ):
+        self.executions[order_id] = execution
+
+    def get_execution(
+        self,
+        order_id : str
+    ) -> Dict[str, Any]:
+        return self.executions[order_id]
+
+    def get_executions(self) -> Dict[str, Dict[str, Any]]:
+        return self.executions
+
+    def get_filled_amount(self) -> float:
+        # filled_amount is in base ccy
+        filled_amount = sum([ self.executions[order_id]['filled'] * self.multiplier for order_id in self.executions ])
+        self.filled_amount = filled_amount
+        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 ])
+        average_cost = average_cost / sum([ self.executions[order_id]['amount'] for order_id in self.executions ])
+        self.average_cost = average_cost
+        return average_cost
+
+    def to_dict(self) -> Dict[JSON_SERIALIZABLE_TYPES, JSON_SERIALIZABLE_TYPES]:
+        rv = super().to_dict()
+        rv['slices'] = self.slices
+        rv['wait_fill_threshold_ms'] = self.wait_fill_threshold_ms
+        rv['executions'] = self.executions
+        rv['filled_amount'] = self.filled_amount
+        rv['average_cost'] = self.average_cost
+        return rv

siglab_py/ordergateway/encrypt_keys_util.py

@@ -0,0 +1,43 @@
+from typing import Union
+from util.aws_util import AwsKmsUtil
+
+'''
+From command line, run 'aws configure' with IAM user's Access key ID and Secret access key. (Assume you have awscli installed)
+    aws configure
+    AWS Access Key ID [****************ABCD]: <-- ***ABCD is your IAM user 
+    AWS Secret Access Key [****************xxx]: <-- xxx is password to your IAM user
+    Default region name [us-east-1]: <-- Region need be where your KMS key resides!
+    Default output format [None]: 
+
+Remember that when you create your KMS Key, you need to grant permission of the key newly created key to IAM user (This is done on KMS side, not IAM).
+'''
+key_id : Union[str, None] = None
+api_key : Union[str, None] = None
+secret : Union[str, None] = None
+passphrase : Union[str, None] = None
+
+print("enter key_id")
+key_id = input()
+
+print("enter apikey")
+apikey = input()
+
+print("enter secret")
+secret = input()
+
+print("enter passphrase")
+passphrase = input()
+
+aws_kms = AwsKmsUtil(key_id=key_id, profile_name=None)
+
+apikey = aws_kms.encrypt(apikey).decode("utf-8")
+secret = aws_kms.encrypt(secret).decode("utf-8")
+
+if passphrase:
+    passphrase = aws_kms.encrypt(passphrase).decode("utf-8")
+
+print(f"apikey: {apikey}")
+print(f"secret: {secret}")
+
+if passphrase:
+    print(f"passphrase: {passphrase}")