working trading on gemini again

Author: timkpaine

algocoin/__main__.py

@@ -3,6 +3,7 @@
 import threading
 from .custom_strategies import CustomStrategy
 from .lib.strategies.sma_crosses_strategy import SMACrossesStrategy
+from .lib.strategies.test_strat import TestStrategy
 from .trading import TradingEngine
 # from .lib.parser import parse_command_line_config, parse_config
 from .lib.parser import parse_command_line_config
@@ -25,10 +26,12 @@ def main(argv: list) -> None:
     application = ServerApplication(te)
 
     # A sample strategy that impelements the correct interface
-    ts = CustomStrategy(50)
-    ts2 = SMACrossesStrategy(5, 10)
+    # ts = CustomStrategy(50)
+    # ts2 = SMACrossesStrategy(5, 10)
+    ts = TestStrategy()
     te.registerStrategy(ts)
-    te.registerStrategy(ts2)
+    # te.registerStrategy(ts)
+    # te.registerStrategy(ts2)
 
     # for i in [5, 10, 20, 25, 50, 100]:
     #     for j in [10, 20, 25, 75, 100, 150, 200]:

algocoin/lib/enums.py

@@ -70,5 +70,6 @@ class OrderSubType(BaseEnum):
 class TradeResult(BaseEnum):
     NONE = 0
     PENDING = 1
-    REJECTED = 2
+    PARTIAL = 2
     FILLED = 3
+    REJECTED = 4

algocoin/lib/exchanges/gemini.py

@@ -2,7 +2,7 @@
 from websocket import create_connection
 from ..oe.gemini import GeminiSession
 from ..config import ExchangeConfig
-from ..enums import TradingType, ExchangeType, TickType
+from ..enums import TradingType, ExchangeType, TickType, TradeResult
 from ..exchange import Exchange
 from ..structs import TradeRequest, TradeResponse, Account
 from ..utils import get_keys_from_environment, str_to_currency_type
@@ -78,13 +78,76 @@ def buy(self, req: TradeRequest) -> TradeResponse:
         '''execute a buy order'''
         params = GeminiExchange.trade_req_to_params(req)
         log.warn("Buy params: %s", str(params))
-        return self._client.buy(params)
+        order = self._client.new_order(params['product_id'],
+                                       params['size'],
+                                       params['price'],
+                                       'buy',
+                                       client_order_id=None,
+                                       order_execution=None)
+        # FIXME check these
+        slippage = float(params['price'])-float(order['avg_execution_price'])
+        txn_cost = 0.0
+        status = TradeResult.NONE
+
+        if (float(order['executed_amount']) - req.volume) < 0.001:
+            status = TradeResult.FILLED
+        elif order.get('is_cancelled', ''):
+            status = TradeResult.REJECTED
+        elif float(order.get('remaining_amount', 0.0)):
+            status = TradeResult.PARTIAL
+        else:
+            status = TradeResult.PENDING
+
+        resp = TradeResponse(request=req,
+                             side=req.side,
+                             volume=float(order['executed_amount']),
+                             price=float(order['avg_execution_price']),
+                             currency=req.currency,
+                             slippage=slippage,
+                             transaction_cost=txn_cost,
+                             status=status,
+                             order_id=order['order_id'],
+                             remaining=float(order.get('remaining_amount', 0.0)),
+                             )
+        return resp
 
     def sell(self, req: TradeRequest) -> TradeResponse:
         '''execute a sell order'''
         params = GeminiExchange.trade_req_to_params(req)
         log.warn("Sell params: %s", str(params))
-        return self._client.sell(params)
+        order = self._client.new_order(params['product_id'],
+                                       params['size'],
+                                       params['price'],
+                                       'sell',
+                                       client_order_id=None,
+                                       order_execution=None)
+
+        # FIXME check these
+        slippage = float(params['price'])-float(order['avg_execution_price'])
+        txn_cost = 0.0
+        status = TradeResult.NONE
+
+        if (float(order['executed_amount']) - req.volume) < 0.001:
+            status = TradeResult.FILLED
+        elif order.get('is_cancelled', ''):
+            status = TradeResult.REJECTED
+        elif float(order.get('remaining_amount', 0.0)):
+            status = TradeResult.PARTIAL
+        else:
+            status = TradeResult.PENDING
+
+        resp = TradeResponse(request=req,
+                             side=req.side,
+                             volume=float(order['executed_amount']),
+                             price=float(order['avg_execution_price']),
+                             currency=req.currency,
+                             slippage=slippage,
+                             transaction_cost=txn_cost,
+                             status=status,
+                             order_id=order['order_id'],
+                             remaining=float(order.get('remaining_amount', 0.0)),
+                             )
+        return resp
 
     def receive(self) -> None:
         jsn = json.loads(self.ws.recv())

algocoin/lib/exchanges/helpers.py

@@ -136,15 +136,27 @@ def trade_req_to_params(req) -> dict:
         p = {}
         p['price'] = str(req.price)
         p['size'] = str(req.volume)
-        p['product_id'] = GDAXHelpersMixin.currency_to_string(req.currency)
-        p['type'] = GDAXHelpersMixin.order_type_to_string(req.order_type)
+        p['product_id'] = GeminiHelpersMixin.currency_to_string(req.currency)
+        p['type'] = GeminiHelpersMixin.order_type_to_string(req.order_type)
 
         if req.order_sub_type == OrderSubType.FILL_OR_KILL:
             p['time_in_force'] = 'FOK'
         elif req.order_sub_type == OrderSubType.POST_ONLY:
             p['post_only'] = '1'
         return p
 
+    @staticmethod
+    def currency_to_string(cur: CurrencyType) -> str:
+        if cur == CurrencyType.BTC:
+            return 'BTCUSD'
+
+    @staticmethod
+    def order_type_to_string(typ: OrderType) -> str:
+        if typ == OrderType.LIMIT:
+            return 'limit'
+        elif typ == OrderType.MARKET:
+            return 'market'
+
 
 class ItBitHelpersMixin(object):
     @staticmethod

algocoin/lib/oe/gemini.py

@@ -11,6 +11,7 @@
 import json
 import hmac
 
+
 class GeminiSession:
     """Defines a Gemini API session.
     A session uses one Gemini API key. An account can have multiple sessions.
@@ -27,15 +28,15 @@ def __init__(self, api_key, api_secret, sandbox=False):
             self.api_url = 'https://api.sandbox.gemini.com/v1/'
 
     def get_symbols(self):
-        """Returns all available symbols for trading."""      
-        try: 
+        """Returns all available symbols for trading."""
+        try:
             return requests.get(self.api_url + 'symbols').json()
         except requests.exceptions.RequestException as e:
             raise e
 
     def get_ticker(self, symbol):
         """Returns recent trading activity for a symbol"""
-        try: 
+        try:
             return requests.get(self.api_url + 'pubticker/' + symbol).json()
         except requests.exceptions.RequestException as e:
             raise e
@@ -45,11 +46,11 @@ def get_current_order_book(self, symbol, limit_bids=None, limit_asks=None):
 
         Args:
             symbol (str): Symbol such as btcusd.
-            limit_bids (int): Optional. Max number of bids (offers to buy) to 
-                return. Default is 50.                
+            limit_bids (int): Optional. Max number of bids (offers to buy) to
+                return. Default is 50.
             limit_asks (int): Optional. Max number of asks (offers to sell) to
                 return. Default is 50.
-        
+
         Returns:
             A JSON object with two arrays, one for bids and one for asks.
         """
@@ -59,19 +60,18 @@ def get_current_order_book(self, symbol, limit_bids=None, limit_asks=None):
             limits["limit_bids"] = limit_bids
         if limit_asks is not None:
             limits["limit_asks"] = limit_asks
-        
+
         try:
             return requests.get(self.api_url + symbol, params=limits).json()
         except requests.exceptions.RequestException as e:
             raise e
 
-    def new_order(self, symbol, amount, price, side, client_order_id=None, 
-        order_execution=None):
+    def new_order(self, symbol, amount, price, side, client_order_id=None, order_execution=None):
         """Place a new order
 
         Args:
             symbol (str): Symbol such as btcusd.
-            amount (str): Decimal amount of BTC to purchase. Note that this 
+            amount (str): Decimal amount of BTC to purchase. Note that this
                 should be a string.
             price (str): Decimal amount of USD to spend per BTC. Note that this
                 should be a string.
@@ -80,10 +80,10 @@ def new_order(self, symbol, amount, price, side, client_order_id=None,
                 "maker-or-cancel" and "immediate-or-cancel" are the currently
                 supported options.
 
-        Returns: 
+        Returns:
             A JSON object with information about the order.
         """
-        
+
         fields = {
                 'request': '/v1/order/new',
                 'nonce': self._nonce(),
@@ -100,16 +100,16 @@ def new_order(self, symbol, amount, price, side, client_order_id=None,
 
         if client_order_id is not None:
             fields['client_order_id'] = client_order_id
-        
+
         if order_execution is not None:
             fields['order_execution'] = [order_execution]
-        
+
         try:
-            return requests.post(self.api_url + 'order/new', 
-                headers=self._create_payload(fields)).json()
+            return requests.post(self.api_url + 'order/new',
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
-    
+
     def cancel_order(self, order_id):
         """Cancels an existing order with the given order_id"""
         fields = {
@@ -119,8 +119,8 @@ def cancel_order(self, order_id):
         }
 
         try:
-            return requests.post(self.api_url + 'order/cancel', 
-                headers=self._create_payload(fields)).json()
+            return requests.post(self.api_url + 'order/cancel',
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
 
@@ -132,11 +132,11 @@ def cancel_all_session_orders(self):
         }
 
         try:
-            return requests.post(self.api_url + 'order/cancel/session', 
-                headers=self._create_payload(fields)).json()
+            return requests.post(self.api_url + 'order/cancel/session',
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
-    
+
     def cancel_all_active_orders(self):
         """Cancels all orders across all sessions"""
         fields = {
@@ -145,8 +145,8 @@ def cancel_all_active_orders(self):
         }
 
         try:
-            return requests.post(self.api_url + 'order/cancel/all', 
-                headers=self._create_payload(fields)).json()
+            return requests.post(self.api_url + 'order/cancel/all',
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
 
@@ -159,8 +159,8 @@ def get_order_status(self, order_id):
         }
 
         try:
-            return requests.post(self.api_url + 'order/status', 
-                headers=self._create_payload(fields)).json()
+            return requests.post(self.api_url + 'order/status',
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
 
@@ -172,21 +172,21 @@ def get_all_order_status(self):
         }
 
         try:
-            return requests.post(self.api_url + 'order', 
-                headers=self._create_payload(fields)).json()
+            return requests.post(self.api_url + 'order',
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
 
     def get_past_trades(self, symbol, limit_trades=None, timestamp=None):
         """Returns information about past trades.
-        
+
         Args:
-            limit_trades (int): Optional. The max number of trades to return. 
+            limit_trades (int): Optional. The max number of trades to return.
                 Default is 50, max is 100.
-            timestamp (int): Optional. Can be provided to only return trades 
+            timestamp (int): Optional. Can be provided to only return trades
                 after timestamp. Can be in milliseconds or seconds.
 
-        Returns: 
+        Returns:
             Array of trade information items.
         """
 
@@ -203,16 +203,16 @@ def get_past_trades(self, symbol, limit_trades=None, timestamp=None):
             fields["timestamp"] = timestamp
 
         try:
-            return requests.post(self.api_url + 'mytrades', 
-                headers=self._create_payload(fields)).json()
+            return requests.post(self.api_url + 'mytrades',
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
 
     def get_trade_volume(self):
         """Get trade volume information for the account
 
-        Returns: 
-            Array where each element contains information about one day of 
+        Returns:
+            Array where each element contains information about one day of
             trading activity.
         """
         fields = {
@@ -222,13 +222,13 @@ def get_trade_volume(self):
 
         try:
             return requests.post(self.api_url + 'tradevolume',
-                headers=self._create_payload(fields)).json()
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
 
     def get_balances(self):
         """Get available balances in the supported currencies
-        
+
         Returns:
             Array where each element is for a different currency.
         """
@@ -239,12 +239,12 @@ def get_balances(self):
 
         try:
             return requests.post(self.api_url + 'balances',
-                headers=self._create_payload(fields)).json()
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
 
     def heartbeat(self):
-        """Prevents a session from timing out if the require heartbeat flag is 
+        """Prevents a session from timing out if the require heartbeat flag is
         set when the API key was provisioned.
         """
         fields = {
@@ -254,7 +254,7 @@ def heartbeat(self):
 
         try:
             return requests.post(self.api_url + 'heartbeat',
-                headers=self._create_payload(fields)).json()
+                                 headers=self._create_payload(fields)).json()
         except requests.exceptions.RequestException as e:
             raise e
 
@@ -269,8 +269,8 @@ def _create_payload(self, fields):
         headers = {
             'X-GEMINI-APIKEY': self.api_key,
             'X-GEMINI-PAYLOAD': encodedFields,
-            'X-GEMINI-SIGNATURE': hmac.new(self.api_secret.encode(), 
-                encodedFields, digestmod=hashlib.sha384).hexdigest()
+            'X-GEMINI-SIGNATURE': hmac.new(self.api_secret.encode(),
+                                           encodedFields, digestmod=hashlib.sha384).hexdigest()
         }
 
-        return headers
+        return headers