Instructions de l'API FMZ

pp - Je ne sais pas. les échanges[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());
}

• Modifier le mode de marché Échanges actuellement pris en charge:

  Échange	Les commentaires
  Huobi Spot	Après avoir pris en charge le protocole WebSocket, le codeexchange.IO(monnaie, ETH) ne peut pas être utilisé pour changer de monnaie

  • exchange.IO("websocket")

    Passez le protocole de communication du marché àwebsocket(par défaut est repos), la façon d'obtenir les cotations de marché changera après le changement.exchange.GetTicker()etexchange.GetDepth()sera basculé verswebsocketLe protocole de mise à jour, de l'acquisition active brute de données de marché à l'acquisition passive de données de marché, seulement Huobi Exchange est actuellement pris en charge.

  Lorsque le mode de marché est le mécanisme de poussée, vous pouvez appeler la fonction suivante pour définir:

  • exchange.IO("mode", 0)Mode de retour immédiat. Si les données de marché actuelles n'ont pas été reçues de l'échange, les anciennes données de marché seront immédiatement retournées. S'il y a de nouvelles données, les nouvelles données seront retournées.

  • exchange.IO("mode", 1)Mode de mise en cache (mode par défaut). Si les dernières données de marché de l'échange n'ont pas été reçues (par rapport aux données obtenues à partir de l'interface précédente), attendez de les recevoir, puis retournez. Si les dernières données de marché ont été reçues avant d'appeler cette fonction, les dernières données seront immédiatement retournées.

  • exchange.IO("mode", 2)Mode de mise à jour forcée. Entrez et attendez jusqu'à ce que la prochaine dernière mise à jour des données de l'échange soit reçue, puis revenez.

  Si vous souhaitez obtenir les dernières informations sur le marché dès la première fois, vous pouvez passer àwebsocketet n'appelez pasSleepLes résultats de l'analyse de l'efficacité de laexchange.GetTicker()etexchange.GetDepth()les fonctions fonctionnent en mode cache, telles que:

  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());
      }
  }
  

• Mode de compte d'effet de levier de change

  Utilisationexchange.IO("trade_margin")pour passer au mode compte à effet de levier, la mise en place d'ordres et l'accès aux actifs du compte utiliseront l'interface d'effet de levier de la bourse. Utilisationexchange.IO("trade_normal")pour revenir au mode de compte normal.

  Échanges pris en charge:

  Échange	Commentaires spéciaux
  - Ça va.	Les paires de négociation du mode de compte à effet de levier sont différentes de celles ordinaires, et certaines paires de négociation peuvent ne pas être disponibles.exchange.IO("cross", true)de passer à la position complète du compte à effet de levier etexchange.IO("cross", false)pour passer à une position isolée.
  Huobi est un joueur.	Les paires de trading du mode de compte à effet de levier sont différentes de celles ordinaires, et certaines paires de trading peuvent ne pas être disponibles.trade_marginpour passer à une position isolée sur un compte à effet de levier;trade_super_marginpour passer à un compte à effet de levier;trade_normalpour passer à un mode de change normal
  ZB	Les fonds ne peuvent être transférés qu'en QC. Dans le secteur du trading à effet de levier, les fonds entre différentes paires de trading sont indépendants, c'est-à-dire que le nombre de pièces QC sous la paire de trading ETH_QC n'est pas visible dans BTC_QC
  Binance	Les comptes d'effet de levier sont divisés en positions croisées et en positions isolées.trade_marginpour passer à une position isolée;trade_super_marginpour passer à la position croisée; utilisertrade_normalpour passer à un mode de change normal
  La porte	Les comptes d'effet de levier sont divisés en positions croisées et en positions isolées.trade_marginpour passer à une position isolée;trade_super_marginpour passer à la position croisée; utilisertrade_normalpour passer à un mode de change normal
  AscendEx	Utilisationexchange.IO("trade_margin")pour passer au mode compte à effet de levier et utiliserexchange.IO("trade_normal")pour revenir au mode de compte normal.

Je suis en train de faire un échange.

exchange.Log(LogType, Price, Amount)n'effectue pas d'ordre lorsqu'il est appelé et enregistre uniquement les informations de négociation pour produire les informations du journal de change.

Note: le numéro de série

• Cette fonction est une fonction membre deexchangeles objets, ce qui est différent de la fonction globaleLog().
• Valeur du paramètre:LogTypepeut prendreLOG_TYPE_BUY, LOG_TYPE_SELL, LOG_TYPE_CANCELetPricecomme prix, etAmountEn tant que quantité.LogTypeestLOG_TYPE_CANCEL, Pricele paramètre est l'identifiant de commande.

Utilisationexchange.Log(LogType, Price, Amount)effectuer les tests de suivi des opérations en direct, simuler la passation d'ordres et aider à enregistrer les ordres.

Le cas d'utilisation le plus courant est:exchange.IOLa fonction d'accéder à l'interface de commande conditionnelle de la bourse pour placer des ordres conditionnels.exchange.IOLa fonction n'affichera pas les informations du journal d'échange dans l'enregistrement du journal du bot.exchange.Log(LogType, Price, Amount)pour compléter la sortie du journal afin d'enregistrer les informations relatives aux ordres passés.

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);
}

Je vous en prie.

exchange.HMAC(Algo, OutputAlgo, Data, Key)Elle soutient laHMACcalcul du chiffrement deMd5/à l'état/à l'état/S1, et seuls les échanges en direct sont pris en charge.

exchange.HMAC("sha256", "hex", "xxxxx", "{{secretkey}}")Pour citeraccessKey, utiliser"{{accesskey}}"Je suis désolée. Pour citersecretKey, utiliser"{{secretkey}}"; ou vous pouvez utiliser du texte brut"abc-123-xxxx". "{{accessKey}}","{{secretkey}}"n'est valable que lorsque cette fonction est utilisée.OutputAlgoles supports: hex, base64.Exemple spécifique

Poussez les changements de position BitMEX (protocole 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"];
        }
    }
}

Je vous échange. Allez.

exchange.Go(Method, Args...)est la fonction asynchrone prise en charge multi-threaded, qui peut transformer le fonctionnement de toutes les fonctions prises en charge en concurrent asynchrone (qui ne prend en charge que les échanges de cryptomonnaies). Valeur du paramètre:Method, de type chaîne, à savoir le nom de la fonction appelée simultanément.

Note: le numéro de série

• Cette fonction ne crée que des tâches d'exécution multi-threaded lorsqu'elle est exécutée dans le commerce en direct.Le backtest ne prend pas en charge les tâches d'exécution simultanée multi-threaded (le backtest est disponible, mais il est toujours exécuté séquentiellement).
• Après leexchange.Gofonction renvoie un objet, lewaitLa fonction est appelée pour récupérer les données renvoyées par le thread à travers l'objet. Le thread sera libéré automatiquement après l'acquisition de données en appelantwaitSi spécifier le paramètre de temps d'arrêt dewait, le thread ne sera pas libéré même si le timeout se produit; de cette façon, le thread ne sera libéré automatiquement qu'en obtenant le résultat du thread (indépendamment du fait que l'interface accédée simultanément soit appelée avec succès ou sans succès).
• En termes simples, peu importe le succès ou l'échec du fil appliqué, le résultat doit être obtenu par lewaitfonction, et la ressource de fil appliquée par leexchange.GoLa fonction est libérée automatiquement par le docker.
• Si le résultat de retour duwaitsi la fonction n'est pas obtenue à la fin, les ressources de fil ne seront pas libérées automatiquement, ce qui entraînera l'accumulation de fils appliqués; si le nombre de fils dépasse 2000, une erreur sera signalée:"too many routine wait, max is 2000".

Fonctions prises en charge:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositionetIO.

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);
}

Note: le numéro de série

• Pour jugerundefined, utilisertypeof(xx)==="undefined", parce quenull == undefinedest disponible en 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);
}

La différence entrePythonetJavaScriptC' est ça?PythonC' est...waitla fonction renvoie deux paramètres: le premier est le résultat renvoyé par l'API asynchrone; le second indique si l'appel asynchrone est terminé.

PythonExemple:

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)       

Acquérir simultanément des cotations de plusieurs bourses:

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);
    }
}

Les appels simultanés à laexchange.IO("api", ...)fonction:

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");
}

Informations sur le compte

Je suis en train de changer de compte.

exchange.GetAccount()renvoie les informations du compte de change.Account structure.

• Accountla structure

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);
}

Si l'objet d'échange est défini sur un échange de contrats à terme de crypto-monnaie et basculé vers un contrat avecUSDTLa marge de conversion est calculée en fonction deexchange.SetContractTypeLes actifs de l'établissement sontUSDTcomme marge, qui est enregistrée dans l'attribut deBalanceetFrozenBalance.

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);
}

Je suis en train d' écrire un article.

exchange.GetName()Retourne la valeur: type de chaîne.exchangeouexchanges[n]des objets dans le code de stratégie.

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");
}

Pour commander la version en ligne de Docker, vous pouvez utiliser le-1commande pour imprimer une liste de noms d'échange.

Je suis en train de changer.GetLabel

exchange.GetLabel()renvoie l'étiquette personnalisée de l'échange.

Leexchangeouexchanges[n]les objets des codes de stratégie sont normalement déterminés par les étiquettes définies lors de la configuration des objets d'échange.

Je suis en train de changer de monnaie.

exchange.GetCurrency()renvoie le nom de la paire de devises exploitée par l'échange, et la plateforme de crypto-monnaie renvoie une chaîne, telle queLTC_BTC. Retourne la valeur: type de chaîne.

La monnaie est la devise de l'échange.

Leexchange.SetCurrency(Symbol)Cette fonction est utilisée pour basculer la paire de négociation actuelle de l'objet d'échange.exchange.IO ("currency","BTC_USDT")Il prend en charge la commutation des paires de négociation dans le système de backtesting, et le nom de la paire de négociationpricing currencyne peut pas être modifiée lors du changement de paires de négociation dans le système de backtesting (par exemple,BTC_USDTpeut être basculé versLTC_USDT, mais il ne peut pas être basculé surLTC_BTCAprès le passage à une paire de négociation initialement définie sur la page non backtesting, le nombre detrading coinsest égal à 0 (par exemple, pendant le backtest, la valeur initiale de la paire de négociation sur la page backtest estBTC_USDT, le nombre de BTC est de 3 et le nombre de USDT est de 10 000.LTC_USDT, le nombre detrading coinsaprès le changement sera 0, ce qui signifie que le nombre de LTC sur le compte est 0, mais le montant USDT partagé des paires de négociation changées est toujours 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());
}

Résultat de l'opération de test antérieur:

La monnaie de l'échange.GetQuoteCurrency

exchange.GetQuoteCurrency()renvoie le nom de la devise de base exploitée par l'échange.BTC_CNYrendementsCNY, etETH_BTCrendementsBTC. Retourne la valeur: type de chaîne.

Échange de contrats à terme

Pour les objets d'échange de contrats à terme de crypto-monnaie, le code du contrat doit être spécifié avant d'appeler sonle marché, l'ordreet autres interfaces, et leexchange.SetContractTypeLorsque vous changez la paire de négociation actuelle de l'objet d'échange, vous devez appeler le code de contrat actuel.exchange.SetContractTypePour les codes de contrats de change de monnaie numérique pris en charge par la plateforme, veuillez consulter leexchange.SetContractType function.

Je suis désolé.

exchange.GetPosition()obtient les informations de position actuelles.positionstructure array. S'il n'y a pas de position, il renvoie un tableau vide, à savoir[].

• Positionla structure

Normalement, les contrats à terme de crypto-monnaie sont divisés en deux types:

• Contrat de livraison Lorsqu'un contrat est établi sur un contrat de livraison, appeler leexchange.GetPosition()Le montant de la transaction est calculé en fonction de la valeur de la transaction, et toutes les positions du contrat de livraison sous la paire de négociation en cours sont renvoyées.

• Un contrat à perpétuité Lorsqu'un contrat est défini sur un contrat perpétuel, appeler leexchange.GetPosition()Le montant de l'impôt sur le revenu est calculé en fonction de la valeur de l'impôt sur le revenu.

/*
    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);
    } 
}

- Je ne sais pas.

exchange.SetMarginLevel(MarginLevel)définit la taille de l'effet de levier.

Définir la taille de l'effet de levier pour placer des ordres à terme de crypto-monnaie, par exemple:

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

def main():
    exchange.SetMarginLevel(10)

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

Pour les contrats à terme de crypto-monnaie, les mécanismes d'effet de levier des échanges de contrats à terme de crypto-monnaie ne sont pas uniformes.SetMarginLevelLa fonction n'est pas capable de générer une requête réseau, mais définit uniquement la variable de levier dans la couche inférieure (utilisée pour transmettre des paramètres dans l'interface de placement d'ordres).SetMarginLevella fonction générera une requête réseau et peut ne pas définir le levier pour diverses raisons. Par exemple: s'il y a des positions en cours et des ordres en attente, la valeur du levier peut ne pas être définie pour cette paire de négociation et l'objet sous-jacent.

Notes pour la définition de l'effet de levier dans la conception de la stratégie:

• Seuls les contrats à terme de crypto-monnaie sont pris en charge.
• Le backtest prend en charge le changement de levier.

Je suis en train de changer de direction.

exchange.SetDirection(Direction)ensembleexchange.Buyouexchange.Sellpour établir des instructions pour placer des ordres de contrats à terme.

LeSetDirectionla fonction définit la correspondance entre la direction de négociation des contrats à terme et la fonction de passation des ordres:

Fonction de placement des commandes	Direction de réglage des paramètres pour la fonction SetDirection	Les commentaires
exchange.Buy	acheter	acheter une position longue ouverte
exchange.Buy	close-sell	acheter une position close short
exchange.Sell	vendre	vendre une position ouverte à court terme
exchange.Sell	achat de près	vendre une position longue fermée

Le paramètreDirectionpeut prendre les quatre paramètres, y comprisbuy, closebuy, selletclosesell.

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);
}

le type de contrat est défini par l'échange.SetContractType(...)

exchange.SetContractType(ContractType)définir le type de contrat. Valeur du paramètre: type de chaîne. Dans les stratégies de crypto-monnaie, prenez BTC_USDT à titre d'exemple. Lorsque vous changez les paires de trading parexchange.SetCurrency("BTC_USDT")ouexchange.IO("currency", "BTC_USDT"), vous devez utiliser leexchange.SetContractTypeLa fonction de réinitialisation du contrat pour déterminer le contrat en cours qui doit être opéré sous la nouvelle paire de négociation.currency-based contractou unU-based contractLes résultatspaire de négociationPar exemple, lorsque la paire de négociation est réglée surBTC_ USDT, fonction d' utilisationexchange.SetContractTypepour définir le code du contratswap, qui est défini comme le contrat perpétuel de BTC basé sur USDT.BTC_ USD, fonction d' utilisationexchange.SetContractTypepour définir le code du contratswap, qui est défini comme le contrat perpétuel de BTC basé sur la monnaie.

Sauf indication contraire, lecontrat de livraisonle code d'un contrat à terme de crypto-monnaie comprend généralement:

• this_week: contrat hebdomadaire
• next_week: contrat de la semaine prochaine
• quarter: contrat trimestriel
• next_quarter: contrat pour le trimestre suivant

Sauf indication contraire, lecontrat à durée indéterminéele code d'un contrat à terme de crypto-monnaie comprend généralement:

• swap: contrat à durée indéterminée

Réglez le contrat actuel sur un contrat hebdomadaire:

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

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

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

Une description détaillée de la dénomination du contrat de chaque échange de crypto-monnaie pris en charge est indiquée comme suit:

• - Je suis désolé. Je suis en contrat à perpétuité:exchange.SetContractType("swap")Le contrat de cette semaine:exchange.SetContractType("this_week")Contrat pour la semaine prochaine:exchange.SetContractType("next_week")Définition du contrat trimestriel:exchange.SetContractType("quarter")Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter")Le contrat de marge OKX USDT peut être basculé vers le contrat utilisant le règlement USDT correspondant au contrat en cours en basculanttrading pair(ou le régler directement lors de l'ajout des objets d'échange).

  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());
  }
  

• Les contrats à terme Le contrat de cette semaine:exchange.SetContractType("this_week")Contrat pour la semaine prochaine:exchange.SetContractType("next_week")Définition du contrat trimestriel:exchange.SetContractType("quarter")Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter")Je suis en contrat à perpétuité:exchange.SetContractType("swap")

  La plateforme prend en charge les contrats à marge USDT. Prenez le contrat BTC à titre d'exemple. Vous pouvez passer à un contrat à marge USDT uniquement en utilisantexchange.SetCurrency("BTC_USDT"), ou en réglant la paire de négociation en cours àBTC_USDTdirectement lorsque vous configurez les paramètres du bot et ajoutez des objets d'échange.exchange.SetContractTypeLa fonction de régler le contrat.

• Les titres à terme Je suis en contrat à perpétuité:exchange.SetContractType("XBTUSD"), exchange.SetContractType("APTUSDT")Je suis désolée. Le contrat est réglé à un moment précis, et connectez-vous au site officiel de BitMEX pour vérifier chaque code de contrat pour plus de détails.exchange.SetContractType("XBTM19").

• Les contrats à terme Le contrat de cette semaine:exchange.SetContractType("this_week")Je suis désolée. Contrat pour la semaine prochaine:exchange.SetContractType("next_week")Je suis désolée. Définition du contrat trimestriel:exchange.SetContractType("quarter")Je suis désolée. Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter")Je suis désolée. Je suis en contrat à perpétuité:exchange.SetContractType("swap")Je suis désolée. L'échange prend en charge les contrats à marge USDT. Prenez le contrat BTC à titre d'exemple. Vous pouvez passer à un contrat à marge USDT en utilisantexchange.SetCurrency("BTC_USDT"), ou en réglant la paire de négociation en cours àBTC_USDTdirectement lorsque vous configurez les paramètres de trading en direct et ajouter des objets d'échange.exchange.SetContractTypeLa fonction de régler le contrat.

• Les titres à terme Je suis en contrat à perpétuité:exchange.SetContractType("BTC-PERPETUAL")Contrat de soutien Deribit USDC; appelexchange.SetContractType("ADA_USDC-PERPETUAL")pour définir un contrat perpétuel à marge ADA USDC. Le contrat est réglé à un moment précis, et connectez-vous au site officiel de Deribit pour vérifier chaque code de contrat pour plus de détails, tels que:exchange.SetContractType("BTC-27APR18").

• Les contrats à terme

  • Les éléments suivants sont pris en compte: Par exemple, régler la paire de négociation àBTC_USD, puis définissez le code du contrat, qui s'appelle le contrat cryptographique à marge. Je suis prêt pour un contrat à perpétuité.exchange.SetContractType("swap")Définition du contrat trimestriel:exchange.SetContractType("quarter")Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter")
  • Le contrat de garantie en USDT: Par exemple, régler la paire de négociation àBTC_USDT, puis définissez le code du contrat, qui est le contrat à marge USDT. Je suis prêt pour un contrat à perpétuité.exchange.SetContractType("swap").

• Les contrats à terme avec Binance Binance Futures ne définit pas le statut du contrat par défaut, vous devez donc définir le contrat en premier. Je suis prêt pour un contrat à perpétuité.exchange.SetContractType("swap")Les contrats perpétuels Binance Futures peuvent être des contrats à marge USDT.BTCContract de marge USDT, la paire de négociation est réglée surBTC_USDT. Les contrats perpétuels Binance Futures incluent également les contrats cryptographiques à marge. Par exemple, dans le contrat cryptographique à marge, définissez la paire de trading àBTC_USD.

  Définition du contrat trimestriel:exchange.SetContractType("quarter")Les contrats de livraison comprennent des contrats cryptographiques à marge (à savoir en prenant la monnaie utilisée comme marge).BTC, la paire de négociation est réglée surBTC_USD, puis définissez le code du contratexchange.SetContractType("quarter"), qui définit un contrat trimestriel de crypto-marge BTC.

  Contrat pour le prochain trimestre:exchange.SetContractType("next_quarter")Par exemple, dans le contrat trimestriel de crypto-marge deBTC, la paire de négociation est réglée surBTC_USD, puis définissez le code du contratexchange.SetContractType("next_quarter)Binance prend en charge une partie des contrats de livraison à marge USDT, tels que la définition de la paire de trading BTC àBTC_USDT, puis définissez le code du contrat.

• Les échanges à terme Code du contrat à durée indéterminée Bibox:swapJe suis désolée. Je suis en contrat à perpétuité:exchange.SetContractType("swap").

• Le montant de la garantie est calculé à partir de la valeur de la garantie. Code du contrat perpétuel AOFEX:swapJe suis désolée. Je suis en contrat à perpétuité:exchange.SetContractType("swap").

• Les contrats à terme Code du contrat perpétuel BFX:swapJe suis désolée. Je suis en contrat à perpétuité:exchange.SetContractType("swap").

• Les échanges à terme Bybit est par défaut au contrat perpétuel de la paire de négociation en cours.swapJe suis désolée. Code du contrat trimestriel:quarterJe suis désolée. Code du contrat pour le trimestre suivant:next_quarter.

• Les contrats à terme Kraken ne définit pas le statut du contrat par défaut, donc vous devez définir le code du contrat.swapLe contrat est perpétuel.month: contrat mensuel.quarter: contrat trimestriel.next_quarterLe contrat pour le prochain trimestre.

• Les titres à terme Bitfinex ne respecte pas le contrat perpétuel de la paire de négociation actuelle.swap.

• Les contrats à terme avec Bitget Bitget par défaut au contrat perpétuel de la paire de négociation en cours.swap. La paire de trading est réglée surBTC_USD, indiquant le contrat cryptographique à marge; la paire de négociation est réglée surBTC_USDTLes contrats simulés peuvent définir les paires de négociation en:SBTC_USDetBTC_SUSDT.

• Les contrats à terme Le code du contrat de contrat perpétuel dYdX:swapJe suis désolée. Je suis en contrat à perpétuité:exchange.SetContractType("swap"). dYdX ne dispose que de contrats à marge USDT.

• Les échanges à terme Le code du contrat du contrat perpétuel MEXC:swapJe suis désolée. Je suis en contrat à perpétuité:exchange.SetContractType("swap"). La paire de trading est réglée surBTC_USD, indiquant le contrat cryptographique à marge; la paire de négociation est réglée surBTC_USDT, indiquant le contrat à marge USDT.

Lorsque vous écrivez des stratégies de crypto-monnaie, appelezexchange.SetContractType(ContractType)fonction et les informations détaillées sur le contrat définies par le paramètre du contratContractTypesera renvoyé.

Par exemple, en exécutant le code de stratégie du contrat OKX défini comme objet d'échange:

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);
}

Exécutez la stratégie dansJavaScriptlangue, et impriméretdonnées, à savoir les informations détailléesthis_weekle contrat:

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

Il est possible de modifier le type de contrat.

exchange.GetContractType()renvoie le code de contrat actuellement défini de l'objet d'échange (exchange), renvoie la valeur: chaîne.

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());
}

Erreurs de mise à jour

Le tableau suivant décrit les informations d'erreur relatives aux objets d'échange des contrats à terme sur crypto-monnaie:

Valeur	Erreur d'affichage des fonctions	Fonction de déclenchement	Définition
0	Opérations futures 0	exchange.SetMarginLevel	erreur d'appel de la fonction de levier
1	Opérations à terme_OP 1	exchange.SetDirection	erreur de réglage de la fonction direction de négociation des contrats à terme
2	Opérations futures 2	exchange.SetContractType	erreur de définition de la fonction de contrat
3	Opérations futures 3	exchange.GetPosition	erreur d'obtention de fonction de position
4	Opérations futures 4	exchange.IO	erreur d'appel de la fonction IO

Options de négociation

Options de crypto-monnaie

Utilisationexchange.SetContractTypeLes différentes bourses ont des codes de contrats d'options différents.

Échanges d'options de crypto-monnaie pris en charge par la plateforme de trading FMZ Quant

• Deribit Pour l'échange Deribit, il suffit d'appeler leexchange.SetContractTypeUne fois le contrat d'options mis en place, lors de l'appel à l'interface de marché telle queGetTicker, toutes les données de marché du contrat d'options sont obtenues.exchange.Selletexchange.BuyLes fonctionnalités suivantes s'appliquent à l'opérateur:exchange.SetDirectionUtilisez leexchange.Cancelfonction d'annuler une commande;exchange.GetPositionfonction pour interroger les positions.

  Le code de référence de la stratégie:La stratégie de test des options Deribit

• - Je suis désolé. L'établissement de contrats, la passation d'ordres, l'annulation d'ordres, la consultation d'ordres et l'obtention de cotations de marché, etc., sont de la même opération queDeribit, et le format du code du contrat estBTC-USD-200626-4500-C. Vous pouvez consulter les informations relatives au contrat à travers l'interfacehttps://www.okx.com/api/v5/public/instruments.

  Par exemple, pour interroger les informations sur les contrats d'options 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"));
  }
  

• Les contrats à terme Par exemple, le code du contrat d'options Huobi:BTC-USDT-201225-P-13000; le contrat est uneBTCle contrat; la date d'exercice est le 25 décembre 2020; les options sont des Put Options (PUT); le prix d'exercice est de 13 000 $. Pour les options d'achat, la prime payée par l'acheteur est USDT, indiquant que l'USDT des actifs du compte est utilisé; la marge du vendeur est la devise, qui est garantie par la devise des actifs. Pour les options de vente, la prime payée par l'acheteur est USDT, indiquant que l'USDT des actifs du compte est utilisé; la marge du vendeur est USDT, qui est garantie par l'USDT des actifs.

• Les échanges à terme Il prend en charge l'option USDC de l'échange Bybit, et définit la paire de trading àETH_USDC, fonction d'appelexchange.SetContractTypeExemple de code du contrat d'option:ETH-25NOV22-1375-P.

Paramètres réseau

- Je suis désolé.

Leexchange.SetBase(Base)fonction est utilisée pour basculer l'adresse de base de l'API enregistrée dans les objets d'échange; par exemple, basculer versOKXNom de domainehttps://aws.okx.com, compatible avecexchange.IO("base","https://aws.okx.com")Le système de backtest ne prend pas en charge la commutation de l'adresse de base API de l'échange (le système de backtest est un environnement de sandbox, pas une interface réelle pour accéder à l'échange).

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());
}

Je suis en train d'écrire.

exchange.SetProxy(...)Cette fonction n'a pas de valeur de retour (obtenue par des variables, et ce que vous obtenez estundefinedSi le paramètre proxy échoue, une valeur nulle sera renvoyée lorsque l'interface est appelée, uniquement pour lereposerchaque objet d'échangeexchanges[n]Après avoir configuré le proxy, l'interface d'échange sera accessible par le proxy.

Prenez le premier objet d'échange ajoutéexchange, à savoir:exchanges[0], par exemple:

• Mettre en place le proxy, sans nom d'utilisateur et mot de passe:exchange.SetProxy("socks5://127.0.0.1:8889")
• Configurez le proxy et entrez le nom d'utilisateur et le mot de passe:exchange.SetProxy("socks5://username:password@127.0.0.1:8889") (usernameest le nom de l'utilisateur,passwordest le mot de passe.)
• Passez au mode normal, sans proxy:exchange.SetProxy("")

Prise en charge pour définir l'adresse IP demandée par l'objet d'échange.

• Spécification globale Le docker dewindowsla version de l'interface système peut être définie directement, comme le montre l'image suivante:

Autres ports exploités par le paramètre d'utilisation de l'invite de commande-Ipour spécifier les adresses IP:

• Sur la base de l'échange, préciser:

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

Plus de