Dieexchange.Buy()Diese Funktion wird verwendet, um Bestellungen zu platzieren.Buy()Die Funktion ist eine Mitgliederfunktion des Austauschobjekts {@var/EXCHANGE exchange}.Buy()Funktion arbeitet auf dem mit dem Tauschobjekt verbundenen Tauschkontoexchange. Zweck der Funktionen der Mitglieder (Methoden) derexchangeObjekt ist nur mitexchange, und wird nach der Dokumentation nicht wiederholt.
Eine erfolgreiche Bestellung gibt die Order-Id zurück, eine fehlgeschlagene Bestellung gibt einen Nullwert zurück.
Das AttributIdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat des SpothandelspaaresETH_USDTdie Reihenfolge der OKX-Börse lautet:ETH-USDT,1547130415509278720- Ich weiß.
Bei Anrufen derexchange.Buy()Funktion, um eine Bestellung zu platzieren, die Wertbestellung zurückzugebenIdist mit demIdAttribut der Struktur der Reihenfolge {@struct/Order Order}.
String, Nullwert
Umtausch.Kauf ((Preis, Betrag) Austausch.Kauf ((Preis, Betrag,... args)
DiepriceDer Parameter wird verwendet, um den Auftragspreis festzulegen.
Preis
wahr
Zahl
DieamountDer Parameter wird verwendet, um den Auftragsbetrag festzulegen.
Betrag
- Das stimmt.
Zahl
Erweiterte Parameter, die die Begleitinformationen in dieses Auftragsprotokoll einfügen können,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
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);
}
Die vonexchange.Buy()kann verwendet werden, um die Bestellinformationen abzufragen und die Bestellung zu stornieren.
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error 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 an error 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);
}
Bei der Bestellung eines Futures-Kontrakts für Kryptowährungen muss darauf geachtet werden, dass die Handelsrichtung korrekt eingestellt ist, da ein Missverhältnis zwischen der Handelsrichtung und der Handelsfunktion zu einem Fehler führt:
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
// For example, the trading pair: ETH_BTC, place a buy order at the market price
function main() {
// Place a buy order at the market price and buy ETH coins with a value of 0.1 BTC (denominated currency)
exchange.Buy(-1, 0.1)
}
def main():
exchange.Buy(-1, 0.1)
void main() {
exchange.Buy(-1, 0.1);
}
Spotmarktbestellung.
Wenn Sie einen Auftrag für einen Futures-Kontrakt aufgeben, müssen Sie darauf achten, ob die Handelsrichtung korrekt eingestellt ist, da ein Fehler gemeldet wird, wenn die Handelsrichtung und die Handelsfunktion nicht übereinstimmen.
Der Parameterpriceist auf-1Bei der Platzierung von Marktordern für Kryptowährungs-Spotkontrakte wird der Parameteramountist der Geldbetrag in der Währung des Auftrags.amountist die Anzahl der Verträge. Es gibt ein paar Kryptowährungsbörsen, die während des Live-Handels keine Marktorder-Schnittstelle unterstützen. Die Bestellmenge für Marktkaufbestellungen an einigen Spotbörsen ist die Anzahl der Handelsmünzen. Bitte beachten Sie dieSondervorschriften für den AustauschSiehe Idderexchange.Buy()Funktion kann sich von dem Rückgabewert des Auftrags unterscheidenIdin diesem Dokument beschrieben.
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Dieexchange.Sell()Funktion wird verwendet, um Verkaufsbestellungen zu platzieren.
Ein erfolgreicher Auftrag gibt die Order-Id zurück, ein fehlgeschlagener Auftrag gibt einen Nullwert zurück.IdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat des SpothandelspaaresETH_USDTdie Reihenfolge der OKX-Börse lautet:ETH-USDT,1547130415509278720. Wenn Sie dieexchange.Sell()Funktion, um eine Bestellung zu platzieren, die Wertbestellung zurückzugebenIdist mit demIdAttribut der Struktur der Reihenfolge {@struct/Order Order}.
String, Nullwert
Umtausch.Verkauf ((Preis, Betrag) Umtausch.Verkauf ((Preis, Betrag,... args)
DiepriceDer Parameter wird verwendet, um den Auftragspreis festzulegen.
Preis
wahr
Zahl
DieamountDer Parameter wird verwendet, um den Auftragsbetrag festzulegen.
Betrag
- Das stimmt.
Zahl
Erweiterte Parameter, die die Begleitinformationen in dieses Auftragsprotokoll einfügen können,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
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);
}
Die vonexchange.Sell()kann verwendet werden, um Bestellinformationen abzufragen und Bestellungen zu stornieren.
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error 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 an error 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);
}
Bei der Bestellung eines Futures-Kontrakts für Kryptowährungen muss darauf geachtet werden, dass die Handelsrichtung korrekt eingestellt ist, da ein Missverhältnis zwischen der Handelsrichtung und der Handelsfunktion zu einem Fehler führt:
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
// For example, the trading pair: ETH_BTC, place a sell order at the market price
function main() {
// Note: place a market order to sell, sell 0.2 ETH
exchange.Sell(-1, 0.2)
}
def main():
exchange.Sell(-1, 0.2)
void main() {
exchange.Sell(-1, 0.2);
}
Spotmarktbestellung.
Wenn Sie einen Auftrag für einen Futures-Kontrakt aufgeben, müssen Sie darauf achten, ob die Handelsrichtung korrekt eingestellt ist, da ein Fehler gemeldet wird, wenn die Handelsrichtung und die Handelsfunktion nicht übereinstimmen.
Der Parameterpriceist auf-1Bei der Platzierung von Marktordern für Kryptowährungs-Spot-Kontrakte wird der Betrag-Parameteramountist der Betrag in der Handelswährung.amountEs gibt einige Kryptowährungsbörsen, die während des Live-Handels keine Marktorder-Schnittstelle unterstützen.
Wenn Sie eine ältere Version des Dockers verwenden, wird der Wert der Bestellung zurückgegebenIdderexchange.Sell()Funktion kann sich von dem Rückgabewert des Auftrags unterscheidenIdin diesem Dokument beschrieben.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Dieexchange.CreateOrder()Funktion wird verwendet, um eine Bestellung zu platzieren.
Wenn die Bestellung erfolgreich platziert wird, wird die Order-ID zurückgegeben; wenn die Bestellung fehlschlägt, wird ein Nullwert zurückgegeben.IdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat der Bestellung des Spot-HandelspaaresETH_USDTder OKX-Börse ist:ETH-USDT,1547130415509278720. Wenn Sie dieexchange.CreateOrder(symbol, side, price, amount)Funktion zur Auftragserteilung, der Wert der AuftragserteilungIdist mit demIdEigenschaft der Struktur der Reihenfolge {@struct/Order Order}.
String, Nullwert
exchange.CreateOrder (Symbol, Seite, Preis, Betrag) exchange.CreateOrder ((Symbol, Seite, Preis, Betrag,... args)
Der ParametersymbolBei der Anforderung der Angabe des Handelspaares und des Auftragscodes der Bestellung wird die Angabe des Handelspaares und des Auftragscodes verwendet.exchange.CreateOrder(symbol, side, price, amount)Funktion zur Bestellung,exchangeist das Spot-Austauschobjekt. Ist die auf USDT lautende Währung der Auftrag und ist BTC die Handelswährung, wird der Parametersymbolist:"BTC_USDT", im Format des von der FMZ-Plattform definierten Handelspaares.exchange.CreateOrder(symbol, side, price, amount)Funktion zur Bestellung,exchangeist das Objekt des Futures-Austauschs. Wenn es sich bei der Bestellung um eine BTCsymbolist:"BTC_USDT.swap", und das Format ist eine Kombination derHandelspaarundVertragskodedie durch die FMZ-Plattform definiert sind, getrennt durch den Zeichen exchange.CreateOrder(symbol, side, price, amount)Funktion zur Bestellung,exchangeist das Futures-Austauschobjekt. Wenn es sich bei der Bestellung um eine BTCsymbolist:"BTC_USDT.BTC-240108-40000-C"(beim Beispiel Binance Option BTC-240108-40000-C), und das Format ist eine Kombination derHandelspaarvon der FMZ-Plattform und dem von der Börse definierten spezifischen Optionsvertragskode definiert, getrennt durch den Zeichen sideDer Parameter wird verwendet, um die Handelsrichtung des Auftrags anzugeben.
Für Spot-Austauschobjekte gelten die optionalen Werte dersideParameter sind:buy, sell. buybedeutet Kauf, undsellbedeutet zu verkaufen.
Für Futures-Börsen werden die optionalen Werte dersideParameter sind:buy, closebuy, sell, closesell. buybedeutet, eine Long-Position zu eröffnen,closebuybedeutet, eine Long-Position zu schließen,sellbedeutet, eine Leerposition zu eröffnen, undclosesellbedeutet, eine Leerposition zu schließen.
Seite
wahr
String
Der ParameterpriceBei einem Preis von -1 wird angegeben, dass es sich bei der Bestellung um eine Marktorder handelt.
Preis
- Das stimmt.
Zahl
Der ParameteramountBei einer Bestellung mit Marktkaufbestellung ist der Kaufbetrag der Bestellbetrag; bei einigen Spotbörsen ist die Bestellmenge der Marktkaufbestellung die Anzahl der Handelsmünzen.Sondervorschriften für den Austauschin der argParameter können übergeben werden.
Arg
falsche
Jeder vom System unterstützte Typ, z. B. Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert usw.
function main() {
var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
}
def main():
id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) # Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
# id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) # Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
void main() {
auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01); // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01); // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id);
}
Die Gegenstände des Spot- und Futures-Austauschs werden alsexchange.CreateOrder()Funktion, um eine Bestellung zu erteilen.
(Durchschnittliche Anzahl von Personen, die in einem Unternehmen tätig sind)
Dieexchange.CancelOrder()Funktion wird verwendet, um die Bestellung zu stornieren.
Das AttributIdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat der Bestellung des Spot-HandelspaaresETH_USDTder OKX-Börse ist:ETH-USDT,1547130415509278720- Ich weiß.
Der ParameterorderIdSie ist bei der Anrufung derexchange.CancelOrder()Funktion, um eine Bestellung zu stornieren, ist mit derIdEigenschaft der Struktur der Reihenfolge {@struct/Order Order}.
Dieexchange.CancelOrder()Funktion gibt einen wahren Wert zurück, zum Beispieltruebedeutet, dass die Stornierungsanfrage erfolgreich gesendet wurde.false, bedeutet, dass die Stornierungsanfrage nicht gesendet wurde. Der zurückgegebene Wert stellt nur den Erfolg oder Misserfolg der gesendeten Anfrage dar, um festzustellen, ob die Börse die Bestellung storniert.exchange.GetOrders()um festzustellen, ob die Bestellung storniert wird.
Boole
Auswechselung.Rückgängig machenBestellung (Bestellnummer) Auswechselung.Auftrag stornieren
DieorderIdDer Parameter wird verwendet, um den zu stornierenden Auftrag anzugeben.
Auftraggeber
- Das stimmt.
Zahl, Zeichenfolge
Erweiterte Parameter, Sie können die angehängten Informationen in dieses Rücktrittsprotokoll einfügen,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
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);
}
Stornieren Sie die Bestellung.
function main() {
if (exchange.GetName().includes("Futures_")) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
}
var ticker = exchange.GetTicker()
exchange.Buy(ticker.Last * 0.5, 0.1)
var orders = exchange.GetOrders()
for (var i = 0 ; i < orders.length ; i++) {
exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i])
Sleep(500)
}
}
def main():
if exchange.GetName().find("Futures_") != -1:
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
ticker = exchange.GetTicker()
exchange.Buy(ticker["Last"] * 0.5, 0.1)
orders = exchange.GetOrders()
for i in range(len(orders)):
exchange.CancelOrder(orders[i]["Id"], "Cancelled orders:", orders[i])
Sleep(500)
void main() {
if (exchange.GetName().find("Futures_") != std::string::npos) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.");
exchange.SetContractType("swap");
exchange.SetDirection("buy");
}
auto ticker = exchange.GetTicker();
exchange.Buy(ticker.Last * 0.5, 0.1);
auto orders = exchange.GetOrders();
for (int i = 0 ; i < orders.size() ; i++) {
exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i]);
Sleep(500);
}
}
FMZ-API-Funktionen, die Log-Output-Funktionen erzeugen können, wie z. B.:Log(), exchange.Buy(), exchange.CancelOrder()Nach den erforderlichen Parametern können einige begleitende Ausgangsparameter folgen.exchange.CancelOrder(orders[i].Id, orders[i]), so dass bei der Stornierung der Bestellung, deren IDorders[i].Id, wird die Auftragsinformation mit ihm ausgegeben. Das heißt, die {@struct/Order Order} Struktur vonorders[i].
Wenn Sie eine ältere Version des Dockers verwenden, kann sich der Parameter orderId der Exchange.CancelOrder() -Funktion von der im aktuellen Dokument beschriebenen orderId unterscheiden.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
Dieexchange.GetOrder()Die Funktion wird verwendet, um die Bestellinformationen zu erhalten.
Abfragen Sie die Bestelldetails nach der Bestellnummer und geben Sie die Struktur {@struct/Order Order} zurück, wenn die Abfrage erfolgreich ist, oder Null zurück, wenn die Abfrage fehlschlägt. {@struct/Order Order}, Nullwert
Auswechselung.GetOrder (OrderId)
DieorderIdParameter wird verwendet, um die zu abfragende Reihenfolge anzugeben.
Das AttributIdDie Struktur der Bestellstruktur {@struct/Order Order} der FMZ-Plattform besteht aus dem Austauschproduktcode und der Austausch-Originalorder-ID, die durch englische Kommas getrennt sind.IdFormat der Bestellung des Spot-HandelspaaresETH_USDTder OKX-Börse ist:ETH-USDT,1547130415509278720- Ich weiß.
Der ParameterorderIdSie ist bei der Anrufung derexchange.GetOrder()Funktion, um eine Bestellung abzufragen, ist mit derIdEigenschaft der Struktur der Reihenfolge {@struct/Order Order}.
Auftrag wahr String
function main(){
var id = exchange.Sell(1000, 1)
// 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);
}
Dieexchange.GetOrder()Die Funktion wird von einigen Börsen nicht unterstützt.AvgPriceEinige Börsen unterstützen dieses Feld nicht, und wenn nicht, wird es auf 0 festgelegt.
Wenn Sie eine ältere Version des Dockers verwenden,orderIdParameter derexchange.GetOrder()Funktion kann von derorderIdin der aktuellen Dokumentation beschrieben.
Dieexchange.GetOrder()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetOrder | Zaif / Coincheck / Bitstamp | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
Dieexchange.GetOrders()Die Funktion wird verwendet, um ausstehende Aufträge zu erhalten.
Dieexchange.GetOrders()Funktion gibt ein Array von {@struct/Order Order}-Strukturen zurück, wenn die Datenanfrage erfolgreich ist, und nullwerte, wenn die Datenanfrage fehlschlägt.
{@struct/Order Order}-Array, Nullwert
- Ich bin nicht hier. - Das ist nicht wahr.
Der Parametersymbolwird verwendet, um dieTransaktionssymboloderTransaktionssymbolbereichSie werden befragt.
Für Spot-Austauschobjekte, wenn diesymbolWenn der Parameter nicht übergeben wird, werden die unvollendeten Bestelldaten aller Spotprodukte angefordert.
Für Futures-BörsensymbolWenn der Parameter nicht übergeben wird, werden standardmäßig die unvollendeten Auftragsdaten aller Sorten im Dimensionsbereich des aktuellen Handelspaares und des Vertragscodes angefordert.
Symbol falsche String
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01)
}
var spotOrders = exchange.GetOrders()
var tbls = []
for (var orders of [spotOrders]) {
var tbl = {type: "table", title: "test GetOrders", cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 0.01)
spotOrders = exchange.GetOrders()
tbls = []
for orders in [spotOrders]:
tbl = {"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01);
}
auto spotOrders = exchange.GetOrders();
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {spotOrders};
for (const auto& orders : arr) {
json tbl = R"({
"type": "table",
"title": "test GetOrders",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back("Symbol");
arrJson.push_back("Id");
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
Verwenden Sie das Spot-Exchange-Objekt, um Kaufoptionen für mehrere verschiedene Handelspare zu der Hälfte des aktuellen Preises zu platzieren und dann die ausstehenden Auftragsinformationen abzufragen.
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1)
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1)
}
var defaultOrders = exchange.GetOrders()
var swapOrders = exchange.GetOrders("USDT.swap")
var futuresOrders = exchange.GetOrders("USDT.futures")
var btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
var tbls = []
var arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
var tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for (var index in arr) {
var orders = arr[index]
var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 1)
exchange.CreateOrder(symbol, "sell", t["Last"] * 2, 1)
defaultOrders = exchange.GetOrders()
swapOrders = exchange.GetOrders("USDT.swap")
futuresOrders = exchange.GetOrders("USDT.futures")
btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
tbls = []
arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for index in range(len(arr)):
orders = arr[index]
tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order["Symbol"], order["Id"], order["Price"], order["Amount"], order["DealAmount"], order["AvgPrice"], order["Status"], order["Type"], order["Offset"], order["ContractType"]])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1);
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1);
}
auto defaultOrders = exchange.GetOrders();
auto swapOrders = exchange.GetOrders("USDT.swap");
auto futuresOrders = exchange.GetOrders("USDT.futures");
auto btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap");
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders};
std::string tblDesc[] = {"defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"};
for (int index = 0; index < arr.size(); index++) {
auto orders = arr[index];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
tbl["title"] = tblDesc[index];
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back(order.Symbol);
arrJson.push_back(to_string(order.Id)); // The Id attribute type in the Order structure is TId, which is encoded using a C++ function to_string built into the FMZ platform.
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
Verwenden Sie Futures-Börsenobjekte, um Aufträge für mehrere verschiedene Handelspare und Vertragscodes zu platzieren. Platzieren Sie Aufträge zu Preisen, die weit vom Gegenparteipreis entfernt sind, halten Sie Aufträge in einem unerfüllten Zustand und abfragen Sie Aufträge auf mehrere Arten.
function main() {
var orders = exchange.GetOrders("BTC_USDT") // Examples of spot products
// var orders = exchange.GetOrders("BTC_USDT.swap") // Examples of futures products
Log("orders:", orders)
}
def main():
orders = exchange.GetOrders("BTC_USDT") # Examples of spot products
# orders = exchange.GetOrders("BTC_USDT.swap") # Examples of futures products
Log("orders:", orders)
void main() {
auto orders = exchange.GetOrders("BTC_USDT"); // Examples of spot products
// auto orders = exchange.GetOrders("BTC_USDT.swap"); // Examples of futures products
Log("orders:", orders);
}
Bei Anrufen derexchange.GetOrders()Funktion, in dieSymbolParameter zur Anforderung von Auftragsdaten für ein bestimmtes Handelspaar und einen Vertragskode.
In derGetOrdersFunktion, werden die Anwendungsszenarien des Symbolparameters wie folgt zusammengefasst:
| Klassifizierung von Exchange-Objekten | Symbol Parameter | Umfang der Abfrage | Anmerkung |
|---|---|---|---|
| Stellfläche | Symbolparameter nicht übergeben | Abfrage aller Spot-Handelspaare | Für alle Anrufszenarien wird, wenn die Austauschoberfläche sie nicht unterstützt, ein Fehler gemeldet und ein Nullwert zurückgegeben. |
| Stellfläche | Angabe des Handelstyps, der Symbolparameter lautet: |
Abfrage des angegebenen BTC_USDT-Handelspaares | Für Spot-Börsenobjekte ist das Symbolparameterformat: |
| Futures | Symbolparameter nicht übergeben | Abfrage aller Handelsprodukte innerhalb des aktuellen Handelspaares und des Dimensionsabstands des Vertragscodes | Wenn das aktuelle Handelspaar BTC_USDT ist und der Vertragscode Swap ist, werden alle USDT-margierten Perpetual Contracts abgefragt.GetOrders("USDT.swap") |
| Futures | Angabe des Handelstyps, der Symbolparameter lautet: |
Abfrage des USDT-basierten Dauerkontrakts für einen bestimmten BTC | Für Futures-Börsenobjekte ist das Format des Parameter-Symbols: eine Kombination vonHandelspaarundVertragskodedurch die FMZ-Plattform definiert, getrennt durch die Zeichen".. |
| Futures | Angabe des Handelssortiments, der Symbolparameter lautet: |
Abfrage aller USDT-basierten Daueraufträge | - |
| Futures-Börsen, die Optionen unterstützen | Symbolparameter nicht übergeben | Abfrage aller Optionskontrakte innerhalb des aktuellen Dimensionsbereichs des Handelspares | Wenn das aktuelle Handelspaar BTC_USDT ist, wird der Vertrag auf einen Optionsvertrag festgelegt, z. B. Binance-Optionvertrag: BTC-240108-40000-C |
| Futures-Börsen, die Optionen unterstützen | Spezifische Handelsprodukte angeben | Abfrage des angegebenen Optionskontrakts | Für die Binance Futures Exchange beispielsweise ist der Symbolparameter: BTC_USDT.BTC-240108-40000-C |
| Futures-Börsen, die Optionen unterstützen | Angabe des Handelssortiments, der Symbolparameter lautet: |
Abfrage aller USDT-basierten Optionskontrakte | - |
In derGetOrdersFunktion, die Futures Exchange-Objektanfrage
Der Abmessungsbereich ist wie folgt zusammengefasst:
| Symbol Parameter | Definition des Anforderungsbereichs | Anmerkung |
|---|---|---|
| USDT.swap | USDT-basierte Dauervertragsspanne. | Für |
Abmessungen, die von der Exchange-API-Schnittstelle nicht unterstützt werden, Ein Fehler wird gemeldet und ein Nullwert wird zurückgegeben, wenn Sie ruft. ♫ USDT.Futures ♫ ♫ USDT-basierte Liefervertragsspanne ♫ ♫ USDT-basierte Liefervertragsspanne ♫ USD.Swap. Eine Reihe von Währungsbasierten Verträge. ♫ USD.Futures ♫ Verträge. USDT.Option. USDT-basierte Optionskontrakt-Bereich. USD.Option. Währungsbasierte Optionskontrakt-Range. USDT.Futures_Combo. Eine Reihe von CFD-Kombinationen. Futures_Deribit-Börse USD.Futures_ff Eine Reihe von Margin-Lieferverträgen. Die Futures_Kraken Exchange. USD.Swap_pf. Eine Reihe von perpetual Margin-Verträgen. Ich habe eine Idee. Ich habe eine Idee.
Wenn das durch den Austauschgegenstand dargestellte Kontoexchangehat keine ausstehenden Aufträge innerhalb derAbfragebereichoderbestimmte Handelsinstrumente(aktive Aufträge in einem unerfüllten Zustand), wenn diese Funktion aufgerufen wird, wird ein leeres Array zurückgegeben, d. h.:[]- Ich weiß.
Bei der Aufforderung der GetOrders-Funktion bei diesen Börsen werden, wenn der Instrumentparameter nicht eingegeben wird, nur die unvollendeten Aufträge des aktuellen Instruments angefordert, nicht die unvollendeten Aufträge aller Instrumente (weil die Exchange-Schnittstelle dies nicht unterstützt).
Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE. Das ist nicht nur ein Spiel.
Dieexchange.GetOrders()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetOrders | – | Futures_Bibox |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
Dieexchange.GetHistoryOrders()Die Funktion wird verwendet, um das aktuelle Handelspaar, die historischen Aufträge für Verträge zu erhalten; sie unterstützt die Spezifikation spezifischer Handelsvarianten.
Dieexchange.GetHistoryOrders()Funktion gibt ein Array von {@struct/Order Order}-Strukturen zurück, wenn die Anfrage erfolgreich ist, und null, wenn die Anfrage fehlschlägt.
{@struct/Order Order} Arrays, Nullwerte
- Ich bin nicht hier. Erhalten Sie die Geschichte der Bestellungen (Symbol) (Symbol, seit) exchange.GetHistoryOrders (Symbol, seit, Grenze) - Ich bin nicht derjenige, der das sagt. exchange.GetHistoryOrders (seit, Grenze)
DiesymbolBei der Angabe des Handelssymbols wird ein Parameter verwendet.BTC_USDTDas Handelspaar wird beispielsweiseexchangeist ein Spot-Austauschobjekt, das Parameterformat fürsymbolistBTC_USDTWenn es sich um ein Futures-Börseobjekt handelt, beispielsweise um einen Dauervertrag, ist das Parameterformat fürsymbolist:BTC_USDT.swap- Ich weiß.
Wenn Sie die Auftragsdaten von Optionsverträgen abfragen, setzen Sie den Parametersymbolzu"BTC_USDT.BTC-240108-40000-C"Das Format ist eine Kombination aus denHandelspaarvon der FMZ-Plattform und dem von der Börse definierten spezifischen Optionsvertragskode definiert, getrennt durch den Zeichen
Symbol
falsche
String
DiesinceParameter wird verwendet, um den Startzeitstempel der Abfrage in Millisekunden anzugeben.
Seit
falsche
Zahl
DielimitParameter wird verwendet, um die Anzahl der zu abfragenden Aufträge anzugeben.
Grenzwerte
falsche
Zahl
function main() {
var historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
}
def main():
historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
void main() {
auto historyOrders = exchange.GetHistoryOrders();
Log(historyOrders);
}
symbol, since, limitWenn keine Parameter angegeben sind, ist die Standardabfrage das aktuelle Handelspaar, die historischen Auftragsverträge. Abfragt die historischen Aufträge innerhalb eines bestimmten Bereichs, der der aktuellen Zeit am nächsten ist, hängt der Abfragebereich vom einzelnen Abfragebereich der Austauschoberfläche ab.symbolDer Anforderungsprozess wird durch die Angabe des Parameters durchgeführt.sinceParameter angegeben ist, Abfrage in Richtung der aktuellen Zeit mit dersinceZeitstempel als Startzeit.limitWenn ein Parameter angegeben wird, wird die Abfrage nach einer ausreichenden Anzahl von Einträgen zurückgegeben.Dieexchange.GetHistoryOrders()Funktion:
| Funktionsname | Nicht unterstützte Spotbörsen | Nicht abgesicherte Futures-Börsen |
|---|---|---|
| GetHistory-Orders | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | Futures_dYdX / Futures_Bibox / Futures_ApolloX |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
exchange.SetPrecision()Funktion wird verwendet, um die Präzision derexchangeAustauschobjektPreisundAuftragsbetrag, wird das System die überschüssigen Daten automatisch ignorieren.
Ausgleich.SetPrecision ((PreisPrecision, BetragPrecision)
DiepricePrecisionDer Parameter wird zur Kontrolle der Präzision der Preisdaten verwendet.
PreisGenauigkeit
wahr
Zahl
DieamountPrecisionDie Parameter werden verwendet, um die Genauigkeit der zu bestellenden Datenmenge zu kontrollieren.
BetragGenauigkeit
- Das stimmt.
Zahl
function main(){
// Set the decimal precision of price to 2 bits, and the decimal precision of variety order amount to 3 bits
exchange.SetPrecision(2, 3)
}
def main():
exchange.SetPrecision(2, 3)
void main() {
exchange.SetPrecision(2, 3);
}
Das Backtesting-System unterstützt diese Funktion nicht, und die numerische Genauigkeit des Backtesting-Systems wird automatisch verarbeitet.
(Durchschnittliche Anzahl von Personen, die in einem Unternehmen tätig sind)
Der aktuelle Wechselkurs des Austauschobjekts wird festgelegt.
Wechselkurs.SetRate ((Rate))
DierateDer Parameter wird zur Angabe des Umrechnungskurses verwendet.
Zinssatz
wahr
Zahl
function main(){
Log(exchange.GetTicker())
// Set exchange rate conversion
exchange.SetRate(7)
Log(exchange.GetTicker())
// Set to 1, no 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);
}
Wenn ein Wechselkurswert unter Verwendung derexchange.SetRate()Sie werden dann alle Preisinformationen wie Tickers, Tiefen, Auftragspreise usw. für den Austausch darstellen.exchangeDer Umrechnungskurs wird durch Multiplikation durch den festgelegten Wechselkurs von 7 umgerechnet.exchangeist ein Austausch mit dem US-Dollar als Stückelwährung.exchange.SetRate(7), werden alle Preise auf dem Live-Markt in Preise umgerechnet, die naheCNYDer Nennwert wird mit 7 multipliziert.
Ich bin nicht derjenige, der das Problem hat, aber ich bin derjenige, der das Problem hat.
Dieexchange.IO()Funktion wird für andere Schnittstellenanrufe im Zusammenhang mit dem Austauschobjekt verwendet.
Dieexchange.IO()Funktion ruft andere Schnittstellen auf, die mit dem Exchange-Objekt verbunden sind, und gibt bei einem erfolgreichen Anruf die angeforderten Antwortdaten zurück und bei einem fehlgeschlagenen Anruf null zurück.
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
exchange.IO(k,... args)
DiekParameter wird verwendet, um den Anruftyp mit optionalen Werten festzulegen"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedund so weiter.
k
wahr
String
Erweiterte Parameter gemäß dem spezifischen Anrufszenario,argDurch den polymorphen Mechanismus derexchange.IO()Die Anzahl und Art der Parameter, die für dieexchange.IO()Funktion sind unbestimmt.
Arg
- Das stimmt.
String, number, bool, object, array, null und alle anderen vom System unterstützten Typen
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 access the exchange's bulk order interface directly
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);
}
Mit Hilfe derexchange.IO("api", httpMethod, resource, params, raw)Aufrufformular derexchange.IO()Die Funktionalität der FMZ-Plattform kann durch die Einreichung eines Antrags auf die Übermittlung von Informationen über die Funktionalität der FMZ-Plattform erweitert werden.POSTAnforderung erfordert nicht, dass Sie sich Sorgen um die Verschlüsselung, Signierung oder Überprüfung der Parameter machen, die bereits von FMZ unten behandelt werden, solange Sie die entsprechenden Parameter ausfüllen.OKX ExchangeFutures-Kontrakte und verwenden Sie den Parameterrawzur Übergabe der Auftragsparameter:
var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
// Note that both amount.toString() and price.toString() have a ' character on the left and right side
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);
}
Wenn der Schlüsselwert in derparamsParameter (d.h. HTTP-Anfrageparameter) ist eine Zeichenfolge, sie muss in einzelnen Anführungszeichen (d.h. das Symbol ') um den Parameterwert geschrieben werden, um den Parameterwert zu umschließen.
function main() {
var ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
}
def main():
ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
void main() {
auto ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC");
Log(ret);
}
Es unterstützt die Übergabe vollständiger URL-Parameter, die den Betrieb des Umschaltens der Basisadresse (Aufrufen der URL-Adresse) weglassen können.exchange.SetBase()Funktion).
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);
}
Beispiel für einen Aufruf ohne Parameterraw:
function main() {
// For example, if you set the current trading pair of the exchange object to BTC_USDT at the beginning of the live trading, print the current trading pair tickers
Log(exchange.GetTicker())
// Switch the 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());
}
Wechseln Sie das Handelspaar des aktuellen Austauschs, so dass es das Handelspaar durch Code konfiguriert wechselnbei der Schaffung von Live-Handelsgeschäftenoderbei Backtest.
function main () {
// exchanges[0] is the first exchange object added when the live trading is created
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");
}```
For example, the default base address when the exchange object is wrapped is ```https://api.huobipro.com```, and when you need to switch to ```https://api.huobi.pro```, use the following code to switch:
```javascript
function main() {
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
}
def main():
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
void main() {
exchange.SetBase("https://api.bitfinex.com");
exchange.IO("mbase", "https://api-pub.bitfinex.com");
}
Für Börsen mit unterschiedlichen Basisadressen für die Tickerschnittstelle und die Handelsschnittstelle haben Bitfinex Futures beispielsweise zwei Adressen, eine für die Tickerschnittstelle und die andere für die Handelsschnittstelle.exchange.SetBase("xxx"). Bitfinex Futures wechseln öffentliche Schnittstelle Basisadresse mitexchange.IO("mbase", "xxx").
I. Für kryptogeldzentrierte Börsen andere API-Schnittstellenanrufe, die nicht einheitlich verkapselt sind, mit Parameterkauf"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GET, usw.URL.Dieexchange.IO("api", httpMethod, resource, params, raw)Funktionsanruf wird auf die Exchange-Schnittstelle zugreifen und null zurückgeben, wenn der Anruf fehlschlägt und ein Fehler auftritt.
Nur der echte Handel unterstützt die Anrufung derexchange.IO("api", httpMethod, resource, params, raw) function.
II. Bei Wechseln von Handelsparen wird der Parameterkist auf"currency":
exchange.IO("currency", currency)
Währung: Der Parameter ist ein Zeichenkettentyp mit einem einheitlichen Großbuchstabenformat, bei dem ein Unterstrich verwendet wird, um zu trennenbaseCurrencyvonquoteCurrency, wie zum BeispielBTC_USDT.
ETH_BTCkann nur aufLTC_BTC, nicht zuLTC_USDT.exchange.IO("currency", currency)um Handelspare zu wechseln.III. Wird verwendet, um den Leveraged-Konto-Modus des Kryptowährungs-Spot-Austauschobjekts zu wechseln:
kist auf"trade_margin"Die Angabe von Aufträgen und der Erwerb von Kontovermögen erfolgt über die Spot-Leveraged-Schnittstelle der Börse.
Wenn die Börse bei Spot-Leverage zwischen voller Marge und isolierter Marge unterscheidet, wird folgendes verwendet:exchange.IO("trade_super_margin")die Umstellung auf die volle Marge für das Hebelkonto undexchange.IO("trade_margin")Umstellung auf eine isolierte Marge für das Hebelkonto.kist auf"trade_normal"Zurück zum normalen Spotkonto-Modus.Spotbörsen, die den Wechsel zwischen Leveraged-Konto-Modellen unterstützen:
| Auswechslungen | Besondere Bemerkungen |
|---|---|
| OKX | Handelspaare im Hebelkonto-Modus unterscheiden sich von normalen, einige Handelspaare haben sie möglicherweise nicht.exchange.IO("trade_super_margin")zur Umstellung auf die volle Position für Hebelkonten und zur Verwendungexchange.IO("trade_margin")Sie können auch eine andere Anlage verwenden.trade_normalSie können die Tabelle in einem anderen Modus verwenden, um in den normalen Spotmodus zu wechseln.exchange.IO("tdMode", "cross")um die Hebelwirkung direkt anzugeben. |
| Weiß nicht. | Bei Huobi gibt es eine Reihe von Handelspaaren, bei denen es sich um die vollständigen Positionen und die Positionen nach Positionen handelt.trade_marginzur Umstellung auf Hebelkontoposition nach Position, Verwendungtrade_super_marginUm auf Hebelwirkung zu wechseln.trade_normalzum normalen Währungs-Währungs-Modus wechseln. |
| Binance | Der Leveraged-Konto-Modus wird in Position nach Position und Vollposition, Verwendungtrade_marginUm von Position zu Position zu wechseln, verwendentrade_super_marginUm in die volle Position zu wechseln, verwenden Sietrade_normalzum normalen Währungs-Währungs-Modus wechseln. |
| Schnittstelle | Der Leveraged-Konto-Modus wird in Position nach Position und Vollposition, Verwendungtrade_marginUm von Position zu Position zu wechseln, verwendentrade_super_marginUm in die volle Position zu wechseln, verwenden Sietrade_normalzum normalen Währungs-Währungs-Modus wechseln. |
| AscendEx | Verwendungexchange.IO("trade_margin")zur Umstellung auf einen Hebelkonto undexchange.IO("trade_normal")Zurück zum normalen Konto-Modus. |
| Wo ist er? | Verwendungexchange.IO("trade_margin")zur Umstellung auf einen Hebelkonto undexchange.IO("trade_normal")Zurück zum normalen Konto-Modus. |
| CoinEx | Verwendungexchange.IO("trade_margin")zur Umstellung auf den Leveraged-Konto-Modus undexchange.IO("trade_normal")Zurück zum normalen Konto-Modus. |
IV. Sonstige Schaltfunktionen:Schauen Sie sich das an.exchange.IO()Funktion fürAndere Schaltfunktionenin der Benutzeranleitung.
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}
Dieexchange.Log()Funktion wird verwendet, um das Protokoll der Auftragserteilung und -abnahme im Bereich der Log-Spalte auszugeben.
Austausch.Log ((Bestellungsdatentyp, Preis, Betrag) Austausch.Log ((Bestellung) Art, Preis, Betrag,... args)
DieorderTypeDer Parameter wird verwendet, um den Ausgabeprototyp festzulegen, die optionalen Werte sind {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}.
Anordnung
- Das stimmt.
Zahl
DiepriceParameter wird verwendet, um den im Ausgangsprotokoll angezeigten Preis festzulegen.
Preis
- Das stimmt.
Zahl
DieamountDer Parameter wird verwendet, um die Menge der in dem Ausgabeprotokoll angezeigten Bestellungen festzulegen.
Betrag
- Das stimmt.
Zahl
Erweiterte Parameter, mit denen die Begleitinformationen in dieses Protokoll ausgeführt werden können,argParameter können mehr als eine übergeben werden.
Arg
falsche
String, number, bool, object, array, null und jeder andere vom System unterstützte Typ
var id = 123
function main() {
// Order type buy, price 999, amount 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);
}
Verwendungexchange.Log(orderType, price, amount)Einer der häufigsten Szenarien ist die Verwendung des {@fun/Trade/exchange.IOexchange.IO} Funktion, um auf die Schnittstelle der Börse für die Erstellung bedingter Aufträge zuzugreifen, aber mit derexchange.IO()Funktion nicht die Transaktionsprotokollinformationen in der Live-Handelsprotokollaufzeichnung ausgibt.exchange.Log()Diese Funktion kann zur Ergänzung des Ausgabeprotokolls verwendet werden, um Informationen über Auftragserteilung und Auftragsausschluss aufzuzeichnen.
Wenn dieorderTypeParameter istLOG_TYPE_CANCEL, diepriceParameter ist die Reihenfolge Id der zurückgezogenen Bestellung, die verwendet wird, um das Rücktrittsprotokoll zu drucken, wenn die Bestellung direkt mit demexchange.IO()Dieexchange.Log()Funktion ist eine Mitgliederfunktion des Austauschobjekts {@var/EXCHANGE exchange} im Gegensatz zur globalen Funktion {@fun/Log Log}.
Die Kommission hat die Kommission aufgefordert, die in Artikel 4 Absatz 1 Buchstabe a der Verordnung (EG) Nr. 45/2001 festgelegten Bedingungen für die Erteilung von Zuschüssen für die Durchführung der Verordnung (EG) Nr. 659/1999 und der Verordnung (EG) Nr. 659/1999 anzuwenden.
Dieexchange.Encode()Die Funktion wird für Signaturverschlüsselungsberechnungen verwendet.
Dieexchange.Encode()Funktion gibt die berechnete Hash-Codierung zurück.
String
exchange.Encode ((algo, inputFormat, outputFormat, Daten) exchange.Encode ((algo, inputFormat, outputFormat, Daten, SchlüsselFormat, Schlüssel)
Der Parameteralgoist der Algorithmus, der für die Kodierung berechnet wird. Unterstützte Einstellungen sind: algounterstützt auch: algounterstützt auch: algokann als ed25519.seedBerechnung.
etwas
wahr
String
Verwendet zur Festlegung des Datenformats derdataDieinputFormatDer Parameter kann auf einen der folgenden Werte gesetzt werden: hexkodiert, base64und outputFormatDer Parameter unterstützt folgende Einstellungen: hexkodiert, base64und dataist die zu verarbeitende Daten.
Daten
wahr
String
Verwendet zur Festlegung des Datenformats derkeyDiekeyDer Parameter kann auf einen der folgenden Werte gesetzt werden: hexkodiert, base64und keyParameter wird verwendet, um den Schlüssel für die Signaturberechnung anzugeben, und es kann als Plaintext-String verwendet werden."{{accesskey}}", "{{secretkey}}"dieaccessKeyundsecretKeyin dem Exchange-Objekt {@var/EXCHANGE exchange} konfiguriert.
Schlüssel
falsche
String
function main() {
var APIKEY = "your Access Key(Bitmex API ID)"
var expires = parseInt(Date.now() / 1000) + 10
var signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{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.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{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.Encode("sha256", "string", "hex", format("GET/realtime%d", expires), "hex", "{{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"];
}
}
}
Beispiel für BitMEX-Positionswechsel (wss-Protokoll):
Nur der echte Handel unterstützt dieexchange.Encode()Die"{{accesskey}}", "{{secretkey}}"Die Referenzen gelten nur, wenn dieexchange.Encode()Funktion verwendet wird.
{@var/EXCHANGE exchange}, {@fun/Global/Encode Encode}
Mehrthreaded asynchrone Support-Funktionen können die Operationen aller unterstützten Funktionen in eine asynchrone gleichzeitige Ausführung umwandeln.
Dieexchange.Go()Funktion gibt ein gleichzeitiges Objekt sofort zurück, und Sie können diewait()Methode dieses gleichzeitigen Objekts, um das Ergebnis der gleichzeitigen Anfrage zu erhalten.
Gegenstand
Wechsel.Gehen (Methode) Auswechselung.Go (Methode,... args)
DiemethodParameter wird verwendet, um den Namen der gleichzeitigen Funktion anzugeben. Beachten Sie, dass der Parameter eine Funktionsnamenfolge ist, keine Funktionsreferenz.
Methode
- Das stimmt.
String
Parameter bisgleichzeitig Funktionen ausführen, kann es mehr als einen Parameter gebenarg. Typ und Anzahl des ParametersargDie Ergebnisse der Studiegleichzeitige Ausführung- Ich weiß.
Arg
falsche
String, number, bool, object, array, function, null und alle anderen vom System unterstützten Typen
function main(){
// The following four operations are concurrently executed asynchronously by multiple threads and do not take time and return immediately
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 ticker results asynchronously
var ticker = a.wait()
// Returns the depth, or null if it fails
var depth = b.wait()
// return order number, limited to 1 second timeout, if timeout, returns undefined, the object can continue to call wait if the last wait 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);
}
Exchange.Go()Funktionsanwendungsbeispiel, um zu bestimmenundefinedzu verwendentypeof(xx) === "undefined", weilnull == undefinedist in JavaScript gültig.
function main() {
var d = exchange.Go("GetRecords", PERIOD_H1)
// Waiting for K-line results
var records = d.wait()
// Here waits an asynchronous operation that has been waited and finished, it will return null, and log the error message
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);
}
Ich rufe diewait()Methode auf einem gleichzeitigen Objekt, das freigegeben wurde, wird einen Fehler melden:
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: "ticker",
cols: ["index", "name", "latest-deal-price"],
rows: []
}
for(var i = 0; i < arrTicker.length; i++) {
tbl.rows.push([i, arrName[i], arrTicker[i].Last])
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", 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": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
}
for i in range(len(arrTicker)):
tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", 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 several exchange objects, several exchanges[n].Go functions have to be executed here, this example is to add four exchange objects, the details can be modified
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": "ticker",
"cols": ["index", "name", "latest-deal-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(), "Total time taken to obtain tickers from multiple exchanges concurrently:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
Sleep(500);
}
}
Gleichzeitiger Zugriff auf mehrere Exchange-Tickers:
function main() {
/*
Testing with OKX futures order interface
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("Concurrent order placement time consumption:", 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("Concurrent order placement time consumption:", 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("Concurrent order placement time consumption:", endTS - beginTS, "millisecond");
}
Gleichzeitige Aufrufeexchange.IO("api", ...)Funktion:
Diese Funktion erstellt nur mehrthreaded Ausführungsaufgaben, wenn sie im realen Handel ausgeführt wird, Backtesting unterstützt nicht mehrthreaded gleichzeitige Ausführung von Aufgaben (Backtesting ist verfügbar, aber immer noch sequenziell ausgeführt).
Nach derexchange.Go()Funktion gibt ein Objekt zurück, seinwait()Funktion wird durch dieses Objekt aufgerufen, um die Daten des Threads zurückzugeben.wait()Die Funktion muss aufgerufen werden, um die Daten zu erhalten, bevor der Thread automatisch freigegeben wird.wait()Wenn die Funktion nicht angegeben ist, wird der Thread nicht automatisch freigegeben, selbst wenn ein Timeout eintritt. Das Ergebnis des Threads muss erhalten werden, bevor er automatisch freigegeben wird (unabhängig vom Erfolg oder Scheitern des Schnittstellenanrufs für gleichzeitigen Zugriff).wait()Funktion, unabhängig davon, ob die Ausführung erfolgreich oder fehlschlägt, und die Ressource des vom Thread angefordertenexchange.Go()Funktion muss automatisch vom Docker freigegeben werden.
Diewait()Methode unterstützt einen Timeout-Parameter:
Ohne einen Timeout-Parameter, alsowait(), oder mit einem Timeout-Parameter von 0, d. h.wait(0). Diewait()Funktionsblöcke und wartet, bis der gleichzeitige Thread ausgeführt ist, und gibt das Ergebnis der gleichzeitigen Threadwait(-1). Diewait()Funktion gibt sofort mit unterschiedlichen Rückgabewerten für verschiedene Programmiersprachen zurück, siehe diesen Unterabschnitt für einen Beispielruf.
Setzen Sie den spezifischen Timeout-Parameter,wait(300), und diewait()Die Funktion wird maximal 300 Millisekunden warten, bevor sie zurückkehrt.
Wenn das Ergebnis der letztenwait()Funktion nicht erreicht wird, werden die Thread-Ressourcen nicht automatisch freigegeben, was zur Anhäufung der angeforderten Threads führt, und mehr als 2000 werden einen Fehler melden:"too many routine wait, max is 2000"- Ich weiß.
Unterstützte Funktionen:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Alle diese Funktionen werden basierend auf dem aktuellen Exchange-Objekt {@var/EXCHANGE exchange} ausgeführt, wenn sie gleichzeitig aufgerufen werden.
Der Unterschied zwischen Python und JavaScript besteht darin, dasswait()Die Funktion der gleichzeitigen Objekte in der Python-Sprache gibt zwei Parameter zurück. Der erste Parameter ist das Ergebnis eines asynchronen API-Aufrufs und der zweite Parameter gibt an, ob der asynchrone Aufruf abgeschlossen ist.
def main():
d = exchange.Go("GetRecords", PERIOD_D1)
# ok will return True definitely, unless the strategy is stopped
ret, ok = d.wait()
# If the wait times out, or if it waits for an instance that has already ended, ok returns False
ret, ok = d.wait(100)
Wir haben eine Reihe von Programmen entwickelt.
Markt Abrechnung