Si eres un principiante en el trading cuantitativo en el ámbito de las criptomonedas, echa un vistazo a este artículo: Te acercamos al trading cuantitativo en el ámbito de las criptomonedas (parte 7)

En el artículo anterior, pensamos y diseñamos una estrategia de cuadrícula simple y de múltiples variedades. A continuación, continuaremos aprendiendo y avanzando en el camino del trading cuantitativo. En este artículo, analizaremos un diseño de estrategia más complejo: el diseño de una estrategia de cobertura. En este artículo se pretende diseñar una estrategia de cobertura multivariable entre períodos. Al hablar de estrategias de cobertura entre períodos, quienes estén familiarizados con el comercio de futuros deben estar familiarizados con ellas. Es posible que los novatos aún no comprendan estos conceptos, por lo que primero explicaremos brevemente el concepto de cobertura entre períodos.

Cobertura entre períodos

La cobertura entre períodos simplemente significa comprar un contrato, vender otro y esperar las tres situaciones siguientes para cerrar las posiciones simultáneamente:

• Ganas dinero cuando operas en largo y pierdes dinero cuando operas en corto. Cuando la ganancia de un lado (un proverbio) es mayor que la pérdida del otro lado (un proverbio), cierra la posición. Después de que las ganancias y las pérdidas se hayan compensado , habrá algún beneficio.
• Los que van en largo pierden dinero, los que van en corto ganan dinero, y usted cierra su posición cuando la ganancia en un lado es mayor que la pérdida en el otro lado… (igual que el anterior).
• Los que operan en largo ganan dinero, y los que operan en corto también ganan dinero, así que ¿en qué más hay que pensar? ¡Cierra la posición!

En otros casos, hay una pérdida flotante y usted puede conservarla o continuar aumentando su posición. (Dado que la fluctuación de la diferencia de precios es mucho más leve que la fluctuación unilateral, el riesgo relativo es menor. ¡Tenga en cuenta que es solo relativo!)

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

Porque los intercambios de monedas digitales tienen contratos de entrega y contratos perpetuos. Además, debido a la tasa de financiación, el precio de los contratos perpetuos siempre está cerca del precio al contado. Luego optamos por utilizar contratos de entrega y contratos perpetuos para cobertura y arbitraje. Elija un contrato de entrega a más largo plazo para no tener que establecer contratos de cobertura con frecuencia.

Vamos a calentarnos haciendo una estadística de diferencia de precios de múltiples variedades.

Una vez que esté familiarizado con los principios básicos, no necesitará apresurarse a escribir estrategias. Primero, haga una estadística sobre la diferencia de precio, dibuje un gráfico y observe la diferencia de precio. Aprendamos a dibujar gráficos de estrategias multivariedad.

Nos basamos enContratos de OKEXDiseñar, dibujar en FMZ es muy sencillo, puedes dibujar fácilmente usando las funciones empaquetadas, la biblioteca de gráficos esHighcharts. Descripción de la función de dibujo en la documentación de la API: https://www.fmz.com/api#chart...

Dado que existen múltiples variedades, primero debes determinar las diferencias de precio de esas variedades para imprimir antes de dibujar el gráfico. Primero escribe dos matrices en el código para representar los contratos a realizar.

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

Inicialice la configuración del gráfico de acuerdo con el código de contrato establecido aquí. Esta configuración del gráfico no debe estar codificada, porque no sabe qué producto fabricar ni cuántos productos fabricar (estos están determinados por los valores de arrDeliveryContractType y arrSwapContractType), por lo que la configuración del gráfico es devuelta por una función. .

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()                                  // 初始化图表内容
    
    // 以下省略.....
}

A continuación, preparemos los datos. Utilizamos la interfaz de mercado agregada de contratos de OKEX:

Contrato perpetuo USDT:

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

Contrato de entrega de USDT:

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

Escribimos una función para manejar las llamadas de estas dos interfaces y ponemos los datos en un formato:

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 
}

Escribe otra función para procesar el código del contrato.

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

Lo que queda es emparejar iterativamente los datos adquiridos, calcular la diferencia de precio, generar el gráfico, etc. Lo que se prueba aquí es la diferencia de precio entre el próximo contrato trimestral 210924 y el contrato perpetuo. Código completo:

// 临时参数
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)
    }
}

Operación en tiempo real

Corre un rato~

¡Observe primero la diferencia de precio! /subir/activo/16a9cc6330dfc9c7fb21.jpg