Es ist ein neues Erlebnis - es bringt Sie näher an die Quantität der Münzscheibe.

Die Münzkreis-Quantifizierung von Transaktionen ist neu und bringt Sie näher an die Münzkreis-Quantifizierung (7).

In diesem Artikel werden wir eine etwas komplexere Strategie entwerfen - die Entwurf einer Hedging-Strategie. In diesem Artikel werden wir eine vielfältige Überschreitungs-Hedging-Strategie entwerfen, die für kleine Partner, die mit Futures vertraut sind, sicherlich nicht fremd ist. Für Liu Xiaobo sind diese Konzepte möglicherweise noch nicht bekannt, daher werden wir zuerst die Konzepte der nächsten Überschreitungs-Hedging-Konzepte kurz beschreiben.

Überschreitende Absicherung

Überlaufende Absicherung bedeutet einfach, einen weiteren Vertrag zu machen, einen leeren zu machen und auf drei verschiedene Situationen zu warten, um gleichzeitig (mehr oder weniger) auszugleichen:

• Wenn man mehr Geld verdient, wenn man weniger Geld verdient, wenn man mehr Geld verdient als man verliert, dann wird man einen Teil des Gewinns haben.
• Wenn man mehr Geld verliert, wenn man weniger Geld verdient, wenn man mehr Geld verdient als man verliert, dann ist man im Gleichgewicht.
• Wer mehr verdient, verdient auch, wer weniger verdient.

Die andere Situation ist ein Aufschwung, ein Halten oder ein weiteres Anheben. ((Denn Differenzschwankungen sind relativ geringer als einseitige Abkühlung und das Risiko ist relativ gering.

设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开仓，搞反了就是相反的了），当然这个是理论上的，实际上还要考虑手续费、滑点等因素。

Da es sich bei den digitalen Währungsbörsen um Transaktionsquoten handelt, gibt es auch dauerhafte Verträge. Und die Preise für dauerhafte Verträge sind immer relativ nah an den aktuellen Preisen, da es sich um Kapitalquoten handelt. Dann wählen wir die Verwendung von Transaktionsquoten und dauerhaften Verträgen.

Wir haben eine Reihe von verschiedenen Preisen.

Wenn Sie sich mit den Grundlagen vertraut gemacht haben, können Sie sich nicht in Eile mit der Handschreibstrategie befassen.

Wir sind aufOKEX-VertragDas Design ist sehr einfach, wenn man ein Diagramm auf FMZ zeichnet, und es ist sehr einfach, ein Diagramm mit einer verpackten Funktion zu zeichnen.HochkartenDie Grafikfunktion in der API-Dokumentation beschreibt:https://www.fmz.com/api#chart...

Da es sich um mehrere Sorten handelt, müssen Sie zuerst die Unterschiede zwischen den Sorten feststellen, bevor Sie ein Diagramm drucken.

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"]  // 交割合约

Initialieren Sie die Chartkonfiguration anhand des hier gesetzten Vertragscodes. Diese Chartkonfiguration kann sicherlich nicht abgeschrieben werden, da Sie auch nicht wissen, welche Sorte Sie tun sollen, sondern mehrere Sorten (Diese werden anhand der Werte von arrDeliveryContractType und arrSwapContractType festgelegt), so dass die Chartkonfiguration 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, und wir verwenden die aggregierte Markt-Interface der OKEX-Verträge:

USDT-Permanentvertrag:

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

Die USDT-Transaktionsrate beträgt etwa:

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

Wir haben eine Funktion geschrieben, um Anrufe an diese beiden Schnittstellen zu verarbeiten und die Daten in einem Format zu erstellen:

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 
}

Dann schreiben Sie eine andere Funktion, die den Code für den Vertrag verarbeitet.

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

Die restliche Aufgabe besteht darin, die gewonnenen Daten zu iterativ zu paaren, die Differenz zu berechnen, die Grafiken auszuführen usw. Hier wird die Differenz zwischen dem zweiten Quartalsvertrag 210 924 und dem dauerhaften Vertrag getestet. Der vollständige 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)
    }
}

Die Festplatte läuft

Lassen Sie uns kurz laufen.

Sieh dir die Differenz an!