def __init__(self, **kwargs):
"""Initialize object."""
self._platform = kwargs["platform"]
self._wss = kwargs.get("wss", "wss://deribit.com")
self._account = kwargs["account"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._update_interval = kwargs.get("update_interval", 10)
self._assets = {"BTC": {}, "ETH": {}} # All currencies
self._last_assets = {} # last updated currencies information
url = self._wss + "/ws/api/v2"
super(DeribitAsset, self).__init__(url, send_hb_interval=5)
self._query_id = 0 # Unique query id for every query message.
self._queries = {} # Uncompleted query message.
self.initialize()
# Register a loop run task to re-authentication, per 1 hour.
LoopRunTask.register(self._do_auth, 60 * 60)
# Register a loop run task to fetching asset information.
LoopRunTask.register(self._publish_asset, self._update_interval)
self._ok = False # If websocket connection authentication successful.
def __init__(self, **kwargs):
""" 初始化
"""
e = None
if not kwargs.get("account"):
e = Error("param account miss")
if not kwargs.get("strategy"):
e = Error("param strategy miss")
if not kwargs.get("symbol"):
e = Error("param symbol miss")
if not kwargs.get("host"):
kwargs["host"] = "https://api.gateio.ws"
if not kwargs.get("wss"):
kwargs["wss"] = "wss://fx-ws.gateio.ws"
if not kwargs.get("access_key"):
e = Error("param access_key miss")
if not kwargs.get("secret_key"):
e = Error("param secret_key miss")
if e:
logger.error(e, caller=self)
if kwargs.get("init_success_callback"):
SingleTask.run(kwargs["init_success_callback"], False, e)
return
self._account = kwargs["account"]
self._strategy = kwargs["strategy"]
self._platform = GATE_FUTURE
self._symbol = kwargs["symbol"]
self._host = kwargs["host"]
self._wss = kwargs["wss"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._asset_update_callback = kwargs.get("asset_update_callback")
self._order_update_callback = kwargs.get("order_update_callback")
self._position_update_callback = kwargs.get("position_update_callback")
self._init_success_callback = kwargs.get("init_success_callback")
self._contract_update_callback = kwargs.get('contract_update_callback')
self._user_id = None
url = self._wss + "/v4/ws"
super(GateFutureTrade, self).__init__(url, send_hb_interval=5)
self.heartbeat_msg = "ping"
self._assets = {
} # 资产 {"BTC": {"free": "1.1", "locked": "2.2", "total": "3.3"}, ... }
self._orders = {} # 订单 {"order_no": order, ... }
self._position = Position(self._platform, self._account,
self._strategy, self._symbol)
# 初始化 REST API 对象
self._rest_api = GateFutureRestAPI(self._host, self._access_key,
self._secret_key)
# 初始化资产订阅
if self._asset_update_callback:
AssetSubscribe(self._platform, self._account,
self.on_event_asset_update)
# 注册定时任务
LoopRunTask.register(self._check_position_update, 1) # 获取持仓
def __init__(self, **kwargs):
"""Initialize."""
e = None
if not kwargs.get("account"):
e = Error("param account miss")
if not kwargs.get("strategy"):
e = Error("param strategy miss")
if not kwargs.get("symbol"):
e = Error("param symbol miss")
if not kwargs.get("contract_type"):
e = Error("param contract_type miss")
if not kwargs.get("host"):
kwargs["host"] = "https://api.hbdm.com"
if not kwargs.get("wss"):
kwargs["wss"] = "wss://api.hbdm.com"
if not kwargs.get("access_key"):
e = Error("param access_key miss")
if not kwargs.get("secret_key"):
e = Error("param secret_key miss")
if e:
logger.error(e, caller=self)
if kwargs.get("init_success_callback"):
SingleTask.run(kwargs["init_success_callback"], False, e)
return
self._account = kwargs["account"]
self._strategy = kwargs["strategy"]
self._platform = HUOBI_FUTURE
self._symbol = kwargs["symbol"]
self._contract_type = kwargs["contract_type"]
self._host = kwargs["host"]
self._wss = kwargs["wss"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._asset_update_callback = kwargs.get("asset_update_callback")
self._order_update_callback = kwargs.get("order_update_callback")
self._position_update_callback = kwargs.get("position_update_callback")
self._init_success_callback = kwargs.get("init_success_callback")
url = self._wss + "/notification"
self._ws = Websocket(url, self.connected_callback, process_binary_callback=self.process_binary)
self._ws.initialize()
LoopRunTask.register(self.send_heartbeat_msg, 5)
self._assets = {} # Asset detail, {"BTC": {"free": "1.1", "locked": "2.2", "total": "3.3"}, ... }.
self._orders = {} # Order objects, {"order_id": order, ...}.
self._position = Position(self._platform, self._account, self._strategy, self._symbol + '/' + self._contract_type)
self._order_channel = "orders.{symbol}".format(symbol=self._symbol.lower())
self._position_channel = "positions.{symbol}".format(symbol=self._symbol.lower())
self._subscribe_order_ok = False
self._subscribe_position_ok = False
self._rest_api = HuobiFutureRestAPI(self._host, self._access_key, self._secret_key)
# Subscribe AssetEvent.
if self._asset_update_callback:
AssetSubscribe(self._platform, self._account, self.on_event_asset_update)
async def connected_callback(self):
""" After create Websocket connection successfully, we will subscribing orderbook/trade/kline.
"""
if not self._symbols:
logger.warn("symbols not found in config file.", caller=self)
return
if not self._channels:
logger.warn("channels not found in config file.", caller=self)
return
for ch in self._channels:
if ch == "orderbook":
# subscription = {"name": "book"}
LoopRunTask.register(self.on_event_update_orderbook, 2)
continue
elif ch == "trade":
subscription = {"name": "trade"}
# elif ch == "kline": # TODO: something wrong from exchange server? subscribe ohlc-1 but receive ohlc-5 ?
# subscription = {"name": "ohlc", "interval": 1}
else:
logger.error("channel error:", ch, caller=self)
continue
d = {
"event": "subscribe",
"pair": self._symbols,
"subscription": subscription
}
await self.ws.send_json(d)
logger.info("subscribe", ch, "success.", caller=self)
def __init__(self, **kwargs):
self._platform = kwargs["platform"]
self._wss = None
self._symbols = list(set(kwargs.get("symbols")))
self._channels = kwargs.get("channels")
self._orderbook_length = kwargs.get("orderbook_length", 10)
self._access_key = None
self._secret_key = None
self._last_msg_ts = tools.get_cur_timestamp_ms() # 上次接收到消息的时间戳
for item in config.accounts:
if item["platform"] == self._platform:
self._wss = item.get("wss", "wss://deribit.com")
self._access_key = item["access_key"]
self._secret_key = item["secret_key"]
if not self._wss or not self._access_key or not self._access_key:
logger.error(
"no find deribit account in ACCOUNTS from config file.",
caller=self)
return
url = self._wss + "/ws/api/v1/"
self._ws = Websocket(url,
connected_callback=self.connected_callback,
process_callback=self.process)
self._ws.initialize()
LoopRunTask.register(self.send_heartbeat_msg, 10)
def __init__(self, **kwargs):
e = None
if not kwargs.get("account"):
e = Error("param account miss")
if not kwargs.get("strategy"):
e = Error("param strategy miss")
if not kwargs.get("symbol"):
e = Error("param symbol miss")
if not kwargs.get("host"):
kwargs["host"] = "https://api.testnet.fmex.com/"
if not kwargs.get("access_key"):
e = Error("param access_key miss")
if not kwargs.get("secret_key"):
e = Error("param secret_key miss")
if e:
logger.error(e, caller=self)
if kwargs.get("init_success_callback"):
SingleTask.run(kwargs["init_success_callback"], False, e)
return
self._account = kwargs["account"]
self._strategy = kwargs["strategy"]
self._platform = FCOIN_FUTURE
self._symbol = kwargs["symbol"]
self._host = kwargs["host"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._asset_update_callback = kwargs.get("asset_update_callback")
self._order_update_callback = kwargs.get("order_update_callback")
self._position_update_callback = kwargs.get("position_update_callback")
self._init_success_callback = kwargs.get("init_success_callback")
self._update_order_interval = kwargs.get("update_order_interval", 1)
self._assets = {
} # 资产 {"BTC": {"free": "1.1", "locked": "2.2", "total": "3.3"}, ... }
self._orders = {} # 订单
self._position = Position(self._platform, self._account,
self._strategy, self._symbol) # 仓位
# 标记订阅订单、持仓是否成功
self._subscribe_order_ok = False
self._subscribe_position_ok = False
# 初始化 REST API 对象
self._rest_api = FCoinFutureRestAPI(self._host, self._access_key,
self._secret_key)
# 初始化资产订阅
if self._asset_update_callback:
AssetSubscribe(self._platform, self._account,
self.on_event_asset_update)
# 注册定时任务，定时查询订单更新、仓位更新情况
if self._position_update_callback:
LoopRunTask.register(self._check_position_update, 60)
# 初始化订单订阅
if self._order_update_callback:
LoopRunTask.register(self.check_order_update,
self._update_order_interval)
def __init__(self, account, access_key, secret_key, wss=None):
""" 初始化
@param wss websocket连接地址
@param account 资产账户
@param access_key 请求的access_key
@param secret_key 请求的secret_key
"""
self._platform = DERIBIT
self._wss = wss or "wss://deribit.com"
self._account = account
self._access_key = access_key
self._secret_key = secret_key
self._update_interval = 10 # 更新时间间隔(秒)
self._assets = {"BTC": {}, "ETH": {}} # 所有资金详情
self._last_assets = {} # 上次推送的资产信息
url = self._wss + "/ws/api/v2"
super(DeribitAsset, self).__init__(url, send_hb_interval=5)
self._query_id = 0 # 消息序号id，用来唯一标识请求消息
self._queries = {} # 未完成的post请求 {"request_id": future}
self.initialize()
# 注册定时任务
LoopRunTask.register(self._do_auth, 60 * 60) # 每隔1小时重新授权
LoopRunTask.register(self._publish_asset, self._update_interval) # 推送资产
self._ok = False # 是否建立授权成功的websocket连接
def __init__(self, **kwargs):
self._platform = kwargs["platform"]
self._wss = kwargs.get("wss", "wss://real.okex.com:10442")
self._host = kwargs.get("host", "https://www.okex.com")
self._symbols = list(set(kwargs.get("symbols")))
self._channels = kwargs.get("channels")
self._orderbook_length = kwargs.get("orderbook_length", 10)
self._access_key = kwargs.get("access_key")
self._secret_key = kwargs.get("secret_key")
self._passphrase = kwargs.get("passphrase")
self._orderbooks = {
} # orderbook data, e.g. {"symbol": {"bids": {"price": quantity, ...}, "asks": {...}}}
url = self._wss + "/ws/v3"
self._ws = Websocket(url,
connected_callback=self.connected_callback,
process_binary_callback=self.process_binary)
self._ws.initialize()
LoopRunTask.register(self.send_heartbeat_msg, 5)
self._rest_api = OKExFutureRestAPI(self._host, self._access_key,
self._secret_key, self._passphrase)
self._initialize()
def __init__(self):
""" 初始化
"""
self.strategy = config.strategy
self.platform = const.BITMEX
self.account = config.platforms.get(self.platform, {}).get("account")
self.access_key = config.platforms.get(self.platform, {}).get("access_key")
self.secret_key = config.platforms.get(self.platform, {}).get("secret_key")
self.symbol = config.symbol
self.buy_open_order_no = None # 开仓做多订单号
self.buy_open_quantity = "10" # 开仓数量(USD)
self.sell_close_order_no = None # 多仓平仓订单号
self.sell_close_time_down = 0 # 平仓倒计时
self.current_price = None # 当前盘口价格，为了方便，这里假设盘口价格为 卖一 和 买一 的平均值
# 交易模块
cc = {
"strategy": self.strategy,
"platform": self.platform,
"symbol": self.symbol,
"account": self.account,
"access_key": self.access_key,
"secret_key": self.secret_key,
"order_update_callback": self.on_event_order_update,
"position_update_callback": self.on_event_position_update
}
self.trader = Trade(**cc)
# 订阅行情
Market(const.MARKET_TYPE_ORDERBOOK, self.platform, self.symbol, self.on_event_orderbook_update)
# 注册系统循环回调
LoopRunTask.register(self.on_ticker, 1) # 每隔1秒执行一次回调
def __init__(self, **kwargs):
""" 初始化
"""
self._platform = kwargs["platform"]
self._wss = kwargs.get("wss", "wss://deribit.com")
self._account = kwargs["account"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._update_interval = kwargs.get("update_interval",
10) # 更新时间间隔(秒)，默认10秒
self._assets = {"BTC": {}, "ETH": {}} # 所有资金详情
self._last_assets = {} # 上次推送的资产信息
url = self._wss + "/ws/api/v2"
super(DeribitAsset, self).__init__(url, send_hb_interval=5)
self._query_id = 0 # 消息序号id，用来唯一标识请求消息
self._queries = {} # 未完成的post请求 {"request_id": future}
self.initialize()
# 注册定时任务
LoopRunTask.register(self._do_auth, 60 * 60) # 每隔1小时重新授权
LoopRunTask.register(self._publish_asset,
self._update_interval) # 推送资产
self._ok = False # 是否建立授权成功的websocket连接
async def connected_callback(self):
"""网络链接成功回调
"""
#订阅公共频道,无需登录认证
for sym in self._symbols:
if self.cb.on_trade_update_callback != None:
await self.send_json({
'op': 'subscribe',
'channel': 'trades',
'market': sym
})
if self.cb.on_orderbook_update_callback != None:
await self.send_json({
'op': 'subscribe',
'channel': 'orderbook',
'market': sym
})
if self.cb.on_ticker_update_callback != None:
await self.send_json({
'op': 'subscribe',
'channel': 'ticker',
'market': sym
})
if self.cb.on_kline_update_callback != None:
LoopRunTask.register(self._kline_loop_query, 60, sym)
def __init__(self, **kwargs):
""" 初始化
"""
e = None
if not kwargs.get("account"):
e = Error("param account miss")
if not kwargs.get("strategy"):
e = Error("param strategy miss")
if not kwargs.get("symbol"):
e = Error("param symbol miss")
if not kwargs.get("host"):
kwargs["host"] = "https://www.deribit.com"
if not kwargs.get("wss"):
kwargs["wss"] = "wss://deribit.com"
if not kwargs.get("access_key"):
e = Error("param access_key miss")
if not kwargs.get("secret_key"):
e = Error("param secret_key miss")
if e:
logger.error(e, caller=self)
if kwargs.get("init_success_callback"):
SingleTask.run(kwargs["init_success_callback"], False, e)
return
self._account = kwargs["account"]
self._strategy = kwargs["strategy"]
self._platform = DERIBIT
self._symbol = kwargs["symbol"]
self._host = kwargs["host"]
self._wss = kwargs["wss"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._asset_update_callback = kwargs.get("asset_update_callback")
self._order_update_callback = kwargs.get("order_update_callback")
self._position_update_callback = kwargs.get("position_update_callback")
self._init_success_callback = kwargs.get("init_success_callback")
self._order_channel = "user.orders.{symbol}.raw".format(symbol=self._symbol) # 订单订阅频道
url = self._wss + "/ws/api/v2"
super(DeribitTrade, self).__init__(url, send_hb_interval=5)
self._assets = {} # 资产 {"BTC": {"free": "1.1", "locked": "2.2", "total": "3.3"}, ... }
self._orders = {} # 订单
self._position = Position(self._platform, self._account, self._strategy, self._symbol) # 仓位
self._query_id = 0 # 消息序号id，用来唯一标识请求消息
self._queries = {} # 未完成的post请求 {"request_id": future}
self.initialize()
# 初始化资产订阅
if self._asset_update_callback:
AssetSubscribe(self._platform, self._account, self.on_event_asset_update)
# 注册定时任务
LoopRunTask.register(self._do_auth, 60 * 60) # 每隔1小时重新授权
LoopRunTask.register(self._check_position_update, 1) # 获取持仓
self._ok = False # 是否建立授权成功的websocket连接
def __init__(self, **kwargs):
"""Initialize Trade module."""
e = None
if not kwargs.get("account"):
e = Error("param account miss")
if not kwargs.get("strategy"):
e = Error("param strategy miss")
if not kwargs.get("symbol"):
e = Error("param symbol miss")
if not kwargs.get("host"):
kwargs["host"] = "https://api.binance.com"
if not kwargs.get("wss"):
kwargs["wss"] = "wss://stream.binance.com:9443"
if not kwargs.get("access_key"):
e = Error("param access_key miss")
if not kwargs.get("secret_key"):
e = Error("param secret_key miss")
if e:
logger.error(e, caller=self)
if kwargs.get("init_success_callback"):
SingleTask.run(kwargs["init_success_callback"], False, e)
return
self._account = kwargs["account"]
self._strategy = kwargs["strategy"]
self._platform = BINANCE
self._symbol = kwargs["symbol"]
self._host = kwargs["host"]
self._wss = kwargs["wss"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._asset_update_callback = kwargs.get("asset_update_callback")
self._order_update_callback = kwargs.get("order_update_callback")
self._init_success_callback = kwargs.get("init_success_callback")
super(BinanceTrade, self).__init__(self._wss)
self._raw_symbol = self._symbol.replace(
"/", "") # Row symbol name, same as Binance Exchange.
self._listen_key = None # Listen key for Websocket authentication.
self._assets = {
} # Asset data. e.g. {"BTC": {"free": "1.1", "locked": "2.2", "total": "3.3"}, ... }
self._orders = {} # Order data. e.g. {order_no: order, ... }
# Initialize our REST API client.
self._rest_api = BinanceRestAPI(self._host, self._access_key,
self._secret_key)
# Subscribe our AssetEvent.
if self._asset_update_callback:
AssetSubscribe(self._platform, self._account,
self.on_event_asset_update)
# Create a loop run task to reset listen key every 30 minutes.
LoopRunTask.register(self._reset_listen_key, 60 * 30)
# Create a coroutine to initialize Websocket connection.
SingleTask.run(self._init_websocket)
def __init__(self, **kwargs):
""" 初始化
"""
e = None
if not kwargs.get("account"):
e = Error("param account miss")
if not kwargs.get("strategy"):
e = Error("param strategy miss")
if not kwargs.get("symbol"):
e = Error("param symbol miss")
if not kwargs.get("host"):
kwargs["host"] = "https://api.binance.com"
if not kwargs.get("wss"):
kwargs["wss"] = "wss://stream.binance.com:9443"
if not kwargs.get("access_key"):
e = Error("param access_key miss")
if not kwargs.get("secret_key"):
e = Error("param secret_key miss")
if e:
logger.error(e, caller=self)
if kwargs.get("init_success_callback"):
SingleTask.run(kwargs["init_success_callback"], False, e)
return
self._account = kwargs["account"]
self._strategy = kwargs["strategy"]
self._platform = BINANCE
self._symbol = kwargs["symbol"]
self._host = kwargs["host"]
self._wss = kwargs["wss"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._asset_update_callback = kwargs.get("asset_update_callback")
self._order_update_callback = kwargs.get("order_update_callback")
self._init_success_callback = kwargs.get("init_success_callback")
super(BinanceTrade, self).__init__(self._wss)
self._raw_symbol = self._symbol.replace("/", "") # 原始交易对
self._listen_key = None # websocket连接鉴权使用
self._assets = {
} # 资产 {"BTC": {"free": "1.1", "locked": "2.2", "total": "3.3"}, ... }
self._orders = {} # 订单
# 初始化 REST API 对象
self._rest_api = BinanceRestAPI(self._host, self._access_key,
self._secret_key)
# 初始化资产订阅
if self._asset_update_callback:
AssetSubscribe(self._platform, self._account,
self.on_event_asset_update)
# 30分钟重置一下listen key
LoopRunTask.register(self._reset_listen_key, 60 * 30)
# 获取listen key
SingleTask.run(self._init_websocket)
def __init__(self, **kwargs):
"""Initialize."""
e = None
if not kwargs.get("account"):
e = Error("param account miss")
if not kwargs.get("strategy"):
e = Error("param strategy miss")
if not kwargs.get("symbol"):
e = Error("param symbol miss")
if not kwargs.get("host"):
kwargs["host"] = "https://openapi-v2.kucoin.com"
if not kwargs.get("access_key"):
e = Error("param access_key miss")
if not kwargs.get("secret_key"):
e = Error("param secret_key miss")
if not kwargs.get("passphrase"):
e = Error("param passphrase miss")
if e:
logger.error(e, caller=self)
if kwargs.get("init_success_callback"):
SingleTask.run(kwargs["init_success_callback"], False, e)
return
self._account = kwargs["account"]
self._strategy = kwargs["strategy"]
self._platform = KUCOIN
self._symbol = kwargs["symbol"]
self._host = kwargs["host"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._passphrase = kwargs["passphrase"]
self._asset_update_callback = kwargs.get("asset_update_callback")
self._order_update_callback = kwargs.get("order_update_callback")
self._init_success_callback = kwargs.get("init_success_callback")
self._check_order_interval = kwargs.get("check_order_interval", 2)
self._raw_symbol = self._symbol.replace("/", "-") # Raw symbol name.
self._assets = {
} # Asset information. e.g. {"BTC": {"free": "1.1", "locked": "2.2", "total": "3.3"}, ... }
self._orders = {} # Order details. e.g. {order_no: order-object, ... }
# Initialize our REST API client.
self._rest_api = KucoinRestAPI(self._host, self._access_key,
self._secret_key, self._passphrase)
# Create a loop run task to check order status.
LoopRunTask.register(self._check_order_update,
self._check_order_interval)
# Subscribe asset event.
if self._asset_update_callback:
AssetSubscribe(self._platform, self._account,
self.on_event_asset_update)
SingleTask.run(self._initialize)
def __init__(self, **kwargs):
""" 初始化
"""
e = None
if not kwargs.get("account"):
e = Error("param account miss")
if not kwargs.get("strategy"):
e = Error("param strategy miss")
if not kwargs.get("symbol"):
e = Error("param symbol miss")
if not kwargs.get("host"):
kwargs["host"] = "https://api.coinsuper.com"
if not kwargs.get("access_key"):
e = Error("param access_key miss")
if not kwargs.get("secret_key"):
e = Error("param secret_key miss")
if e:
logger.error(e, caller=self)
if kwargs.get("init_success_callback"):
SingleTask.run(kwargs["init_success_callback"], False, e)
return
self._account = kwargs["account"]
self._strategy = kwargs["strategy"]
self._platform = COINSUPER
self._symbol = kwargs["symbol"]
self._host = kwargs["host"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._asset_update_callback = kwargs.get("asset_update_callback")
self._order_update_callback = kwargs.get("order_update_callback")
self._init_success_callback = kwargs.get("init_success_callback")
self._check_order_interval = kwargs.get("check_order_interval",
2) # 检查订单状态更新时间间隔(秒)，默认2秒
self._raw_symbol = self._symbol # 原始交易对
self._assets = {
} # 资产 {"BTC": {"free": "1.1", "locked": "2.2", "total": "3.3"}, ... }
self._orders = {} # 订单
# 初始化 REST API 对象
self._rest_api = CoinsuperRestAPI(self._host, self._access_key,
self._secret_key)
# 循环更新订单状态
LoopRunTask.register(self._check_order_update,
self._check_order_interval)
# 初始化资产订阅
if self._asset_update_callback:
AssetSubscribe(self._platform, self._account,
self.on_event_asset_update)
SingleTask.run(self._initialize)
def __init__(self, **kwargs):
self._platform = kwargs["platform"]
self._wss = kwargs.get("wss", "wss://www.bitmex.com")
self._symbols = list(set(kwargs.get("symbols")))
self._channels = kwargs.get("channels")
self._c_to_s = {} # {"channel": "symbol"}
url = self._wss + "/realtime"
self._ws = Websocket(url, self.connected_callback, process_callback=self.process)
self._ws.initialize()
LoopRunTask.register(self.send_heartbeat_message, 30)
def __init__(self):
self._host = config.rabbitmq.get("host", "localhost")
self._port = config.rabbitmq.get("port", 5672)
self._username = config.rabbitmq.get("username", "guest")
self._password = config.rabbitmq.get("password", "guest")
self._protocol = None
self._channel = None # 连接通道
self._connected = False # 是否连接成功
self._subscribers = [] # 订阅者 [(event, callback, multi), ...]
self._event_handler = {} # 事件对应的处理函数 {"exchange:routing_key": [callback_function, ...]}
LoopRunTask.register(self._check_connection, 10) # 检查连接是否正常
def __init__(self):
self._host = config.rabbitmq.get("host", "localhost")
self._port = config.rabbitmq.get("port", 5672)
self._username = config.rabbitmq.get("username", "guest")
self._password = config.rabbitmq.get("password", "guest")
self._protocol = None
self._channel = None # Connection channel.
self._connected = False # If connect success.
self._subscribers = [] # e.g. [(event, callback, multi), ...]
self._event_handler = {} # e.g. {"exchange:routing_key": [callback_function, ...]}
# Register a loop run task to check TCP connection's healthy.
LoopRunTask.register(self._check_connection, 10)
def __init__(self, **kwargs):
self._platform = kwargs["platform"]
self._wss = kwargs.get("wss", "wss://real.okex.com:8443")
self._symbols = list(set(kwargs.get("symbols")))
self._channels = kwargs.get("channels")
self._orderbook_length = kwargs.get("orderbook_length", 10)
self._orderbooks = {} # 订单薄数据 {"symbol": {"bids": {"price": quantity, ...}, "asks": {...}}}
url = self._wss + "/ws/v3"
self._ws = Websocket(url, connected_callback=self.connected_callback,
process_binary_callback=self.process_binary)
self._ws.initialize()
LoopRunTask.register(self.send_heartbeat_msg, 5)
def __init__(self, **kwargs):
self._platform = kwargs["platform"]
self._wss = kwargs.get("wss", "wss://ws.gate.io")
self._symbols = list(set(kwargs.get("symbols")))
self._channels = kwargs.get("channels")
self._orderbook_length = kwargs.get("orderbook_length", 10)
self._orderbook_price_precious = kwargs.get("orderbook_price_precious", "0.00000001")
self._request_id = 0 # unique request id for per request message.
self._orderbooks = {} # orderbook data, e.g. {"symbol": {"bids": {"price": quantity, ...}, "asks": {...}, "timestamp": 0}, ... }
url = self._wss + "/v3/"
self._ws = Websocket(url, connected_callback=self.connected_callback, process_callback=self.process)
self._ws.initialize()
LoopRunTask.register(self.send_heartbeat_msg, 10)
def __init__(self, **kwargs):
self._platform = kwargs["platform"]
self._wss = kwargs.get("wss", "wss://ws.gate.io")
self._symbols = list(set(kwargs.get("symbols")))
self._channels = kwargs.get("channels")
self._orderbook_length = kwargs.get("orderbook_length", 10)
self._orderbook_price_precious = kwargs.get("orderbook_price_precious", "0.00000001")
self._request_id = 0 # unique request id for per request message.
self._orderbooks = {} # orderbook data, e.g. {"symbol": {"bids": {"price": quantity, ...}, "asks": {...}, "timestamp": 0}, ... }
url = self._wss + "/v3/"
super(GateMarket, self).__init__(url, send_hb_interval=30)
self.initialize()
LoopRunTask.register(self._reset_ping_message, 10)
def __init__(self, **kwargs):
"""Initialize object."""
self._platform = kwargs["platform"]
self._host = kwargs.get("host", "https://api.huobi.pro")
self._account = kwargs["account"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._update_interval = kwargs.get("update_interval", 10)
self._assets = {} # All currencies
# Create a REST API client.
self._rest_api = HuobiRestAPI(self._host, self._access_key, self._secret_key)
# Register a loop run task to fetching asset information.
LoopRunTask.register(self.check_asset_update, self._update_interval)
def __init__(self):
""" 初始化
"""
self.strategy = config.strategy
self.platform = const.BINANCE
self.account = config.accounts[0]["account"]
self.access_key = config.accounts[0]["access_key"]
self.secret_key = config.accounts[0]["secret_key"]
self.symbol = config.symbol
self.buy_open_order_no = None # 开仓做多订单号
self.buy_open_price = 0
self.buy_open_quantity = "0.003" # 开仓数量(USD)
self.sell_close_order_no = None # 多仓平仓订单号
self.sell_close_time_down = 0 # 平仓倒计时
self.bsud_usdt_price = 0
self.btc_busd_relative = {}
self.highest_price = 0
self.lowest_price = 999999
self.threshold = 0.001
#self.current_price = None # 当前盘口价格，为了方便，这里假设盘口价格为 卖一 和 买一 的平均值
# 交易模块
cc = {
"strategy": self.strategy,
"platform": self.platform,
"symbol": self.symbol,
"account": self.account,
"access_key": self.access_key,
"secret_key": self.secret_key,
"order_update_callback": self.on_event_order_update,
"position_update_callback": self.on_event_position_update
}
self.trader = Trade(**cc)
# 订阅行情
Market(const.MARKET_TYPE_ORDERBOOK, 'binance', 'BTC/USDT',
self.on_event_orderbook_btcusdt_update)
Market(const.MARKET_TYPE_ORDERBOOK, 'binance', 'BUSD/USDT',
self.on_event_orderbook_busdusdt_update)
Market(const.MARKET_TYPE_ORDERBOOK, 'binance', 'BTC/BUSD',
self.on_event_orderbook_update)
# 注册系统循环回调
LoopRunTask.register(self.on_ticker, 1) # 每隔1秒执行一次回调
async def connected_callback(self):
"""网络链接成功回调
"""
if self._account != None:
#账号不为空就要进行登录认证,然后订阅2个需要登录后才能订阅的私有频道:用户挂单通知和挂单成交通知(FTX只支持这2个私有频道)
await self._login() #登录认证
#`用户挂单通知回调`不为空,就进行订阅
if self.cb.on_order_update_callback != None:
await self.ws.send_json({
'op': 'subscribe',
'channel': 'orders'
})
#`用户挂单成交通知回调`不为空,就进行订阅
if self.cb.on_fill_update_callback != None:
await self.ws.send_json({
'op': 'subscribe',
'channel': 'fills'
})
#订阅公共频道,无需登录认证
for sym in self._symbols:
if self.cb.on_trade_update_callback != None:
await self.ws.send_json({
'op': 'subscribe',
'channel': 'trades',
'market': sym
})
if self.cb.on_orderbook_update_callback != None:
await self.ws.send_json({
'op': 'subscribe',
'channel': 'orderbook',
'market': sym
})
if self.cb.on_ticker_update_callback != None:
await self.ws.send_json({
'op': 'subscribe',
'channel': 'ticker',
'market': sym
})
if self.cb.on_kline_update_callback != None:
LoopRunTask.register(self._kline_loop_query, 60, sym)
async def _initialize(self):
"""Initialize."""
for channel in self._channels:
if channel == "orderbook":
LoopRunTask.register(self.do_orderbook_update,
self._orderbook_interval)
elif channel == "trade":
# Create Websocket connection.
success, error = await self._rest_api.get_websocket_token()
if error:
logger.error("get websocket token error!", caller=self)
return
url = "{}?token={}".format(
success["instanceServers"][0]["endpoint"],
success["token"])
self._ws = Websocket(url, self.connected_callback,
self.process)
self._ws.initialize()
LoopRunTask.register(self.send_heartbeat_msg, 30)
def __init__(self, **kwargs):
""" 初始化
"""
self._platform = kwargs["platform"]
self._host = kwargs.get("host", "https://www.bitmex.com")
self._account = kwargs["account"]
self._access_key = kwargs["access_key"]
self._secret_key = kwargs["secret_key"]
self._update_interval = kwargs.get("update_interval",
10) # 更新时间间隔(秒)，默认10秒
self._assets = {} # 所有资金详情
# 创建rest api请求对象
self._rest_api = BitmexAPI(self._host, self._access_key,
self._secret_key)
# 注册心跳定时任务
LoopRunTask.register(self.check_asset_update, self._update_interval)
def __init__(self,
account,
strategy,
symbol,
host=None,
wss=None,
access_key=None,
secret_key=None,
order_update_callback=None):
""" 初始化
@param account 账户
@param strategy 策略名称
@param symbol 交易对（合约名称）
@param host HTTP请求主机地址
@param wss websocket连接地址
@param access_key ACCESS KEY
@param secret_key SECRET KEY
@param order_update_callback 订单更新回调
"""
self._account = account
self._strategy = strategy
self._platform = BINANCE
self._symbol = symbol
self._raw_symbol = symbol.replace("/", "")
self._host = host if host else "https://api.binance.com"
self._wss = wss if wss else "wss://stream.binance.com:9443"
self._access_key = access_key
self._secret_key = secret_key
self._order_update_callback = order_update_callback
super(BinanceTrade, self).__init__(self._wss)
self._listen_key = None # websocket连接鉴权使用
self._orders = {} # 订单
# 初始化 REST API 对象
self._rest_api = BinanceRestAPI(self._host, self._access_key,
self._secret_key)
# 30分钟重置一下listen key
LoopRunTask.register(self._reset_listen_key, 60 * 30)
# 获取listen key
SingleTask.run(self._init_websocket)
def __init__(self, account, strategy, symbol, host=None, wss=None, access_key=None, secret_key=None,
order_update_callback=None, position_update_callback=None):
""" 初始化
@param account 账户
@param strategy 策略名称
@param symbol 交易对（合约名称）
@param host HTTP请求主机地址
@param wss websocket连接地址
@param access_key ACCESS KEY
@param secret_key SECRET KEY
@param order_update_callback 订单更新回调
@param position_update_callback 持仓更新回调
"""
self._account = account
self._strategy = strategy
self._platform = DERIBIT
self._symbol = symbol
self._host = host if host else "https://www.deribit.com"
self._wss = wss if wss else "wss://deribit.com/ws/api/v2"
self._access_key = access_key
self._secret_key = secret_key
self._order_update_callback = order_update_callback
self._position_update_callback = position_update_callback
self._order_channel = "user.orders.{symbol}.raw".format(symbol=symbol) # 订单订阅频道
super(DeribitTrade, self).__init__(self._wss, send_hb_interval=5)
self._orders = {} # 订单
self._position = Position(self._platform, self._account, strategy, symbol) # 仓位
self._query_id = 0 # 消息序号id，用来唯一标识请求消息
self._queries = {} # 未完成的post请求 {"request_id": future}
self.initialize()
# 注册定时任务
LoopRunTask.register(self._do_auth, 60 * 60) # 每隔1小时重新授权
LoopRunTask.register(self._check_position_update, 1) # 获取持仓
self._ok = False # 是否建立授权成功的websocket连接
def __init__(self, **kwargs):
"""Initialized."""
self._platform = kwargs["platform"]
self._host = kwargs.get("host", "https://api.kraken.com")
self._wss = kwargs.get("wss", "wss://ws.kraken.com")
self._symbols = list(set(kwargs.get("symbols")))
self._channels = kwargs.get("channels")
self._orderbook_length = kwargs.get("orderbook_length", 10)
self.heartbeat_msg = {}
self._orderbooks = {
} # orderbook data, e.g. {"symbol": {"bids": {"price": quantity, ...}, "asks": {...}, "timestamp": 0}, ... }
self._rest_api = KrakenRestAPI(self._host, None, None)
super(KrakenMarket, self).__init__(self._wss)
self.initialize()
# Register a loop run task to reset heartbeat message request id.
LoopRunTask.register(self._update_heartbeat_msg, 5)