Instruções da API FMZ

pp - Não, não. As trocas[0].IO(base, https://api.huobipro.com”); }

The ZB exchange is special. There are two addresses: one is the market data interface address, and the other is the trading interface address. Switch the address:
```js
function main() {
    // The second parameter of exchange.IO is the trading interface address, and the third parameter is the market interface address, which is switched to an address that can be accessed domestically
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus")    
    // Print the account information
    Log(exchange.GetAccount())                                            
}

def main():
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus")
    Log(exchange.GetAccount())

void main() {
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus");
    Log(exchange.GetAccount());
}

• Mudança de modo de mercado Intercâmbios atualmente suportados:

  Intercâmbio	Observações
  Huobi Spot	Depois de suportar o protocolo WebSocket, o códigoexchange.IO(moeda, ETH) não podem ser utilizadas para trocar moedas

  • exchange.IO("websocket")

    Mudar o protocolo de comunicação de mercado parawebsocket(default is rest), a forma de obter as cotações de mercado mudará após a mudança.exchange.GetTicker()eexchange.GetDepth()será mudado parawebsocketO protocolo para atualizar, a partir da aquisição ativa bruta de dados de mercado para a aquisição passiva de dados de mercado, apenas Huobi Exchange é suportado atualmente.

  Quando o modo de mercado é o mecanismo push, você pode chamar a seguinte função para definir:

  • exchange.IO("mode", 0)Modo de retorno imediato. Se o impulso de dados de mercado atual não tiver sido recebido da bolsa, os dados de mercado antigos serão devolvidos imediatamente. Se houver novos dados, os novos dados serão devolvidos.

  • exchange.IO("mode", 1)Modo de cache (modo padrão). Se os dados de mercado mais recentes da bolsa não tiverem sido recebidos (em comparação com os dados obtidos da interface anterior), espere por receber e depois retorne.

  • exchange.IO("mode", 2)Modo de atualização forçada. Entre e espere até que os dados de push mais recentes da troca sejam recebidos e depois retorne.

  Se quiser obter as informações mais recentes do mercado pela primeira vez, pode mudar parawebsocketE não chamemSleepA análise dos dados deve ser efetuada de forma imediata.exchange.GetTicker()eexchange.GetDepth()funções que funcionam no modo cache, tais como:

  function main () {
      exchange.IO("websocket")
      while (true) {
          Log(exchange.GetTicker())
      }
  }
  

  def main():
      exchange.IO("websocket")
      while True:
          Log(exchange.GetTicker())
  

  void main() {
      exchange.IO("websocket");
      while(true) {
          Log(exchange.GetTicker());
      }
  }
  

• Modo da conta de alavancagem de câmbio

  Utilizaçãoexchange.IO("trade_margin")Para mudar para o modo de conta de alavancagem, a colocação de ordens e o acesso aos activos da conta utilizarão a interface de alavancagem da bolsa. Utilizaçãoexchange.IO("trade_normal")para voltar ao modo de conta normal.

  Intercâmbios suportados:

  Intercâmbio	Observações especiais
  OKX	Os pares de negociação do modo de conta de alavancagem são diferentes dos comuns, e alguns pares de negociação podem não estar disponíveis.exchange.IO("cross", true)mudar para a posição total da conta alavancada eexchange.IO("cross", false)para mudar para posição isolada.
  Huobi	Os pares de negociação do modo de conta de alavancagem são diferentes dos comuns, e alguns pares de negociação podem não estar disponíveis.trade_marginpara mudar para uma posição isolada numa conta de alavancagem;trade_super_marginpara mudar para uma posição cruzada numa conta de alavancagem;trade_normalpara mudar para um modo de moeda normal
  ZB	Os fundos só podem ser transferidos em QC. No setor de negociação de alavancagem, os fundos entre diferentes pares de negociação são independentes, ou seja, o número de moedas QC sob o par de negociação ETH_QC não é visível em BTC_QC
  Binance	As contas de alavancagem são divididas em posição cruzada e posição isolada.trade_marginpara mudar para uma posição isolada;trade_super_marginpara mudar para a posição cruzada;trade_normalpara mudar para um modo de moeda normal
  Portão	As contas de alavancagem são divididas em posição cruzada e posição isolada.trade_marginpara mudar para uma posição isolada;trade_super_marginpara mudar para a posição cruzada;trade_normalpara mudar para um modo de moeda normal
  AscendEx	Utilizaçãoexchange.IO("trade_margin")para mudar para o modo de conta de alavancagem e utilizarexchange.IO("trade_normal")para voltar ao modo de conta normal.

Troca. Registo.

exchange.Log(LogType, Price, Amount)Não coloca uma ordem quando chamada, e só registra informações de negociação para produzir as informações do diário de câmbio.

Nota:

• Esta função é uma função membro deexchangeobjetos, que é diferente da função globalLog().
• Valor do parâmetro:LogTypePode levarLOG_TYPE_BUY, LOG_TYPE_SELL, LOG_TYPE_CANCELePricecomo preço, eAmountQuando:LogTypeéLOG_TYPE_CANCEL, PriceO parâmetro é o ID da ordem.

Utilizaçãoexchange.Log(LogType, Price, Amount)Realizar os testes de acompanhamento da negociação em tempo real, a simulação da colocação de ordens e prestar assistência no registo das ordens.

O caso de utilização mais comum é:exchange.IOA função para acessar a interfaz de criação de ordens condicionais da troca para colocar ordens condicionais.exchange.IOfunção não irá produzir as informações do registro de troca no registro do bot.exchange.Log(LogType, Price, Amount)Complementar a saída do log para registar as informações relativas às ordens de colocação.

var id = 123
function main() {
    // Order type: buy; price: 999; quantity: 0.1
    exchange.Log(LOG_TYPE_BUY, 999, 0.1)      
    // Cancel the order
    exchange.Log(LOG_TYPE_CANCEL, id)         
}

id = 123
def main():
    exchange.Log(LOG_TYPE_BUY, 999, 0.1)
    exchange.Log(LOG_TYPE_CANCEL, id)

void main() {
    auto id = 123;
    exchange.Log(LOG_TYPE_BUY, 999, 0.1);
    exchange.Log(LOG_TYPE_CANCEL, id);
}

troca.HMAC(...)

exchange.HMAC(Algo, OutputAlgo, Data, Key)Apoia oHMACcálculo de encriptação deMd5/Sha256/Sha512/Sha1, e só é suportada a operação de negociação em tempo real.

exchange.HMAC("sha256", "hex", "xxxxx", "{{secretkey}}")Para citaraccessKey, utilizar"{{accesskey}}"- Não. Para citarsecretKey, utilizar"{{secretkey}}"; ou pode utilizar texto simples"abc-123-xxxx". "{{accessKey}}","{{secretkey}}"é válida apenas quando esta função for utilizada.OutputAlgoSuportes: hex, base64.Exemplo específico

Push BitMEX mudanças de posição (protocolo wss)

function main() {
    var APIKEY = "your Access Key(Bitmex API ID)"
    var expires = parseInt(Date.now() / 1000) + 10
    var signature = exchange.HMAC("sha256", "hex", "GET/realtime" + expires, "{{secretkey}}")
    var client = Dial("wss://www.bitmex.com/realtime", 60)
    var auth = JSON.stringify({args: [APIKEY, expires, signature], op: "authKeyExpires"})
    var pos = 0
    client.write(auth)
    client.write('{"op": "subscribe", "args": "position"}')
    while (true) {
        bitmexData = client.read()
        if(bitmexData.table == 'position' && pos != parseInt(bitmexData.data[0].currentQty)){
            Log('position change', pos, parseInt(bitmexData.data[0].currentQty), '@')
            pos = parseInt(bitmexData.data[0].currentQty)
        }
    }
}

import time
def main():
    APIKEY = "your Access Key(Bitmex API ID)"
    expires = int(time.time() + 10)
    signature = exchange.HMAC("sha256", "hex", "GET/realtime" + str(expires), "{{secretkey}}")
    client = Dial("wss://www.bitmex.com/realtime", 60)
    auth = json.dumps({"args": [APIKEY, expires, signature], "op": "authKeyExpires"})
    pos = 0
    client.write(auth)
    client.write('{"op": "subscribe", "args": "position"}')
    while True:
        bitmexData = json.loads(client.read())
        if "table" in bitmexData and bitmexData["table"] == "position" and len(bitmexData["data"]) != 0 and pos != bitmexData["data"][0]["currentQty"]:   
            Log("position change", pos, bitmexData["data"][0]["currentQty"], "@")
            pos = bitmexData["data"][0]["currentQty"]

void main() {
    auto APIKEY = "your Access Key(Bitmex API ID)";
    auto expires = Unix() + 10;
    auto signature = exchange.HMAC("sha256", "hex", format("GET/realtime%d", expires), "{{secretkey}}");
    
    auto client = Dial("wss://www.bitmex.com/realtime", 60);
    json auth = R"({"args": [], "op": "authKeyExpires"})"_json;

    auth["args"].push_back(APIKEY);
    auth["args"].push_back(expires);
    auth["args"].push_back(signature);
    auto pos = 0;
    client.write(auth.dump());
    client.write("{\"op\": \"subscribe\", \"args\": \"position\"}");
    while(true) {
        auto bitmexData = json::parse(client.read());
        if(bitmexData["table"] == "position" && bitmexData["data"][0].find("currentQty") != bitmexData["data"][0].end() && pos != bitmexData["data"][0]["currentQty"]) {
            Log("Test");
            Log("position change", pos, bitmexData["data"][0]["currentQty"], "@");
            pos = bitmexData["data"][0]["currentQty"];
        }
    }
}

Troca. Vai.

exchange.Go(Method, Args...)é a função assíncrona suportada com vários fios, que pode transformar a operação de todas as funções suportadas em simultânea assíncrona (que só suporta trocas de criptomoedas). Valor do parâmetro:Method, do tipo de string, ou seja, o nome da função chamada simultaneamente.

Nota:

• Esta função só cria tarefas de execução multi-threaded quando executadas em negociação ao vivo.O backtest não suporta tarefas de execução simultânea multi-threaded (o backtest está disponível, mas ainda é executado sequencialmente).
• Após oexchange.Gofunção retorna um objeto, owaitA função é chamada para recuperar os dados devolvidos pelo thread através do objeto.waitSe especificar o parâmetro timeout dewait, o thread não será liberado mesmo que o timeout ocorra; desta forma, o thread será liberado automaticamente apenas obtendo o resultado do thread (não importa se a interface acessada simultaneamente for chamada com sucesso ou sem sucesso).
• Em termos simples, independentemente do sucesso ou fracasso do fio aplicado, o resultado deve ser obtido pelowaitfunção, e o recurso de fio aplicado peloexchange.GoA função é liberada automaticamente pelo docker.
• Se o resultado de retorno dowaitse a função não for obtida no final, os recursos de thread não serão liberados automaticamente, o que causará o acúmulo de threads aplicados; se o número de threads exceder 2000, um erro será relatado:"too many routine wait, max is 2000".

Funções suportadas:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositioneIO.

function main(){
    // The following four operations are executed concurrently and asynchronously by multiple threads, without time-consuming, but with immediate return.
    var a = exchange.Go("GetTicker")
    var b = exchange.Go("GetDepth") 
    var c = exchange.Go("Buy", 1000, 0.1)
    var d = exchange.Go("GetRecords", PERIOD_H1)
           
    // Call the "wait" method, to wait for the return of the asynchronously obtained "ticker" result 
    var ticker = a.wait()            
    // Return the depth; it is possible to return null, if the acquisition fails 
    var depth = b.wait()             
    // Return the order number; limit the timeout in 1 second; the timeout returns "undefined"; this object can continue to call "wait" to wait if the last "wait" is timeout 
    var orderId = c.wait(1000)
    if(typeof(orderId) == "undefined") {
        // Timeout, reacquire
        orderId = c.wait()
    }
    var records = d.wait()
}

def main():
    a = exchange.Go("GetTicker")
    b = exchange.Go("GetDepth")
    c = exchange.Go("Buy", 1000, 0.1)
    d = exchange.Go("GetRecords", PERIOD_H1)

    ticker, ok = a.wait()
    depth, ok = b.wait()
    orderId, ok = c.wait(1000)
    if ok == False:
        orderId, ok = c.wait()
    records, ok = d.wait()

void main() {
    auto a = exchange.Go("GetTicker");
    auto b = exchange.Go("GetDepth");
    auto c = exchange.Go("Buy", 1000, 0.1);
    auto d = exchange.Go("GetRecords", PERIOD_H1);

    Ticker ticker;
    Depth depth;
    Records records;
    TId orderId;
    a.wait(ticker);
    b.wait(depth);
    if(!c.wait(orderId, 300)) {
        c.wait(orderId);
    }
    d.wait(records);
}

Nota:

• Para julgarundefined, utilizartypeof(xx)==="undefined", porquenull == undefinedestá disponível em JavaScript.

function main() {
    var d = exchange.Go("GetRecords", PERIOD_H1)
    // Wait for K-line result
    var records = d.wait()
    // Here we wait for an asynchronous operation that has been waited and ended; it will return null, and record the error
    var ret = d.wait()
}

def main():
    d = exchange.Go("GetRecords", PERIOD_H1)
    records, ok = d.wait()
    ret, ok = d.wait()

void main() {
    auto d = exchange.Go("GetRecords", PERIOD_H1);
    Records records;
    d.wait(records);
    Records ret;
    d.wait(ret);
}

A diferença entrePythoneJavaScriptÉ isso?PythonÉ...waitA função retorna dois parâmetros: o primeiro é o resultado devolvido pela API assíncrona; o segundo indica se a chamada assíncrona foi concluída.

PythonExemplo:

def main():
    d = exchange.Go("GetRecords", PERIOD_D1)
    # "ok" must return "True", unless the strategy is stopped
    ret, ok = d.wait()          
    # If the waiting times out, or "wait" for an ended instance, "ok" returns "False"
    ret, ok = d.wait(100)       
    ret, ok = d.wait(100)       

Adquirir várias cotações de bolsa simultaneamente:

function main() {
    while(true) {
        var beginTS = new Date().getTime()
        var arrRoutine = []
        var arrTicker = []
        var arrName = []
        for(var i = 0; i < exchanges.length; i++) {
            arrRoutine.push(exchanges[i].Go("GetTicker"))
            arrName.push(exchanges[i].GetName())
        }

        for(var i = 0; i < arrRoutine.length; i++) {
            arrTicker.push(arrRoutine[i].wait())
        }
        var endTS = new Date().getTime()

        var tbl = {
            type: "table", 
            title: "Market Quotes", 
            cols: ["Index", "Name", "Latest Executed Price"], 
            rows: []
        }
        
        for(var i = 0; i < arrTicker.length; i++) {
            tbl.rows.push([i, arrName[i], arrTicker[i].Last])
        }

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", endTS - beginTS, "millisecond", "\n", "`" + JSON.stringify(tbl) + "`")
        Sleep(500)
    }
}

import time 
import json
def main():
    while True:
        beginTS = time.time()
        arrRoutine = []
        arrTicker = []
        arrName = []
        for i in range(len(exchanges)):
            arrRoutine.append(exchanges[i].Go("GetTicker"))
            arrName.append(exchanges[i].GetName())

        for i in range(len(exchanges)):
            ticker, ok = arrRoutine[i].wait()
            arrTicker.append(ticker)

        endTS = time.time()
        tbl = {
            "type": "table", 
            "title": "Market Quote", 
            "cols": ["Index", "Name", "Latest Executed Price"], 
            "rows": [] 
        }

        for i in range(len(arrTicker)):
            tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", endTS - beginTS, "second", "\n", "`" + json.dumps(tbl) + "`")
        Sleep(500)

void main() {
    while(true) {
        int length = exchanges.size();
        auto beginTS = UnixNano() / 1000000;
        Ticker arrTicker[length] = {};
        string arrName[length] = {};
        
        // Note that to add a few exchange objects, here we need to execute the "exchanges[n].Go" function several times. In this example, we need to add four exchange objects, which can be modified in details
        auto r0 = exchanges[0].Go("GetTicker");
        auto r1 = exchanges[1].Go("GetTicker");
        auto r2 = exchanges[2].Go("GetTicker");
        auto r3 = exchanges[3].Go("GetTicker");
        GoObj *arrRoutine[length] = {&r0, &r1, &r2, &r3};
        
        for(int i = 0; i < length; i++) {
            arrName[i] = exchanges[i].GetName();
        }

        for(int i = 0; i < length; i++) {
            Ticker ticker;
            arrRoutine[i]->wait(ticker);
            arrTicker[i] = ticker;
        }        
        auto endTS = UnixNano() / 1000000;

        json tbl = R"({
            "type": "table", 
            "title": "Market Quote", 
            "cols": ["Index", "Name", "Latest Executed Price"], 
            "rows": [] 
        })"_json;

        for(int i = 0; i < length; i++) {
            json arr = R"(["", "", ""])"_json;
            arr[0] = format("%d", i);
            arr[1] = arrName[i];
            arr[2] = format("%f", arrTicker[i].Last);
            tbl["rows"].push_back(arr);
        }

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
        Sleep(500);
    }
}

Conjunto de chamadas para oexchange.IO("api", ...)Função:

function main() {
    /*  
       Use the OKX placing order interface to test
        POST /api/v5/trade/order        
    */
    
    var beginTS = new Date().getTime()
    var param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
    var ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    var ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    var ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    
    var id1 = ret1.wait()
    var id2 = ret2.wait()
    var id3 = ret3.wait()
    var endTS = new Date().getTime()    

    Log("id1:", id1)
    Log("id2:", id2)
    Log("id3:", id3)
    Log("Time for placing orders concurrently:", endTS - beginTS, "millisecond")
}

import time
import json
def main():
    beginTS = time.time()
    param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
    ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
    ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
    ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))

    id1, ok1 = ret1.wait()
    id2, ok2 = ret2.wait()
    id3, ok3 = ret3.wait()
    endTS = time.time()

    Log("id1:", id1)
    Log("id2:", id2)
    Log("id3:", id3)
    Log("Time for placing orders concurrently:", endTS - beginTS, "second")

void main() {
    auto beginTS = UnixNano() / 1000000;
    json param = R"({"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"})"_json;
    auto ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
    auto ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
    auto ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());

    json id1 = R"({})"_json;
    json id2 = R"({})"_json;
    json id3 = R"({})"_json;

    ret1.wait(id1);
    ret2.wait(id2);
    ret3.wait(id3);
    auto endTS = UnixNano() / 1000000;

    Log("id1:", id1);
    Log("id2:", id2);
    Log("id3:", id3);
    Log("Time for placing orders concurrently:", endTS - beginTS, "millisecond");
}

Informações sobre a conta

troca.GetAccount ((()

exchange.GetAccount()Retorna as informações da conta de câmbio. Valor de retorno:Account structure.

• AccountEstrutura

function main(){
    var account = exchange.GetAccount()
    Log("Account information, Balance:", account.Balance, "FrozenBalance:", account.FrozenBalance, "Stocks:",
        account.Stocks, "FrozenStocks:", account.FrozenStocks)
}

def main():
    account = exchange.GetAccount()
    Log("Account information, Balance", account["Balance"], "FrozenBalance:", account["FrozenBalance"], "Stocks:", 
        account["Stocks"], "FrozenStocks:", account["FrozenStocks"])

void main() {
    auto account = exchange.GetAccount();
    Log("Account information, Balance", account.Balance, "FrozenBalance:", account.FrozenBalance, "Stocks:", 
        account.Stocks, "FrozenStocks:", account.FrozenStocks);
}

Se o objeto de troca for definido como uma troca de futuros de criptomoedas e mudado para um contrato comUSDTA margem (verexchange.SetContractTypeA função de saber como mudar), os ativosUSDTcomo margem, que é registada no atributo deBalanceeFrozenBalance.

function main(){
    // Switch the trading pair
    exchange.IO("currency", "BTC_USDT")     
    // Take OKX futures as an example; set the contract as the contract of the week, and the current trading pair is BTC_USDT, so the current contract is BTC USDT-margined contract of this week
    exchange.SetContractType("this_week")   
    // Acquire the data of the current account assets
    var account = exchange.GetAccount()
    // The available balance of USDT as margin
    Log(account.Balance)
    // The frozen amount of USDT as margin
    Log(account.FrozenBalance)
}

def main():
    exchange.IO("currency", "BTC_USDT")
    exchange.SetContractType("this_week")    
    account = exchange.GetAccount()
    Log(account["Balance"])
    Log(account["FrozenBalance"])

void main() {
    exchange.IO("currency", "BTC_USDT");
    exchange.SetContractType("this_week");    
    auto account = exchange.GetAccount();
    Log(account.Balance);
    Log(account.FrozenBalance);
}

troca.GetName()

exchange.GetName()Retorna o nome de troca. Retorna valor: tipo de string. Geralmente é usado para determinar oexchangeouexchanges[n]objetos no código de estratégia.

function main() {
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX")
}

def main():
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX")

void main() {
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX");
}

Para comandar a versão de linha do docker, você pode usar o-1comando para imprimir uma lista de nomes de câmbio.

troca.GetLabel ((()

exchange.GetLabel()Retorna o rótulo personalizado da troca.

Oexchangeouexchanges[n]Os objetos dos códigos de estratégia são normalmente determinados pelos rótulos definidos na configuração dos objetos de troca.

troca.GetCurrency ((()

exchange.GetCurrency()retorna o nome do par de moedas operado pela bolsa, e a plataforma de criptomoedas retorna uma cadeia, comoLTC_BTC. Retorna valor: tipo de cadeia.

troca.Configurar moeda ((...)

Oexchange.SetCurrency(Symbol)A função é utilizada para trocar o par de negociação corrente do objeto de troca.exchange.IO ("currency","BTC_USDT")Suporta a troca de pares de negociação no sistema de backtesting, e o nome dopricing currencyNão pode ser alterado ao mudar de pares de negociação no sistema de backtesting (por exemplo,BTC_USDTpode ser mudado paraLTC_USDT, mas não pode ser mudado paraLTC_BTCApós a mudança para um par de negociação inicialmente definido na página de não backtesting, o número detrading coinsé 0 (por exemplo, durante o backtest, o valor inicial do par comercial na página do backtest éBTC_USDT, o número de BTC é 3, e o número de USDT é 10.000.LTC_USDT, o númerotrading coinsO montante de LTC na conta é 0, mas o montante USDT compartilhado dos pares de negociação trocados continua a ser 10000).

function main() {
    var ticker = exchange.GetTicker() 
    Log(ticker)
    Log(exchange.GetAccount())    
    // Switch trading pairs, and pay attention to changes in market quote data and account information after switching
    Log("Switch LTC_USDT: ", exchange.SetCurrency("LTC_USDT"))
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())
}

def main():
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())
    Log(" Switch LTC_USDT: ", exchange.SetCurrency("LTC_USDT"))
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())

void main() {
    auto ticker = exchange.GetTicker();
    Log(ticker);
    Log(exchange.GetAccount());
    exchange.SetCurrency("LTC_USDT");
    Log(" Switch LTC_USDT: ");
    ticker = exchange.GetTicker();
    Log(ticker);
    Log(exchange.GetAccount());
}

Resultado da operação de ensaio de retrocesso:

troca.GetQuoteCurrency()

exchange.GetQuoteCurrency()Retorna o nome da moeda de base operada pela central de câmbio.BTC_CNYretornoCNY, eETH_BTCretornoBTC. Retorna valor: tipo de cadeia.

Negociação de futuros

Para os objectos de câmbio de futuros de criptomoedas, o código do contrato deve ser especificado antes de chamar o seumercado, ordeme outras interfaces, e oexchange.SetContractTypeQuando mudar o par de negociação atual do objeto de troca, você precisa chamar oexchange.SetContractTypePara códigos de contratos de câmbio de moeda digital suportados pela plataforma, consulte oexchange.SetContractType function.

troca.GetPosition ((()

exchange.GetPosition()Obtém as informações da posição atual. Valor de retorno:positionSe não houver posição, ele retorna uma matriz vazia, ou seja[].

• PositionEstrutura

Normalmente, os contratos futuros de criptomoedas são divididos em dois tipos:

• Contrato de entrega Quando um contrato é definido como um contrato de entrega, chamar oexchange.GetPosition()O valor do valor da transação é o valor do valor da transação, e todas as posições no contrato de entrega sob o par de negociação corrente serão devolvidas.

• Contrato perpétuo Quando um contrato é definido para um contrato perpétuo, chamar oexchange.GetPosition()O valor do contrato perpétuo no par de negociação corrente será devolvido.

/*
    Note: if there is no position, it will returns an empty array, so you should judge whether the data returned by the interface is a null array, before you use the returned data
    For example:
    When the exchange is set to OKX futures, if the contract is set to be a delivery contract, when the position data of the current week, the next week, and the quarter is obtained, the data type will be an array of position structure.
    When the exchange is set to OKX futures, if the contract is set to a perpetual contract, the array of position structure containing the position data of the perpetual contract will be obtained.
*/

function main(){
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(10)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    var position = exchange.GetPosition()
    if(position.length > 0){
        Log("Amount:", position[0].Amount, "FrozenAmount:", position[0].FrozenAmount, "Price:",
            position[0].Price, "Profit:", position[0].Profit, "Type:", position[0].Type,
            "ContractType:", position[0].ContractType)
    }
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(10)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    position = exchange.GetPosition()
    if len(position) > 0:
        Log("Amount:", position[0]["Amount"], "FrozenAmount:", position[0]["FrozenAmount"], "Price:", 
            position[0]["Price"], "Profit:", position[0]["Profit"], "Type:", position[0]["Type"], 
            "ContractType:", position[0]["ContractType"])

void main() {
    exchange.SetContractType("this_week");
    exchange.SetMarginLevel(10);
    exchange.SetDirection("buy");
    exchange.Buy(10000, 2);
    auto position = exchange.GetPosition();
    if(position.size() > 0) {
        Log("Amount:", position[0].Amount, "FrozenAmount:", position[0].FrozenAmount, "Price:", 
            position[0].Price, "Profit:", position[0].Profit, "Type:", position[0].Type, 
            "ContractType:", position[0].ContractType);
    } 
}

troca.SetMarginLevel(...)

exchange.SetMarginLevel(MarginLevel)O valor do parâmetro: tipo numérico.

Defina o tamanho da alavancagem para a colocação de ordens de futuros de criptomoedas, por exemplo:

function main() {
    exchange.SetMarginLevel(10)
}

def main():
    exchange.SetMarginLevel(10)

void main() {
    exchange.SetMarginLevel(10);
}

Para futuros de criptomoedas, os mecanismos de alavancagem das bolsas de futuros de criptomoedas não são uniformes.SetMarginLevelA função não pode gerar uma solicitação de rede, mas apenas define a variável de alavancagem na camada inferior (usada para passar parâmetros na interface de ordem de colocação).SetMarginLevelA função gerará uma solicitação de rede e pode não definir a alavancagem por várias razões.

Notas para a definição da alavancagem no desenho da estratégia:

• Apenas os futuros de criptomoedas são suportados.
• O backtest suporta a troca de alavancas.

troca.Configurar direcção ((...)

exchange.SetDirection(Direction)Conjuntoexchange.Buyouexchange.SellPara fazer instruções para a colocação de ordens de futuros.

OSetDirectionA função define a correspondência entre a direção de negociação de futuros e a função de colocação de ordens:

Função de colocação de pedidos	Direção de definição de parâmetros para a função SetDirection	Observações
exchange.Buy	comprar	comprar posição longa aberta
exchange.Buy	fechamento de venda	Comprar posição curta fechada
exchange.Sell	venda	vender posição curta aberta
exchange.Sell	closebuy	vender posição longa fechada

O parâmetroDirectionpode tomar os quatro parâmetros, incluindobuy, closebuy, selleclosesell.

function main(){
    // Make an example for setting OKX futures weekly contract
    exchange.SetContractType("this_week")    
    // Set 5 times of leverage
    exchange.SetMarginLevel(5)
    // Set the order placing type into placing long order
    exchange.SetDirection("buy")
    // Place an order with the contract quantity of 2, at the price of 10,000
    exchange.Buy(10000, 2)              
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(5)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)

void main() {
    exchange.SetContractType("this_week");
    exchange.SetMarginLevel(5);
    exchange.SetDirection("buy");
    exchange.Buy(10000, 2);
    exchange.SetMarginLevel(5);
    exchange.SetDirection("closebuy");
    exchange.Sell(1000, 2);
}

exchange.SetContractType ((...)

exchange.SetContractType(ContractType)definir o tipo de contrato. Valor do parâmetro: tipo de cadeia. Nas estratégias de criptomoeda, tome BTC_USDT como exemplo. Quando mudar pares de negociação porexchange.SetCurrency("BTC_USDT")ouexchange.IO("currency", "BTC_USDT"), você precisa usar oexchange.SetContractTypeO sistema determina se é um par de negociação ou um par de negociação.currency-based contractou umU-based contractbaseado nopar de negociaçãoPor exemplo, quando o par de negociação está definido paraBTC_ USDT, função de utilizaçãoexchange.SetContractTypePara definir o código do contratoswap, que é definido como o contrato perpétuo de BTC baseado em USDT.BTC_ USD, função de utilizaçãoexchange.SetContractTypePara definir o código do contratoswap, que é definido como o contrato perpétuo baseado em moeda do BTC.

Salvo disposição em contrário, ocontrato de entregaCódigo em um contrato de futuros de criptomoedas que, em geral, inclui:

• this_week: contrato semanal
• next_weekContrato da próxima semana.
• quarter: contrato trimestral
• next_quarter: contrato do próximo trimestre

Salvo disposição em contrário, ocontrato perpétuoCódigo em um contrato de futuros de criptomoedas que, em geral, inclui:

• swap: contrato perpétuo

Configure o contrato atual para um contrato semanal:

function main() {
    // Set to weekly contract
    exchange.SetContractType("this_week") 
}

def main():
    exchange.SetContractType("this_week")

void main() {
    exchange.SetContractType("this_week");
}

A descrição pormenorizada da denominação do contrato de cada exchange de criptomoedas suportada é mostrada da seguinte forma:

• OKX Contrato perpétuo:exchange.SetContractType("swap")Contrato para esta semana:exchange.SetContractType("this_week")Contrato para a semana que vem:exchange.SetContractType("next_week")Contrato trimestral:exchange.SetContractType("quarter")Contrato para o próximo trimestre:exchange.SetContractType("next_quarter")O contrato com margem OKX USDT pode ser trocado para o contrato que utiliza a liquidação em USDT correspondente ao contrato em curso, trocandotrading pair(ou definir diretamente ao adicionar os objetos de troca).

  function main() {
      // The default trading pair is BTC_USD, the contract is set to the weekly contract, and the contract is the crypto-margined contract
      exchange.SetContractType("this_week")
      Log("ticker:", exchange.GetTicker())
      
      // Switch trading pairs, and then set a contract to a USDT-margined contract, which is different from the crypto-margined contract
      exchange.IO("currency", "BTC_USDT")   
      exchange.SetContractType("swap")
      Log("ticker:", exchange.GetTicker())
  }
  

  def main():
      exchange.SetContractType("this_week")
      Log("ticker:", exchange.GetTicker())
      exchange.IO("currency", "BTC_USDT")
      exchange.SetContractType("swap")
      Log("ticker:", exchange.GetTicker())
  

  void main() {
      exchange.SetContractType("this_week");
      Log("ticker:", exchange.GetTicker());
      exchange.IO("currency", "BTC_USDT");
      exchange.SetContractType("swap");
      Log("ticker:", exchange.GetTicker());
  }
  

• Futures_HuobiDM Contrato para esta semana:exchange.SetContractType("this_week")Contrato para a semana que vem:exchange.SetContractType("next_week")Contrato trimestral:exchange.SetContractType("quarter")Contrato para o próximo trimestre:exchange.SetContractType("next_quarter")Contrato perpétuo:exchange.SetContractType("swap")

  A plataforma suporta os contratos com margem USDT. Tome o contrato BTC como exemplo. Você pode mudar para um contrato com margem USDT apenas usandoexchange.SetCurrency("BTC_USDT"), ou definindo o par de negociação actual paraBTC_USDTDepois de trocar o par de negociação, você precisa chamarexchange.SetContractTypeA função de novo para definir o contrato.

• Futuros_BitMEX Contrato perpétuo:exchange.SetContractType("XBTUSD"), exchange.SetContractType("APTUSDT")- Não. O contrato é liquidado em algum momento específico, e faça login no site oficial do BitMEX para verificar cada código de contrato para mais detalhes.exchange.SetContractType("XBTM19").

• Futures_GateIO Contrato para esta semana:exchange.SetContractType("this_week")- Não. Contrato para a semana que vem:exchange.SetContractType("next_week")- Não. Contrato trimestral:exchange.SetContractType("quarter")- Não. Contrato para o próximo trimestre:exchange.SetContractType("next_quarter")- Não. Contrato perpétuo:exchange.SetContractType("swap")- Não. A troca suporta os contratos com margem USDT. Tome o contrato BTC como exemplo.exchange.SetCurrency("BTC_USDT"), ou definindo o par de negociação actual paraBTC_USDTDepois de trocar o par de negociação, você precisa chamarexchange.SetContractTypeA função de novo para definir o contrato.

• Futuros_Deribit Contrato perpétuo:exchange.SetContractType("BTC-PERPETUAL")Apoio ao contrato Deribit USDC; chamadaexchange.SetContractType("ADA_USDC-PERPETUAL")para estabelecer um contrato perpétuo com margem ADA USDC. O contrato é liquidado em um momento específico, e entre no site oficial da Deribit para verificar cada código do contrato para mais detalhes, como:exchange.SetContractType("BTC-27APR18").

• Futures_KuCoin

  • Contrato de criptomoedas com margem; Por exemplo, definir o par de negociação paraBTC_USD, e depois definir o código do contrato, que é chamado contrato cripto-marginado. Contrato perpétuo:exchange.SetContractType("swap")Contrato trimestral:exchange.SetContractType("quarter")Contrato para o próximo trimestre:exchange.SetContractType("next_quarter")
  • Contrato com margem USDT: Por exemplo, definir o par de negociação paraBTC_USDT, e, em seguida, definir o código do contrato, que é o contrato com margem USDT. Contrato perpétuo:exchange.SetContractType("swap").

• Futures_Binance O Binance Futures não define o status do contrato, então você precisa definir o contrato primeiro. Contrato perpétuo:exchange.SetContractType("swap")Os contratos perpétuos Binance Futures podem ser contratos com margem USDT.BTCContrato com margem USDT, o par de negociação está definido emBTC_USDTOs contratos perpétuos do Binance Futures também incluem contratos de cripto-margem.BTC_USD.

  Contrato trimestral:exchange.SetContractType("quarter")Os contratos de entrega incluem contratos cripto-marginados (ou seja, tomando a moeda utilizada como margem).BTC, o par de negociação está definido emBTC_USD, e depois definir o código do contratoexchange.SetContractType("quarter"), que está a definir um contrato trimestral de cripto-margem BTC.

  Contrato para o próximo trimestre:exchange.SetContractType("next_quarter")Por exemplo, no contrato trimestral de cripto-margem deBTC, o par de negociação está definido emBTC_USD, e depois definir o código do contratoexchange.SetContractType("next_quarter)A Binance suporta parte dos contratos de entrega com margem USDT, como definir o par de negociação BTC paraBTC_USDT, e depois definir o código do contrato.

• Futures_Bibox Código do contrato perpétuo Bibox:swap- Não. Contrato perpétuo:exchange.SetContractType("swap").

• Futuros_OFEX Código do contrato perpétuo AOFEX:swap- Não. Contrato perpétuo:exchange.SetContractType("swap").

• Futuros_BFX Código do contrato perpétuo BFX:swap- Não. Contrato perpétuo:exchange.SetContractType("swap").

• Futures_Bybit A Bybit é padrão para o contrato perpétuo do par de negociação atual.swap- Não. Código do contrato trimestral:quarter- Não. Código do contrato do próximo trimestre:next_quarter.

• Futures_Kraken O Kraken não define o estado do contrato, então você precisa definir o código do contrato.swapContrato perpétuo.monthContrato mensal.quarter: contrato trimestral.next_quarterContrato para o próximo trimestre.

• Futuros_Bitfinex A Bitfinex não cumpre o contrato perpétuo do par de negociação atual.swap.

• Futures_Bitget Bitget predefinições para o contrato perpétuo do par de negociação atual. Código de contrato:swap. O par de negociação está definido emBTC_USD, indicando contrato de cripto-margem; o par de negociação está definido emBTC_USDTOs contratos simulados podem definir os pares de negociação:SBTC_USDeBTC_SUSDT.

• Futures_dYdX Código de contrato do contrato perpétuo dYdX:swap- Não. Contrato perpétuo:exchange.SetContractType("swap"). dYdX tem apenas contratos com margem USDT.

• Futuros_MEXC Código do contrato do contrato perpétuo do MEXC:swap- Não. Contrato perpétuo:exchange.SetContractType("swap"). O par de negociação está definido emBTC_USD, indicando contrato de cripto-margem; o par de negociação está definido emBTC_USDT, indicando contrato com margem USDT.

Ao escrever estratégias de criptomoedas, chameexchange.SetContractType(ContractType)Função e informações detalhadas do contrato definidas pelo parâmetro do contratoContractTypeserá devolvido.

Por exemplo, executando o código de estratégia do contrato OKX definido como objeto de troca:

function main(){
    // Set to weekly contract
    var ret = exchange.SetContractType("this_week")     
    // Return the information of the weekly contract
    Log(ret)
}

def main():
    ret = exchange.SetContractType("this_week")
    Log(ret)

void main() {
    auto ret = exchange.SetContractType("this_week");
    Log(ret);
}

Execute a estratégiaJavaScriptlinguagem e impressãoretdados, nomeadamente as informações pormenorizadas dethis_weekContrato:

{
    "instrument":"BTC-USD-191101",
    "InstrumentID":"BTC-USD-191101"
}   

exchange.GetContractType (()

exchange.GetContractType()Retorna o código do contrato atualmente definido do objeto de troca (exchange), retorna o valor: string.

function main () {
    Log(exchange.SetContractType("this_week")) 
    Log(exchange.GetContractType())
}

def main():
    Log(exchange.SetContractType("this_week"))
    Log(exchange.GetContractType())

void main() {
    Log(exchange.SetContractType("this_week"));
    Log(exchange.GetContractType());
}

Erros do Futures_OP

A tabela a seguir descreve as informações de erro relacionadas com os objetos de troca dos contratos futuros de criptomoedas:

Valor	Erro de exibição da função	Função de desencadeamento	Descrição
0	Futuros_OP 0	exchange.SetMarginLevel	erro de chamada da função de alavancagem
1	Futuros_OP 1	exchange.SetDirection	erro de definição da função de direção de negociação de futuros
2	Futuros_OP 2	exchange.SetContractType	erro de definição da função do contrato
3	Futuros_OP 3	exchange.GetPosition	erro de obtenção da função de posição
4	Futuros_OP 4	exchange.IO	erro de chamada da função IO

Negociação de opções

Opções de criptomoeda

Utilizaçãoexchange.SetContractTypeFunção para definir contratos; diferentes bolsas têm diferentes códigos de contratos de opções.

Bolsas de opções de criptomoedas suportadas pela plataforma de negociação FMZ Quant

• Deribit Para a troca de Deribit, é apenas necessário chamar oexchange.SetContractTypeApós a configuração do contrato de opções, ao ligar para a interface de mercado, tais comoGetTicker, todos os dados de mercado do contrato de opções são obtidos.exchange.Selleexchange.BuyA função de colocar uma ordem, e prestar atenção à direcção de negociação ao colocar uma ordem, e definir a direcção de negociação porexchange.SetDirection. Use oexchange.Cancelfunção para cancelar uma encomenda;exchange.GetPositionFunção para consultar posições.

  Código de referência da estratégia:A estratégia de teste das opções Deribit

• OKX A criação de contratos, a colocação de ordens, o cancelamento de ordens, a consulta de ordens e a obtenção de cotações de mercado, etc., são da mesma operação que aDeribit, e o formato do código do contrato éBTC-USD-200626-4500-C. Pode consultar as informações relacionadas com o contrato através da interfacehttps://www.okx.com/api/v5/public/instruments.

  Por exemplo, para consultar as informações dos contratos de opções BTC:

  function main() {
      Log(HttpQuery("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD"))
  }
  

  import json
  import urllib.request
  def main():
      ret = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD").read().decode('utf-8'))
      Log(ret)
  

  void main() {
      Log(HttpQuery("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD"));
  }
  

• Futures_HuobiDM Por exemplo, o código do contrato de opções da Huobi:BTC-USDT-201225-P-13000; o contrato é umBTCcontrato; a data de exercício é 25 de dezembro de 2020; as opções são Put Options (PUT); o preço de exercício é de US$ 13.000. Para as opções de compra, o prémio pago pelo comprador é USDT, indicando que o USDT dos activos da conta é utilizado; a margem do vendedor é a moeda, que é garantida pela moeda dos activos. Para as opções de venda, o prémio pago pelo comprador é USDT, indicando que o USDT dos ativos da conta é utilizado; a margem do vendedor é USDT, que é garantida pelo USDT dos ativos.

• Futures_Bybit Ele suporta a opção USDC da troca Bybit, e define o par de negociação paraETH_USDC, função de chamadaexchange.SetContractTypeExemplo de código do contrato de opção:ETH-25NOV22-1375-P.

Configurações de rede

troca.SetBase(Base)

Oexchange.SetBase(Base)função é usada para mudar o endereço de base da API registrado nos objetos de troca; por exemplo, mudar paraOKXnome de domíniohttps://aws.okx.com, compatível comexchange.IO("base","https://aws.okx.com")O sistema de backtest não suporta a comutação do endereço de base da API do exchange (o sistema de backtest é um ambiente de sandbox, não uma interface real para acessar o exchange).

function main() {
    // Use the default base address
    Log(exchange.GetTicker())
    // Switch to https://aws.okx.com
    exchange.SetBase("https://aws.okx.com")
    Log(exchange.GetTicker())
}

def main():
    Log(exchange.GetTicker())
    exchange.SetBase("https://aws.okx.com")
    Log(exchange.GetTicker())

void main() {
    Log(exchange.GetTicker());
    exchange.SetBase("https://aws.okx.com");
    Log(exchange.GetTicker());
}

troca.SetProxy(...)

exchange.SetProxy(...)Esta função não tem valor de retorno (obtido por variáveis, e o que você obtém éundefined) Se a configuração do proxy falhar, um valor nulo será devolvido quando a interface for chamada, apenas para odescansoCada objeto de trocaexchanges[n]Depois de configurar o proxy, a interface de troca será acessada através do proxy.

Pegue o primeiro objeto de troca adicionadoexchange, nomeadamente:exchanges[0], por exemplo:

• Configure o proxy, sem nome de usuário e senha:exchange.SetProxy("socks5://127.0.0.1:8889")
• Configure o proxy e digite o nome de usuário e senha:exchange.SetProxy("socks5://username:password@127.0.0.1:8889") (usernameé o nome do utilizador,passwordé a senha.)
• Mudar para o modo normal, sem proxy:exchange.SetProxy("")

Suporte para definir o endereço IP solicitado pelo objeto de troca.

• Especificação global O doqueiro dewindowsversão da interface do sistema pode ser definido diretamente, que é mostrado como a seguinte imagem:

Outras docas operadas pelo parâmetro de utilização do prompt de comando-IPara especificar os endereços IP:

• Com base na troca, para especificar:

  function main(){
      exchange.SetProxy("ip://10.0.3.15")
      exchange.GetTicker()                      // The reque

Mais.