Neulinge im quantitativen Handel in Kryptowährungskreisen, schauen Sie sich bitte dies an - Wir bringen Sie dem quantitativen Handel in Kryptowährungskreisen näher (Teil 7)

Im vorherigen Artikel haben wir über eine einfache Multivariate-Grid-Strategie nachgedacht und diese entworfen. Als nächstes werden wir weiter lernen und auf dem Weg des quantitativen Handels vorankommen. In diesem Artikel diskutieren wir einen komplexeren Strategieentwurf – den Entwurf einer Absicherungsstrategie. In diesem Artikel soll eine mehrteilige, periodenübergreifende Absicherungsstrategie entworfen werden. Wenn wir über periodenübergreifende Absicherungsstrategien sprechen, müssen diejenigen, die mit dem Futures-Handel vertraut sind, damit vertraut sein. Da diese Konzepte für Neulinge möglicherweise noch nicht verständlich sind, wollen wir zunächst kurz das Konzept der Inter-Perioden-Absicherung erläutern.

Periodenübergreifende Absicherung

Beim zeitraumübergreifenden Hedging geht es einfach darum, bei einem Kontrakt Long zu gehen, bei einem anderen Kontrakt Short zu gehen und auf die folgenden drei Situationen zu warten, um die Positionen gleichzeitig zu schließen:

• Sie verdienen Geld, wenn Sie Long gehen, und verlieren Geld, wenn Sie Short gehen. Wenn der Gewinn auf der einen Seite (ein Sprichwort) größer ist als der Verlust auf der anderen Seite (ein Sprichwort), schließen Sie die Position. Nachdem die Gewinne und Verluste ausgeglichen sind , es wird einen gewissen Gewinn geben.
• Wer eine Long-Position einnimmt, verliert Geld, wer eine Short-Position einnimmt, verdient Geld, und Sie schließen Ihre Position, wenn der Gewinn auf der einen Seite größer ist als der Verlust auf der anderen Seite … (wie oben).
• Wer eine Long-Position einnimmt, verdient Geld, und wer eine Short-Position einnimmt, verdient ebenfalls Geld. Woran soll man also sonst noch denken? Position schließen!

In anderen Fällen liegt ein schwebender Verlust vor, den Sie behalten oder Ihre Position weiter ausbauen können. (Da die Preisdifferenzschwankung viel geringer ist als die einseitige Schwankung, ist das relative Risiko geringer. Bitte beachten Sie, dass es nur relativ ist!)

设A1为合约A在1时刻的价格，设B1为合约B在1时刻的价格，此时做空A合约，做空价格A1，做多B合约，做多价格B1。
设A2为合约A在2时刻的价格，设B2为合约B在2时刻的价格，此时平仓A合约（平空），平空价格A2，平仓B合约（平多），平多价格B2。

1时刻的差价：A1 - B1 = X 
2时刻的差价：A2 - B2 = Y 
X - Y = A1 - B1 - (A2 - B2)
X - Y = A1 - B1 - A2 + B2
X - Y = A1 - A2 + B2 - B1

可以看到，A1 - A2 就是A合约平仓的盈利差价。
B2 - B1就是B合约平仓的盈利差价。只要这两个平仓总体是正数，即：A1 - A2 + B2 - B1 > 0 就是盈利的。也就是说只要X - Y > 0。
因为：X - Y = A1 - A2 + B2 - B1

得出结论，只要开仓时的差价X大于平仓时的差价Y就是盈利的（注意是做空A，做多B开仓，搞反了就是相反的了），当然这个是理论上的，实际上还要考虑手续费、滑点等因素。

Denn digitale Währungsbörsen haben sowohl Lieferverträge als auch unbefristete Verträge. Darüber hinaus liegt der Preis unbefristeter Verträge aufgrund des Finanzierungssatzes immer nahe am Spotpreis. Dann entscheiden wir uns für die Verwendung von Lieferverträgen und unbefristeten Verträgen zur Absicherung und Arbitrage. Wählen Sie für die Lieferung einen längerfristigen Vertrag, damit Sie nicht häufig Absicherungsverträge abschließen müssen.

Lassen Sie uns mit einer Preisunterschiedsstatistik für mehrere Sorten aufwärmen

Wenn Sie mit den Grundprinzipien vertraut sind, müssen Sie sich mit dem Schreiben von Strategien nicht beeilen. Erstellen Sie zunächst eine Statistik über die Preisunterschiede, zeichnen Sie ein Diagramm und beobachten Sie die Preisunterschiede. Lassen Sie uns lernen, wie man Strategiediagramme mit verschiedenen Varianten zeichnet.

Wir basieren aufOKEX-VerträgeDas Entwerfen und Zeichnen auf FMZ ist sehr einfach, Sie können problemlos mit den gepackten Funktionen zeichnen, die Diagrammbibliothek istHighcharts. Beschreibung der Zeichenfunktion in der API-Dokumentation: https://www.fmz.com/api#chart...

Da es mehrere Sorten gibt, müssen Sie zunächst die Preisunterschiede dieser Sorten zum Ausdrucken ermitteln, bevor Sie das Diagramm zeichnen. Schreiben Sie zunächst zwei Arrays in den Code, um die abzuschließenden Verträge darzustellen.

var arrSwapContractType = ["BTC-USDT-SWAP", "LTC-USDT-SWAP", "ETH-USDT-SWAP", "ETC-USDT-SWAP"]   // 永续合约
var arrDeliveryContractType = ["BTC-USDT-210924", "LTC-USDT-210924", "ETH-USDT-210924", "ETC-USDT-210924"]  // 交割合约

Initialisieren Sie die Diagrammkonfiguration gemäß dem hier festgelegten Vertragscode. Diese Diagrammkonfiguration darf nicht fest codiert sein, da Sie nicht wissen, welches Produkt oder wie viele Produkte hergestellt werden sollen (diese werden durch die Werte von arrDeliveryContractType und arrSwapContractType bestimmt), sodass die Diagrammkonfiguration von einer Funktion zurückgegeben wird .

function createCfg(symbol) {
    var cfg = {
        extension: {
            // 不参于分组，单独显示，默认为分组 'group'
            layout: 'single', 
            // 指定高度，可以设置为字符串，"300px"，设置数值300会自动替换为"300px"
            height: 300,      
            // 指定宽度占的单元值，总值为12
            col: 6
        },
        title: {
            text: symbol
        },
        xAxis: {
            type: 'datetime'
        },
        series: [{
            name: 'plus',
            data: []
        }]
    }

    return cfg
}

function main() {
    // 声明arrCfg
    var arrCfg = []                                    // 声明一个数组,用来存放图表配置信息
    _.each(arrSwapContractType, function(ct) {         // 迭代记录永续合约代码的数组，用合约名称XXX-USDT部分作为参数传给createCfg函数，构造图表配置信息，返回
        arrCfg.push(createCfg(formatSymbol(ct)[0]))    // createCfg返回的图表配置信息push进arrCfg数组
    })
    var objCharts = Chart(arrCfg)                      // 调用FMZ平台的图表函数Chart，创建图表控制对象objCharts
    objCharts.reset()                                  // 初始化图表内容
    
    // 以下省略.....
}

Als nächstes bereiten wir die Daten vor. Wir verwenden die aggregierte Marktschnittstelle von OKEX-Verträgen:

Unbefristeter USDT-Vertrag:

https://www.okex.com/api/v5/market/tickers?instType=SWAP

USDT-Liefervertrag:

https://www.okex.com/api/v5/market/tickers?instType=FUTURES

Wir schreiben eine Funktion, um die Aufrufe dieser beiden Schnittstellen zu verarbeiten und die Daten in ein Format zu bringen:

function getTickers(url) {
    var ret = []
    try {
        var arr = JSON.parse(HttpQuery(url)).data
        _.each(arr, function(ele) {
            ret.push({
                bid1: parseFloat(ele.bidPx),             // 买一价
                bid1Vol: parseFloat(ele.bidSz),          // 买一价的量
                ask1: parseFloat(ele.askPx),             // 卖一价
                ask1Vol: parseFloat(ele.askSz),          // 卖一价的量
                symbol: formatSymbol(ele.instId)[0],     // 格式成交易对
                type: "Futures",                         // 类型
                originalSymbol: ele.instId               // 原始合约代码
            })
        })
    } catch (e) {
        return null 
    }
    return ret 
}

Schreiben Sie eine weitere Funktion zur Verarbeitung des Vertragscodes

function formatSymbol(originalSymbol) {
    var arr = originalSymbol.split("-")
    return [arr[0] + "_" + arr[1], arr[0], arr[1]]
}

Was bleibt, ist die iterative Paarung der gewonnenen Daten, die Berechnung der Preisdifferenz, die Ausgabe des Charts usw. Getestet wird hier die Preisdifferenz zwischen dem nächsten Quartalskontrakt 210924 und dem unbefristeten Kontrakt. Vollständiger Code:

// 临时参数
var arrSwapContractType = ["BTC-USDT-SWAP", "LTC-USDT-SWAP", "ETH-USDT-SWAP", "ETC-USDT-SWAP"]
var arrDeliveryContractType = ["BTC-USDT-210924", "LTC-USDT-210924", "ETH-USDT-210924", "ETC-USDT-210924"]
var interval = 2000

function createCfg(symbol) {
    var cfg = {
        extension: {
            // 不参于分组，单独显示，默认为分组 'group'
            layout: 'single', 
            // 指定高度，可以设置为字符串，"300px"，设置数值300会自动替换为"300px"
            height: 300,      
            // 指定宽度占的单元值，总值为12
            col: 6
        },
        title: {
            text: symbol
        },
        xAxis: {
            type: 'datetime'
        },
        series: [{
            name: 'plus',
            data: []
        }]
    }

    return cfg
}

function formatSymbol(originalSymbol) {
    var arr = originalSymbol.split("-")
    return [arr[0] + "_" + arr[1], arr[0], arr[1]]
}

function getTickers(url) {
    var ret = []
    try {
        var arr = JSON.parse(HttpQuery(url)).data
        _.each(arr, function(ele) {
            ret.push({
                bid1: parseFloat(ele.bidPx), 
                bid1Vol: parseFloat(ele.bidSz), 
                ask1: parseFloat(ele.askPx), 
                ask1Vol: parseFloat(ele.askSz), 
                symbol: formatSymbol(ele.instId)[0], 
                type: "Futures", 
                originalSymbol: ele.instId
            })
        })
    } catch (e) {
        return null 
    }
    return ret 
}

function main() {
    // 声明arrCfg
    var arrCfg = []
    _.each(arrSwapContractType, function(ct) {
        arrCfg.push(createCfg(formatSymbol(ct)[0]))
    })
    var objCharts = Chart(arrCfg)
    objCharts.reset()
    
    while (true) {
        // 获取行情数据        
        var deliveryTickers = getTickers("https://www.okex.com/api/v5/market/tickers?instType=FUTURES")
        var swapTickers = getTickers("https://www.okex.com/api/v5/market/tickers?instType=SWAP")
        if (!deliveryTickers || !swapTickers) {
            Sleep(2000)
            continue
        }

        var tbl = {
            type : "table",
            title : "交割-永续差价",
            cols : ["交易对", "交割", "永续", "正对冲", "反对冲"],
            rows : []
        }
        
        var subscribeDeliveryTickers = []
        var subscribeSwapTickers = []
        _.each(deliveryTickers, function(deliveryTicker) {
            _.each(arrDeliveryContractType, function(symbol) {
                if (deliveryTicker.originalSymbol == symbol) {
                    subscribeDeliveryTickers.push(deliveryTicker)
                }
            })
        })
        _.each(swapTickers, function(swapTicker) {
            _.each(arrSwapContractType, function(symbol) {
                if (swapTicker.originalSymbol == symbol) {
                    subscribeSwapTickers.push(swapTicker)
                }
            })
        })
        
        var pairs = []
        var ts = new Date().getTime()
        _.each(subscribeDeliveryTickers, function(deliveryTicker) {
            _.each(subscribeSwapTickers, function(swapTicker) {
                if (deliveryTicker.symbol == swapTicker.symbol) {
                    var pair = {symbol: swapTicker.symbol, swapTicker: swapTicker, deliveryTicker: deliveryTicker, plusDiff: deliveryTicker.bid1 - swapTicker.ask1, minusDiff: deliveryTicker.ask1 - swapTicker.bid1}
                    pairs.push(pair)
                    tbl.rows.push([pair.symbol, deliveryTicker.originalSymbol, swapTicker.originalSymbol, pair.plusDiff, pair.minusDiff])
                    for (var i = 0 ; i < arrCfg.length ; i++) {
                        if (arrCfg[i].title.text == pair.symbol) {
                            objCharts.add([i, [ts, pair.plusDiff]])
                        }                        
                    }                    
                }
            })
        })

        LogStatus(_D(), "\n`" + JSON.stringify(tbl) + "`")        
        Sleep(interval)
    }
}

Echtzeitbetrieb

Lauf eine Weile ~

Beachten Sie zunächst den Preisunterschied!