Utilisez l’interface de marché agrégée des échanges de devises numériques pour créer des stratégies multi-produits

Plateforme de trading quantitative FMZSection de veille stratégiqueIl est courant de voir certaines stratégies multi-produits qui surveillent simultanément les conditions de marché de dizaines, voire de l’ensemble du marché d’une bourse. Comment cela se fait-il ? Et comment devrait-il être conçu ? Cet article explique comment utiliser l’interface de marché agrégée des échanges pour créer une stratégie multi-produits.

Prenons l’exemple de Binance et Huobi et vérifions leurs documents API. Nous constatons qu’ils disposent tous deux d’interfaces d’informations de marché agrégées :

Interface de marché

• Contrats à terme Binance : https://fapi.binance.com/fapi/v1/ticker/bookTicker Données de retour de l’interface

  [
      {
          "symbol": "BTCUSDT", // 交易对
          "bidPrice": "4.00000000", //最优买单价
          "bidQty": "431.00000000", //挂单量
          "askPrice": "4.00000200", //最优卖单价
          "askQty": "9.00000000", //挂单量
          "time": 1589437530011   // 撮合引擎时间
      }
      ...
  ]

• Monnaie actuelle de Huobi : https://api.huobi.pro/market/tickers Données de retour de l’interface

  [  
      {  
          "open":0.044297,      // 开盘价
          "close":0.042178,     // 收盘价
          "low":0.040110,       // 最低价
          "high":0.045255,      // 最高价
          "amount":12880.8510,  
          "count":12838,
          "vol":563.0388715740,
          "symbol":"ethbtc",
          "bid":0.007545,
          "bidSize":0.008,
          "ask":0.008088,
          "askSize":0.009
      }, 
      ...
  ]

Cependant, ce n’est pas le cas. La structure réellement renvoyée par l’interface Huobi est :

  {
      "status": "ok",
      "ts": 1616032188422,
      "data": [{
          "symbol": "hbcbtc",
          "open": 0.00024813,
          "high": 0.00024927,
          "low": 0.00022871,
          "close": 0.00023495,
          "amount": 2124.32,
          "vol": 0.517656218,
          "count": 1715,
          "bid": 0.00023427,
          "bidSize": 2.3,
          "ask": 0.00023665,
          "askSize": 2.93
      }, ...]
  }

Soyez prudent lors du traitement des données renvoyées par l’interface.

Élaboration d’un cadre de programme politique

Comment encapsuler ces deux interfaces dans la stratégie et comment traiter les données ? Regardons cela ensemble.

Écrivons d’abord un constructeur pour construire l’objet de contrôle.

// 参数e用于传入exchange交易所对象，参数subscribeList是需要处理的交易对列表，例如["BTCUSDT", "ETHUSDT", "EOSUSDT", "LTCUSDT", "ETCUSDT", "XRPUSDT"]
function createManager(e, subscribeList) {           
    var self = {}
    self.supportList = ["Futures_Binance", "Huobi"]  // 支持的交易所的

    // 对象属性
    self.e = e
    self.name = e.GetName()
    self.type = self.name.includes("Futures_") ? "Futures" : "Spot"
    self.label = e.GetLabel()
    self.quoteCurrency = ""  
    self.subscribeList = subscribeList   // subscribeList : [strSymbol1, strSymbol2, ...]
    self.tickers = []                    // 接口获取的所有行情数据，定义数据格式：{bid1: 123, ask1: 123, symbol: "xxx"}}
    self.subscribeTickers = []           // 需要的行情数据，定义数据格式：{bid1: 123, ask1: 123, symbol: "xxx"}}
    self.accData = null                  // 用于记录账户资产数据

    // 初始化函数
    self.init = function() { 
    	// 判断是否支持该交易所
        if (!_.contains(self.supportList, self.name)) {        	
        	throw "not support"
        }
    }

    // 判断数据精度
    self.judgePrecision = function (p) {
        var arr = p.toString().split(".")
        if (arr.length != 2) {
            if (arr.length == 1) {
                return 0
            }
            throw "judgePrecision error, p:" + String(p)
        }
        
        return arr[1].length
    }

    // 更新资产
    self.updateAcc = function(callBackFuncGetAcc) {
        var ret = callBackFuncGetAcc(self)
        if (!ret) {
        	return false 
        }
        self.accData = ret 
        return true 
    }

    // 更新行情数据
    self.updateTicker = function(url, callBackFuncGetArr, callBackFuncGetTicker) {
    	var tickers = []
    	var subscribeTickers = []
    	var ret = self.httpQuery(url)
    	if (!ret) {
    		return false 
    	}
    	try {
            _.each(callBackFuncGetArr(ret), function(ele) {
            	var ticker = callBackFuncGetTicker(ele)
            	tickers.push(ticker)
            	for (var i = 0 ; i < self.subscribeList.length ; i++) {
            		if (self.subscribeList[i] == ele.symbol) {
            			subscribeTickers.push(ticker)
            		}
            	}
            })
        } catch(err) {
        	Log("错误：", err)
        	return false 
        }

        self.tickers = tickers
        self.subscribeTickers = subscribeTickers
        return true 
    }

    self.httpQuery = function(url) {
    	var ret = null
        try {
            var retHttpQuery = HttpQuery(url)
            ret = JSON.parse(retHttpQuery)
        } catch (err) {
            // Log("错误:", err)
            ret = null
        }
        return ret 
    }

    self.returnTickersTbl = function() {
        var tickersTbl = {
        	type : "table", 
        	title : "tickers",
        	cols : ["symbol", "ask1", "bid1"], 
        	rows : []
        }
        _.each(self.subscribeTickers, function(ticker) {        
        	tickersTbl.rows.push([ticker.symbol, ticker.ask1, ticker.bid1])
        })
        return tickersTbl
    }

    // 初始化
    self.init()
	return self 
}

Utilisation des fonctions de l’API FMZHttpQueryLa fonction envoie une requête pour accéder à l’interface d’échange. utiliserHttpQueryLa gestion des exceptions est requisetry...catchGérer les exceptions telles que les échecs de retour d’interface. Certains étudiants peuvent se demander : « Les structures de données renvoyées par les interfaces d’échange sont différentes. Comment les traiter ? Il n’est certainement pas possible d’utiliser la même méthode de traitement. » En effet, non seulement la structure des données renvoyées par l’interface d’échange est différente, mais même la dénomination des champs de données renvoyés est différente. La même signification peut être nommée différemment. Par exemple, les interfaces que nous avons listées ci-dessus. La même expression désigne le prix d’achat, qui est appelé :bidPrice, qui s’appellebid。

Nous utilisons ici des fonctions de rappel pour séparer ces parties de traitement spéciales. Ainsi, une fois l’objet ci-dessus initialisé, il devient comme ceci lorsqu’il est utilisé : (Le code suivant omet le constructeurcreateManager） Surveillez ces contrats avec Binance Futures :["BTCUSDT", "ETHUSDT", "EOSUSDT", "LTCUSDT", "ETCUSDT", "XRPUSDT"] Huobi Spot surveille ces paires de trading coin-to-coin :["btcusdt", "ethusdt", "eosusdt", "etcusdt", "ltcusdt", "xrpusdt"]Par exemple.

function main() {
    var manager1 = createManager(exchanges[0], ["BTCUSDT", "ETHUSDT", "EOSUSDT", "LTCUSDT", "ETCUSDT", "XRPUSDT"])
    var manager2 = createManager(exchanges[1], ["btcusdt", "ethusdt", "eosusdt", "etcusdt", "ltcusdt", "xrpusdt"])   

    while (true) {
    	// 更新行情数据
    	var ticker1GetSucc = manager1.updateTicker("https://fapi.binance.com/fapi/v1/ticker/bookTicker", 
    		function(data) {return data}, 
    		function (ele) {return {bid1: ele.bidPrice, ask1: ele.askPrice, symbol: ele.symbol}})
    	var ticker2GetSucc = manager2.updateTicker("https://api.huobi.pro/market/tickers", 
    		function(data) {return data.data}, 
    		function(ele) {return {bid1: ele.bid, ask1: ele.ask, symbol: ele.symbol}})
        if (!ticker1GetSucc || !ticker2GetSucc) {
        	Sleep(1000)
        	continue
        }
        
        var tbl1 = {
        	type : "table", 
        	title : "期货行情数据",
        	cols : ["期货合约", "期货买一", "期货卖一"], 
        	rows : []
        }
        _.each(manager1.subscribeTickers, function(ticker) {
        	tbl1.rows.push([ticker.symbol, ticker.bid1, ticker.ask1])
        })
        var tbl2 = {
        	type : "table", 
        	title : "现货行情数据",
        	cols : ["现货合约", "现货买一", "现货卖一"], 
        	rows : []
        }
        _.each(manager2.subscribeTickers, function(ticker) {
        	tbl2.rows.push([ticker.symbol, ticker.bid1, ticker.ask1])
        })
        LogStatus(_D(), "\n`" + JSON.stringify(tbl1) + "`", "\n`" + JSON.stringify(tbl2) + "`")
        Sleep(10000)
    }
}

Exécutez les tests : Le premier objet d’échange ajoute les contrats à terme Binance et le deuxième objet d’échange ajoute les contrats au comptant Huobi

On peut voir qu’ici, les opérations telles que la manière d’obtenir les données renvoyées par l’interface sont traitées spécifiquement pour différents échanges à l’aide de fonctions de rappel.

    	var ticker1GetSucc = manager1.updateTicker("https://fapi.binance.com/fapi/v1/ticker/bookTicker", 
    		function(data) {return data}, 
    		function (ele) {return {bid1: ele.bidPrice, ask1: ele.askPrice, symbol: ele.symbol}})
    	var ticker2GetSucc = manager2.updateTicker("https://api.huobi.pro/market/tickers", 
    		function(data) {return data.data}, 
    		function(ele) {return {bid1: ele.bid, ask1: ele.ask, symbol: ele.symbol}})

Après avoir formulé l’acquisition des informations de marché, nous pouvons ensuite formuler l’acquisition des actifs du compte. En raison de la stratégie multi-produits, les données sur les actifs du compte doivent également être multiples. Heureusement, l’interface des actifs du compte d’échange renvoie généralement toutes les données des actifs.

Dans le constructeurcreateManagerAjouter une méthode pour obtenir des ressources

    // 更新资产
    self.updateAcc = function(callBackFuncGetAcc) {
        var ret = callBackFuncGetAcc(self)
        if (!ret) {
        	return false 
        }
        self.accData = ret 
        return true 
    }

De plus, en raison des différents formats et noms de champs renvoyés par l’interface d’échange, des fonctions de rappel sont également nécessaires pour un traitement spécial.

En prenant comme exemples Huobi spot et Binance futures, la fonction de rappel peut être écrite comme ceci :

    // 获取账户资产的回调函数
    var callBackFuncGetHuobiAcc = function(self) {
        var account = self.e.GetAccount()
        var ret = []
        if (!account) {
        	return false 
        }
        // 构造资产的数组结构
        var list = account.Info.data.list
        _.each(self.subscribeList, function(symbol) {
            var coinName = symbol.split("usdt")[0]
            var acc = {symbol: symbol}
            for (var i = 0 ; i < list.length ; i++) {
            	if (coinName == list[i].currency) {
                    if (list[i].type == "trade") {
                        acc.Stocks = parseFloat(list[i].balance)
                    } else if (list[i].type == "frozen") {
                    	acc.FrozenStocks = parseFloat(list[i].balance)
                    }
                } else if (list[i].currency == "usdt") {
                	if (list[i].type == "trade") {
                		acc.Balance = parseFloat(list[i].balance)
                	} else if (list[i].type == "frozen") {
                		acc.FrozenBalance = parseFloat(list[i].balance)
                	}
                }
            }
            ret.push(acc)
        })
        return ret 
    }

    var callBackFuncGetFutures_BinanceAcc = function(self) {
    	self.e.SetCurrency("BTC_USDT")   // 设置为U本位合约的交易对
        self.e.SetContractType("swap")   // 合约都是永续合约
        var account = self.e.GetAccount() 
        var ret = []
        if (!account) {
        	return false 
        }
        var balance = account.Balance
        var frozenBalance = account.FrozenBalance
        // 构造资产数据结构
        _.each(self.subscribeList, function(symbol) {
            var acc = {symbol: symbol}
            acc.Balance = balance
            acc.FrozenBalance = frozenBalance
            ret.push(acc)
        })
        return ret 
    }

Exécuter un cadre stratégique avec la fonction d’obtenir des informations sur le marché et les actifs

Citations:

actifs:

On peut voir qu’après avoir obtenu les données du marché, les données peuvent être traitées pour calculer la différence de prix de chaque variété et surveiller la différence de prix spot-futures de plusieurs paires de négociation. Ensuite, une stratégie de couverture multi-variétés de contrats à terme et de contrats au comptant peut être conçue.

D’autres échanges peuvent également être développés selon cette méthode de conception. Les étudiants intéressés peuvent l’essayer.