From 8d02c24206eb91fa5b906f31f7b68cd2878f6a9c Mon Sep 17 00:00:00 2001
From: uelin <uelinx@gmail.com>
Date: Wed, 5 Jun 2019 21:32:15 +0800
Subject: [PATCH 1/4] add binance gateway

---
 tests/trader/run.py                     |  82 +--
 vnpy/gateway/binance/__init__.py        |   1 +
 vnpy/gateway/binance/binance_gateway.py | 861 ++++++++++++++++++++++++
 vnpy/trader/constant.py                 |   1 +
 4 files changed, 905 insertions(+), 40 deletions(-)
 create mode 100644 vnpy/gateway/binance/__init__.py
 create mode 100644 vnpy/gateway/binance/binance_gateway.py

diff --git a/tests/trader/run.py b/tests/trader/run.py
index cf698f0e..43eccd5b 100644
--- a/tests/trader/run.py
+++ b/tests/trader/run.py
@@ -4,28 +4,29 @@ from vnpy.event import EventEngine
 from vnpy.trader.engine import MainEngine
 from vnpy.trader.ui import MainWindow, create_qapp
 
-from vnpy.gateway.bitmex import BitmexGateway
-from vnpy.gateway.futu import FutuGateway
-from vnpy.gateway.ib import IbGateway
-from vnpy.gateway.ctp import CtpGateway
+from vnpy.gateway.binance import BinanceGateway
+#from vnpy.gateway.bitmex import BitmexGateway
+#from vnpy.gateway.futu import FutuGateway
+#from vnpy.gateway.ib import IbGateway
+#from vnpy.gateway.ctp import CtpGateway
 # from vnpy.gateway.ctptest import CtptestGateway
-from vnpy.gateway.femas import FemasGateway
-from vnpy.gateway.tiger import TigerGateway
-from vnpy.gateway.oes import OesGateway
-from vnpy.gateway.okex import OkexGateway
-from vnpy.gateway.huobi import HuobiGateway
-from vnpy.gateway.bitfinex import BitfinexGateway
-from vnpy.gateway.onetoken import OnetokenGateway
-from vnpy.gateway.okexf import OkexfGateway
-from vnpy.gateway.xtp import XtpGateway
-from vnpy.gateway.hbdm import HbdmGateway
+#from vnpy.gateway.femas import FemasGateway
+#from vnpy.gateway.tiger import TigerGateway
+#from vnpy.gateway.oes import OesGateway
+#from vnpy.gateway.okex import OkexGateway
+#from vnpy.gateway.huobi import HuobiGateway
+#from vnpy.gateway.bitfinex import BitfinexGateway
+#from vnpy.gateway.onetoken import OnetokenGateway
+#from vnpy.gateway.okexf import OkexfGateway
+#from vnpy.gateway.xtp import XtpGateway
+#from vnpy.gateway.hbdm import HbdmGateway
 
-from vnpy.app.cta_strategy import CtaStrategyApp
-from vnpy.app.csv_loader import CsvLoaderApp
-from vnpy.app.algo_trading import AlgoTradingApp
-from vnpy.app.cta_backtester import CtaBacktesterApp
-from vnpy.app.data_recorder import DataRecorderApp
-from vnpy.app.risk_manager import RiskManagerApp
+#from vnpy.app.cta_strategy import CtaStrategyApp
+#from vnpy.app.csv_loader import CsvLoaderApp
+#from vnpy.app.algo_trading import AlgoTradingApp
+#from vnpy.app.cta_backtester import CtaBacktesterApp
+#from vnpy.app.data_recorder import DataRecorderApp
+#from vnpy.app.risk_manager import RiskManagerApp
 
 
 def main():
@@ -35,28 +36,29 @@ def main():
     event_engine = EventEngine()
 
     main_engine = MainEngine(event_engine)
-    main_engine.add_gateway(XtpGateway)
-    main_engine.add_gateway(CtpGateway)
+    main_engine.add_gateway(BinanceGateway)
+    #main_engine.add_gateway(XtpGateway)
+    #main_engine.add_gateway(CtpGateway)
     # main_engine.add_gateway(CtptestGateway)
-    main_engine.add_gateway(FemasGateway)
-    main_engine.add_gateway(IbGateway)
-    main_engine.add_gateway(FutuGateway)
-    main_engine.add_gateway(BitmexGateway)
-    main_engine.add_gateway(TigerGateway)
-    main_engine.add_gateway(OesGateway)
-    main_engine.add_gateway(OkexGateway)
-    main_engine.add_gateway(HuobiGateway)
-    main_engine.add_gateway(BitfinexGateway)
-    main_engine.add_gateway(OnetokenGateway)
-    main_engine.add_gateway(OkexfGateway)
-    main_engine.add_gateway(HbdmGateway)
+    #main_engine.add_gateway(FemasGateway)
+    #main_engine.add_gateway(IbGateway)
+    #main_engine.add_gateway(FutuGateway)
+    #main_engine.add_gateway(BitmexGateway)
+    #main_engine.add_gateway(TigerGateway)
+    #main_engine.add_gateway(OesGateway)
+    #main_engine.add_gateway(OkexGateway)
+    #main_engine.add_gateway(HuobiGateway)
+    #main_engine.add_gateway(BitfinexGateway)
+    #main_engine.add_gateway(OnetokenGateway)
+    #main_engine.add_gateway(OkexfGateway)
+    #main_engine.add_gateway(HbdmGateway)
 
-    main_engine.add_app(CtaStrategyApp)
-    main_engine.add_app(CtaBacktesterApp)
-    main_engine.add_app(CsvLoaderApp)
-    main_engine.add_app(AlgoTradingApp)
-    main_engine.add_app(DataRecorderApp)
-    main_engine.add_app(RiskManagerApp)
+    #main_engine.add_app(CtaStrategyApp)
+    #main_engine.add_app(CtaBacktesterApp)
+    #main_engine.add_app(CsvLoaderApp)
+    #main_engine.add_app(AlgoTradingApp)
+    #main_engine.add_app(DataRecorderApp)
+    #main_engine.add_app(RiskManagerApp)
 
     main_window = MainWindow(main_engine, event_engine)
     main_window.showMaximized()
diff --git a/vnpy/gateway/binance/__init__.py b/vnpy/gateway/binance/__init__.py
new file mode 100644
index 00000000..6b951a7a
--- /dev/null
+++ b/vnpy/gateway/binance/__init__.py
@@ -0,0 +1 @@
+from .binance_gateway import BinanceGateway
diff --git a/vnpy/gateway/binance/binance_gateway.py b/vnpy/gateway/binance/binance_gateway.py
new file mode 100644
index 00000000..4345067f
--- /dev/null
+++ b/vnpy/gateway/binance/binance_gateway.py
@@ -0,0 +1,861 @@
+# encoding: UTF-8
+
+"""
+币安交易接口
+"""
+
+import re
+import urllib
+import base64
+import json
+import zlib
+import hashlib
+import hmac
+import time
+from copy import copy
+from datetime import datetime
+from threading import Thread
+
+from vnpy.event import Event
+from vnpy.api.rest import RestClient, Request
+from vnpy.api.websocket import WebsocketClient
+from vnpy.trader.constant import (
+    Direction,
+    Exchange,
+    Product,
+    Status,
+    OrderType
+)
+from vnpy.trader.gateway import BaseGateway, LocalOrderManager
+from vnpy.trader.object import (
+    TickData,
+    OrderData,
+    TradeData,
+    AccountData,
+    ContractData,
+    OrderRequest,
+    CancelRequest,
+    SubscribeRequest
+)
+from vnpy.trader.event import EVENT_TIMER
+
+
+REST_HOST = "https://www.binance.com"
+WEBSOCKET_TRADE_HOST = "wss://stream.binance.com:9443/ws/"                  # Account and Order
+WEBSOCKET_DATA_HOST = "wss://stream.binance.com:9443/stream?streams="       # Market Data
+
+STATUS_BINANCE2VT = {
+    "NEW": Status.NOTTRADED,
+    "PARTIALLY_FILLED": Status.PARTTRADED,
+    "FILLED": Status.ALLTRADED,
+    "CANCELED": Status.CANCELLED,
+    "REJECTED": Status.REJECTED
+}
+
+ORDERTYPE_VT2BINANCE = {
+    OrderType.LIMIT: "LIMIT",
+    OrderType.MARKET: "MARKET",
+    OrderType.STOP: "STOP_LOSS", 
+}
+
+ORDERTYPE_BINANCE2VT = {v: k for k, v in ORDERTYPE_VT2BINANCE.items()}
+
+DIRECTION_VT2BINANCE = {
+    Direction.LONG: "BUY",
+    Direction.SHORT: "SELL"
+}
+
+DIRECTION_BINANCE2VT = {v: k for k, v in DIRECTION_VT2BINANCE.items()}
+
+binance_symbols = set()
+symbol_name_map = {}
+
+
+class BinanceGateway(BaseGateway):
+    """
+    VN Trader Gateway for Binance connection.
+    """
+
+    default_setting = {
+        "key": "",
+        "secret": "",
+        "session_number": 3,
+        "proxy_host": "127.0.0.1",
+        "proxy_port": 1080,
+    }
+
+    exchanges = [Exchange.BINANCE]
+
+    def __init__(self, event_engine):
+        """Constructor"""
+        super(BinanceGateway, self).__init__(event_engine, "BINANCE")
+
+        self.order_manager = LocalOrderManager(self)
+
+        self.rest_api = BinanceRestApi(self)
+        self.trade_ws_api = BinanceTradeWebsocketApi(self)
+        self.market_ws_api = BinanceDataWebsocketApi(self)
+
+    def connect(self, setting: dict):
+        """"""
+        key = setting["key"]
+        secret = setting["secret"]
+        session_number = setting["session_number"]
+        proxy_host = setting["proxy_host"]
+        proxy_port = setting["proxy_port"]
+
+        self.rest_api.connect(key, secret, session_number,
+                              proxy_host, proxy_port)
+        #self.trade_ws_api.connect(key, secret, proxy_host, proxy_port)
+        self.market_ws_api.connect(key, secret, proxy_host, proxy_port)
+
+        #self.init_query()
+
+    def subscribe(self, req: SubscribeRequest):
+        """"""
+        self.market_ws_api.subscribe(req)
+        self.trade_ws_api.subscribe(req)
+
+    def send_order(self, req: OrderRequest):
+        """"""
+        return self.rest_api.send_order(req)
+
+    def cancel_order(self, req: CancelRequest):
+        """"""
+        self.rest_api.cancel_order(req)
+
+    def query_account(self):
+        """"""
+        self.rest_api.query_account()
+
+    def query_position(self):
+        """"""
+        pass
+
+    def close(self):
+        """"""
+        self.rest_api.stop()
+        self.trade_ws_api.stop()
+        self.market_ws_api.stop()
+
+    def process_timer_event(self, event: Event):
+        """"""
+        self.count += 1
+        if self.count < 3:
+            return
+
+        self.query_account()
+
+    def init_query(self):
+        """"""
+        self.count = 0
+        self.event_engine.register(EVENT_TIMER, self.process_timer_event)
+
+class BinanceRestApi(RestClient):
+    """
+    BINANCE REST API
+    """
+
+    def __init__(self, gateway: BaseGateway):
+        """"""
+        super(BinanceRestApi, self).__init__()
+
+        self.gateway = gateway
+        self.gateway_name = gateway.gateway_name
+        self.order_manager = gateway.order_manager
+        self.trade_ws_api = BinanceTradeWebsocketApi(self.gateway)
+
+        self.host = ""
+        self.key = ""
+        self.secret = ""
+        self.userStreamKey = ""
+        self.keepaliveCount = 0
+        self.recvWindow = 5000
+        self.time_offset = 0
+
+        self.cancel_requests = {}
+        self.orders = {}
+
+    def sign(self, request):
+        """
+        Generate BINANCE signature.
+        """
+        if request.params:
+            path = request.path + "?" + urllib.parse.urlencode(request.params)
+        else:
+            request.params = dict()
+            path = request.path
+        security = "NONE"
+        if request.data:
+            security = request.data['security']
+        
+        if security == "SIGNED":
+            timestamp = int(time.time() * 1000)
+            if self.time_offset > 0:
+                timestamp -= abs(self.time_offset)
+            elif self.time_offset < 0:
+                timestamp += abs(self.time_offset)
+            request.params['timestamp'] = timestamp
+            request.params['recvWindow'] = self.recvWindow
+
+            query = urllib.parse.urlencode(sorted(request.params.items()))
+            signature = hmac.new(self.secret, query.encode('utf-8'), hashlib.sha256).hexdigest()
+            query += "&signature={}".format(signature)
+            path = request.path + "?" + query
+        request.path = path
+        request.params = {}
+        request.data = {}
+        # Add headers
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Accept": "application/json",
+            "X-MBX-APIKEY": self.key
+        }
+        if security == "SIGNED" or security == "API-KEY":
+            request.headers = headers
+        return request
+
+    def connect(
+        self,
+        key: str,
+        secret: str,
+        session_number: int,
+        proxy_host: str,
+        proxy_port: int
+    ):
+        """
+        Initialize connection to REST server.
+        """
+        self.key = key
+        self.secret = secret.encode()
+        self.proxy_port = proxy_port
+        self.proxy_host = proxy_host 
+
+        self.host, _ = _split_url(REST_HOST)
+
+        self.init(REST_HOST, proxy_host, proxy_port)
+        self.start(session_number)
+
+        self.gateway.write_log("REST API启动成功")
+
+        self.query_time()
+        self.query_account()
+        self.query_order()
+        self.query_contract()
+        self.start_userStream()
+    
+    def query_time(self):
+        """"""
+        data = {
+            "security": "NONE"
+        }
+        path = '/api/v1/time'
+        return self.add_request(
+            "GET",
+            path,
+            callback=self.on_query_time,
+            data=data
+        )
+    
+    def query_account(self):
+        """"""
+        data = {
+            "security": "SIGNED"
+        }
+        self.add_request(
+            method="GET",
+            path="/api/v3/account",
+            callback=self.on_query_account,
+            data=data
+        )
+
+    def query_order(self):
+        """"""
+        data = {
+            "security": "SIGNED"
+        }
+        self.add_request(
+            method="GET",
+            path="/api/v3/openOrders",
+            callback=self.on_query_order,
+            data=data
+        )
+
+    def query_contract(self):
+        """"""
+        data = {
+            "security": "NONE"
+        }
+        self.add_request(
+            method="GET",
+            path="/api/v1/exchangeInfo",
+            callback=self.on_query_contract,
+            data=data
+        )
+
+    def send_order(self, req: OrderRequest):
+        """"""
+        local_orderid = self.order_manager.new_local_orderid()
+        order = req.create_order_data(
+            local_orderid,
+            self.gateway_name
+        )
+        order.time = datetime.now().strftime("%H:%M:%S")
+
+        data = {
+            "security": "SIGNED"
+        }
+
+        params = {
+            "symbol": req.symbol,
+            "timeInForce": "GTC",
+            "side": DIRECTION_VT2BINANCE[req.direction],
+            "type": ORDERTYPE_VT2BINANCE[req.type],
+            "price": str(req.price),
+            "quantity": str(req.volume)
+        }
+
+        self.add_request(
+            method="POST",
+            path="/api/v3/order",
+            callback=self.on_send_order,
+            data=data,
+            params=params,
+            extra=order,
+            on_error=self.on_send_order_error,
+            on_failed=self.on_send_order_failed
+        )
+
+        self.order_manager.on_order(order)
+        return order.vt_orderid
+
+    def cancel_order(self, req: CancelRequest):
+        """"""
+        sys_orderid = self.order_manager.get_sys_orderid(req.orderid)
+
+        data = {
+            "security": "SIGNED"
+        }
+        params = {
+            "symbol": req.symbol,
+            "orderId": req.orderid
+        }
+        self.add_request(
+            method="DELETE",
+            path="/api/v3/order",
+            callback=self.on_cancel_order,
+            params=params,
+            data=data,
+            extra=req
+        )
+
+    def start_userStream(self):
+        """"""
+        data = {
+            "security": "API-KEY"
+        }
+        self.add_request(
+            method="POST",
+            path='/api/v1/userDataStream',
+            callback=self.on_start_userStream,
+            data=data
+        )
+
+    def keepalive_userStream(self):
+        """"""
+        self.keepaliveCount += 1
+        if self.keepaliveCount < 1800:
+            return
+        data = {
+            "security": "SIGNED"
+        }
+        params = {
+            'listenKey': self.userStreamKey
+        }
+        self.add_request(
+            method='PUT', 
+            path='/api/v1/userDataStream', 
+            callback=self.on_keepalive_userStream,
+            params=params, 
+            data=data
+        )
+
+    def close_userStream(self, listenKey):
+        """"""
+        data = {
+            "security": "SIGNED"
+        }
+        params = {
+            'listenKey': listenKey
+        }
+        self.add_request(
+            method='DELETE',
+            path='/api/v1/userDataStream',
+            callback=self.on_close_userStream,
+            params=params,
+            data=data
+        ) 
+
+    def on_query_time(self, data, request):
+        """"""
+        time_now = int(time.time() * 1000)
+        time_server = int(data["serverTime"])
+        server_local_time = time.localtime(float(time_server / 1000))
+        now_local_time = time.localtime(float(time_now / 1000))
+        self.time_offset = time_now - time_server
+        server_time = time.strftime("%Y-%m-%d %H:%M:%S", server_local_time)
+        local_time = time.strftime("%Y-%m-%d %H:%M:%S", now_local_time)
+        msg = f"服务器时间：{server_time}，本机时间：{local_time}"
+        self.gateway.write_log(msg)
+
+    def on_query_account(self, data, request):
+        """"""
+        for account_data in data["balances"]:
+            account = AccountData(
+                accountid=account_data["asset"],
+                balance=float(account_data["free"]),
+                frozen=float(account_data["locked"]),
+                gateway_name=self.gateway_name
+            )
+            self.gateway.on_account(account)
+
+        self.gateway.write_log("账户资金查询成功")
+
+    def on_query_order(self, data, request):
+        """"""
+        for d in data:
+            sys_orderid = d["orderId"]
+            local_orderid = self.order_manager.get_local_orderid(sys_orderid)
+
+            direction = DIRECTION_BINANCE2VT[d["side"]]
+            order_type = ORDERTYPE_BINANCE2VT[d["type"]]
+            dt = datetime.fromtimestamp(d["time"] / 1000)
+            time = dt.strftime("%Y-%m-%d %H:%M:%S")
+
+            order = OrderData(
+                orderid=sys_orderid,
+                symbol=d["symbol"],
+                exchange=Exchange.BINANCE,
+                price=float(d["price"]),
+                volume=float(d["origQty"]),
+                type=order_type,
+                direction=direction,
+                traded=float(d["executedQty"]),
+                status=STATUS_BINANCE2VT.get(d["status"], None),
+                time=time,
+                gateway_name=self.gateway_name,
+            )
+
+            self.order_manager.on_order(order)
+
+        self.gateway.write_log("委托信息查询成功")
+
+    def on_query_contract(self, data, request):
+        """"""
+        for d in data["symbols"]:
+            base_currency = d["baseAsset"]
+            quote_currency = d["quoteAsset"]
+            name = f"{base_currency.upper()}/{quote_currency.upper()}"
+            pricetick = 0
+            min_volume = 0
+            for f in d["filters"]:
+                if f["filterType"] == "PRICE_FILTER":
+                    pricetick = f["tickSize"]
+                if f["filterType"] == "LOT_SIZE":
+                    min_volume = f["stepSize"]
+            contract = ContractData(
+                symbol=d["symbol"],
+                exchange=Exchange.BINANCE,
+                name=name,
+                pricetick=pricetick,
+                size=1,
+                min_volume=min_volume,
+                product=Product.SPOT,
+                gateway_name=self.gateway_name,
+            )
+            self.gateway.on_contract(contract)
+
+            binance_symbols.add(contract.symbol)
+            symbol_name_map[contract.symbol] = contract.name
+
+        self.gateway.write_log("合约信息查询成功")
+
+    def on_send_order(self, data, request):
+        """"""
+        order = request.extra
+        if self.check_error(data, "委托"):
+            order.status = Status.REJECTED
+            self.order_manager.on_order(order)
+            return
+        order.status = STATUS_BINANCE2VT.get(data["status"], None)
+        sys_orderid = data["orderId"]
+        self.order_manager.on_order(order)
+        self.order_manager.update_orderid_map(order.orderid, sys_orderid) 
+
+    def on_send_order_failed(self, status_code: str, request: Request):
+        """
+        Callback when sending order failed on server.
+        """
+        order = request.extra
+        order.status = Status.REJECTED
+        self.gateway.on_order(order)
+
+        msg = f"委托失败，状态码：{status_code}，信息：{request.response.text}"
+        self.gateway.write_log(msg)
+
+    def on_send_order_error(
+        self, exception_type: type, exception_value: Exception, tb, request: Request
+    ):
+        """
+        Callback when sending order caused exception.
+        """
+        order = request.extra
+        order.status = Status.REJECTED
+        self.gateway.on_order(order)
+
+        # Record exception if not ConnectionError
+        if not issubclass(exception_type, ConnectionError):
+            self.on_error(exception_type, exception_value, tb, request)
+
+    def on_cancel_order(self, data, request):
+        """"""
+        cancel_request = request.extra
+        local_orderid = cancel_request.orderid
+        order = self.order_manager.get_order_with_local_orderid(local_orderid)
+        
+        if self.check_error(data, "撤单"):
+            order.status = Status.REJECTED
+        else:
+            order.status = Status.CANCELLED
+            self.gateway.write_log(f"委托撤单成功：{order.orderid}")
+        
+        self.order_manager.on_order(order)
+    
+    def on_start_userStream(self, data, request):
+        self.userStreamKey = data['listenKey']
+        self.keepaliveCount = 0
+        url = WEBSOCKET_TRADE_HOST + self.userStreamKey
+        self.trade_ws_api.connect(
+            key=self.key, 
+            secret=self.secret, 
+            url=url, 
+            proxy_host=self.proxy_host, 
+            proxy_port=self.proxy_port)
+
+    def on_keepalive_userStream(self, data, request):
+        self.gateway.write_log("交易推送刷新成功")
+        if self.keepaliveCount >= 1800:
+            self.keepaliveCount = 0
+            self.keepalive_userStream(self.userStreamKey)
+
+    def on_close_userStream(self, listenKey):
+        self.gateway.write_log("交易推送关闭")
+    
+    def check_error(self, data: dict, func: str = ""):
+        """"""
+        if data["status"] != "error":
+            return False
+        
+        error_code = data["err-code"]
+        error_msg = data["err-msg"]
+
+        self.gateway.write_log(f"{func}请求出错，代码：{error_code}，信息：{error_msg}")
+        return True
+
+
+class BinanceWebsocketApiBase(WebsocketClient):
+    """"""
+
+    def __init__(self, gateway):
+        """"""
+        super(BinanceWebsocketApiBase, self).__init__()
+
+        self.gateway = gateway
+        self.gateway_name = gateway.gateway_name
+
+        self.key = ""
+        self.secret = ""
+        #self.sign_host = ""
+        self.path = ""
+
+    def connect(
+        self, 
+        key: str, 
+        secret: str, 
+        url: str, 
+        proxy_host: str, 
+        proxy_port: int
+    ):
+        """"""
+        self.key = key
+        self.secret = secret
+        
+        #host, path = _split_url(url)
+        #self.sign_host = host
+        #self.path = path
+
+        self.init(url, proxy_host, proxy_port)
+        self.start()
+
+    def login(self):
+        """"""
+        params = {"op": "auth"}
+        #params.update(create_signature(self.key, "GET", self.sign_host, self.path, self.secret))        
+        return self.send_packet(params)
+
+    def on_login(self, packet):
+        """"""
+        pass
+
+    @staticmethod
+    def unpack_data(data):
+        """"""
+        print("==============unpack_data============")
+        print(data)
+        return json.loads(data)
+        #return json.loads(zlib.decompress(data, zlib.Z_BEST_COMPRESSION))
+
+    def on_packet(self, packet):
+        """"""
+        print("=============on_packet=============")
+        print("event type:"+packet["e"])
+        print(packet)
+        #if packet["e"] == "executionReport":
+        if "ping" in packet:
+            req = {"pong": packet["ping"]}
+            self.send_packet(req)
+        elif "op" in packet and packet["op"] == "ping":
+            req = {
+                "op": "pong",
+                "ts": packet["ts"]
+            }
+            self.send_packet(req)
+        elif "err-msg" in packet:
+            return self.on_error_msg(packet)
+        elif "op" in packet and packet["op"] == "auth":
+            return self.on_login()
+        else:
+            self.on_data(packet)
+    
+    def on_data(self, packet): 
+        """"""
+        print("data : {}".format(packet))
+
+    def on_error_msg(self, packet): 
+        """"""
+        msg = packet["err-msg"]
+        if msg == "invalid pong":
+            return
+        
+        self.gateway.write_log(packet["err-msg"])
+
+
+class BinanceTradeWebsocketApi(BinanceWebsocketApiBase):
+    """"""
+    def __init__(self, gateway):
+        """"""
+        super().__init__(gateway)
+
+        self.order_manager = gateway.order_manager
+        self.order_manager.push_data_callback = self.on_data
+
+        self.req_id = 0
+
+    def connect(self, key, secret, url, proxy_host, proxy_port):
+        """"""
+        super().connect(key, secret, url, proxy_host, proxy_port)
+        self.gateway.write_log("交易Websocket API连接成功")
+        self.gateway.rest_api.keepalive_userStream()
+
+    def subscribe(self, req: SubscribeRequest):
+        """"""
+        self.req_id += 1
+        req = {
+            "op": "sub",
+            "cid": str(self.req_id),
+            "topic": f"orders.{req.symbol}"
+        }
+        self.send_packet(req)
+
+    def on_connected(self):
+        """"""
+        pass
+
+    def on_login(self):
+        """"""
+        pass
+
+    def on_data(self, packet):  # type: (dict)->None
+        """"""
+        print("==========on_data1=========")
+        # push order data change
+        if packet["e"] == "executionReport":
+            order = OrderData(
+                    symbol=packet["s"],
+                    exchange=Exchange.BINANCE,
+                    orderid=packet["i"],
+                    status=STATUS_BINANCE2VT.get(packet["X"], None),
+                    traded=float(packet["Z"]),
+                    price=float(packet["L"]),
+                    time=packet["O"],
+                    gateway_name=self.gateway_name
+                )
+            self.on_order(order)
+        # push account data change
+        if packet["e"] == "outboundAccountInfo":
+            for account_data in packet["B"]:
+                account = AccountData(
+                    accountid=account_data["a"],
+                    balance=float(account_data["f"]),
+                    frozen=float(account_data["l"]),
+                    gateway_name=self.gateway_name
+                )
+                self.on_account(account)
+
+    def on_order(self, data: dict):
+        """"""
+        sys_orderid = data.orderid
+        
+        order = self.order_manager.get_order_with_sys_orderid(sys_orderid)
+        if not order:
+            self.order_manager.add_push_data(sys_orderid, data)
+            return
+
+        # Push order event
+        order.traded = data.traded
+        order.status = data.status
+        self.order_manager.on_order(order)
+        
+        # Push trade event
+        traded_volume = data.traded
+        if not traded_volume:
+            return
+
+        trade = TradeData(
+            symbol=order.symbol,
+            exchange=Exchange.BINANCE,
+            orderid=order.orderid,
+            direction=order.direction,
+            price=float(order.price),
+            volume=float(order.traded),
+            time=datetime.now().strftime("%H:%M:%S"),
+            gateway_name=self.gateway_name,
+        )    
+        self.gateway.on_trade(trade)
+
+    def on_account(self, data: dict):
+        """"""
+        self.gateway.on_account(data)
+
+class BinanceDataWebsocketApi(BinanceWebsocketApiBase):
+    """"""
+
+    def __init__(self, gateway):
+        """"""
+        super().__init__(gateway)
+
+        self.req_id = 0
+        self.ticks = {}
+
+    def connect(self, key: str, secret: str, proxy_host: str, proxy_port: int):
+        """"""
+        super().connect(key, secret, WEBSOCKET_DATA_HOST, proxy_host, proxy_port)
+        self.gateway.write_log("行情Websocket API连接成功")
+
+    def on_connected(self):
+        """"""
+        pass
+        
+    def subscribe(self, req: SubscribeRequest):
+        """"""
+        symbol = req.symbol
+        print("============BinanceDataWebsocketApi.subscribe===========")
+        print("symbol"+symbol)
+        # Create tick data buffer
+        tick = TickData(
+            symbol=symbol,
+            name=symbol_name_map.get(symbol, ""),
+            exchange=Exchange.BINANCE,
+            datetime=datetime.now(),
+            gateway_name=self.gateway_name,
+        )
+        self.ticks[symbol] = tick            
+            
+        # Subscribe to market depth update
+        self.req_id += 1
+        req = {
+            "sub": f"market.{symbol}.depth.step0",
+            "id": str(self.req_id)     
+        }
+        self.send_packet(req)
+        
+        # Subscribe to market detail update
+        self.req_id += 1
+        req = {
+            "sub": f"market.{symbol}.detail",
+            "id": str(self.req_id)     
+        }
+        self.send_packet(req)
+
+    def on_data(self, packet):  # type: (dict)->None
+        """"""
+        print("===================on_data=====================")
+        print(packet)
+    
+        channel = packet.get("ch", None)
+        if channel:
+            if "depth.step" in channel:
+                self.on_market_depth(packet)
+            elif "detail" in channel:
+                self.on_market_detail(packet)
+        elif "err-code" in packet:
+            code = packet["err-code"]
+            msg = packet["err-msg"]
+            self.gateway.write_log(f"错误代码：{code}, 错误信息：{msg}")
+
+    def on_market_depth(self, data):
+        """行情深度推送 """
+        symbol = data["ch"].split(".")[1]
+        tick = self.ticks[symbol]
+        tick.datetime = datetime.fromtimestamp(data["ts"] / 1000)
+        
+        bids = data["tick"]["bids"]
+        for n in range(5):
+            price, volume = bids[n]
+            tick.__setattr__("bid_price_" + str(n + 1), float(price))
+            tick.__setattr__("bid_volume_" + str(n + 1), float(volume))
+
+        asks = data["tick"]["asks"]
+        for n in range(5):
+            price, volume = asks[n]
+            tick.__setattr__("ask_price_" + str(n + 1), float(price))
+            tick.__setattr__("ask_volume_" + str(n + 1), float(volume))
+
+        if tick.last_price:
+            self.gateway.on_tick(copy(tick))
+
+    def on_market_detail(self, data):
+        """市场细节推送"""
+        symbol = data["ch"].split(".")[1]
+        tick = self.ticks[symbol]
+        tick.datetime = datetime.fromtimestamp(data["ts"] / 1000)
+        
+        tick_data = data["tick"]
+        tick.open_price = float(tick_data["open"])
+        tick.high_price = float(tick_data["high"])
+        tick.low_price = float(tick_data["low"])
+        tick.last_price = float(tick_data["close"])
+        tick.volume = float(tick_data["vol"])
+
+        if tick.bid_price_1:
+            self.gateway.on_tick(copy(tick))
+
+
+def _split_url(url):
+    """
+    将url拆分为host和path
+    :return: host, path
+    """
+    result = re.match("\w+://([^/]*)(.*)", url)  # noqa
+    if result:
+        return result.group(1), result.group(2)
\ No newline at end of file
diff --git a/vnpy/trader/constant.py b/vnpy/trader/constant.py
index eb2eec7a..4965a0de 100644
--- a/vnpy/trader/constant.py
+++ b/vnpy/trader/constant.py
@@ -113,6 +113,7 @@ class Exchange(Enum):
     OKEX = "OKEX"
     HUOBI = "HUOBI"
     BITFINEX = "BITFINEX"
+    BINANCE = "BINANCE"
 
 
 class Currency(Enum):

From ace002609a757aa9d11749878dc0312464d7c28c Mon Sep 17 00:00:00 2001
From: 1122455801 <zhangyangffff@gmail.com>
Date: Mon, 10 Jun 2019 23:44:46 +0800
Subject: [PATCH 2/4] Create backtesting_portfolio.ipynb

---
 tests/backtesting/backtesting_portfolio.ipynb | 223 ++++++++++++++++++
 1 file changed, 223 insertions(+)
 create mode 100644 tests/backtesting/backtesting_portfolio.ipynb

diff --git a/tests/backtesting/backtesting_portfolio.ipynb b/tests/backtesting/backtesting_portfolio.ipynb
new file mode 100644
index 00000000..4e035c6b
--- /dev/null
+++ b/tests/backtesting/backtesting_portfolio.ipynb
@@ -0,0 +1,223 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from vnpy.app.cta_strategy.backtesting import BacktestingEngine, OptimizationSetting\n",
+    "from vnpy.app.cta_strategy.strategies.atr_rsi_strategy import AtrRsiStrategy\n",
+    "from vnpy.app.cta_strategy.strategies.boll_channel_strategy import BollChannelStrategy\n",
+    "from datetime import datetime"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_backtesting(strategy_class, setting, vt_symbol, interval, start, end, rate, slippage, size, pricetick, capital):\n",
+    "    engine = BacktestingEngine()\n",
+    "    engine.set_parameters(\n",
+    "        vt_symbol=vt_symbol,\n",
+    "        interval=interval,\n",
+    "        start=start,\n",
+    "        end=end,\n",
+    "        rate=rate,\n",
+    "        slippage=slippage,\n",
+    "        size=size,\n",
+    "        pricetick=pricetick,\n",
+    "        capital=capital    \n",
+    "    )\n",
+    "    engine.add_strategy(strategy_class, setting)\n",
+    "    engine.load_data()\n",
+    "    engine.run_backtesting()\n",
+    "    df = engine.calculate_result()\n",
+    "    return df\n",
+    "\n",
+    "def show_portafolio(df):\n",
+    "    engine = BacktestingEngine()\n",
+    "    engine.calculate_statistics(df)\n",
+    "    engine.show_chart(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2019-06-10 23:37:47.321851\t开始加载历史数据\n",
+      "2019-06-10 23:37:47.736877\t加载进度：## [25%]\n",
+      "2019-06-10 23:37:47.990762\t加载进度：##### [50%]\n",
+      "2019-06-10 23:37:48.298379\t加载进度：####### [76%]\n",
+      "2019-06-10 23:37:48.518127\t加载进度：########## [100%]\n",
+      "2019-06-10 23:37:48.518127\t历史数据加载完成，数据量：17280\n",
+      "2019-06-10 23:37:48.584513\t策略初始化完成\n",
+      "2019-06-10 23:37:48.584513\t开始回放历史数据\n",
+      "2019-06-10 23:37:49.319839\t历史数据回放结束\n",
+      "2019-06-10 23:37:49.319839\t开始计算逐日盯市盈亏\n",
+      "2019-06-10 23:37:49.324736\t逐日盯市盈亏计算完成\n"
+     ]
+    }
+   ],
+   "source": [
+    "df1 = run_backtesting(\n",
+    "    strategy_class=AtrRsiStrategy, \n",
+    "    setting={}, \n",
+    "    vt_symbol=\"IF88.CFFEX\",\n",
+    "    interval=\"1m\", \n",
+    "    start=datetime(2019, 1, 1), \n",
+    "    end=datetime(2019, 4, 30),\n",
+    "    rate=0.3/10000,\n",
+    "    slippage=0.2,\n",
+    "    size=300,\n",
+    "    pricetick=0.2,\n",
+    "    capital=1_000_000,\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2019-06-10 23:37:54.953582\t开始加载历史数据\n",
+      "2019-06-10 23:37:55.452611\t加载进度：## [25%]\n",
+      "2019-06-10 23:37:55.905706\t加载进度：##### [50%]\n",
+      "2019-06-10 23:37:56.352015\t加载进度：####### [76%]\n",
+      "2019-06-10 23:37:56.885187\t加载进度：########## [100%]\n",
+      "2019-06-10 23:37:56.885187\t历史数据加载完成，数据量：27168\n",
+      "2019-06-10 23:37:56.903729\t策略初始化完成\n",
+      "2019-06-10 23:37:56.903729\t开始回放历史数据\n",
+      "2019-06-10 23:37:57.144939\t历史数据回放结束\n",
+      "2019-06-10 23:37:57.144939\t开始计算逐日盯市盈亏\n",
+      "2019-06-10 23:37:57.150828\t逐日盯市盈亏计算完成\n"
+     ]
+    }
+   ],
+   "source": [
+    "df2 = run_backtesting(\n",
+    "    strategy_class=BollChannelStrategy, \n",
+    "    setting={'fixed_size': 16}, \n",
+    "    vt_symbol=\"RB88.SHFE\",\n",
+    "    interval=\"1m\", \n",
+    "    start=datetime(2019, 1, 1), \n",
+    "    end=datetime(2019, 4, 30),\n",
+    "    rate=1/10000,\n",
+    "    slippage=1,\n",
+    "    size=10,\n",
+    "    pricetick=1,\n",
+    "    capital=1_000_000,\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2019-06-10 23:38:00.683004\t开始计算策略统计指标\n",
+      "2019-06-10 23:38:00.799241\t------------------------------\n",
+      "2019-06-10 23:38:00.799241\t首个交易日：\t2019-01-16\n",
+      "2019-06-10 23:38:00.799241\t最后交易日：\t2019-04-19\n",
+      "2019-06-10 23:38:00.799241\t总交易日：\t62\n",
+      "2019-06-10 23:38:00.799241\t盈利交易日：\t31\n",
+      "2019-06-10 23:38:00.799241\t亏损交易日：\t31\n",
+      "2019-06-10 23:38:00.799241\t起始资金：\t1,000,000.00\n",
+      "2019-06-10 23:38:00.799241\t结束资金：\t1,094,312.31\n",
+      "2019-06-10 23:38:00.799241\t总收益率：\t9.43%\n",
+      "2019-06-10 23:38:00.799241\t年化收益：\t36.51%\n",
+      "2019-06-10 23:38:00.799241\t最大回撤: \t-119,944.93\n",
+      "2019-06-10 23:38:00.799241\t百分比最大回撤: -10.84%\n",
+      "2019-06-10 23:38:00.799241\t总盈亏：\t94,312.31\n",
+      "2019-06-10 23:38:00.799241\t总手续费：\t11,787.69\n",
+      "2019-06-10 23:38:00.799241\t总滑点：\t23,500.00\n",
+      "2019-06-10 23:38:00.799241\t总成交金额：\t333,377,980.00\n",
+      "2019-06-10 23:38:00.799241\t总成交笔数：\t320.0\n",
+      "2019-06-10 23:38:00.799241\t日均盈亏：\t1,521.17\n",
+      "2019-06-10 23:38:00.799241\t日均手续费：\t190.12\n",
+      "2019-06-10 23:38:00.799241\t日均滑点：\t379.03\n",
+      "2019-06-10 23:38:00.799241\t日均成交金额：\t5,377,064.19\n",
+      "2019-06-10 23:38:00.799241\t日均成交笔数：\t5.161290322580645\n",
+      "2019-06-10 23:38:00.800195\t日均收益率：\t0.14%\n",
+      "2019-06-10 23:38:00.800195\t收益标准差：\t1.86%\n",
+      "2019-06-10 23:38:00.800195\tSharpe Ratio：\t1.20\n",
+      "2019-06-10 23:38:00.800195\t收益回撤比：\t0.87\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x1152 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dfp = df1 + df2\n",
+    "dfp =dfp.dropna() \n",
+    "show_portafolio(dfp)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.1"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 127e863c3b116c28ad9a46fa989e31cb66f81325 Mon Sep 17 00:00:00 2001
From: 1122455801 <zhangyangffff@gmail.com>
Date: Mon, 10 Jun 2019 23:45:08 +0800
Subject: [PATCH 3/4] Update backtesting.py

---
 vnpy/app/cta_strategy/backtesting.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/vnpy/app/cta_strategy/backtesting.py b/vnpy/app/cta_strategy/backtesting.py
index 115881cc..c63fda23 100644
--- a/vnpy/app/cta_strategy/backtesting.py
+++ b/vnpy/app/cta_strategy/backtesting.py
@@ -328,9 +328,11 @@ class BacktestingEngine:
         """"""
         self.output("开始计算策略统计指标")
 
-        if not df:
+        # Check DataFrame input exterior
+        if df is None:
             df = self.daily_df
         
+        # Check for init DataFrame 
         if df is None:
             # Set all statistics to 0 if no trade.
             start_date = ""
@@ -474,9 +476,11 @@ class BacktestingEngine:
 
     def show_chart(self, df: DataFrame = None):
         """"""
-        if not df:
+        # Check DataFrame input exterior        
+        if df is None:
             df = self.daily_df
-        
+
+        # Check for init DataFrame        
         if df is None:
             return
 

From b4bea248025cf4f2ab2a7f9b9b834e81b7345c80 Mon Sep 17 00:00:00 2001
From: "vn.py" <xiaoyou.chen@foxmail.com>
Date: Tue, 11 Jun 2019 11:21:03 +0800
Subject: [PATCH 4/4] [Mod] relpace bar second/microsecond to 0 when force
 generated, #1815

---
 vnpy/trader/utility.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/vnpy/trader/utility.py b/vnpy/trader/utility.py
index bdd3f93d..1843b31f 100644
--- a/vnpy/trader/utility.py
+++ b/vnpy/trader/utility.py
@@ -253,6 +253,9 @@ class BarGenerator:
         """
         Generate the bar data and call callback immediately.
         """
+        self.bar.datetime = self.bar.datetime.replace(
+            second=0, microsecond=0
+        )
         self.on_bar(self.bar)
         self.bar = None