Introdução ao código fonte da estratégia de negociação de pares de moedas digitais e à API mais recente da plataforma FMZ

Prefácio

O artigo anterior introduziu o princípio e backtesting de negociação de pares,https://www.fmz.com/bbs-topic/10459. Aqui está um código-fonte prático baseado na plataforma FMZ. A estratégia é simples e clara, adequada para iniciantes aprenderem. A plataforma FMZ atualizou recentemente algumas APIs para ser mais amigável para estratégias de pares de negociação múltiplos. Este artigo apresentará o código-fonte JavaScript desta estratégia em detalhes. Embora o código de estratégia seja de apenas cem linhas, ele contém todos os aspectos necessários para uma estratégia completa. A API específica pode ser visualizada no documento API, que é muito detalhado.https://www.fmz.com/strategy/456143podem ser copiados diretamente.

Utilização da plataforma FMZ

Se você não está familiarizado com a plataforma FMZ, recomendo fortemente que você leia este tutorial:https://www.fmz.com/bbs-topic/4145Introduz as funções básicas da plataforma em pormenor, bem como como como implantar um robô a partir do zero.

Quadro estratégico

O loop infinito garante que a estratégia seja executada continuamente, e um pequeno tempo de sono é adicionado para evitar que a frequência de acesso exceda o limite de troca.

function main(){
    while(true){
        //strategy content
        Sleep(Interval * 1000) //Sleep
    }
}

Registro de dados históricos

O robô será reiniciado repetidamente por várias razões, como erros, atualizações de parâmetros, atualizações de estratégia, etc., e alguns dados precisam ser salvos para a próxima inicialização. Aqui está uma demonstração de como salvar o capital inicial para calcular retornos. A função _G() pode armazenar vários dados. _G(key, value) pode armazenar o valor do valor e chamá-lo com _G(key), onde key é uma cadeia.

let init_eq = 0 //defining initial equity
if(!_G('init_eq')){  //If there is no storage, _G('init_eq') returns null.
    init_eq = total_eq
    _G('init_eq', total_eq) //Since there is no storage, the initial equity is the current equity and is stored here
}else{
    init_eq = _G('init_eq') //If stored, read the value of the initial equity
}

Estratégia de tolerância a falhas

Ao obter dados como posições e condições de mercado através da API, erros podem ser devolvidos devido a vários motivos. Chamar diretamente os dados fará com que a estratégia pare devido a erros, por isso é necessário um mecanismo tolerante a falhas. A função _C() tentará novamente automaticamente após um erro até que os dados corretos sejam devolvidos. Ou verifique se os dados estão disponíveis após o retorno.

let pos = _C(exchange.GetPosition, pair)

let ticker_A = exchange.GetTicker(pair_a)
let ticker_B = exchange.GetTicker(pair_b)
if(!ticker_A || !ticker_B){
    continue //If the data is not available, exit the loop.
}

API compatível com várias moedas

Funções como GetPosition, GetTicker e GetRecords podem adicionar um parâmetro de par de negociação para obter os dados correspondentes, sem ter que definir o par de negociação vinculado à troca, o que facilita muito a compatibilidade de várias estratégias de par de negociação.https://www.fmz.com/bbs-topic/10456É claro que o docker mais recente é necessário para suportá-lo.

Parâmetros da estratégia

• Pair_A: O par de negociação A que precisa ser emparelhado para a negociação. Você precisa escolher o par de negociação você mesmo. Você pode consultar a introdução e backtesting no artigo anterior.
• Par_B: Par B de negociação que precisa ser emparelhado.
• Citação: A moeda de margem da bolsa de futuros, geralmente em USDT.
• Pct: Quanto desvio para adicionar posições, ver o artigo sobre princípios de estratégia para mais detalhes, devido a taxas de manipulação e razões de deslizamento, não deve ser definido muito pequeno.
• O valor de negociação da adição de posições para cada desvio do tamanho da grade.
• Ice_Value: Se o valor da transação for muito grande, você pode usar o valor da comissão do iceberg para abrir uma posição.
• Valor máximo: Valor máximo das posições numa moeda única, para evitar o risco de manter posições excessivas.
• N: O parâmetro utilizado para calcular o rácio de preço médio, a unidade é hora, por exemplo, 100 representa a média de 100 horas.
• Intervalo: o tempo de sono entre cada ciclo da estratégia.

Notas completas sobre a estratégia

Se você ainda não entende, pode usar a documentação da API do FMZ, ferramentas de depuração e ferramentas de diálogo de IA comumente usadas no mercado para resolver suas perguntas.

function GetPosition(pair){
    let pos = _C(exchange.GetPosition, pair)
    if(pos.length == 0){ //Returns null to indicate no position
        return {amount:0, price:0, profit:0}
    }else if(pos.length > 1){ //The strategy should be set to unidirectional position mode
        throw 'Bidirectional positions are not supported'
    }else{ //For convenience, long positions are positive and short positions are negative
        return {amount:pos[0].Type == 0 ? pos[0].Amount : -pos[0].Amount, price:pos[0].Price, profit:pos[0].Profit}
    }
}

function GetRatio(){
    let kline_A = exchange.GetRecords(Pair_A+"_"+Quote+".swap", 60*60, N) //Hourly K-line
    let kline_B = exchange.GetRecords(Pair_B+"_"+Quote+".swap", 60*60, N)
    let total = 0
    for(let i= Math.min(kline_A.length,kline_B.length)-1; i >= 0; i--){ //Calculate in reverse to avoid the K-line being too short.
        total += kline_A[i].Close / kline_B[i].Close
    }
    return total / Math.min(kline_A.length,kline_B.length)
}

function GetAccount(){
    let account = _C(exchange.GetAccount)
    let total_eq = 0
    if(exchange.GetName == 'Futures_OKCoin'){ //Since the API here is not compatible, only OKX Futures Exchange obtains the total equity currently.
        total_eq = account.Info.data[0].totalEq //The equity information of other exchanges is also included. You can look for it yourself in the exchange API documentation.
    }else{
        total_eq = account.Balance //Temporary use of available balances on other exchanges will cause errors in calculating returns, but will not affect the use of strategies.
    }
    let init_eq = 0
    if(!_G('init_eq')){
        init_eq = total_eq
        _G('init_eq', total_eq)
    }else{
        init_eq = _G('init_eq')
    }
    LogProfit(total_eq - init_eq)
    return total_eq
}

function main(){
    var precision = exchange.GetMarkets() //Get the precision here
    var last_get_ratio_time = Date.now()
    var ratio = GetRatio()
    var total_eq = GetAccount()
    while(true){
        let start_loop_time = Date.now()
        if(Date.now() - last_get_ratio_time > 10*60*1000){ //Update the average price and account information every 10 minutes
            ratio = GetRatio()
            total_eq = GetAccount()
            last_get_ratio_time = Date.now()
        }
        let pair_a = Pair_A+"_"+Quote+".swap" //The trading pair is set as BTC_USDT.swap
        let pair_b = Pair_B+"_"+Quote+".swap"
        let CtVal_a = "CtVal" in precision[pair_a] ? precision[pair_a].CtVal : 1 //Some exchanges use sheets to represent quantity, such as one sheet represents 0.01 coin, so you need to convert.
        let CtVal_b = "CtVal" in precision[pair_b] ? precision[pair_b].CtVal : 1 //No need to include this field
        let position_A = GetPosition(pair_a)
        let position_B = GetPosition(pair_b)
        let ticker_A = exchange.GetTicker(pair_a)
        let ticker_B = exchange.GetTicker(pair_b)
        if(!ticker_A || !ticker_B){ //If the returned data is abnormal, jump out of this loop
            continue
        }
        let diff = (ticker_A.Last / ticker_B.Last - ratio) / ratio //Calculate the ratio of deviation
        let aim_value = - Trade_Value * diff / Pct //Target holding position
        let id_A = null
        let id_B = null
        //The following is the specific logic of opening a position
        if( -aim_value + position_A.amount*CtVal_a*ticker_A.Last > Trade_Value && position_A.amount*CtVal_a*ticker_A.Last > -Max_Value){
            id_A = exchange.CreateOrder(pair_a, "sell", ticker_A.Buy, _N(Ice_Value / (ticker_A.Buy * CtVal_a), precision[pair_a].AmountPrecision))
        }
        if( -aim_value - position_B.amount*CtVal_b*ticker_B.Last > Trade_Value && position_B.amount*CtVal_b*ticker_B.Last < Max_Value){
            id_B = exchange.CreateOrder(pair_b, "buy", ticker_B.Sell, _N(Ice_Value / (ticker_B.Sell * CtVal_b), precision[pair_b].AmountPrecision))
        }
        if( aim_value - position_A.amount*CtVal_a*ticker_A.Last > Trade_Value && position_A.amount*CtVal_a*ticker_A.Last < Max_Value){
            id_A = exchange.CreateOrder(pair_a, "buy", ticker_A.Sell, _N(Ice_Value / (ticker_A.Sell * CtVal_a), precision[pair_a].AmountPrecision))
        }
        if( aim_value + position_B.amount*CtVal_b*ticker_B.Last > Trade_Value &&  position_B.amount*CtVal_b*ticker_B.Last > -Max_Value){
            id_B = exchange.CreateOrder(pair_b, "sell", ticker_B.Buy, _N(Ice_Value / (ticker_B.Buy * CtVal_b), precision[pair_b].AmountPrecision))
        }
        if(id_A){
            exchange.CancelOrder(id_A) //Cancel directly here
        }
        if(id_B){
            exchange.CancelOrder(id_B)
        }
        let table = {
            type: "table",
            title: "trading Information",
            cols: ["initial equity", "current equity", Pair_A+"position", Pair_B+"position", Pair_A+"holding price", Pair_B+"holding price", Pair_A+"profits", Pair_B+"profits", Pair_A+"price", Pair_B+"price", "current price comparison", "average price comparison", "deviation from average price", "loop delay"],
            rows: [[_N(_G('init_eq'),2), _N(total_eq,2), _N(position_A.amount*CtVal_a*ticker_A.Last, 1), _N(position_B.amount*CtVal_b*ticker_B.Last,1),
                _N(position_A.price, precision[pair_a].PircePrecision), _N(position_B.price, precision[pair_b].PircePrecision),
                _N(position_A.profit, 1), _N(position_B.profit, 1), ticker_A.Last, ticker_B.Last,
                _N(ticker_A.Last / ticker_B.Last,6), _N(ratio, 6), _N(diff, 4), (Date.now() - start_loop_time)+"ms"
            ]]
        }
        LogStatus("`" + JSON.stringify(table) + "`") //This function will display a table containing the above information on the robot page.
        Sleep(Interval * 1000) //Sleep time in ms
    }
}