Novatos em Negociação Quantitativa em Círculos de Criptomoedas, por favor, dêem uma olhada nisso - Levando vocês mais perto da Negociação Quantitativa em Círculos de Criptomoedas (Parte 7)

No artigo anterior, pensamos e projetamos uma estratégia simples de grade multivariedade. Em seguida, continuaremos aprendendo e avançando no caminho da negociação quantitativa. Neste artigo, discutiremos um design de estratégia mais complexo: o design de estratégia de hedge. Este artigo planeja projetar uma estratégia de hedge multivariada de período cruzado. Falando em estratégias de hedge de período cruzado, aqueles que estão familiarizados com negociação de futuros devem estar familiarizados com elas. Os novatos podem não entender esses conceitos ainda, então vamos primeiro explicar brevemente o conceito de hedge entre períodos.

Cobertura entre períodos

A cobertura entre períodos significa simplesmente operar comprado em um contrato, vendido em outro contrato e esperar pelas três situações a seguir para fechar as posições simultaneamente:

• Você ganha dinheiro quando vai longo e perde dinheiro quando vai curto. Quando o lucro de um lado (um provérbio) for maior que a perda do outro lado (um provérbio), feche a posição. Depois que os ganhos e perdas forem compensados , haverá algum lucro.
• Aqueles que operam comprados perdem dinheiro, aqueles que operam vendidos ganham dinheiro, e você fecha sua posição quando o lucro de um lado é maior que a perda do outro lado… (o mesmo que acima).
• Aqueles que operam comprados ganham dinheiro, e aqueles que operam vendidos também ganham dinheiro, então o que mais há para pensar! Feche a posição!

Em outros casos, há uma perda flutuante e você pode mantê-la ou continuar a aumentar sua posição. (Como a flutuação da diferença de preço é muito mais suave do que a flutuação unilateral, o risco relativo é menor. Observe que ele é apenas 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 as exchanges de moedas digitais têm contratos de entrega e contratos perpétuos. Além disso, devido à taxa de financiamento, o preço dos contratos perpétuos está sempre próximo do preço à vista. Então optamos por usar contratos de entrega e contratos perpétuos para hedge e arbitragem. Escolha um contrato de entrega de longo prazo para que você não precise configurar contratos de hedge com frequência.

Vamos aquecer fazendo uma estatística de diferença de preços multivariada

Depois de se familiarizar com os princípios básicos, você não precisa se apressar para escrever estratégias. Primeiro, faça uma estatística sobre a diferença de preço, desenhe um gráfico e observe a diferença de preço. Vamos aprender a desenhar gráficos de estratégia multivariados.

Nós somos baseados emContratos OKEXPara projetar, desenhar no FMZ é muito simples, você pode desenhar facilmente usando as funções empacotadas, a biblioteca de gráficos éHighcharts. Descrição da função de desenho na documentação da API: https://www.fmz.com/api#chart...

Como existem diversas variedades, você deve primeiro determinar as diferenças de preço dessas variedades para imprimir antes de desenhar o gráfico. Primeiro escreva duas matrizes no código para representar os contratos a serem feitos.

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

Inicialize a configuração do gráfico de acordo com o código de contrato definido aqui. Esta configuração de gráfico não deve ser codificada, porque você não sabe qual produto fazer ou quantos produtos fazer (estes são determinados pelos valores de arrDeliveryContractType e arrSwapContractType), então a configuração do gráfico é retornada por uma função .

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

Em seguida, vamos preparar os dados. Usamos a interface de mercado agregada dos contratos OKEX:

Contrato perpétuo USDT:

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

Contrato de entrega USDT:

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

Escrevemos uma função para manipular as chamadas dessas duas interfaces e colocamos os dados em um 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 
}

Escreva outra função para processar o código do contrato

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

O que resta é parear iterativamente os dados adquiridos, calcular a diferença de preço, gerar o gráfico, etc. O que é testado aqui é a diferença de preço entre o próximo contrato trimestral 210924 e o contrato perpétuo. 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)
    }
}

Operação em tempo real

Corra um pouco~

Observe primeiro a diferença de preço! /carregar/ativo/16a9cc6330dfc9c7fb21.jpg