moving to pairtypes, working subscription to multiple currency pairs

Author: timkpaine

algocoin/backtest.py

@@ -3,7 +3,7 @@
 from .lib.logging import LOG as log, DATA as dlog
 from .lib.structs import MarketData
 from .lib.utils import parse_date
-from .lib.enums import CurrencyType, TickType, Side
+from .lib.enums import PairType, TickType, Side
 
 
 class Backtest(StreamingDataSource):
@@ -32,7 +32,7 @@ def receive(self, line: str) -> None:
                           price=float(res[1]),
                           volume=float(res[2]),
                           type=TickType.TRADE,
-                          currency=CurrencyType.BTC,
+                          currency_pair=PairType.BTCUSD,
                           side=Side.NONE)
 
         if data.type == TickType.TRADE:

algocoin/lib/config.py

@@ -1,12 +1,13 @@
 from .utils import config
-from .enums import TradingType, ExchangeType
+from .enums import TradingType, ExchangeType, PairType
 
 
 @config
 class ExchangeConfig:
     exchange_type = ExchangeType, ExchangeType.NONE
     exchange_types = [ExchangeType], []
     trading_type = TradingType, TradingType.NONE
+    currency_pairs = [PairType], [PairType.BTCUSD]
 
 
 @config

algocoin/lib/define.py

@@ -10,6 +10,8 @@
     (ExchangeType.CEX, TradingType.LIVE): '',
     (ExchangeType.GDAX, TradingType.SANDBOX): 'wss://ws-feed.sandbox.gdax.com',
     (ExchangeType.GDAX, TradingType.LIVE): 'wss://ws-feed.gdax.com',
+    (ExchangeType.COINBASE, TradingType.SANDBOX): 'wss://ws-feed.pro.pro.coinbase.com',
+    (ExchangeType.COINBASE, TradingType.LIVE): 'wss://ws-feed.pro.coinbase.com',
     (ExchangeType.GEMINI, TradingType.SANDBOX): 'wss://api.sandbox.gemini.com/v1/marketdata/btcusd?heartbeat=true',
     (ExchangeType.GEMINI, TradingType.LIVE): 'wss://api.gemini.com/v1/marketdata/btcusd?heartbeat=true',
     (ExchangeType.HITBTC, TradingType.SANDBOX): '',
@@ -33,6 +35,8 @@
     (ExchangeType.CEX, TradingType.LIVE): '',
     (ExchangeType.GDAX, TradingType.SANDBOX): 'https://api-public.sandbox.gdax.com',
     (ExchangeType.GDAX, TradingType.LIVE): 'https://api.gdax.com',
+    (ExchangeType.COINBASE, TradingType.SANDBOX): 'https://api-public.sandbox.pro.coinbase.com',
+    (ExchangeType.COINBASE, TradingType.LIVE): 'https://api.pro.coinbase.com',
     (ExchangeType.GEMINI, TradingType.SANDBOX): 'https://api.sandbox.gemini.com/v1/marketdata/btcusd?heartbeat=true',
     (ExchangeType.GEMINI, TradingType.LIVE): 'https://api.gemini.com/v1/marketdata/btcusd?heartbeat=true',
     (ExchangeType.HITBTC, TradingType.SANDBOX): '',

algocoin/lib/enums.py

@@ -34,6 +34,7 @@ class ExchangeType(BaseEnum):
     BITFINEX = 2
     CEX = 3
     GDAX = 4
+    COINBASE = 11
     GEMINI = 5
     HITBTC = 6
     ITBIT = 7
@@ -47,6 +48,41 @@ class CurrencyType(BaseEnum):
     BTC = 1
     ETH = 2
     LTC = 3
+    BCH = 4
+    ZEC = 5
+
+
+class PairType(BaseEnum):
+    # USD Pairs
+    USDBTC = (CurrencyType.USD, CurrencyType.BTC)
+    USDETH = (CurrencyType.USD, CurrencyType.ETH)
+    USDLTC = (CurrencyType.USD, CurrencyType.LTC)
+    USDBCH = (CurrencyType.USD, CurrencyType.BCH)
+    USDZEC = (CurrencyType.USD, CurrencyType.ZEC)
+
+    # BTC Pairs
+    BTCUSD = (CurrencyType.BTC, CurrencyType.USD)
+    BTCETH = (CurrencyType.BTC, CurrencyType.ETH)
+    BTCLTC = (CurrencyType.BTC, CurrencyType.LTC)
+    BTCBCH = (CurrencyType.BTC, CurrencyType.BCH)
+    BTCZEC = (CurrencyType.BTC, CurrencyType.ZEC)
+
+    # ETH Pairs
+    ETHUSD = (CurrencyType.ETH, CurrencyType.USD)
+    ETHBTC = (CurrencyType.ETH, CurrencyType.BTC)
+
+    # LTC Pairs
+    LTCUSD = (CurrencyType.LTC, CurrencyType.USD)
+    LTCBTC = (CurrencyType.LTC, CurrencyType.BTC)
+
+    # BCH Pairs
+    BCHUSD = (CurrencyType.BCH, CurrencyType.USD)
+    BCHBTC = (CurrencyType.BCH, CurrencyType.BTC)
+
+    # ZEC Pairs
+    ZECUSD = (CurrencyType.ZEC, CurrencyType.USD)
+    ZECBTC = (CurrencyType.ZEC, CurrencyType.BTC)
+    ZECETH = (CurrencyType.ZEC, CurrencyType.ETH)  # Gemini
 
 
 class Side(BaseEnum):

algocoin/lib/exchanges/gdax.py

@@ -27,7 +27,6 @@ def __init__(self, options: ExchangeConfig) -> None:
 
         elif options.trading_type == TradingType.SANDBOX:
             self._key, self._secret, self._passphrase = get_keys_from_environment('GDAX_SANDBOX')
-            import ipdb; ipdb.set_trace()
             self._client = gdax.AuthenticatedClient(self._key,
                                                     self._secret,
                                                     self._passphrase,
@@ -48,12 +47,12 @@ def __init__(self, options: ExchangeConfig) -> None:
             account = Account(id=id, currency=currency, balance=balance)
             self._accounts.append(account)
 
-        self._subscription = json.dumps({"type": "subscribe",
-                                         "product_id": "BTC-USD"})
+        self._subscription = [json.dumps({"type": "subscribe",
+                                         "product_id": GDAXExchange.currency_pair_to_string(x)}) for x in options.currency_pairs]
         self._heartbeat = json.dumps({"type": "heartbeat",
                                       "on": True})
 
-        self._seqnum_enabled = True
+        self._seqnum_enabled = False  # FIXME?
 
     def run(self, engine) -> None:
         # DEBUG
@@ -66,8 +65,9 @@ def run(self, engine) -> None:
                 self.ws = create_connection(self._md_url)
                 log.info('Connected!')
 
-                self.ws.send(self._subscription)
-                log.info('Sending Subscription %s' % self._subscription)
+                for sub in self._subscription:
+                    self.ws.send(sub)
+                    log.info('Sending Subscription %s' % sub)
                 self.ws.send(self._heartbeat)
                 log.info('Sending Heartbeat %s' % self._heartbeat)
 
@@ -128,7 +128,7 @@ def buy(self, req: TradeRequest) -> TradeResponse:
                              side=req.side,
                              volume=float(order['filled_size']),
                              price=float(order['price']),
-                             currency=req.currency,
+                             currency_pair=req.currency_pair,
                              slippage=slippage,
                              transaction_cost=txn_cost,
                              status=status,

algocoin/lib/exchanges/helpers.py

@@ -1,6 +1,6 @@
 from datetime import datetime
-from ..enums import CurrencyType, OrderType, OrderSubType, Side
-from ..utils import parse_date, str_to_currency_type, str_to_side, \
+from ..enums import OrderType, OrderSubType, Side, PairType, CurrencyType
+from ..utils import parse_date, str_to_currency_type, str_to_currency_pair_type, str_to_side, \
     str_to_order_type
 from ..structs import MarketData
 from ..enums import TickType
@@ -13,19 +13,18 @@ def tickToData(jsn: dict) -> MarketData:
         price = float(jsn.get('price', 'nan'))
         volume = float(jsn.get('size', 'nan'))
         typ = GDAXHelpersMixin.strToTradeType(jsn.get('type'))
-        currency = str_to_currency_type(jsn.get('product_id'))
+        currency_pair = str_to_currency_pair_type(jsn.get('product_id'))
 
         order_type = str_to_order_type(jsn.get('order_type', ''))
         side = str_to_side(jsn.get('side', ''))
         remaining_volume = float(jsn.get('remaining_size', 'nan'))
         reason = jsn.get('reason', '')
         sequence = int(jsn.get('sequence'))
-
         ret = MarketData(time=time,
                          volume=volume,
                          price=price,
                          type=typ,
-                         currency=currency,
+                         currency_pair=currency_pair,
                          remaining=remaining_volume,
                          reason=reason,
                          side=side,
@@ -55,7 +54,7 @@ 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['product_id'] = GDAXHelpersMixin.currency_pair_to_string(req.currency_pair)
         p['type'] = GDAXHelpersMixin.order_type_to_string(req.order_type)
 
         if req.order_sub_type == OrderSubType.FILL_OR_KILL:
@@ -67,7 +66,40 @@ def trade_req_to_params(req) -> dict:
     @staticmethod
     def currency_to_string(cur: CurrencyType) -> str:
         if cur == CurrencyType.BTC:
+            return 'BTC'
+        if cur == CurrencyType.ETH:
+            return 'ETH'
+        if cur == CurrencyType.LTC:
+            return 'LTC'
+        if cur == CurrencyType.BCH:
+            return 'BCH'
+        else:
+            raise Exception('Pair not recognized: %s' % str(cur))
+
+    @staticmethod
+    def currency_pair_to_string(cur: PairType) -> str:
+        if cur == PairType.BTCUSD:
             return 'BTC-USD'
+        if cur == PairType.BTCETH:
+            return 'BTC-ETH'
+        if cur == PairType.BTCLTC:
+            return 'BTC-LTC'
+        if cur == PairType.BTCBCH:
+            return 'BTC-BCH'
+        if cur == PairType.ETHUSD:
+            return 'ETH-USD'
+        if cur == PairType.LTCUSD:
+            return 'LTC-USD'
+        if cur == PairType.BCHUSD:
+            return 'BCH-USD'
+        if cur == PairType.ETHBTC:
+            return 'ETH-BTC'
+        if cur == PairType.LTCBTC:
+            return 'LTC-BTC'
+        if cur == PairType.BCHBTC:
+            return 'BCH-BTC'
+        else:
+            raise Exception('Pair not recognized: %s' % str(cur))
 
     @staticmethod
     def order_type_to_string(typ: OrderType) -> str:
@@ -96,13 +128,13 @@ def tickToData(jsn: dict) -> MarketData:
         remaining_volume = float(jsn.get('remaining', 'nan'))
 
         sequence = -1
-        currency = str_to_currency_type('BTC')
+        currency_pair = str_to_currency_type('BTC')
 
         ret = MarketData(time=time,
                          volume=volume,
                          price=price,
                          type=typ,
-                         currency=currency,
+                         currency_pair=currency_pair,
                          remaining=remaining_volume,
                          reason=reason,
                          side=side,
@@ -136,7 +168,7 @@ def trade_req_to_params(req) -> dict:
         p = {}
         p['price'] = str(req.price)
         p['size'] = str(req.volume)
-        p['product_id'] = GeminiHelpersMixin.currency_to_string(req.currency)
+        p['product_id'] = GeminiHelpersMixin.currency_pair_to_string(req.currency_pair)
         p['type'] = GeminiHelpersMixin.order_type_to_string(req.order_type)
 
         if p['type'] == OrderType.MARKET:
@@ -152,9 +184,21 @@ def trade_req_to_params(req) -> dict:
         return p
 
     @staticmethod
-    def currency_to_string(cur: CurrencyType) -> str:
-        if cur == CurrencyType.BTC:
+    def currency_pair_to_string(cur: PairType) -> str:
+        if cur == PairType.BTCUSD:
             return 'BTCUSD'
+        if cur == PairType.ZECUSD:
+            return 'ZECUSD'
+        if cur == PairType.ZECBTC:
+            return 'ZECBTC'
+        if cur == PairType.ZECETH:
+            return 'ZECETH'
+        if cur == PairType.ETHBTC:
+            return 'ETHBTC'
+        if cur == PairType.ETHUSD:
+            return 'ETHUSD'
+        else:
+            raise Exception('Pair not recognized: %s' % str(cur))
 
     @staticmethod
     def order_type_to_string(typ: OrderType) -> str:

algocoin/lib/parser.py

@@ -1,9 +1,9 @@
 from configparser import ConfigParser
 from pydoc import locate
 from .config import TradingEngineConfig, BacktestConfig, StrategyConfig
-from .enums import TradingType
+from .enums import TradingType, PairType
 from .exceptions import ConfigException
-from .utils import str_to_exchange, exchange_to_file, set_verbose
+from .utils import str_to_exchange, exchange_to_file, set_verbose, str_to_currency_pair_type
 from .logging import LOG as log
 
 
@@ -116,6 +116,14 @@ def _parse_args_to_dict(argv: list) -> dict:
     return ret
 
 
+def _parse_currencies(currencies):
+    splits = [x.strip().upper().replace('-', '') for x in currencies.split(',')]
+    ret = []
+    for s in splits:
+        ret.append(str_to_currency_pair_type(s))
+    return ret
+
+
 def _parse_live_options(argv, config: TradingEngineConfig) -> None:
     log.critical("\n\nWARNING: Live trading. money will be lost ;^)\n\n")
     if argv.get('exchange'):
@@ -126,6 +134,9 @@ def _parse_live_options(argv, config: TradingEngineConfig) -> None:
         config.exchange_options.exchange_type = str_to_exchange('')
         log.critical('No Exchange set, using default: %s', config.exchange_options.exchange_type)
 
+    if argv.get('currency_pairs'):
+        config.exchange_options.currency_pairs = _parse_currencies(argv.get('currency_pairs'))
+
 
 def _parse_sandbox_options(argv, config) -> None:
     log.critical("\n\nSandbox trading\n\n")
@@ -138,6 +149,9 @@ def _parse_sandbox_options(argv, config) -> None:
         config.exchange_options.exchange_type = str_to_exchange('')
         log.critical('No Exchange set, using default: %s', config.exchange_options.exchange_type)
 
+    if argv.get('currency_pairs'):
+        config.exchange_options.currency_pairs = _parse_currencies(argv.get('currency_pairs'))
+
 
 def _parse_backtest_options(argv, config) -> None:
     log.critical("\n\nBacktesting\n\n")
@@ -152,6 +166,9 @@ def _parse_backtest_options(argv, config) -> None:
         config.exchange_options.exchange_type = str_to_exchange('')
         log.critical('No Exchange set, using default: %s', config.exchange_options.exchange_type)
 
+    if argv.get('currency_pairs'):
+        config.exchange_options.currency_pairs = _parse_currencies(argv.get('currency_pairs'))
+
 
 def parse_command_line_config(argv: list) -> TradingEngineConfig:
     # Every engine run requires a static config object

algocoin/lib/strategies/backtest.py

@@ -1,8 +1,8 @@
 import numpy
-from .lib.strategy import TradingStrategy
-from .lib.structs import MarketData, TradeRequest, TradeResponse
-from .lib.enums import Side, OrderType
-from .lib.logging import STRAT as slog, ERROR as elog
+from ..strategy import TradingStrategy
+from ..structs import MarketData, TradeRequest, TradeResponse
+from ..enums import Side, OrderType
+from ..logging import STRAT as slog, ERROR as elog
 
 
 class CustomStrategy(TradingStrategy):

algocoin/lib/strategies/sma_crosses_strategy.py

@@ -95,7 +95,7 @@ def onTrade(self, data: MarketData) -> bool:
             req = TradeRequest(side=Side.BUY,
                                # buy between .2 and 1 BTC
                                volume=max(min(1.0, data.volume), .2),
-                               currency=data.currency,
+                               currency_pair=data.currency_pair,
                                order_type=OrderType.MARKET,
                                price=data.price)
             # slog.info("requesting buy : %s", req)
@@ -106,7 +106,7 @@ def onTrade(self, data: MarketData) -> bool:
                 self.bought > 0.0:
             req = TradeRequest(side=Side.SELL,
                                volume=self.bought_qty,
-                               currency=data.currency,
+                               currency_pair=data.currency_pair,
                                order_type=OrderType.MARKET,
                                price=data.price)
             # slog.info("requesting sell : %s", req)

algocoin/lib/structs.py

@@ -1,6 +1,7 @@
 import datetime
 from .enums import Side, \
                    CurrencyType, \
+                   PairType, \
                    OrderType, \
                    OrderSubType, \
                    TickType, \
@@ -15,7 +16,7 @@ class MarketData:
     volume = float
     price = float
     type = TickType
-    currency = CurrencyType, CurrencyType.BTC
+    currency_pair = PairType
     side = Side
 
     # maybe specific
@@ -31,7 +32,7 @@ class TradeRequest:
 
     volume = float
     price = float
-    currency = CurrencyType
+    currency_pair = PairType
 
     order_type = OrderType
     order_sub_type = OrderSubType, OrderSubType.NONE
@@ -49,7 +50,7 @@ class TradeResponse:
 
     volume = float
     price = float
-    currency = CurrencyType
+    currency_pair = PairType
 
     slippage = float, 0.0
     transaction_cost = float, 0.0