Die Ressourcen sind geladen. Beförderung...

FMZ-API-Anweisungen

Schriftsteller:Null, Erstellt: 2020-04-20 10:19:00, Aktualisiert: 2023-04-12 14:44:56

in die letzten 10 Protokolle und löschen Sie den Rest LogReset ((10)
}


```Python
def main():
    LogReset(10)

void main() {
    LogReset(10);
}

LogVacuum (siehe unten)

LogVacuum(), nachdem er dieLogReset()Funktion, um das Protokoll zu löschen, erholt den Speicherplatz, denSQLiteDie Funktion gibt keinen Wert zurück. Der Grund dafür ist, dassSQLitenicht den Platz zurückgewinnen, wenn Daten gelöscht werden, so müssen SieVACUUMWenn diese Funktion aufgerufen wird, erfolgt die Dateibewegung mit großer Verzögerung. Es wird empfohlen, sie in einem geeigneten Zeitintervall aufzurufen.

API für Marktnoten

Die wichtigsten Funktionen der Marktschnittstelle sind:

Funktionsname	Beschreibung
GetTicker	Erhalten Sie die Daten von Anführungszeichen
GetRecords	Holen Sie K-Liniendaten.
GetDepth	Erhalten Sie Bestellbuchdaten (Bestelltiefe-Daten)
GetTrades	Erhalten Sie die neuesten Handelsdaten auf dem Markt

Die folgenden Funktionen können überexchangeoderexchanges[0]Objekte; zum Beispiel: Funktionen, wieexchange.GetTicker();oderexchanges[0].GetTicker();, gibt die Marktkurse der aktuellen Handelspare und die Festlegung von Verträgen zurück.

Wichtige Tipps für den Aufruf von API-Funktionen mit Netzwerkzugang:Bei Aufruf einer API-Funktion, die auf eine Plattformoberfläche zugreift (z. B.exchange.GetTicker(), exchange.Buy(Price, Amount), exchange.CancelOrder(Id), etc.) ist der Ausfall des Zugriffs wahrscheinlich aus verschiedenen Gründen verursacht. Daher müssen wir fehlertolerante Verarbeitung für den Aufruf dieser Funktionen durchführen.exchange.GetTicker()Die Funktion zur Erfassung von Marktdaten kann aufgrund von Problemen mit Plattformservern und Netzübertragungsproblemen usw. dazu führen, dass der Rückgabewert desexchange.GetTicker()Funktion istnull. Dann wird der Wert vonexchange.GetTicker()Die Bearbeitung muss fehlertolerant erfolgen.

Die von derexchange.GetTicker()Funktion in folgendem Code wird demtickerWir müssen uns mit der Fehlerverträglichkeit befassen, bevor wir dieticker variable.

function main() {
    var ticker = exchange.GetTicker()
    if(!ticker){
        // Recall once, or use other processing logic
        ticker = exchange.GetTicker()
    }
}

def main():
    ticker = exchange.GetTicker()
    if not ticker:
        ticker = exchange.GetTicker()

void main() {
    auto ticker = exchange.GetTicker();
    if(!ticker.Valid) {
        ticker = exchange.GetTicker();
        Log("Test");
    }
}

Darüber hinaus hat das FMZ für die Fehlertoleranztestung der Strategie speziell ein einzigartigesFehlertoleranzmodusDas Backtest-System kann zufällig einige API-Aufrufe zurückgeben, die auftreten, wenn das Netzwerk gemäß den festgelegten Parametern aufgerufen wird, und die Rückgabewerte einiger fehlgeschlagener Anrufe zurückgeben. Wechseln Sie zur Backtest-Systemseite auf der Strategiebearbeitungsseite, klicken Sie aufumgekehrtes DreieckEin Drop-down-System befindet sich auf der rechten Seite der Schaltfläche Start Backtest und die Schaltfläche Backtest Fault Tolerant wird angezeigt.

- Ich bin nicht derjenige, der das tut.

exchange.GetTicker()Erhält die aktuellen Marktnotierungen aktueller Handelspare und -verträge mit dem Renditewert:TickerStruktur. Im Backtest-System werden dieTickerDaten, die von derexchange.GetTicker()Funktion, woHighundLowsind simulierte Werte, die aus dem aktuellen Zeitpunkt von sell 1 und buy 1 im Bot genommen wurden.Tick interface.

TickerStruktur

function main(){
    var ticker = exchange.GetTicker()
    /*
        The platform interface may not be accessible due to network problems (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, ticker is null, when accessing ticker. When it is "High", it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Volume:", ticker.Volume)
}

def main():
    ticker = exchange.GetTicker()
    Log("High:", ticker["High"], "Low:", ticker["Low"], "Sell:", ticker["Sell"], "Buy:", ticker["Buy"], "Last:", ticker["Last"], "Volume:", ticker["Volume"])

void main() {
    auto ticker = exchange.GetTicker();
    Log("High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Volume:", ticker.Volume);
}

Im echten Bot (nicht Backtest), dieInfoAttribut im Rückgabewert derexchange.GetTicker()Die Funktion speichert die ursprünglichen Daten, die bei Aufruf der Schnittstelle zurückgegeben werden.

Erhalten Sie die Tiefe.

exchange.GetDepth()erhält die Daten des Tauschaufträgebuchs aktueller Handelspare und -verträge.Depth structure.

DepthDie Struktur besteht aus zwei Strukturen, nämlichAsks[]undBids[], AsksundBidsdie folgenden Strukturvariablen enthalten:

Datentyp	Name der Variablen	Beschreibung
Zahl	Preis	Preis
Zahl	Betrag	Betrag

DepthStruktur

Zum Beispiel, wenn ich den aktuellen Verkauf zweiter Preis erhalten möchte, kann ich den Code wie folgt schreiben:

function main(){
    var depth = exchange.GetDepth()
    /*
       The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
       At this time, depth is null. When accessing depth.Asks[1].Price, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    var price = depth.Asks[1].Price
    Log("Sell 2 price is:", price)
}

def main():
    depth = exchange.GetDepth()
    price = depth["Asks"][1]["Price"]
    Log("Sell 2 price is:", price)

void main() {
    auto depth = exchange.GetDepth();
    auto price = depth.Asks[1].Price;
    Log("Sell 2 price is:", price);
}

- Das ist nicht wahr.

exchange.GetTrades()Erhält den Handelshistorikverlauf der Plattform (nicht Ihren eigenen).TradeEinige Börsen unterstützen es nicht. Die spezifischen zurückgegebenen Daten hängen von den Handelsdaten innerhalb des Bereichs ab, je nach spezifischen Umständen. Die zurückgegebenen Daten sind ein Array, bei dem die Zeitfolge jedes Elements mit der zurückgegebenen Datenfolge desexchange.GetRecordsFunktion, das heißt, das letzte Element des Arrays ist die Daten, die der aktuellen Zeit am nächsten sind.

TradeStruktur

// In the simulated backtest, the data is empty; to have a trading history, there must be a real bot running
function main(){
    var trades = exchange.GetTrades()
    /*
        The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, "trades" is null. When accessing trades[0].Id, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
}

def main():
    trades = exchange.GetTrades()
    Log("id:", trades[0]["Id"], "time:", trades[0]["Time"], "Price:", trades[0]["Price"], "Amount:", trades[0]["Amount"], "type:", trades[0]["Type"])

void main() {
    auto trades = exchange.GetTrades();
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
}

- Ich bin nicht derjenige, der das tut.

exchange.GetRecords(Period)K-Zeilperiode wird beim Erstellen des Bots angegeben; wenn Sie die Parameter angeben, wenn derexchange.GetRecords()Wenn die Funktion aufgerufen wird, werden die erhaltenen Daten die K-Zeilendaten sein, die dem Parameterzeitraum entsprechen. Wenn kein Parameter angegeben ist, werden die K-Zeilendaten gemäß der K-Zeilendefinition auf den Bot-Parametern oder der K-Zeilendefinition auf der Backtest-Seite zurückgegeben.

ParameterPeriod:

Der Wert des Zinssatzes: bezieht sich auf 1 Minute
Der Wert des Zinses wird nach Maßgabe des Zinssatzes berechnet: bezieht sich auf 5 Minuten
Der Wert des Zinssatzes wird in den folgenden Zahlen angegeben:: bezieht sich auf 15 Minuten
Periode_M30: bezieht sich auf 30 Minuten
Periode_H1: bezieht sich auf 1 Stunde
Periode_D1: bezieht sich auf 1 Tag Der Parameterwert vonPeriodkann nicht nur die oben definierten Standardperioden überschreiten, sondern auch Zahlen in der Sekundeinheit.

Der Rücklaufwert vonexchange.GetRecords(Period)Funktion: Der zurückgegebene Wert ist ein Array vonRecordDie Daten werden im Laufe der Zeit akkumuliert, die Obergrenze der akkumulierten K-Linienbalken wird durch dieexchange.SetMaxBarLenDie Standardobergrenze beträgt 5000 K-Line-Bars, wenn sie nicht festgelegt ist. Wenn die K-Line-Daten die K-Line-Barsammelungsgrenze erreichen, werden sie aktualisiert, indem eine K-Line-Bar hinzugefügt und die früheste K-Line-Bar gelöscht wird (z. B. Warteschlange in / aus). Einige Börsen bieten keine K-Line-Schnittstelle, dann sammelt der Docker die Markttransaktionsdatensätze in Echtzeit, um K-Lines zu generieren.

Anzahl der K-Linienbalken, die bei derGetRecordsDie Funktion wird zunächst aufgerufen.

Die ersten 1000 K-Linienbalken zum Beginn des Backtesting-Zeitraums werden im Backtesting-System im Voraus als erste K-Liniendaten erfasst.
Die spezifische Anzahl von K-Line-Bars, die während eines echten Bots erworben werden sollen, basiert auf der maximalen Datenmenge, die durch die K-Line-Schnittstelle der Börse erworben werden kann.

Für dieexchange.GetRecords(Period)Funktion, die bot und backtest vonKryptowährungBeide unterstützen benutzerdefinierte Zeiträume, und der ParameterPeriodist die Anzahl der Sekunden.

function main() {
    // Print K-line data with a K-line period of 120 seconds (2 minutes)
    Log(exchange.GetRecords(60 * 2))         
    // Print K-line data with a K-line period of 5 minutes
    Log(exchange.GetRecords(PERIOD_M5))      
}

def main():
    Log(exchange.GetRecords(60 * 2))
    Log(exchange.GetRecords(PERIOD_M5))

void main() {
    Log(exchange.GetRecords(60 * 2)[0]);
    Log(exchange.GetRecords(PERIOD_M5)[0]);
}

EinstellungPeriodParameter 5 ist die Anforderung von K-Liniendaten mit einer Periode von 5 Sekunden. Wenn diePeriodDer Parameter ist nicht gleichmäßig durch 60 geteilt (d. h. die dargestellte Periode ist eine Periode von nicht verfügbaren Minuten), verwendet die untere Schicht des Systems die entsprechende Schnittstelle vonGetTradesdie Erfassung von Handelsdaten und die Synthese der erforderlichen K-Liniendaten. Wenn diePeriodDer Parameter wird gleichmäßig durch 60 geteilt, dann werden die erforderlichen K-Liniendaten mit mindestens 1-minütigen K-Liniendaten synthetisiert (wenn möglich mit einer größeren Periode zur Synthese der erforderlichen K-Liniendaten).

RecordStruktur

function main(){
    var records = exchange.GetRecords(PERIOD_H1)
    /*
        The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, "records" is null. When accessing records[0].Time, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("The first k-line data is, Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
    Log("The second k-line data is, Time:", records[1].Time ,"Close:", records[1].Close)
    Log("Current K-line (latest)", records[records.length-1], "Current K-line (latest)", records[records.length-2])
}

def main():
    records = exchange.GetRecords(PERIOD_H1)
    Log("The first k-line data is, Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
    Log("The second k-line data is, Time:", records[1]["Time"], "Close:", records[1]["Close"])
    Log("Current K-line (latest)", records[-1], "Current K-line (latest)", records[-2])

void main() {
    auto records = exchange.GetRecords(PERIOD_H1);
    Log("The first k-line data is, Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
    Log("The second k-line data is, Time:", records[1].Time, "Close:", records[1].Close);
    Log("Current K-line (latest)", records[records.size() - 1], "Current K-line (latest)", records[records.size() - 2]);
}

exchange.GetRecords()Die Funktion hat zwei Bedingungen für die Erfassung von K-Liniendaten:

Der Austausch stellt eine K-Linien-Datenoberfläche zur Verfügung.
Die Börse bietet keine K-Line-Datenoberfläche. Das FMZ-Docker-Programm erhält jedes Mal, wenn das Strategieprogramm aufruft, die neuesten Handelsdaten der Börse.exchange.GetRecords(), das heißt, es nennt dieexchange.GetTrades()Funktion zur Erfassung von Daten und Synthese von K-Liniendaten.

Der Simulations-Backtest im System muss diedie zugrunde liegende K-Linieperiode(Wenn das Backtesting-System den Stand des Backtesting simuliert, werden die entsprechenden K-Liniendaten verwendet, um Tick-Daten nach dem Satz zu erzeugendie zugrunde liegende K-Linieperiode); es ist zu beachten, dass die Dauer der in der Strategie erfassten K-Liniendaten nicht kürzer alsdie zugrunde liegende K-LinienperiodeDenn im Backtest auf Simulationsebene werden die K-Liniendaten jedes Zeitraums durch die K-Liniendaten der zugrunde liegenden K-Linienperioden im Backtestsystem synthetisiert.

IncppSprache, wenn Sie Ihre eigenen K-Liniendaten konstruieren müssen, gibt es die folgenden Codebeispiele:

#include <sstream>
void main() { 
    Records r;
    r.Valid = true;
    for (auto i = 0; i < 10; i++) {
        Record ele;
        ele.Time = i * 100000;
        ele.High = i * 10000;
        ele.Low = i * 1000;
        ele.Close = i * 100;
        ele.Open = i * 10;
        ele.Volume = i * 1;
        r.push_back(ele);
    }
    // Output display: Records[10]
    Log(r);                      
    auto ma = TA.MA(r,10);       
    // Output display: [nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
    Log(ma);                     
}

Auswechselung.GetPeriod

Dieexchange.GetPeriod()Funktion gibt die auf der Website der FMZ-Plattform festgelegte K-Zeile zurück, wenn Strategien inZurückprüfungundBot. Der zurückgegebene Wert ist eine ganze Zahl in der Sekundeinheit.

function main() {
    // For example, in the backtest and bot, set the K-line period on the website page of FMZ platform to 1 hour
    var period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hour")
}

def main():
    period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hour")

void main() {
    auto period = exchange.GetPeriod();
    Log("K-line period:", period / (60 * 60.0), "hour");
}

- Ich bin nicht derjenige, der das Problem hat.

Dieexchange.SetMaxBarLen(Len)Funktion wirkt sich während der Laufzeit der Kryptowährungsstrategie auf zwei Aspekte aus:

Einfluss auf die Anzahl der erstmals gewonnenen K-Linienbalken (BAR).
Einfluss auf die obere Grenze der K-Linienbalken (BAR).

function main() {
    exchange.SetMaxBarLen(50)
    var records = exchange.GetRecords()
    Log(records.length, records)
}

def main():
    exchange.SetMaxBarLen(50)
    r = exchange.GetRecords()
    Log(len(r), r)

void main() {
    exchange.SetMaxBarLen(50);
    auto r = exchange.GetRecords();
    Log(r.size(), r[0]);
}

- Das ist nicht wahr.

exchange.GetRawJSON()Gibt den Rohinhalt (Strings) zurück, der von der letztenRESTDie Funktion wird nicht unterstützt. Die Funktion ist nur in der Live-Handelsumgebung für Kryptowährung gültig. Strategien incppDie Sprache unterstützt die Funktion nicht.

function main(){
    exchange.GetAccount(); 
    var obj = JSON.parse(exchange.GetRawJSON());
    Log(obj);
}

import json
def main():
    exchange.GetAccount()
    obj = json.loads(exchange.GetRawJSON())
    Log(obj)

void main() {
    auto obj = exchange.GetAccount();
    // C++ doe not support "GetRawJSON" function
    Log(obj);
}

Auswechselung.GetRate()

exchange.GetRate()Gibt die Wechselkurse der aktuell im Austausch verwendeten Währung und der aktuell angezeigten Preiswährung zurück, wobei ein zurückgegebener Wert von 1 anzeigt, dass die Umrechnung des Wechselkurses deaktiviert ist.

Anmerkung:

Wennexchange.SetRate()wurde nicht zur Festlegung des Wechselkurses aufgerufen, wird der vonexchange.GetRate()ist standardmäßig 1, d. h. die derzeit angezeigte Wechselkursumrechnung wurde nicht ausgetauscht.
Wenn dieexchange.SetRate()wurde verwendet, um einen Wechselkurswert festzulegen, z. B.exchange.SetRate(7), werden alle Preisinformationen des aktuellen Tauschobjekts, das die zirkulierende Währung der Handelsplattform darstellt, wie z. B. Angebote, Tiefe, Auftragspreise usw., mit dem zuvor festgelegten Umrechnungskurs 7 multipliziert.
Wenn dieexchangeentspricht einem Austausch mit USD als Preiswährung, nachdemexchange.SetRate(7), werden alle Preise des Bots umgerechnet in Preise nahe dem CNY, indem sie mit 7 multipliziert werden.exchange.GetRate()ist 7.

- Ich bin nicht derjenige, der das Problem hat.

exchange.GetUSDCNY()Gibt den aktuellsten Wechselkurs des US-Dollars zurück (Datenquelle:yahoo) Der zurückgegebene Wert: numerischer Typ.

exchange.SetData ((Schlüssel, Wert)

Dieexchange.SetData(Key, Value)Die Funktion wird verwendet, um die Daten zu setzen, die zum Zeitpunkt des Laufens der Strategie geladen werden, was jeder Wirtschaftsindikator, Branchendaten, relevanter Index usw. sein kann. Sie kann verwendet werden, um alle quantifizierbaren Informationen für Handelsstrategien zu quantifizieren und auch die Verwendung im Backtestsystem zu unterstützen.

Anrufmethode vonexchange.SetData(Key, Value)Funktion:

Daten direkt in die Strategie schreiben Das Datenformat ist erforderlich, dadataVariable im folgenden Beispiel.

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    var data = [
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
    exchange.SetData("test", data)
    while(true) {
        Log(exchange.GetData("test"))
        Sleep(1000)
    }
}

'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''  

def main():
    data = [
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
    exchange.SetData("test", data)
    while True:
        Log(exchange.GetData("test"))
        Sleep(1000)

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/  

void main() {
    json data = R"([
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ])"_json;
    
    exchange.SetData("test", data);
    while(true) {
        Log(exchange.GetData("test"));
        Sleep(1000);
    }
}

Bei Ausführung des obigen Prüfcodes werden die entsprechenden Daten zum entsprechenden Zeitpunkt erhalten, wie in der Abbildung dargestellt:

Wie wir sehen können, die entsprechende Zeit des Zeitstempels1579622400000ist2020-01-22 00: 00: 00; wenn das Strategieprogramm nach dieser Zeit ausgeführt wird, vor dem nächsten Datenzeitstempel1579708800000, d. h. vor dem Zeitpunkt der2020-01-23 00: 00: 00Ruf denexchange.GetData(Source)Das Ergebnis ist der Inhalt der[1579622400000, 123]Während das Programm weiterläuft und sich die Zeit ändert, erhalten Sie Daten Stück für Stück, wie diese.

Anforderung von Daten über externe Links

Gefordertes Datenformat

{
    "schema":["time","data"],
    "data":[
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
}

Wo ist er?schemaist das Datenformat jedes Datensatzes im Hauptbestand der geladenen Daten, das Format wird wie folgt festgelegt:["time", "data"], entspricht derdataDas Attributformat der DatendataDas Attribut speichert den Hauptbestand der Daten, und jedes Stück der Daten besteht aus Zeitstempeln auf Millisekundenebene und Dateninhalten (der Dateninhalt kann beliebige JSON-kodierte Daten sein).

Das Serviceprogramm für die Prüfung ist inGoSprache:

package main
import (
    "fmt"
    "net/http"
    "encoding/json"
)  

func Handle (w http.ResponseWriter, r *http.Request) {
    defer func() {
        fmt.Println("req:", *r)
        ret := map[string]interface{}{
            "schema": []string{"time","data"},
            "data": []interface{}{
                []interface{}{1579536000000, "abc"},
                []interface{}{1579622400000, 123},
                []interface{}{1579708800000, map[string]interface{}{"price":123}},
                []interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
            },
        }
        b, _ := json.Marshal(ret)
        w.Write(b)
    }()
}  

func main () {
    fmt.Println("listen http://localhost:9090")
    http.HandleFunc("/data", Handle)
    http.ListenAndServe(":9090", nil)
}

Nach Erhalt der Anfrage reagiert das Programm auf die Daten:

{
    "schema":["time","data"],
    "data":[
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
}

Teststrategiecode:

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    while(true) {
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
        Sleep(1000)
    }
}

'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''  

def main():
    while True:
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
        Sleep(1000)

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/  

void main() {
    while(true) {
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
        Sleep(1000);
    }
}

exchange.GetData (Quelle)

Dieexchange.GetData(Source)Funktion wird verwendet, um die Daten durch dieexchange.SetData(Key, Value)Die Daten werden während des Backtests einmal erhoben und während des tatsächlichen Handels eine Minute lang zwischengespeichert.

Erlangung der Anrufmethode von Daten, die direkt geschrieben werden

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    exchange.SetData("test", [[1579536000000, _D(1579536000000)], [1579622400000, _D(1579622400000)], [1579708800000, _D(1579708800000)]])
    while(true) {
        Log(exchange.GetData("test"))
        Sleep(1000 * 60 * 60 * 24)
    }
}

'''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''  
def main():
    exchange.SetData("test", [[1579536000000, _D(1579536000000/1000)], [1579622400000, _D(1579622400000/1000)], [1579708800000, _D(1579708800000/1000)]])
    while True:
        Log(exchange.GetData("test"))
        Sleep(1000 * 60 * 60 * 24)

/*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/    
void main() {
    json arr = R"([[1579536000000, ""], [1579622400000, ""], [1579708800000, ""]])"_json;
    arr[0][1] = _D(1579536000000);
    arr[1][1] = _D(1579622400000);
    arr[2][1] = _D(1579708800000);
    exchange.SetData("test", arr);
    while(true) {
        Log(exchange.GetData("test"));
        Sleep(1000 * 60 * 60 * 24);
    }
}

Methode zum Aufrufen von Daten aus externen Verbindungen

function main() {
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
}

def main():
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))

void main() {
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
}

Nutzen Sie die grundlegenden Daten des Plattformdatenzentrums Verwendenexchange.GetData(Source)Funktion zu erhaltenGrundlegende Daten.

Bei Anrufen derexchange.GetData(Source)In der Backtest-System, wenn Sie die Zugriffsoberfläche verwenden, um Daten anzufordern, wird das Backtest-System die Parameter from (Zeitstempel Sekunden), zu (Zeitstempel Sekunden), Periode (unterliegende K-Zeile Periode, Zeitstempel Millisekunden) und andere Parameter automatisch der Anfrage hinzufügen, um den Zeitrahmen der zu erhaltenden Daten zu bestimmen.

Handelsplattform

Die folgenden Funktionen können über dieexchangeoderexchanges[0]Objekt, zum Beispiel:exchange.Sell(100, 1);Angabe, dass die nächste Bestellung eine Verkaufsbestellung mit einem Preis von 100 und einer Menge von 1 an der Börse ist.

Auswechselung.Kauf ((Preis, Betrag)

exchange.Buy(Price, Amount)wird verwendet, um einen Kaufbefehl zu erteilen und eine Order-ID zurückzugeben.Priceist der Bestellpreis in Nummern undAmountist der Auftragsbetrag in Zahlenform. Rückgabewert: Zeichenfolge- oder Zahlenart (der spezifische Typ hängt von der Rückgabeart jeder Börsenplattform ab).

Die zurückgegebene Bestellnummer kann verwendet werden, um Bestellinformationen abzufragen und Bestellungen zu stornieren.

function main() {
    var id = exchange.Buy(100, 1);
    Log("id:", id);
}

def main():
    id = exchange.Buy(100, 1)
    Log("id:", id)

void main() {
    auto id = exchange.Buy(100, 1);
    Log("id:", id);
}

Futures-Orders

Bei der Bestellung von Futures müssen wir darauf achten, ob die Handelsrichtung korrekt eingestellt ist. Wenn die Handelsrichtung und die Handelsfunktion nicht übereinstimmen, wird ein Fehler gemeldet. Die Anzahl der auf einer Kryptowährungs-Futures-Börse platzierten Aufträge ist die Anzahl der Verträge, sofern nicht anders angegeben. Zum Beispiel:

// The following is the wrong call
function main() {
    exchange.SetContractType("quarter")
  
    // Set short direction
    exchange.SetDirection("sell")     
    // Place a buy order, and you will get an error, so you can only sell short
    var id = exchange.Buy(50, 1)      

    // Set short direction
    exchange.SetDirection("buy")      
    // Place a sell order, and you will get an error, so you can only buy long
    var id2 = exchange.Sell(60, 1)    
  
    // Set close long position direction
    exchange.SetDirection("closebuy")    
    // Place a buy order, and you will get an error, so you can only sell short
    var id3 = exchange.Buy(-1, 1)        
  
    // Set close short position direction
    exchange.SetDirection("closesell")   
    // Place a sell order, and you will get an error, so you can only buy long
    var id4 = exchange.Sell(-1, 1)       
}

# The following is the wrong call
def main():
    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    id = exchange.Buy(50, 1)
    exchange.SetDirection("buy")
    id2 = exchange.Sell(60, 1)
    exchange.SetDirection("closebuy")
    id3 = exchange.Buy(-1, 1)
    exchange.SetDirection("closesell")
    id4 = exchange.Sell(-1, 1)

// The following is the wrong call
void main() {
    exchange.SetContractType("quarter");
    exchange.SetDirection("sell");
    auto id = exchange.Buy(50, 1);
    exchange.SetDirection("buy");
    auto id2 = exchange.Sell(60, 1);
    exchange.SetDirection("closebuy");
    auto id3 = exchange.Buy(-1, 1);
    exchange.SetDirection("closesell");
    auto id4 = exchange.Sell(-1, 1);
}

Fehlermeldungen:

direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell

Marktordnung

Anmerkung: Die Exchange-Order-Schnittstelle ist erforderlich, um Marktordern zu unterstützen (wenn der Auftragstyp ein Kaufbefehl ist, ist der Auftragsbetrag der Betrag in der Kurswährung), und die Market-Order-Methode von Kryptowährungs-Futures wird zum Platzieren von Aufträgen verwendet, und die Einheit des Quantitätsparameters ist dieAnzahl der VerträgeEinige Live-Handelsbörsen für digitale Währungen unterstützen keine Marktorder-Schnittstellen.
```
// For example, trading pairs: ETH_BTC, bought in by market order
function main() {
    // Buy a market order, and buy ETH coins equal to 0.1 BTC (quote currency) 
    exchange.Buy(-1, 0.1)    
}
```
```
def main():
    exchange.Buy(-1, 0.1)
```
```
void main() {
    exchange.Buy(-1, 0.1);
}
```

Umtausch.Verkauf ((Preis, Betrag)

exchange.Sell(Price, Amount)platziert einen Verkaufsbefehl und gibt eine Order-ID zurück. Parameterwert:Priceist der Auftragspreis, numerischer Typ.Amountist der Auftragsbetrag, numerische Art. Rückgabewert: Zeichenfolge oder numerische Art (der spezifische Typ hängt von der Rückgabeart jedes Austauschs ab).

Zurückgegebene Bestellnummer, mit der Bestellinformationen abfragen und Bestellungen storniert werden können.

function main(){
    var id = exchange.Sell(100, 1)
    Log("id:", id)
}

def main():
    id = exchange.Sell(100, 1)
    Log("id:", id)

void main() {
    auto id = exchange.Sell(100, 1);
    Log("id:", id);
}

Futures-Orders

Bei der Bestellung von Futures müssen Sie darauf achten, ob die Handelsrichtung korrekt eingestellt ist. Wenn die Handelsrichtung und die Handelsfunktion nicht übereinstimmen, wird ein Fehler gemeldet. Der Auftragsbetrag der Kryptowährungs-Futures-Plattformen ist die Anzahl der Verträge, sofern nicht anders angegeben.
Marktordnungen

Hinweis: Plattform-Orderplacement-Schnittstelle ist erforderlich, um Marktordern zu unterstützen. (Wenn der Auftragstyp eine Verkaufsorder ist, ist der Auftragsbetrag Parameter die Anzahl der verkauften Betriebsmünzen), und Kryptowährungs-Futures platzieren Aufträge nach Marktordern Form, und die Auftragsbetrag Parameter-Einheit ist dieAnzahl der VerträgeEinige digitale Währungsaustauschstellen im realen Handel unterstützen keine Marktorder-Schnittstellen.
```
// For example, trading pairs: ETH_BTC, sold out by market order 
function main() {
    // Note: Sell by a market order, and sell 0.2 ETH coins 
    exchange.Sell(-1, 0.2)   
}
```
```
def main():
    exchange.Sell(-1, 0.2)
```
```
void main() {
    exchange.Sell(-1, 0.2);
}
```

Auswechselung.Auftrag stornieren (Id)

exchange.CancelOrder(orderId)Diese Funktion dient der Stornierung einer Bestellung mit Id. Parameterwert:Idist die Auftragsnummer, in Zeichenfolge- oder Zahlenart (der spezifische Typ hängt von der Rückgabeart ab, wenn eine Bestellung auf jeder Plattform gestellt wird); Rückgabewert: bool-Typ.

Das Betriebsergebnis wird zurückgegeben.truebedeutet, dass die Anforderung zur Stornierung der Bestellung erfolgreich gesendet wurde;falsebedeutet, dass die Stornierungsanforderung nicht gesendet wird (der Rückgabewert zeigt nur an, ob die Sendung erfolgreich ist oder nicht, daher ist es am besten,exchange.GetOrders()um zu überprüfen, ob die Plattform den Auftrag storniert).

function main(){
    var id = exchange.Sell(99999, 1)
    exchange.CancelOrder(id)
}

def main():
    id = exchange.Sell(99999, 1)
    exchange.CancelOrder(id)

void main() {
    auto id = exchange.Sell(99999, 1);
    exchange.CancelOrder(id);
}

Die API-Funktion von FMZ, die Log-Output-Funktionen erzeugen kann, wieLog(...), exchange.Buy(Price, Amount)undexchange.CancelOrder(Id). Sie können die erforderlichen Parameter mit einigen zusätzlichen Ausgabeparametern, wieexchange.CancelOrder(orders[j].Id, orders[j])Auf diese Weise annulliert esorders[j]Bestellung, die durch die Ausgabe dieser Bestellung Informationen begleitet wird, nämlichOrderStruktur derorders[j].

function main() {
    Log("data1", "data2", "data3", "...")
    var data2 = 200
    var id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...")
    exchange.CancelOrder(id, "Incidental data1", data2, "...")
    LogProfit(100, "Incidental data1", data2, "...")
}

def main():
    Log("data1", "data2", "data3", "...")
    data2 = 200
    id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...")
    exchange.CancelOrder(id, "Incidental data1", data2, "...")
    LogProfit(100, "Incidental data1", data2, "...")

void main() {
    Log("data1", "data2", "data3", "...");
    int data2 = 200;
    auto id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...");
    exchange.CancelOrder(id, "Incidental data1", data2, "...");
    LogProfit(100, "Incidental data1", data2, "...");
}

Auswechselung.GetOrder ((Id))

exchange.GetOrder(orderId)Erhält die Bestelldetails nach der Bestellnummer.Idist die zu ermittelnde Ordnungsnummer undIdist von Zeichenfolge- oder Zahlentyp (der spezifische Typ hängt vom Rückgabetyp jedes Austauschs ab).OrderStruktur. (Nicht von einigen Börsen unterstützt)

OrderStruktur
AvgPricezeigt den durchschnittlichen ausgeführten Preis an (einige Börsen unterstützen dieses Feld nicht; setzen Sie es auf 0, wenn sie es nicht unterstützen).

function main(){
    var id = exchange.Sell(1000, 1)
    // The parameter id is the order number, you need to fill in the number of the order you want to query
    var order = exchange.GetOrder(id)      
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
        order.DealAmount, "Status:", order.Status, "Type:", order.Type)
}

def main():
    id = exchange.Sell(1000, 1)
    order = exchange.GetOrder(id)
    Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"], "DealAmount:", 
        order["DealAmount"], "Status:", order["Status"], "Type:", order["Type"])

void main() {
    auto id = exchange.Sell(1000, 1);
    auto order = exchange.GetOrder(id);
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:", 
        order.DealAmount, "Status:", order.Status, "Type:", order.Type);
}

- Ich bin nicht hier.

exchange.GetOrders()Erhält alle unvollendeten Aufträge.OrderStruktur-Array. FürOrderStruktur, sieheexchange.GetOrder()Wenn das Konto, das durch den Austauschobjekt dargestellt wirdexchangehat keine ausstehenden Aufträge, rufenexchange.GetOrders()um ein leeres Array zurückzugeben, nämlich:[].

function main(){
    exchange.Sell(1000, 1)
    exchange.Sell(1000, 1)
    var orders = exchange.GetOrders()
    Log("Information for unfinished order 1, ID:", orders[0].Id, "Price:", orders[0].Price, "Amount:", orders[0].Amount,
        "DealAmount:", orders[0].DealAmount, "type:", orders[0].Type)
    Log("Information for unfinished order 2, ID:", orders[1].Id, "Price:", orders[1].Price, "Amount:", orders[1].Amount,
        "DealAmount:", orders[1].DealAmount, "type:", orders[1].Type)
}

def main():
    exchange.Sell(1000, 1)
    exchange.Sell(1000, 1)
    orders = exchange.GetOrders()
    Log("Information for unfinished order 1, ID:", orders[0]["Id"], "Price:", orders[0]["Price"], "Amount:", orders[0]["Amount"], 
        "DealAmount:", orders[0]["DealAmount"], "type:", orders[0]["Type"])
    Log("Information for unfinished order 2, ID:", orders[1]["Id"], "Price:", orders[1]["Price"], "Amount:", orders[1]["Amount"],
        "DealAmount:", orders[1]["DealAmount"], "type:", orders[1]["Type"])

void main() {
    exchange.Sell(1000, 1);
    exchange.Sell(1000, 1);
    auto orders = exchange.GetOrders();
    Log("Information for unfinished order 1, ID:", orders[0].Id, "Price:", orders[0].Price, "Amount:", orders[0].Amount, 
        "DealAmount:", orders[0].DealAmount, "type:", orders[0].Type);
    Log("Information for unfinished order 2, ID:", orders[1].Id, "Price:", orders[1].Price, "Amount:", orders[1].Amount,
        "DealAmount:", orders[1].DealAmount, "type:", orders[1].Type);
}

Dieexchange.GetOrders()Funktion erhält die unvollendeten Auftragsinformationen des aktuellen SatzesHandelspaarEs sollte beachtet werden, dass die Kryptowährungs-Futures nicht nur zwischen Handelsparen, sondern auch zwischen Vertragscodes unterscheiden.

// Test OKX contract tradings, to know whether "GetOrders" gets all unfinished contract orders
function main(){
    // The next weekly buy order; the price of the order minus 50 guarantees no execution; pending orders
    exchange.SetContractType("this_week")
    exchange.SetDirection("buy")
    var ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Buy(ticker.Last - 50, 1)

    // The next quarterly sell order; the price plus 50 guarantees that it will not be executed, and the pending order has been switched to a quarterly contract
    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Sell(ticker.Last + 50, 1)

    // Get the unfinished orders
    Log("orders", exchange.GetOrders())
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetDirection("buy")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Buy(ticker["Last"] - 50, 1)

    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Sell(ticker["Last"] + 50, 1)

    Log("orders", exchange.GetOrders())

void main() {
    exchange.SetContractType("this_week");
    exchange.SetDirection("buy");
    auto ticker = exchange.GetTicker();
    Log(ticker);
    exchange.Buy(ticker.Last - 50, 1);

    exchange.SetContractType("quarter");
    exchange.SetDirection("sell");
    ticker = exchange.GetTicker();
    Log(ticker);
    exchange.Sell(ticker.Last + 50, 1);

    Log("orders", exchange.GetOrders());
}

Die erhaltenen unvollendeten Auftragsinformationen:

[{"Id":17116430886,"Amount":1,"Price":808.4,"DealAmount":0,"AvgPrice":0,"Status":0,"Type":1,"ContractType":"quarter"}]

Es kann gesehen werden, dass im Handel mit Kryptowährungen die Aufträge, die vonexchange.GetOrders()sind nur die noch nicht abgeschlossenen Aufträge des derzeit festgelegten Auftrags.

Auswechselung. SetPrecision ((...)

exchange.SetPrecision(PricePrecision, AmountPrecision)setzt die Dezimalpräzision des Preises und des Symbolorderaufkommens; nach Einstellung wird er automatisch abgeschnitten.PricePrecisionist Zahlenart und dient zur Kontrolle der Anzahl der Dezimalstellen in den Preisdaten;AmountPrecisionist Zahlenart, verwendet, um den Dezimalpunkt nach dem Auftragsbetrag zu steuern.PricePrecisionundAmountPrecisionDer Backtest unterstützt die Funktion nicht, und die Zahlenpräzision des Backtests wird automatisch verarbeitet.

function main(){
    // Set the decimal precision of the price to 2 digits, and set the precision of the quantity of the symbol order to 3 digits
    exchange.SetPrecision(2, 3)
}

def main():
    exchange.SetPrecision(2, 3)

void main() {
    exchange.SetPrecision(2, 3);
}

Wechselkurs.SetRate ((Rate))

exchange.SetRate(Rate)legt den Wechselkurs der in Umlauf befindlichen Währung an der Börse fest.Rateist vonnumberRückgabewert:number type.

function main(){
    Log(exchange.GetTicker())
    // Set the exchange rate conversion
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    // Set to 1, without conversion
    exchange.SetRate(1)
}

def main():
    Log(exchange.GetTicker())
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    exchange.SetRate(1)

void main() {
    Log(exchange.GetTicker());
    exchange.SetRate(7);
    Log(exchange.GetTicker());
    exchange.SetRate(1);
}

Anmerkung:

Wenn Sie einen Wechselkurswert mitexchange.SetRate(Rate), wie 7, dann alle Preisinformationen, einschließlich des aktuellen Marktpreises, der Tiefe und des Auftragspreises der von der aktuellen Währung dargestellten Umlaufwährung.exchangeDer Umrechnungskurs wird mit 7 multipliziert.
Zum Beispiel:exchangeist ein in US-Dollar lautender Wechselkurs.exchange.SetRate(7)Wenn der Wert des Zinssatzes in der Währung der Union (CZK) in der Währung der Gemeinschaft (CZK) angegeben wird, werden alle Preise des realen Handels mit 7 multipliziert und auf Preise in der Nähe des CNY umgerechnet.

exchange.IO(…)

exchange.IO("api", httpMethod, resource, params, raw), andere funktionelle Schnittstellen der Exchange aufrufen.httpMehodist String-Typ; er füllt den Anforderungstyp aus, z. B.POSToderGET. resourceist String-Typ, füllt den Anforderungspfad aus.paramsist von String-Typ, füllt er die Anforderungsparameter ein.rawist der ursprüngliche JSON-Stringparameter und kann weggelassen werden.exchange.IO("api", httpMethod, resource, params, raw)Wenn ein Fehler auftritt und der Anruf fehlschlägt, gibt er einen Nullwert zurück (die Funktion mit der Netzwerkanfrage, z. B.GetTicker()undGetAccount(), etc., die Nullwerte zurückgeben, wenn Anrufe fehlschlagen).exchange.IO("api", ...) function.

Für das Beispiel von OKX-Batchorder verwenden Sie den ParameterrawUm die Bestellparameter zu übergeben:

function main() {
    var arrOrders = [
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ]
    
    // Call exchange.IO to directly access the platform batch ordering interface
    var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
    Log(ret)
}

import json
def main():
    arrOrders = [
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}, 
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ]
    ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
    Log(ret)

void main() {
    json arrOrders = R"([
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ])"_json;
    auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
    Log(ret);
}

Um diese Funktion zu verwenden, müssen Sie zum Austausch gehen, um dieAPISie müssen sich nicht um den Prozess der Parameterverschlüsselung, Signatur und Verifizierung kümmern, wenn Sie einePOSTAnfrage. FMZ hat vollständig an der unteren Schicht verarbeitet, so dass Sie nur die entsprechenden Parameter ausfüllen müssen).

Anmerkung: Wenn der Schlüsselwert in derparamsParameter (d.h. der HTTP-Anfrageparameter) ist eine Zeichenkette, sie muss mit einzelnen Anführungszeichen (Symbol') auf beiden Seiten des Parameterwerts. Zum Beispiel:bitfinex exchange.

var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
    // Notice that amount.toString() and price.toString() both have a ' character on the left and right
    var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
    var id = exchange.IO("api", "POST", "/v1/order/new", message)
}

amount = 1
price = 10
basecurrency = "ltc"
def main():
    message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
    id = exchange.IO("api", "POST", "/v1/order/new", message)

void main() {
    auto amount = 1.0;
    auto price = 10.0;
    auto basecurrency = "ltc";
    string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
    auto id = exchange.IO("api", "POST", "/v1/order/new", message);
}

Beispiel für den ZugriffOKXSchnittstelle:

function main(){
    var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
    Log(ret)
}

def main():
    ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
    Log(ret)

void main() {
    auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
    Log(ret);
}

Daten, die während der Prüfung zurückgegeben werden:

{"code":"0","data":[],"msg":""}

Weitere Einstellungen desexchange.IOFunktion:

Wechseln Sie die Handelspare der aktuellen Börse

exchange.IO("currency", "ETH_BTC")
```
function main() {
    // For example, set the current trading pair of the exchange object on the bot to BTC_USDT, and print the current trading pair market
    Log(exchange.GetTicker())
    // Switch trading pair to LTC_BTC      
    exchange.IO("currency", "LTC_BTC")
    Log(exchange.GetTicker())
}
```
```
def main():
    Log(exchange.GetTicker())
    exchange.IO("currency", "LTC_BTC")
    Log(exchange.GetTicker())
```
```
void main() {
    Log(exchange.GetTicker());
    exchange.IO("currency", "LTC_BTC");
    Log(exchange.GetTicker());
}
```
Auf diese Weise wird dieHandelspaarekonfiguriertwenn der Bot hinzugefügt wirdoderDer Backtest ist ausgeführtwird durch die Codes gewechselt.

Anmerkung:
- 1. Das Backtest-System unterstützt nun das Wechseln von Handelsparen (nur die Spot-Austauschobjekte von Kryptowährung). Während des Backtests sollte beachtet werden, dass nur Handelspare der gleichen Notenwährung gewechselt werden können.ETH_BTC, die nur aufLTC_BTC, nichtLTC_USDT.
- 1. Wenn diewebsocketProtokollmodus ist auf den Huobi Spot-Austausch-Objekte geschaltet, können Sie nicht verwendenexchange.IO("currency", "XXX_YYY")Um die Währungen zu wechseln.
- 1. Für Kryptowährungs-Futures-Börsen müssen Sie, wenn die Handelspare gewechselt werden, den Vertrag erneut einrichten, um festzustellen, mit welchem Vertrag Sie handeln möchten.
- 1. Sie können auch die neuenexchange.SetCurrency(Symbol)Funktion, um Handelspare zu wechseln undexchange.IO("currency","XXX_YYY")Methode zur Aufrechterhaltung der Kompatibilität.
exchange.IOFunktion die Exchange-API-Basisadresse (RESET-Vertrag; einige Börsen unterstützen das nicht) wechseln. Jetzt die Verwendung vonexchange.SetBase(Base)Funktion wurde unterstützt, um die Exchange-API-Basisadresse zu wechseln undexchange.IO("base","https://xxx.xxx.xxx")Methode zur Aufrechterhaltung der Kompatibilität.

Zum Beispiel: Wenn das Exchange-Objekt verkapselt ist, ist die Standardbasisadressehttps://api.huobipro.com, um auf:https://api.huobi.pro, verwenden Sie den folgenden Code.
```
function main () {
    // exchanges[0] is the first exchange object added when the bot is added 
    exchanges[0].IO("base", "https://api.huobi.pro")        
}
```
```
def main():
    exchanges[0].IO("base", "https://api.huobi.pro")
```
```
void main() {
    exchanges[0].IO("base", "https://api.huobi.pro");
}
```
Wechseln Sie die Basisadresse zurück auf:https://api.huobipro.com.
```
function main () {
    exchanges[0].IO("base", "https://api.huobipro.com")
}
```
```
def main():
    exchanges[0].IO("base", "https://api.huobipro.com")
```

Die nächste Seite Nächste Seite

Mehr