Estratégias de hedging entre moedas em negociações de quantificação de ativos blockchain

Estratégias de hedging entre moedas em negociações de quantificação de ativos blockchain

Existem vários tipos de hedge em estratégias de hedge; hedge cross-market, hedge cross-period, etc. Hoje vamos falar sobre hedge cross-variety, ou melhor, a estratégia de hedge cross-currency em negociações de quantificação de ativos da blockchain. Os itens normalmente indicados em negociações de hedge são os mesmos, enquanto os hedge cross-currency são itens comprados e vendidos em diferentes marcas. No mesmo tipo de hedge, podemos usar o diferencial de preço como preço de compra e venda em negociações de hedge.

Por exemplo: A par de transações é LTC_USDT O par B é: ETH_USDT

De acordo comA交易对的价格/B交易对的价格Este preço proporcional é numérico, disperso. Quanto maior for este valor, mais vendemos A e compramos B. Quanto maior a proporção inversa, mais compramos A e vendemos B. A quantidade de USDT igual a cada hedge é, na verdade, uma estratégia para negociar na rede com o preço relativo do LTC/ETH forte e fraco. A estratégia não é complexa.

Com a plataforma de negociação quantitativa do inventor, é fácil escrever um protótipo de estratégia: O código da estratégia precisa ser citado para ser executadoe"A biblioteca de linhas gráficas":https://www.fmz.com/strategy/27293"A biblioteca de transações em tempo real de moedas digitais": é uma lista de modelos que cada usuário traz consigo quando cria uma nova estratégia.

/*backtest
start: 2019-05-01 00:00:00
end: 2019-11-04 00:00:00
period: 1m
exchanges: [{"eid":"OKEX","currency":"LTC_USDT","balance":100000,"stocks":30},{"eid":"OKEX","currency":"ETH_USDT","balance":100000,"stocks":30}]
*/

/*
A exchanges[0] : EOS_USDT   
B exchanges[1] : ETH_USDT
*/

var Interval = 500

// 参数
var numPoint = 100        // 节点数
var distance = 0.08       // 比例间距
var amountPoint = 100     // 节点金额，单位USDT
var arrHedgeList = []

function main () {
    var isFirst = true
    while(true) {
        var rA = exchanges[0].Go("GetTicker")
        var rB = exchanges[1].Go("GetTicker")

        var tickerA = rA.wait()
        var tickerB = rB.wait()

        if (tickerA && tickerB) {
            var priceRatioSell = tickerB.Buy / tickerA.Sell     // B sell , A buy
            var priceRatioBuy = tickerB.Sell / tickerA.Buy      // B buy , A sell
            
            if (isFirst) {
                for (var i = 0 ; i < numPoint ; i++) {
                    var point = {
                        priceRatio : priceRatioSell + (i + 1) * distance,
                        coverRatio : priceRatioSell + i * distance,
                        amount : (0.08 * i + 1) * amountPoint,
                        isHold : false,
                    }
                    arrHedgeList.push(point)
                }
                isFirst = false
            }

            for (var j = 0 ; j < arrHedgeList.length; j++) {
                if (priceRatioSell > arrHedgeList[j].priceRatio && arrHedgeList[j].isHold == false) {
                    // B sell , A buy
                    Log("对冲，价格比", priceRatioSell, "#FF0000")
                    $.Buy(exchanges[0], arrHedgeList[j].amount / tickerA.Sell)
                    $.Sell(exchanges[1], arrHedgeList[j].amount / tickerB.Buy)
                    arrHedgeList[j].isHold = true
                    LogStatus(_D(), exchanges[0].GetAccount(), "\n", exchanges[1].GetAccount())
                    $.PlotLine("ratio", (priceRatioSell + priceRatioBuy) / 2)
                    break 
                }

                if (priceRatioBuy < arrHedgeList[j].coverRatio && arrHedgeList[j].isHold == true) {    
                    // B buy , A sell
                    Log("对冲，价格比", priceRatioBuy, "#32CD32")
                    $.Sell(exchanges[0], arrHedgeList[j].amount / tickerA.Buy)
                    $.Buy(exchanges[1], arrHedgeList[j].amount / tickerB.Sell)
                    arrHedgeList[j].isHold = false
                    LogStatus(_D(), exchanges[0].GetAccount(), "\n", exchanges[1].GetAccount())
                    $.PlotLine("ratio", (priceRatioSell + priceRatioBuy) / 2)
                    break
                }
            }
        }
        Sleep(Interval)
    }
}

A primeira etapa é a verificação das ideias estratégicas através da retrospecção.

Usando a configuração padrão de rastreamento:

Como pode ser visto, usando apenas algumas dezenas de linhas de código, é muito fácil construir uma estratégia de sua própria idéia. No inventor, a realização de um protótipo de uma idéia é uma coisa muito fácil.

No que diz respeito ao controle de posições, pode-se aumentar o montante de cobertura de cada nó de hedge, por exemplo, no código:

if (isFirst) {
    for (var i = 0 ; i < numPoint ; i++) {
        var point = {
            priceRatio : priceRatioSell + (i + 1) * distance,
            coverRatio : priceRatioSell + i * distance,
            amount : (0.08 * i + 1) * amountPoint,          // 每次递增amountPoint的8%
            isHold : false,
        }
        arrHedgeList.push(point)
    }
    isFirst = false
}

Isso permite que as posições com um peso relativo se concentrem em posições com uma proporção de preço mais alta, evitando que as posições sejam muito grandes quando a proporção de preço é baixa. É claro que essa cobertura transversal é muito arriscada, e se um preço de uma moeda continuar a subir em relação ao outro, isso gerará um flutuação, então a cobertura transversal requer uma correlação mais forte das duas variedades.

Esta estratégia é apenas uma demonstração inicial e pode continuar a ser modificada e otimizada.