Les ressources ont été chargées... Je charge...

Le commerce

exchange.Buy

Leexchange.Buy()La fonction est utilisée pour passer des ordres d'achat.Buy()fonction est une fonction membre de l'objet d'échange {@var/EXCHANGE exchange}.Buy()fonction fonctionne sur le compte de change lié à l'objet de changeexchangeLe but des fonctions (méthodes) des membres duexchangel'objet est uniquement lié àexchange, et il ne sera pas répété après la documentation.

Une commande réussie renvoie l'identifiant de commande, une commande ratée renvoie une valeur nulle. L'attributIdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de la paire de négociation au comptantETH_USDTl'ordre de l'échange OKX est le suivant:ETH-USDT,1547130415509278720- Je ne sais pas. Lorsque vous appelez leexchange.Buy()fonction pour passer une commande, la commande de retour de valeurIdest conforme à laIdattribute de la structure de l'ordre {@struct/Order Order}.

chaîne, valeur nulle

échange.Acheter ((prix, montant) échange.acheter ((prix, montant,... arguments)

LepriceLe paramètre est utilisé pour définir le prix de la commande. prix vrai Numéro LeamountLe paramètre est utilisé pour définir le montant de la commande. Le montant vrai Numéro Paramètres étendus pouvant fournir des informations d'accompagnement à ce journal des commandes,argLes paramètres peuvent être passés à plus d'un. arg faux chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système

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

Le numéro d'ordre renvoyé parexchange.Buy()peut être utilisé pour interroger les informations de commande et annuler la commande.

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

Lors de la passation d'un ordre pour un contrat à terme de crypto-monnaie, il faut veiller à ce que la direction du commerce soit correctement définie, car un décalage entre la direction du commerce et la fonction de commerce entraînera une erreur:

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

Commande au comptant.

Lorsque vous passez un ordre pour un contrat à terme, vous devez faire attention à savoir si la direction du commerce est correctement définie, car une erreur sera signalée si la direction du commerce et la fonction du commerce ne correspondent pas. Le paramètrepriceest réglée sur-1pour placer des ordres de marché, ce qui nécessite que l'interface de placement des ordres de l'échange supporte les ordres de marché.amountest le montant de l'argent dans la devise de l'ordre.amountest le nombre de contrats. Il y a quelques échanges de crypto-monnaie qui ne prennent pas en charge l'interface d'ordre de marché pendant la négociation en direct. La quantité d'ordre pour les ordres d'achat de marché sur certains échanges au comptant est le nombre de pièces de monnaie de négociation. Veuillez vous référer auInstructions spéciales pour les échangesPour plus de détails, voir le Guide utilisateur. Si vous utilisez une ancienne version du docker, la valeur de retour de l'ordreIdde l'annéeexchange.Buy()fonction peut être différente de la valeur de retour de l'ordreIddécrits dans le présent document.

{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}

exchange.Sell

Leexchange.Sell()fonction est utilisée pour placer des ordres de vente.

Une commande réussie renvoie l'identifiant de commande, une commande ratée renvoie une valeur nulle.IdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de la paire de négociation au comptantETH_USDTl'ordre de l'échange OKX est le suivant:ETH-USDT,1547130415509278720Lorsque vous appelez leexchange.Sell()fonction pour passer une commande, la commande de retour de valeurIdest conforme à laIdattribute de la structure de l'ordre {@struct/Order Order}. chaîne, valeur nulle

échange.Vente (prix, montant) échange.Vente ((prix, montant,... arguments)

LepriceLe paramètre est utilisé pour définir le prix de la commande. prix vrai Numéro LeamountLe paramètre est utilisé pour définir le montant de la commande. Le montant vrai Numéro Paramètres étendus pouvant fournir des informations d'accompagnement à ce journal des commandes,argLes paramètres peuvent être passés à plus d'un. arg faux chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système

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

Le numéro d'ordre renvoyé parexchange.Sell()peut être utilisé pour interroger les informations relatives aux commandes et annuler les commandes.

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

Lors de la passation d'un ordre pour un contrat à terme de crypto-monnaie, il faut veiller à ce que la direction du commerce soit correctement définie, car un décalage entre la direction du commerce et la fonction de commerce entraînera une erreur:

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

Commande au comptant.

Lorsque vous passez un ordre pour un contrat à terme, vous devez faire attention à savoir si la direction du commerce est correctement définie, car une erreur sera signalée si la direction du commerce et la fonction de trading ne correspondent pas. Le paramètrepriceest réglée sur-1pour la passation d'ordres de marché, ce qui nécessite que l'interface de passation d'ordres de l'échange soutienne les ordres de marché.amountest le montant en monnaie de négociation.amountIl y a quelques échanges de crypto-monnaie qui ne prennent pas en charge l'interface d'ordre de marché lors de la négociation en direct. Si vous utilisez une ancienne version du docker, la valeur de retour de l'ordreIdde l'annéeexchange.Sell()fonction peut être différente de la valeur de retour de l'ordreIddécrits dans le présent document.

{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}

exchange.CreateOrder

Leexchange.CreateOrder()La fonction est utilisée pour passer une commande.

Si l'ordre est placé avec succès, l'identifiant de commande est renvoyé; si l'ordre échoue, une valeur nulle est renvoyée.IdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de l'ordre de la paire de négociation au comptantETH_USDTde la bourse OKX est:ETH-USDT,1547130415509278720Lorsque vous appelez leexchange.CreateOrder(symbol, side, price, amount)fonction de passer une commande, la valeur retournée de l'ordreIdest conforme à laIdpropriété de la structure de l'ordre {@struct/Order Order}. chaîne, valeur nulle

Créer un ordre (symbole, côté, prix, montant) L'échange.CréerOrder (symbole, côté, prix, montant,... arguments)

Le paramètresymbolest utilisé pour spécifier la paire de négociation spécifique et le code du contrat de l'ordre.exchange.CreateOrder(symbol, side, price, amount)fonction de passer une commande,exchangeest l'objet d'échange au comptant. Si la monnaie libellée de l'ordre est l'USDT et la monnaie de négociation est le BTC, le paramètresymbolest:"BTC_USDT", dans le format de la paire de négociation définie par la plateforme FMZ.exchange.CreateOrder(symbol, side, price, amount)fonction de passer une commande,exchangeest l'objet de l'échange de contrats à terme.symbolest:"BTC_USDT.swap", et le format est une combinaison despaire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par le caractère ..exchange.CreateOrder(symbol, side, price, amount)fonction de passer une commande,exchangeest l'objet de l'échange de contrats à terme.symbolest:"BTC_USDT.BTC-240108-40000-C"(en prenant Binance Option BTC-240108-40000-C comme exemple), et le format est une combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère .. le symbole vrai chaîne LesideParamètre utilisé pour spécifier la direction de négociation de l'ordre. Pour les objets d'échange au comptant, les valeurs facultatives desideLes paramètres sont:buy, sell. buysignifie acheter, etsellÇa veut dire vendre. Pour les objets d'échange de contrats à terme, les valeurs facultatives desideLes paramètres sont:buy, closebuy, sell, closesell. buydésigne l'ouverture d'une position longue,closebuysignifie la clôture d'une position longue,selldésigne l'ouverture d'une position courte, etclosesellsignifie la clôture d'une position courte.

côté vrai chaîne Le paramètrepriceUn prix de -1 indique que l'ordre est un ordre de marché. prix vrai Numéro Le paramètreamountest utilisé pour définir la quantité d'ordre. Veuillez noter que lorsque l'ordre est un ordre d'achat sur le marché, la quantité d'ordre est le montant d'achat; la quantité d'ordre de l'ordre d'achat sur le marché de certaines bourses à vue est le nombre de pièces de monnaie de négociation.Instructions spéciales pour les échangesdans le Guide de l'utilisateur. Le montant vrai Numéro Les paramètres étendus peuvent fournir des informations supplémentaires à ce journal des commandes.argles paramètres peuvent être passés. arg faux Tout type pris en charge par le système, tel que chaîne, nombre, bool, objet, tableau, valeur nulle, etc.

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

Les objets d'échange au comptant et les objets d'échange à terme s'appellentexchange.CreateOrder()fonction pour passer une commande.

{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy exchange.Buy.Buy}, {@fun/Trade/exchange.Buy.Buy.Buy}, {@fun/Trade/Exchange.Buy.Buy}

exchange.CancelOrder

Leexchange.CancelOrder()La fonction est utilisée pour annuler la commande. L'attributIdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de l'ordre de la paire de négociation au comptantETH_USDTde la bourse OKX est:ETH-USDT,1547130415509278720- Je ne sais pas. Le paramètreorderIdIl est passé à l'appelexchange.CancelOrder()La fonction d'annulation d'une commande est conforme à laIdpropriété de la structure de l'ordre {@struct/Order Order}.

Leexchange.CancelOrder()la fonction renvoie une valeur vraie, par exempletruesignifie que la demande d'ordre d'annulation a été envoyée avec succès.false, signifie que la demande d'ordre d'annulation n'a pas été envoyée. La valeur renvoyée représente uniquement le succès ou l'échec de la demande envoyée pour déterminer si l'échange annule l'ordre.exchange.GetOrders()pour déterminer si l'ordre est annulé. Boole

Échange.Annuler la commande ((Identifier la commande) Échange.Annuler la commande ((Identifier la commande,... arguments)

LeorderIdLe paramètre est utilisé pour spécifier l'ordre à annuler. commandé vrai Numéro, chaîne Paramètres étendus, vous pouvez exécuter les informations jointes à ce journal de retrait,argLes paramètres peuvent être passés à plus d'un. arg faux chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système

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

Annuler la commande.

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

Fonctions d'API FMZ pouvant produire des fonctions de sortie de log tels que:Log(), exchange.Buy(), exchange.CancelOrder()peuvent être suivies de quelques paramètres de sortie d'accompagnement après les paramètres nécessaires.exchange.CancelOrder(orders[i].Id, orders[i]), de sorte que lors de l' annulation de la commande dont l' ID estorders[i].Id, l'information de l'ordre est produite avec elle.orders[i].

Si vous utilisez une ancienne version du docker, le paramètre orderId de la fonction exchange.CancelOrder() peut être différent de l'orderId décrit dans le document actuel.

{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Buy exchange.Buy.Buy}, {@fun/Trade/exchange.Sell exchange.GetOrders}

exchange.GetOrder

Leexchange.GetOrder()La fonction est utilisée pour obtenir les informations de commande.

Rechercher les détails de l'ordre selon le numéro d'ordre, et retourner la structure {@struct/Order Order} si la requête réussit, ou retourner null si la requête échoue. {@struct/Order Order}, valeur nulle

Je ne sais pas si c'est le cas.

LeorderIdLe paramètre est utilisé pour spécifier l'ordre à interroger. L'attributIdLa structure de l'ordre {@struct/Order Order} de la plateforme FMZ se compose du code de produit de l'échange et de l'identifiant d'ordre d'origine de l'échange, séparés par des virgules en anglais.Idformat de l'ordre de la paire de négociation au comptantETH_USDTde la bourse OKX est:ETH-USDT,1547130415509278720- Je ne sais pas. Le paramètreorderIdIl est passé à l'appelexchange.GetOrder()La fonction de requête d'une commande est compatible avec laIdpropriété de la structure de l'ordre {@struct/Order Order}.

commandé vrai chaîne

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

Leexchange.GetOrder()La fonction n'est pas prise en charge par certains échanges.AvgPriceL'attribut dans la structure {@struct/Order Order} de la valeur de retour est le prix moyen de la transaction. Certains échanges ne prennent pas en charge ce champ, et s'ils ne le font pas, il est défini sur 0. Si vous utilisez une ancienne version du docker, leorderIdparamètre duexchange.GetOrder()fonction peut différer de laorderIddécrits dans la documentation actuelle. Les échanges qui ne soutiennent pas leexchange.GetOrder()fonction:

Nom de la fonction Échanges au comptant non pris en charge Échanges de contrats à terme non soutenus
Obtenir un ordre Il y a un autre problème. –

{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/HistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange}, {@fun/Trade/exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders},

exchange.GetOrders

Leexchange.GetOrders()La fonction est utilisée pour obtenir des commandes en suspens.

Leexchange.GetOrders()la fonction renvoie un tableau de structures {@struct/Order Order} si la demande de données est réussie, et elle renvoie des valeurs nulles si la demande de données échoue. {@struct/Order Order} tableau, valeur nulle

Je suis en train d' échanger des ordres. Les commandes (symbole)

Le paramètresymbolest utilisé pour régler lesymbole de transactionougamme de symboles de transactionPour être interrogé. Pour les objets d'échange au comptant, sisymbolsi le paramètre n'est pas passé, les données de commande incomplètes de tous les produits au comptant seront demandées. Pour les objets d'échange de contrats à terme,symbolsi le paramètre n'est pas passé, la valeur par défaut est de demander les données d'ordre incomplètes de toutes les variétés dans la gamme de dimensions de la paire de négociation et du code de contrat en cours.

le symbole faux chaîne

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

Utilisez l'objet de change au comptant pour passer des ordres d'achat pour plusieurs paires de transactions différentes à la moitié du prix actuel, puis interrogez les informations sur les ordres en cours.

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

Utilisez des objets d'échange de contrats à terme pour passer des ordres pour plusieurs paires de transactions et codes de contrats différents.

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

Lorsque vous appelez leexchange.GetOrders()fonction, passer dans leSymbolparamètre permettant de demander des données d'ordre pour une paire de négociation spécifique et le code du contrat.

Dans leGetOrdersfonction, les scénarios d'utilisation du paramètre symbole sont résumés comme suit:

Classification des objets Exchange Symbole Paramètres Portée de la requête Nom de l'entreprise
Le point Ne pas passer le paramètre de symbole Rechercher toutes les paires de négociation au comptant Pour tous les scénarios d'appel, si l'interface d'échange ne le prend pas en charge, une erreur sera signalée et une valeur nulle sera renvoyée.
Le point Indiquer le type de négociation, le paramètre du symbole est: BTC_USDT Rechercher la paire de négociation BTC_USDT spécifiée Pour les objets de change au comptant, le format du paramètre du symbole est: BTC_USDT
Les contrats à terme Ne pas passer le paramètre de symbole Rechercher tous les produits de négociation dans la gamme de dimensions de la paire de négociation et du code du contrat en cours Si la paire de trading actuelle est BTC_USDT et que le code du contrat est swap, tous les contrats perpétuels à marge USDT seront interrogés.GetOrders("USDT.swap")
Les contrats à terme Indiquer le type de négociation, le paramètre du symbole est: BTC_USDT.swap Rechercher le contrat perpétuel basé sur USDT pour un BTC spécifié Pour les objets d'échange de contrats à terme, le format du symbole du paramètre est:paire de négociationetcode du contratdéfinies par la plateforme FMZ, séparées par les caractères"..
Les contrats à terme Spécifier la gamme de produits de négociation, le paramètre du symbole est: USDT.swap Rechercher tous les contrats perpétuels basés sur USDT -
Échanges de contrats à terme qui prennent en charge les options Ne pas passer le paramètre de symbole Rechercher tous les contrats d'options dans la plage de dimension de la paire de négociation en cours Si la paire de négociation actuelle est BTC_USDT, le contrat est défini sur un contrat d'option, par exemple, le contrat d'option Binance: BTC-240108-40000-C
Échanges de contrats à terme qui prennent en charge les options Spécifier les produits commerciaux spécifiques Rechercher le contrat d' option spécifié Par exemple, pour Binance Futures Exchange, le paramètre du symbole est le suivant: BTC_USDT.BTC-240108-40000-C
Échanges de contrats à terme qui prennent en charge les options Spécifiez la gamme de produits de négociation, le paramètre du symbole est: USDT.option Rechercher tous les contrats d'options basés sur USDT -

Dans leGetOrdersfonction, la requête de l'objet d'échange à terme la plage de dimensions est résumée comme suit:

Symbole Paramètres Définition de la plage de demande Nom de l'entreprise
USDT.swap la valeur de l'échange est la valeur de l'échange à terme. Pour

les dimensions qui ne sont pas prises en charge par l'interface API d'échange, une erreur sera signalée et une valeur nulle sera renvoyée lorsque Je vous appelle. Une gamme de contrats de livraison basés sur USDT. Une gamme de change perpétuel basé sur la devise Des contrats. Une gamme de livraison basée sur la devise Des contrats. Une gamme d'options basée sur USDT. L'option USD est basée sur la variété des contrats d'options. Une gamme de combinaisons de CFD. Les échanges de dérivés futures. Une gamme de contrats de livraison de marge mixte. Je suis en train d'écrire un livre. Une gamme de contrats perpétuels à marge mixte. Je suis en train d'essayer de vous aider.

Lorsque le compte représenté par l'objet d'échangeexchangen'a pas d'ordres en attente dans leplage de requêteouinstruments de négociation spécifiques(ordres actifs dans un état non rempli), l'appel de cette fonction renvoie un tableau vide, c'est à dire:[]Je suis désolée. Les échanges suivants exigent que l'instrument passe dans le paramètre de l'instrument lors de la requête des ordres actuellement inachevés. Lors de l'appel de la fonction GetOrders avec ces échanges, si le paramètre de l'instrument n'est pas passé, seuls les ordres inachevés de l'instrument actuel sont demandés, pas les ordres inachevés de tous les instruments (car l'interface d'échange ne le prend pas en charge). Il a été vendu à des entreprises comme Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE.

Les échanges qui ne soutiennent pas leexchange.GetOrders()fonction:

Nom de la fonction Échanges au comptant non pris en charge Échanges de contrats à terme non soutenus
Obtenir des ordres – Les échanges à terme

{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@struct/Trade/Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder.GetOrder}, {@

exchange.GetHistoryOrders

Leexchange.GetHistoryOrders()Cette fonction permet d'obtenir la paire de négociation en cours, les ordres historiques pour les contrats; elle permet de spécifier des variétés de négociation spécifiques.

Leexchange.GetHistoryOrders()fonction renvoie un tableau de structures {@struct/Order Order} si la demande de données est réussie, et nul si la demande échoue. {@struct/Order Order} tableaux, valeurs nulles

Les commandes de l' échange.GetHistory Les commandes d'échange.GetHistory (symbole) Je ne sais pas comment faire. Les commandes d'exchange.GetHistory (symbole, depuis, limite) Je ne peux pas faire ça. Les commandes de l'historique (depuis)

LesymbolLe paramètre est utilisé pour spécifier le symbole commercial.BTC_USDTPar exemple, lorsque leexchangeest un objet d'échange au comptant, le format de paramètre poursymbolestBTC_USDT; si il s'agit d'un objet d'échange de contrats à terme, en prenant par exemple le contrat perpétuel, le format de paramètre poursymbolest:BTC_USDT.swapJe suis désolée. Si vous interrogez les données d'ordre des contrats d'option, définissez le paramètresymbolà"BTC_USDT.BTC-240108-40000-C"Le format est une combinaison depaire de négociationdéfini par la plateforme FMZ et le code du contrat d'option spécifique défini par la bourse, séparés par le caractère .. Si ce paramètre n'est pas passé, les données d'ordre de la paire de négociation actuellement définie et le code du contrat sont demandés par défaut.

le symbole faux chaîne LesinceLe paramètre est utilisé pour spécifier l'horodatage de début de la requête en millisecondes. depuis faux Numéro LelimitLe paramètre est utilisé pour spécifier le nombre d'ordres à interroger. limite faux Numéro

function main() {
    var historyOrders = exchange.GetHistoryOrders()
    Log(historyOrders)
}

def main():
    historyOrders = exchange.GetHistoryOrders()
    Log(historyOrders)

void main() {
    auto historyOrders = exchange.GetHistoryOrders();
    Log(historyOrders);
}
  • Quand?symbol, since, limitLes paramètres ne sont pas spécifiés, la requête par défaut est la paire de négociation actuelle, les ordres historiques de contrat.
  • Lorsque lesymbolSi le paramètre est spécifié, interroger l'historique des ordres pour le type de transaction défini.
  • Lorsque lesinceParamètre est spécifié, requête dans le sens de l'heure actuelle en utilisant lesincel'horodatage comme heure de début.
  • Si lelimitparamètre est spécifié, la requête est renvoyée après un nombre suffisant d'entrées.
  • Cette fonction n'est prise en charge que pour les échanges qui fournissent une interface de requête d'ordre historique.

Les échanges qui ne soutiennent pas leexchange.GetHistoryOrders()fonction:

Nom de la fonction Échanges au comptant non pris en charge Échanges de contrats à terme non soutenus
Les commandes GetHistory Il est également disponible en téléchargement gratuit. Les états financiers des États membres sont définis par le règlement (UE) no 575/2013.

{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@struct/Trade/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrders}, {@fun/Trade/exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder}

exchange.SetPrecision

exchange.SetPrecision()fonction est utilisée pour régler la précision duexchangeobjet d'échangeprixetmontant de la commande, le système ignore automatiquement les données excédentaires.

Je ne sais pas si je peux le faire.

LepricePrecisionLe paramètre est utilisé pour contrôler la précision des données sur les prix. prixPrécision vrai Numéro LeamountPrecisionParamètre utilisé pour contrôler la précision de la quantité de données à commander. Montant précise vrai Numéro

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

Le système de backtesting ne prend pas en charge cette fonction, et la précision numérique du système de backtesting est gérée automatiquement.

{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Sell}, {@fun/Trade/exchange.Buy exchange.Buy exchange.Buy.Buy}, {@fun/Trade/exchange.Buy.Buy.Buy}, {@fun/Trade/Exchange.Buy.Buy}

exchange.SetRate

Définir le taux de change actuel de l'objet d'échange.

Le taux d'échange.SetRate

LerateLe paramètre est utilisé pour spécifier le taux de conversion. taux vrai Numéro

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

Si une valeur de taux de change a été fixée en utilisant leexchange.SetRate()Ensuite, toutes les informations de prix telles que les tickers, les profondeurs, les prix des commandes, etc. pour l'échange représenté par le courantexchangeL'objet de change sera converti en le multipliant par le taux de change fixé de 7.exchangeest un échange avec le dollar américain comme monnaie.exchange.SetRate(7), tous les prix sur le marché en direct seront convertis en prix proches deRésultats de l'enquêteNominalité multipliée par 7.

{@fun/Marché/échange.GetRate échange.GetRate}

exchange.IO

Leexchange.IO()la fonction est utilisée pour d'autres appels d'interface liés à l'objet d'échange.

Leexchange.IO()La fonction appelle d'autres interfaces liées à l'objet d'échange, renvoyant les données de réponse demandées lors d'un appel réussi et elle renvoie null lors d'un appel raté. chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système

exchange.IO(k,... args)

Lekparamètre est utilisé pour définir le type d'appel, avec des valeurs facultatives"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedet ainsi de suite. K vrai chaîne Paramètres étendus, passés selon le scénario d'appel spécifique,argEn raison du mécanisme polymorphe de laexchange.IO()Le nombre et le type de paramètres correspondent aux fonctions de l'appareil.exchange.IO()Les fonctions sont indéterminées. arg vrai chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système

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

En utilisant leexchange.IO("api", httpMethod, resource, params, raw)Le formulaire d'appelexchange.IO()Il est nécessaire de comprendre l'interface API de l'échange et de vérifier d'abord la documentation pertinente.POSTla demande ne vous oblige pas à vous soucier du chiffrement, de la signature ou de la vérification des paramètres, qui sont déjà gérés par FMZ en bas, tant que vous remplissez les paramètres correspondants.Échange OKXles contrats à terme, et utiliser le paramètrerawpour passer les paramètres d'ordre:

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

Si la valeur clé dans leparamsparamètre (par exemple, paramètre de demande HTTP) est une chaîne, il doit être écrit en guillemets simples (par exemple, le symbole ') autour de la valeur du paramètre pour envelopper la valeur du paramètre.

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

Il prend en charge le passage de paramètres d'url complets, ce qui peut omettre l'opération de commutation de l'adresse de base (appelant leexchange.SetBase()fonction).

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

Exemple d'appel sans paramètreraw:

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

Modifier la paire de négociation de l'échange actuel, de sorte qu'il changera la paire de négociation configurée par codelors de la création de transactions en directouau 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");
}

Pour les bourses avec différentes adresses de base pour l'interface ticker et l'interface de trading, par exemple, Bitfinex Futures dispose de deux adresses, l'une pour l'interface ticker et l'autre pour l'interface de trading.exchange.SetBase("xxx")Les contrats à terme de Bitfinex changent d'adresse de base d'interface publique en utilisantexchange.IO("mbase", "xxx").

I. Pour les échanges centrés sur les crypto-monnaies, autres appels d'interface API qui ne sont pas uniformément encapsulés, avec paramètrekréglé sur"api":

exchange.IO("api", httpMethod, resource, params, raw)
  • httpMethod : Le paramètre est un type de chaîne, renseignez le type de requêtePOST, GET, etc.
  • resource : Le paramètre est de type chaîne et remplit le chemin de requête; il prend en charge l'utilisation de chemins de requête complets, voir l'exemple de référence pour plus de détails.
  • Paramètres: Le paramètre est un type de chaîne, rempli de paramètres de demande, codé avecURL.
  • raw: le paramètre est le paramètre de chaîne raw et peut être omis.

Leexchange.IO("api", httpMethod, resource, params, raw)l'appel de fonction accède à l'interface d'échange et renvoie null si l'appel échoue et qu'une erreur se produit. Seul le commerce réel soutient l'appelexchange.IO("api", httpMethod, resource, params, raw) function.

II. Pour le changement de paires de négociation, le paramètrekest réglée sur"currency":

exchange.IO("currency", currency)

  • monnaie : Le paramètre est un type de chaîne avec un format majuscule uniforme, avec un trait de soulignement pour séparerbaseCurrencydequoteCurrency, tels queBTC_USDT.

    1. Le système de backtesting prend désormais en charge la commutation des paires de négociation (uniquement pour les objets de change au comptant de devises numériques), lors du backtesting, vous devez faire attention que vous ne pouvez passer à des paires de négociation avec la même monnaie libellée, par exemple, la paire de négociation actuelle estETH_BTCJe peux seulement passer àLTC_BTC, pas àLTC_USDT.
    2. Pour les contrats à terme de crypto-monnaie, l'objet d'échange change de paire de négociation et le code du contrat doit être réinitialisé pour déterminer le contrat à négocier.
    3. Utiliser la fonction {@fun/Account/exchange.SetCurrency exchange.SetCurrency} pour changer de paire de trading est exactement la même chose que d'utiliserexchange.IO("currency", currency)pour changer de paire de négociation.

III. Utilisé pour basculer sur le mode de compte à effet de levier de l'objet de l'échange au comptant de crypto-monnaie:

  • Le paramètrekest réglée sur"trade_margin"Pour placer des ordres et obtenir des actifs de compte, vous aurez accès à l'interface à effet de levier au comptant de l'échange. Si la bourse fait la distinction entre marge totale et marge isolée dans l'effet de levier au comptant, utiliser:exchange.IO("trade_super_margin")passer à la marge totale pour le compte à effet de levier, etexchange.IO("trade_margin")de passer à une marge isolée pour le compte à effet de levier.
  • Paramètrekest réglée sur"trade_normal"pour revenir au mode de compte au comptant normal.

Échanges au comptant qui prennent en charge le passage entre les modèles de comptes à effet de levier:

Les échanges Remarques spéciales
- Ça va. Les paires de trading en mode compte à effet de levier sont différentes des paires normales, certaines paires de trading peuvent ne pas les avoir.exchange.IO("trade_super_margin")passer à la position complète pour les comptes à effet de levier et utiliserexchange.IO("trade_margin")pour passer à la position par position.trade_normalutiliser le dispositif pour passer en mode spot normal.exchange.IO("tdMode", "cross")pour spécifier directement le mode d'effet de levier.
Huobi est un joueur. Les paires de trading en mode compte à effet de levier sont différentes des paires normales, certaines paires de trading peuvent ne pas les avoir.trade_marginpour passer à un compte d'effet de levier position par position, utilisertrade_super_marginpour passer à la position complète du compte à effet de levier.trade_normalpour passer au mode monnaie-monnaie normal.
Binance Le mode de compte à effet de levier est divisé en position par position et position totale, utilisationtrade_marginpour passer à position par position, utilisertrade_super_marginpour passer à la position complète, utilisertrade_normalpour passer au mode monnaie-monnaie normal.
La porte Le mode de compte à effet de levier est divisé en position par position et position totale, utilisationtrade_marginpour passer à position par position, utilisertrade_super_marginpour passer à la position complète, utilisertrade_normalpour passer au mode monnaie-monnaie normal.
AscendEx Utilisationexchange.IO("trade_margin")de passer au mode de compte à effet de levier etexchange.IO("trade_normal")pour revenir au mode de compte normal.
Je vous en prie! Utilisationexchange.IO("trade_margin")de passer au mode de compte à effet de levier etexchange.IO("trade_normal")pour revenir au mode de compte normal.
CoinEx Utilisationexchange.IO("trade_margin")de passer au mode de compte à effet de levier etexchange.IO("trade_normal")pour revenir au mode de compte normal.

IV. Autres fonctions de commutationRegardez leexchange.IO()fonction pourAutres fonctions de commutationdans le guide de l'utilisateur.

{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}, {@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}, {@var EXCHANGE_OP_IO_CONTROL}

exchange.Log

Leexchange.Log()fonction est utilisée pour produire le journal des commandes passées et retirées dans la zone de la colonne de journal.

échange.Log ((ordreTyp, prix, montant) Compte rendu de la commande type, prix, montant,... arguments

LeorderTypeLe paramètre est utilisé pour définir le type de journal de sortie, les valeurs optionnelles sont {@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}. ordreTypes vrai Numéro LepriceLe paramètre est utilisé pour définir le prix affiché dans le journal de sortie. prix vrai Numéro LeamountParamètre utilisé pour définir le nombre de commandes passées affiché dans le journal de sortie. Le montant vrai Numéro Paramètres étendus pouvant fournir des informations d'accompagnement à ce journal,argLes paramètres peuvent être passés à plus d'un. arg faux chaîne, nombre, bool, objet, tableau, nul et tout autre type pris en charge par le système

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

Utilisationexchange.Log(orderType, price, amount)L'un des scénarios les plus courants consiste à utiliser le {@fun/Trade/exchange.IOexchange.IOLa fonction d'accès à l'interface de l'échange pour la création d'ordres conditionnels, mais en utilisant leexchange.IO()La fonction n'affiche pas les informations du journal des transactions dans l'enregistrement du journal des transactions en direct.exchange.Log()Cette fonction peut être utilisée pour compléter le journal de sortie afin d'enregistrer les informations relatives au placement des commandes, de même que pour les opérations de retrait des commandes.

Lorsque leorderTypele paramètre estLOG_TYPE_CANCEL, lepriceParamètre est l'ordre Id de l'ordre retiré qui est utilisé pour imprimer le journal de retrait lorsque l'ordre est retiré directement en utilisant leexchange.IO()La fonctionexchange.Log()fonction est une fonction membre de l'objet d'échange {@var/EXCHANGE exchange}, par opposition à la fonction globale {@fun/Log Log}.

Le nombre de points de vente est calculé en fonction du nombre de points de vente.

exchange.Encode

Leexchange.Encode()fonction est utilisée pour les calculs de chiffrement de signature.

Leexchange.Encode()la fonction renvoie le codage de la valeur de hachage calculée. chaîne

L'échange.Encode ((algo, entréeFormat, sortieFormat, données) Le code de l'appareil est le code de l'appareil.

Le paramètrealgoest l'algorithme utilisé pour le calcul du codage. Les paramètres pris en charge sont: raw (pas d'algorithme utilisé), sign, signTx, md4, md5, sha256, sha512, sha1, keccak256, sha3.224, sha3.256, sha3.384, sha3.512, sha3.keccak256, sha3.keccak512, sha512.384, sha512.256, sha512.224, emd160, ripke2b.256, blake2b.512, blake2s.128, blake2s.256.algoIl prend également en charge: text.encoder.utf8, text.decoder.utf8, text.encoder.gbk, text.decoder.gbk, pour le codage et le décodage des chaînes.algosupporte également: ed25519 algorithme. Il supporte l'utilisation de différents algorithmes de hachage, par exemple le paramètrealgopeut être écrit comme ed25519.md5, ed25519.sha512, etc.ed25519.seedle calcul. quelque chose vrai chaîne Utilisé pour spécifier le format de données dudataParamètre.inputFormatle paramètre peut être défini sur l'un des paramètres suivants: raw, hex, base64, et string. raw signifie que les données sont des données brutes, hex signifie que les données sonthexcodé, base64 signifie que les données sontbase64encodé, et string signifie que les données sont une chaîne. Le format d'entrée vrai chaîne Utilisé pour spécifier le format des données de sortie.outputFormatparamètre prend en charge les paramètres suivants: raw, hex, base64, string. raw signifie que les données sont des données brutes, hex signifie que les données sonthexcodé, base64 signifie que les données sontbase64encodé, et string signifie que les données sont une chaîne. SortieFormat vrai chaîne Le paramètredataest les données à traiter. données vrai chaîne Utilisé pour spécifier le format de données dukeyParamètre.keyle paramètre peut être défini sur l'un des paramètres suivants: raw, hex, base64, et string. raw signifie que les données sont des données brutes, hex signifie que les données sonthexcodé, base64 signifie que les données sontbase64encodé, et string signifie que les données sont une chaîne. Le format faux chaîne Lekeyparamètre est utilisé pour spécifier la clé utilisée dans le calcul de la signature, et il peut être utilisé comme une chaîne de texte brut."{{accesskey}}", "{{secretkey}}"pour faire référence à laaccessKeyetsecretKeyconfiguré dans l'objet d'échange {@var/EXCHANGE exchange}. clé faux chaîne

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

Exemple de modification de position de BitMEX (protocole wss):

Seul le commerce réel soutient l'appelexchange.Encode()La fonction"{{accesskey}}", "{{secretkey}}"Les références ne sont valables que lorsque leexchange.Encode()fonction est utilisée.

{@var/EXCHANGE échange}, {@fun/Global/Encode Encode}

exchange.Go

Les fonctions de support asynchrone à plusieurs fils peuvent transformer les opérations de toutes les fonctions prises en charge en exécution asynchrone simultanée.

Leexchange.Go()fonction renvoie un objet concurrent immédiatement, et vous pouvez utiliser lewait()méthode de cet objet concurrent pour obtenir le résultat de la requête concurrente. objet

Métode d'échange (Go) L'échange.Méthode Go,... args)

Lemethodparamètre est utilisé pour spécifier le nom de la fonction concurrente. Notez que le paramètre est une chaîne de noms de fonction, pas une référence de fonction. méthode vrai chaîne Paramètres àexécutant simultanément des fonctions, il peut y avoir plusieurs paramètresarg. Le type et le nombre de paramètresargdépend des paramètres dufonction d'exécution simultanéeJe suis désolée. arg faux chaîne, nombre, bool, objet, tableau, fonction, nul et tous les autres types pris en charge par le système

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()exemple d'utilisation de la fonction, pour déterminerundefinedà utilisertypeof(xx) === "undefined", parce quenull == undefinedest valide en JavaScript.

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

On appelle lewait()la méthode sur un objet simultané qui a été libéré signalera une erreur:

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

Accès simultané à plusieurs tickers de change:

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

Les appels concomitantsexchange.IO("api", ...)fonction:

Cette fonction crée uniquement des tâches d'exécution multi-threaded lors de l'exécution dans le commerce réel, le backtesting ne prend pas en charge l'exécution simultanée de tâches multi-threaded (le backtesting est disponible, mais toujours exécuté séquentiellement). Après leexchange.Go()fonction renvoie un objet, sonwait()fonction est appelée à travers cet objet pour obtenir les données renvoyées par le fil.wait()La fonction doit être appelée pour obtenir les données avant que le fil ne soit libéré automatiquement.wait()Le résultat du thread doit être obtenu avant qu'il ne soit libéré automatiquement (indépendamment du succès ou de l'échec de l'appel d'interface pour l'accès simultané).wait()fonction indépendamment du succès ou de l'échec de l'exécution, et la ressource du fil demandée par leexchange.Go()La fonction doit être libérée automatiquement par le docker. Lewait()la méthode prend en charge un paramètre de temps d'arrêt: Sans paramètre de temps d'arrêt, c'est à dire,wait(), ou avec un paramètre de temps d'arrêt de 0, c'est-à-direwait(0)Lewait()blocs de fonction et attend que le thread concurrent ait terminé d'exécuter, renvoyant le résultat de l'exécution du thread concurrent. Mettre le paramètre de temps d'arrêt -1, c'est à direwait(-1)Lewait()la fonction renvoie immédiatement, avec des valeurs de retour différentes pour différents langages de programmation, voir cette sous-section pour un exemple d'appel. Définir le paramètre de temps d'arrêt spécifique,wait(300), et lewait()La fonction attend au maximum 300 millisecondes avant de revenir.

Si le résultat de retour de la finalewait()si la fonction n'est pas obtenue, les ressources de thread ne seront pas libérées automatiquement, ce qui entraînera l'accumulation des threads demandés, et plus de 2000 signalera une erreur:"too many routine wait, max is 2000"- Je ne sais pas. Fonctions prises en charge:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Toutes ces fonctions sont exécutées sur la base de l'objet d'échange {@var/EXCHANGE exchange} en cours lorsqu'il est appelé simultanément. La différence entre le langage Python et le langage JavaScript est que lewait()fonction d'objets concurrents dans le langage Python renvoie deux paramètres. Le premier paramètre est le résultat renvoyé par un appel API asynchrone, et le deuxième paramètre indique si l'appel asynchrone est terminé.


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)

Je ne sais pas si je peux vous aider, mais je vais vous aider.

Le marché Compte

2019 FMZ - Tous les droits réservés