文法ガイド

資源の読み込みに... 荷物...

貿易

exchange.Buy

についてexchange.Buy()購入オーダーを出すために使用されます.Buy()交換オブジェクト {@var/EXCHANGE exchange} のメンバー関数である.Buy()交換対象に結合した交換口座で動作します.exchangeメンバーの機能 (方法) の目的exchange対象は,単に関連しているexchange文書化後には繰り返されないでしょう

成功したオーダーはオーダー Id を返します.失敗したオーダーは null 値を返します. 属性IdFMZプラットフォームのオーダー {@struct/Order Order} 構造は,英語の逗子で分離された交換製品コードと交換元の注文IDで構成されています.Idスポット取引対の形式ETH_USDTOKX取引所の順序は次のとおりです.ETH-USDT,1547130415509278720- わかった呼び出すときexchange.Buy()注文を出す機能,返品値の注文Id基準に合致していますIdオーダー {@struct/Order Order} 構造の属性

文字列,ゼロ値

交換.購入 (価格,金額) 交換する.購入する (価格,金額,... args)

についてpriceパラメータは注文価格を設定するために使用されます. 価格本当番号についてamountパラメータは注文金額を設定するために使用されます. 額本当番号この注文日記に付随情報を出力できる拡張パラメータargパラメータは"つ以上渡すことができますアルグ偽り文字列,数,ボール,オブジェクト,配列,null,およびシステムでサポートされる他の種類

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

返した順序番号exchange.Buy()注文情報への問い合わせや注文のキャンセルに使用できます

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

暗号通貨の先物契約のオーダーを出すとき,取引方向が正しく設定されていることを注意する必要があります.取引方向と取引機能の不一致はエラーを引き起こすため:

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

スポットマーケットオーダー

フューチャー契約の注文をすると,取引方向と取引機能が一致しない場合はエラーが報告されるため,取引方向が正しく設定されているかどうか注意する必要があります.仮想通貨フューチャー契約の注文サイズは,指定されていない場合の契約数です. パラメーターprice設定されています.-1取引所のオーダー配置インターフェースが市場オーダーをサポートすることを要求する.仮想通貨のスポット契約の市場オーダーを配置する際に,パラメータは,amount取引先は,取引先の取引先の取引先の取引先の取引先の取引先です.amount取引数です. ライブ取引中にマーケットオーダーインターフェースをサポートしない数少ない仮想通貨取引所があります. いくつかのスポット取引所で市場購入注文の注文量は取引コインの数です.交換に関する特別指示詳細についてはユーザーガイドを参照してください. 命令の返却値が,この命令の返却値が,Idについてexchange.Buy()命令の返却値とは異なる可能性があります.Idこのドキュメントで説明されています

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

exchange.Sell

についてexchange.Sell()販売注文を出すために使われます.

順序 Id を返します.失敗した順序は null 値を返します.IdFMZプラットフォームのオーダー {@struct/Order Order} 構造は,英語の逗子で分離された交換製品コードと交換元の注文IDで構成されています.Idスポット取引対の形式ETH_USDTOKX取引所の順序は次のとおりです.ETH-USDT,1547130415509278720. 呼び出すときexchange.Sell()注文を出す機能,返品値の注文Id基準に合致していますIdオーダー {@struct/Order Order} 構造の属性文字列,ゼロ値

交換.販売 (価格,金額) 交換.販売 (価格,金額,... args)

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

返した順序番号exchange.Sell()注文情報をクエリしたり注文をキャンセルしたりできます

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

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

スポットマーケットオーダー

フューチャー契約の注文をすると,取引方向と取引機能が一致しない場合はエラーが報告されるため,取引方向が正しく設定されているか注意する必要があります.仮想通貨フューチャー契約の注文金額は,指定されていない場合の契約数です. パラメーターprice設定されています.-1取引所のオーダー配置インターフェイスが市場オーダーをサポートすることを要求する.仮想通貨のスポット契約の市場オーダーを配置する際に,金額パラメータは,amount取引通貨の金額です. 仮想通貨先物契約の市場オーダーを出すとき,金額パラメータamount契約数です. ライブ取引中にマーケットオーダーインターフェースをサポートしない数少ない仮想通貨取引所があります. 命令の返却値が,この命令の返却値が,Idについてexchange.Sell()命令の返却値とは異なる可能性があります.Idこのドキュメントで説明されています

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

exchange.CreateOrder

についてexchange.CreateOrder()この関数は,注文をするのに使用されます.

順序が成功した場合,順序 ID が返されます.順序が失敗した場合, null 値が返されます.IdFMZプラットフォームのオーダー {@struct/Order Order} 構造は,英語の逗子で分離された交換製品コードと交換元の注文IDで構成されています.Idスポット取引対のオーダーの形式ETH_USDTOKXの取引所は:ETH-USDT,1547130415509278720. 呼び出すときexchange.CreateOrder(symbol, side, price, amount)オーダーを表示する機能,オーダーの返却値Id基準に合致していますIdオーダー {@struct/Order Order} 構造の属性文字列,ゼロ値

exchange.CreateOrder ((シンボル,サイド,価格,金額) exchange.CreateOrder ((シンボル,サイド,価格,金額,... args)

パラメータsymbol注文の特定の取引ペアと契約コードを指定するために使用されます.exchange.CreateOrder(symbol, side, price, amount)オーダーを出す機能exchange注文の通貨がUSDTで取引通貨がBTCである場合,パラメータはsymbolこれは:"BTC_USDT"FMZ プラットフォームで定義された取引対の形式でexchange.CreateOrder(symbol, side, price, amount)オーダーを出す機能exchange取引対象である.もし注文が BTCのU標準の永続契約注文である場合,パラメータはsymbolこれは:"BTC_USDT.swap"形式は,トレーディングペアそして契約コードFMZ プラットフォームによって定義され,文字で区切られています.exchange.CreateOrder(symbol, side, price, amount)オーダーを出す機能exchange取引対象である.もしその注文が BTCのU標準オプション契約の注文である場合,パラメータはsymbolこれは:"BTC_USDT.BTC-240108-40000-C"(Binance Option BTC-240108-40000-C を例として) 形式はトレーディングペアFMZプラットフォームで定義され,取引所によって定義された特定のオプション契約コードは,文字.で分離されます. シンボル本当文字列についてsideこのパラメータは,注文の取引方向を指定するために使用されます. スポット交換対象の場合,オプション値はsideパラメータは:buy, sell. buy購入を意味しますsell売るという意味ですフューチャー取引対象については,sideパラメータは:buy, closebuy, sell, closesell. buy長いポジションを開くことを意味します.closebuy長いポジションを閉じるという意味ですsellショートポジションを開くことを意味します.closesellショートポジションを閉じる

側本当文字列パラメーターpriceオーダーの価格を設定するために使用されます. -1 の価格は,オーダーが市場オーダーであることを示します. 価格本当番号パラメーターamount注文量設定に使用されます. 注文が市場購入オーダーである場合,注文量は購入金額であり,一部のスポット取引所の市場購入オーダーの注文量は取引コインの数であることに注意してください.詳細については,交換に関する特別指示ユーザーガイド額本当番号拡張パラメータは,この注文ログに追加の情報を出力することができます.argパラメーターは渡すことができますアルグ偽り文字列,数,ボール,オブジェクト,配列,ゼロ値など,システムでサポートされる任意のタイプ

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

スポット取引物と先物取引物とはexchange.CreateOrder()注文する機能です

{@fun/Trade/exchange.buy exchange.buy} {@fun/Trade/exchange.sell exchange.sell} {@fun/Trade/exchange.exchange.buy} {@fun/Trade/exchange.sell exchange.sell} {@fun/Trade/exchange.sell} {@fun/Trade/exchange.exchange.buy} {@fun/Trade/exchange.exchange.sell} {@fun/Trade/exchange.sell} {@fun/Trade/exchange.exchange.sell} {@fun/Trade/exchange.sell.sell} {@fun/Trade/exchange.sell} {@fun/Trade/exchange.sell} {@fun/Trade/exchange.sell.sell}

exchange.CancelOrder

についてexchange.CancelOrder()命令をキャンセルするために使用されます. 属性IdFMZプラットフォームのオーダー {@struct/Order Order} 構造は,英語の逗子で分離された交換製品コードと交換元の注文IDで構成されています.Idスポット取引対のオーダーの形式ETH_USDTOKXの取引所は:ETH-USDT,1547130415509278720- わかったパラメーターorderId呼び出すときに通過したexchange.CancelOrder()命令をキャンセルする機能は,Idオーダー {@struct/Order Order} 構造の属性

についてexchange.CancelOrder()例えば,この関数は,真値を返します.trueキャンセル注文要求が成功して送信されたことを意味します.false, はキャンセルオーダー要求が送信されなかったことを意味します.返した値は,交換が注文をキャンセルするかどうかを決定するために送信された要求の成功または失敗を表します.exchange.GetOrders()命令がキャンセルされたかどうかを判断するためにボール

交換.注文をキャンセル (注文Id) 交換.注文をキャンセル (注文Id,... args)

についてorderIdこのパラメータは,キャンセルされるオーダーを指定するために使用されます. 命令された本当番号,文字列この退会日記に添付された情報を出力できますargパラメータは"つ以上渡すことができますアルグ偽り文字列,数,ボール,オブジェクト,配列,null,およびシステムでサポートされる他の種類

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

注文をキャンセル

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 機能は,次のようなログ出力機能を生成することができる.Log(), exchange.Buy(), exchange.CancelOrder()必要なパラメータの後にいくつかの付随の出力パラメータが続きます.例えば:exchange.CancelOrder(orders[i].Id, orders[i])注文をキャンセルするときにIDがorders[i].Id命令の情報が出力されます.つまり, {@struct/Order Order} の構造orders[i].

古いバージョンのドッカーを使用している場合は,Exchange.CancelOrder (※) 関数の orderId パラメータは,現在のドキュメントで説明されているorderId と異なる可能性があります.

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

exchange.GetOrder

についてexchange.GetOrder()オーダー情報を取得するために使用されます.

順序番号に従って順序の詳細をクエリし,クエリが成功した場合 {@struct/Order Order} 構造を返します. {@struct/Order Order},ゼロ値

交換.GetOrder (注文番号)

についてorderIdパラメータは,クエリする順序を指定するために使用されます. 属性IdFMZプラットフォームのオーダー {@struct/Order Order} 構造は,英語の逗子で分離された交換製品コードと交換元の注文IDで構成されています.Idスポット取引対のオーダーの形式ETH_USDTOKXの取引所は:ETH-USDT,1547130415509278720- わかったパラメーターorderId呼び出すときに通過したexchange.GetOrder()順序をクエリする機能は,Idオーダー {@struct/Order Order} 構造の属性

命令された本当文字列

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

についてexchange.GetOrder()機能は,いくつかの交換によってサポートされていません.AvgPrice{@struct/Order Order} 構造の帰還値の属性は,取引の平均価格である.一部の取引所はこのフィールドをサポートしていないが,そうでない場合は0に設定されている. 古いバージョンを使用している場合は,orderIdパラメータexchange.GetOrder()機能はorderId現在のドキュメントに記載されています. 支援しない取引所exchange.GetOrder()機能:

機能名	サポートされていないスポット交換	サポートされていない先物取引
GetOrder を取得する	ザイフ / コインチェック / ビットスタンプ	–

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

exchange.GetOrders

についてexchange.GetOrders()欠点オーダーを得るのに使われます

についてexchange.GetOrders()この関数は,データ要求が成功した場合に {@struct/Order Order} 構造の配列を返し,データ要求が失敗した場合に null 値を返します. {@struct/Order Order}配列,ゼロ値

交換する.GetOrders (GetOrders) 交換.GetOrders (GetOrders) を表示する

パラメータsymbol設定するために使用されます.トランザクションシンボルまたはトランザクションシンボルの範囲尋問されるスポット交換対象の場合,symbolパラメータが渡されない場合,すべてのスポット製品の未完了注文データは要求されます. フューチャー取引対象の場合,symbolパラメータが渡されない場合,デフォルトでは,現在の取引ペアと契約コードの次元範囲内のすべての種類の未完了オーダーデータを要求します.

シンボル偽り文字列

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

スポット交換オブジェクトを使用して,現在の価格の半分で複数の異なる取引ペアの購入オーダーを置き,その後に未払いオーダー情報をクエリします.

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

フューチャー交換オブジェクトを使用して,複数の異なる取引ペアと契約コードの注文をします. 対価価格から遠く離れた価格で注文を入れ,未履行状態で注文を保持し,複数の方法で注文をクエリします.

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

呼び出すときexchange.GetOrders()機能,パスSymbol特定の取引ペアと契約コードのオーダーデータを要求するパラメータ

についてGetOrdersfunction,シンボルのパラメータの使用シナリオは,以下のように要約されます.

エクスチェンジオブジェクト分類	パラメータ	クエリの範囲	コメント
スポット	シンボルのパラメータを通さない	すべてのスポット取引ペアをクエリ	すべての呼び出しシナリオでは,交換インターフェイスがサポートしていない場合は,エラーが報告され,ゼロ値が返されます.さらなる説明はされません.
スポット	取引の種類を指定します. シンボルのパラメータは: BTC_USDT	指定された BTC_USDT 取引ペアをクエリする	スポット取引対象のシンボルのパラメータ形式は: BTC_USDT
フューチャー	シンボルのパラメータを通さない	現在の取引ペアと契約コードの次元範囲内のすべての取引製品を検索する.	現在の取引ペアが BTC_USDT で,契約コードがスワップである場合,USDTのマージング付き永続契約はすべてクエリされます.これは,呼び出しに相当します`GetOrders("USDT.swap")`
フューチャー	取引の種類を指定し,シンボルのパラメータは: BTC_USDT.swap	指定されたBTCのUSDTベースの永続契約をクエリする	フューチャー取引対象のパラメータシンボルの形式は:トレーディングペアそして契約コードFMZプラットフォームで定義され,文字で区切られています.`".`.
フューチャー	取引商品の範囲を指定します. シンボルのパラメータは: USDT.swap	すべてのUSDTベースの永続契約をクエリ	-
オプションをサポートする先物取引	シンボルのパラメータを通さない	現在の取引ペアサイズ範囲内のすべてのオプション契約をクエリする	現在の取引ペアが BTC_USDTである場合,契約はオプション契約に設定されます.例えば,Binanceオプション契約: BTC-240108-40000-C
オプションをサポートする先物取引	特定の取引製品を指定する	指定されたオプション契約をクエリ	たとえば,Binance 期貨取引所では,シンボルのパラメータは: BTC_USDT.BTC-240108-40000-C
オプションをサポートする先物取引	取引商品の範囲を指定します,シンボルのパラメータは: USDT.option	すべてのUSDTベースのオプション契約をクエリ	-

についてGetOrdersフューチャー交換オブジェクトのクエリサイズ範囲は以下のように要約される:

パラメータ	要求範囲の定義	コメント
USDT.swap	USDTベースの永続契約範囲	について

交換 API インターフェースでサポートされていない次元エラーが報告され, null 値が返されます. 呼び出しています送料契約の範囲です送料契約の範囲です USD.swap. 通貨ベースの永続的な契約です USD.futures. 貨幣による配送の範囲契約です USDTのオプションです USDTベースのオプション契約の範囲です通貨ベースのオプション契約の範囲です USDT.futures_combo CFDの組み合わせの範囲 FUTURES_DERIBIT 取引所 USD.futures_ff ミックスド・マーージン・デリバリー・コントラクトフューチャーズ_クラッケン取引所 USD.swap_pf 混合型永続契約の範囲です未来_クラケン取引所

取引対象となる口座がexchange待機中の注文はありません問い合わせ範囲または特定取引手段この関数を呼び出すと空の配列が返されます.[]- わかった以下の交換では,当面未完了の注文をクエリする際に,インストラムがインストゥルメントパラメータに送信することを要求する.これらの交換でGetOrders関数を呼び出すとき,インストゥルメントパラメータが送信されない場合は,すべてのインストゥルメントの未完了の注文ではなく,当面のインストゥルメントの未完了の注文のみが要求される (交換インターフェイスがこれをサポートしていないため). Zaif,MEXC,LBank,Korbit,Coinw,BitMart,Bithumb,BitFlyer,ビッグONE について

支援しない取引所exchange.GetOrders()機能:

機能名	サポートされていないスポット交換	サポートされていない先物取引
GetOrders を取得する	–	フューチャーズ_ビボックス

{@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}, {@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders}, {@fun/Trade/exchange}, {@struct/Trade/Exchange}, {@struct/Trade/Exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrder}, {@fun/Trade/Exchange.GetHistoryOrders}, {@

exchange.GetHistoryOrders

についてexchange.GetHistoryOrders()この関数は,現在の取引ペア,契約の過去のオーダーを取得するために使用されます.

についてexchange.GetHistoryOrders()この関数は,データ要求が成功した場合に {@struct/Order Order} 構造の配列を返し,要求が失敗した場合に null を返します. {@struct/Order Order}配列,ゼロ値

交換.GetHistoryOrders (取得履歴) exchange.GetHistoryOrders (シンボル) をクリックする exchange.GetHistoryOrders ((シンボル,から) exchange.GetHistoryOrders (シンボル,から,制限) 交換.GetHistoryOrders (過去からの) exchange.GetHistoryOrders (ここから制限)

についてsymbol取引の記号を指定するために使用されます.BTC_USDT取引相手は,例えば,exchangeスポット交換オブジェクトで,パラメータ形式はsymbolはBTC_USDT■ 期貨取引対象である場合,永久契約を例として,パラメータ形式symbolこれは:BTC_USDT.swap- わかったオプション契約の注文データをクエリする場合は,パラメータを設定しますsymbolに"BTC_USDT.BTC-240108-40000-C"(Binance Option BTC-240108-40000-C を例として)トレーディングペアFMZプラットフォームで定義され,取引所によって定義された特定のオプション契約コードは,文字.で分離されます. このパラメータが送信されない場合,現在設定されている取引ペアのオーダーデータと契約コードがデフォルトで要求されます.

シンボル偽り文字列についてsinceこのパラメータは,クエリの開始タイムスタンプをミリ秒で指定するために使用されます. それ以来偽り番号についてlimitこのパラメータは,クエリする注文の数を指定するために使用されます. 制限偽り番号

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, limitパラメータが指定されていない場合,デフォルトクエリは現在の取引ペア,契約の歴史的な注文です.現在の時間に近い特定の範囲内の歴史的な注文をクエリします.クエリ範囲は,交換インターフェイスの単一のクエリ範囲に依存します.
その時にsymbol設定された取引タイプの注文履歴をクエリします.
その時にsince設定されている場合,現在の時間方向で問い合わせsince開始時間としてタイムスタンプを
もしlimitパラメータが指定された場合,十分な数の入力後にクエリが返されます.
この機能は,履歴の注文クエリインターフェースを提供する取引所のみにサポートされています.

支援しない取引所exchange.GetHistoryOrders()機能:

機能名	サポートされていないスポット交換	サポートされていない先物取引
GetHistoryOrders を取得する	Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / ビッグONE	Futures_dYdX / Futures_Bibox / Futures_ApolloX について

{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@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.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrder exchange.GetOrder exchange.GetOrder exchange.GetOrders}, {@fun/

exchange.SetPrecision

exchange.SetPrecision()精度を設定するために使用されます.exchange交換対象価格そして注文金額設定後,システムは過剰なデータを自動的に無視します.

交換.セット精度 ((価格精度,金額精度)

についてpricePrecisionこのパラメータは,価格データの精度を制御するために使用されます. 価格精度本当番号についてamountPrecisionパラメータは,注文されるデータの量の精度を制御するために使用されます. 額精度本当番号

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

バックテストシステムはこの機能をサポートせず,バックテストシステムの数値精度は自動的に処理されます.

exchange.SetRate

交換対象の現在の為替レートを設定する.

交換.セットレート (レート)

についてrateこのパラメータは,変換為替レートを指定するために使用されます. 税率本当番号

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

通貨レートの値がexchange.SetRate()価格の情報,例えばティッカー,深さ,注文価格,など,現在の取引所によって代表される.exchange交換対象は,設定された為替レート7に掛けることで変換されます.例えば,exchange通貨として,アメリカドルと交換です.exchange.SetRate(7)市場でのすべての価格は,CNY7で掛けると

{@fun/Market/exchange.GetRate exchange.GetRate} 取引先は取引先の取引先の取引先の

exchange.IO

についてexchange.IO()交換オブジェクトに関連する他のインターフェース呼び出しに使用されます.

についてexchange.IO()機能は交換オブジェクトに関連する他のインターフェースに呼び出し,成功した呼び出しで要求された応答データを返します.失敗した呼び出しでは null を返します. 文字列,数, bool,オブジェクト,配列,null,およびシステムによってサポートされる他の種類

exchange.IO(k,... args)

についてkパラメータは,オプション値でコールタイプを設定するために使用されます."api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedそしてこれからも k 本当文字列拡張されたパラメータ,特定のコールシナリオに従って通過,arg複数のパラメータが通過できます.exchange.IO()パラメータの数と種類は,異なる機能に対応します. パラメータの数と種類は,exchange.IO()機能は不確定ですアルグ本当文字列,数, bool,オブジェクト,配列,null,その他のシステムでサポートされるタイプ

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

システムを使用exchange.IO("api", httpMethod, resource, params, raw)呼び出しのフォームexchange.IO()FMZプラットフォームに追加されていない機能を拡張することができます. 交換のAPIインターフェースを理解し,関連するドキュメントを最初に確認する必要があります.POST対応するパラメータを記入する限り,FMZが既に下に処理しているパラメータを暗号化,署名,検証する心配する必要はありません.OKX 交換所パラメーターを使用します.raw順序パラメータを表示するには:

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

キー値がparamsパラメータ (つまり,Http リクエストパラメータ) は文字列で,パラメータ値を包むためにパラメータ値の周りに単一の引数で (つまり,符号 ') 書き込む必要があります.

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

ベースアドレスを切り替える操作を省略できる.exchange.SetBase()機能)

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

パラメータなしの呼び出しの例raw:

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

コードで設定された取引ペアを切り替えるように,現在の交換の取引ペアを切り替える直接取引の作成時にまたはバックテストで.

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

取引先のインターフェースと取引インターフェースの異なるベースアドレスを持つ取引所では,例えば,Bitfinex Futuresには2つのアドレスがあり,一つは ticker インターフェース,もう一つは取引インターフェースです.Bitfinex futuurs はプライベートインターフェースのベースアドレスを使用して切り替えます.exchange.SetBase("xxx")Bitfinexの先物取引は,公開インターフェースのベースアドレスをexchange.IO("mbase", "xxx").

I. 暗号通貨中心の取引所では,パラメータが均一にカプセル化されていない他のAPIインターフェース呼び出しkに設定"api":

exchange.IO("api", httpMethod, resource, params, raw)

httpメソッド: パラメータは文字列タイプで,リクエストタイプを入力しますPOST, GETなど
resource: このパラメータは文字列タイプで,要求経路を埋めます.完全な要求経路の使用をサポートします.詳細については参照例を参照してください.
params: パラメータは,要求パラメータで満たされた文字列タイプで,URL.
raw: このパラメータは raw の文字列パラメータであり,省略することもできます.

についてexchange.IO("api", httpMethod, resource, params, raw)呼び出しが失敗してエラーが発生した場合,関数呼び出しは交換インターフェースにアクセスし null を返します. 真の取引のみをサポートしますexchange.IO("api", httpMethod, resource, params, raw) function.

II. 取引対を切り替える場合,パラメータはk設定されています."currency":

exchange.IO("currency", currency)

通貨: パラメータは,単一の上文字形式の文字列タイプで,下文字で区切ります.baseCurrencyからquoteCurrency例えばBTC_USDT.
1. バックテストでは,同じ通貨の取引ペアに切り替えるのみに注意を払う必要があります. 例えば,現在の取引ペアは,ETH_BTC切り替えるだけですLTC_BTCしないLTC_USDT.
2. 仮想通貨先物契約の場合,取引対象は取引ペアを切り替えており,どの契約が取引されるかを決定するために,契約コードを再設定する必要があります.
3. {@fun/Account/exchange.SetCurrency exchange.SetCurrency}関数を使って取引ペアを切り替えるのは,exchange.IO("currency", currency)取引相手を切り替える

(III) 仮想通貨スポット取引所オブジェクトのレバレッジアカウントモードを切り替えるために使用する:

パラメータk設定されています."trade_margin"スポットレバレッジアカウントモードに切り替える.オーダーと口座資産の取得は,取引所のスポットレバレッジインターフェイスにアクセスします. 取引所が,即日レバレッジにおいて,完全なリマージと孤立したリマージを区別する場合,以下を用います.exchange.IO("trade_super_margin")利回り口座の全保安金に切り替える,およびexchange.IO("trade_margin")利回り口座の利回り分担に切り替える
パラメーターk設定されています."trade_normal"通常のスポット口座モードに戻る.

ローバー付き口座モデル間の切り替えをサポートするスポット取引所:

交換	特別注意事項
OKX	レバレッジアカウントモードの取引ペアは通常のものとは異なります.一部の取引ペアはそれらを持たない可能性があります.`exchange.IO("trade_super_margin")`レバレッジ付き口座の全ポジションに切り替えて使用する`exchange.IO("trade_margin")`位置から位置に切り替える.`trade_normal`通常のスポットモードに切り替える.`exchange.IO("tdMode", "cross")`直接レバレッジモードを指定する.
ハウビー	ハーバードアカウントモードの取引ペアは通常のペアとは異なります.一部の取引ペアはそうでない場合があります. Huobi ハーバードアカウントにはフルポジションとポジションごとに位置があります.`trade_margin`レバレッジ口座のポジションごとに切り替える`trade_super_margin`レバレッジアカウントの完全なポジションに切り替える.`trade_normal`通常の通貨対通貨モードに切り替える
バイナンス	レバレッジされた口座モードは,ポジションごとにポジションとフルポジションに分けられる.`trade_margin`位置から位置に切り替え,使用`trade_super_margin`フルポジションに切り替えるには,`trade_normal`通常の通貨対通貨モードに切り替える
ゲート	レバレッジされた口座モードは,ポジションごとにポジションとフルポジションに分けられる.`trade_margin`位置から位置に切り替え,使用`trade_super_margin`フルポジションに切り替えるには,`trade_normal`通常の通貨対通貨モードに切り替える
アセンデックス	使用`exchange.IO("trade_margin")`レバレッジアカウントモードに切り替える`exchange.IO("trade_normal")`普通のアカウントモードに戻る
ワオ	使用`exchange.IO("trade_margin")`レバレッジアカウントモードに切り替える`exchange.IO("trade_normal")`普通のアカウントモードに戻る
コインエックス	使用`exchange.IO("trade_margin")`レバレッジ付き口座モードに切り替える`exchange.IO("trade_normal")`普通のアカウントモードに戻る

他のスイッチ機能:チェックしてくださいexchange.IO()の関数他のスイッチ機能ユーザーガイドで

{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@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

についてexchange.Log()この関数は,ログ列領域のオーダープレスメントと撤収のログを出力するために使用されます.呼び出されると,注文は行われず,トランザクションログだけが出力され記録されます.

取引日記 (注文の種類,価格,金額) 取引日記 (注文の種類,価格,金額,... args)

についてorderTypeパラメータは出力ログのタイプを設定するために使用され,オプション値は {@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}. 命令型本当番号についてpriceパラメータは出力ログに表示される価格を設定するために使用されます. 価格本当番号についてamountパラメータは,出力日記に表示される注文の量を設定するために使用されます. 額本当番号このログに付随情報を出力できる拡張パラメータargパラメータは"つ以上渡すことができますアルグ偽り文字列,数,ボール,オブジェクト,配列,null,およびシステムでサポートされる他の種類

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

使用するexchange.Log(orderType, price, amount)テスト,シミュレーションされた注文の配達,および注文の配達をログインするのに役立ちます.最も一般的なシナリオの1つは, {@fun/Trade/exchange.IOを使用することです.exchange.IO条件付きの注文を作成するための交換のインターフェースにアクセスする機能,しかし,exchange.IO()取引日誌の記録にトランザクションログ情報を出力しません.exchange.Log()オーダー発注の情報を記録するために出力日記を補完するために使用できますし,オーダー撤回も同様です

その時にorderTypeパラメータはLOG_TYPE_CANCELについてpriceパラメータは,引き出されたオーダーの順序 Id で,直接注文を引き出すときに引き出すログを印刷するために使用されます.exchange.IO()機能exchange.Log()function は,グローバル関数 {@fun/Log Log} と区別される {@var/EXCHANGE exchange} 交換オブジェクトのメンバー関数です.

{@fun/Log Log}, {@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}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}, ローグ・タイプは, ローグ・タイプは, ローグ・タイプが, ログ・タイプが, ログ・タイプが, ログ・タイプが, ログ・タイプが

exchange.Encode

についてexchange.Encode()この関数は署名暗号化計算に使用されます.

についてexchange.Encode()計算したハッシュ値のエンコーディングを返します. 文字列

exchange.Encode ((algo, input 形式, output 形式,データ) exchange.Encode ((algo, input形式, output形式,データ,キー形式,キー)

パラメータalgoは,暗号化計算に使用されるアルゴリズムである. サポートされている設定は: raw (アルゴリズムが使用されていない), 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, blake2b.512, s.128s, blake2256 パラメーター.algoまた,文字列のエンコーディングと解読のために, text.encoder.utf8, text.decoder.utf8, text.encoder.gbk, text.decoder.gbk をサポートしています. パラメータalgoまた: ed25519 アルゴリズムもサポートしています. 異なるハッシュアルゴリズムの使用もサポートしています.algoed25519.md5,ed25519.sha512などと書けるサポートed25519.seed計算するアルゴ本当文字列データの形式を指定するために使用されます.dataパラメータinputFormatパラメータは,次のいずれかに設定できます: raw, hex, base64, string. rawはデータが原始データ, hexはデータがhexbase64 は,データがbase64文字列が文字列であることを意味します. input 形式本当文字列出力データ形式を指定するために使用されます.outputFormatパラメータは以下の設定をサポートします: raw, hex, base64, string. rawはデータが原始データ, hexはデータがhexbase64 は,データがbase64文字列が文字列であることを意味します. output 形式本当文字列パラメーターdata処理されるデータですデータ本当文字列データの形式を指定するために使用されます.keyパラメータkeyパラメータは,次のいずれかに設定できます: raw, hex, base64, string. rawはデータが原始データ, hexはデータがhexbase64 は,データがbase64文字列が文字列であることを意味します. キー形式偽り文字列についてkeyパラメータは署名計算に使用されたキーを指定するために使用され, 文字列として使用できます."{{accesskey}}", "{{secretkey}}"参照するaccessKeyそしてsecretKey{@var/EXCHANGE exchange} exchange オブジェクトで設定されている. キー偽り文字列

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

BitMEX の位置変更プッシュ (wss プロトコル) の例:

真の取引のみをサポートしますexchange.Encode()機能"{{accesskey}}", "{{secretkey}}"参照は,exchange.Encode()機能が使われています.

{@var/EXCHANGE exchange}, {@fun/Global/Encode エンコード}

exchange.Go

多スレッドアシンクロンサポート機能は,すべてのサポートされた機能の操作をアシンクロン同時実行に変えることができます.

についてexchange.Go()この関数で,同じオブジェクトをすぐに返します.wait()同期リクエストの結果を取得するために,同期オブジェクトの方法. オブジェクト

交換.Go (方法) 交換.Go (方法,... args)

についてmethodパラメーターは,関数の名前文字列であり,関数の参照ではないことに注意してください. 方法本当文字列パラメータ同時に機能を実行する複数のパラメータがある可能性があります.argパラメータの種類と番号arg測定する同期実行機能- わかったアルグ偽り文字列,数, bool,オブジェクト,配列,関数,null,およびシステムでサポートされる他のすべてのタイプ

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()function の使用例を決定するundefined使うtypeof(xx) === "undefined"なぜならnull == undefinedJavaScriptで有効です

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

呼び出すwait()このメソッドは,リリースされた同時オブジェクトでエラーを報告します.

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

複数の交換チケットへの同時アクセス:

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

同期募集についてexchange.IO("api", ...)機能:

この機能は,実際の取引で実行する際に多スレッド実行タスクのみを作成し,バックテストは多スレッド同時実行タスクをサポートしません (バックテストは利用可能ですが,それでも順番で実行されます). その後にexchange.Go()この関数は,そのオブジェクトを返しますwait()このスレッドで返されるデータを得るため,そのオブジェクトを通して呼び出されます.wait()スレッドが自動的にリリースされる前にデータを取得するために呼び出す必要があります.wait()インタフェースの機能が指定されている場合,タイムアウトが発生してもスレッドは自動的にリリースされません.スレッドが自動的にリリースされる前にスレッドの結果が取得されなければならない (同時アクセスのためのインターフェースコールが成功するか失敗するかに関わらず). シンプルな言葉で,要求されたスレッドは,スレッドが自動的にリリースされる前に取得する必要があります.wait()実行が成功するか失敗するかに関わらず, 要求されたスレッドのリソースexchange.Go()自動で解き放たれる必要があります. についてwait()このメソッドはタイムアウトパラメータをサポートします. タイムアウトパラメータがないとwait(),またはタイムアウトパラメータが0である,すなわち,wait(0).....wait()機能ブロックで,並行スレッドが実行を終了するまで待機し,並行スレッドの実行結果を返します. タイムアウトパラメータを -1 に設定します.wait(-1).....wait()異なるプログラミング言語の異なる返却値で,このサブセクションを例の呼び出しのために参照してください. 特定のタイムアウトパラメータを設定しますwait(300)そして,wait()戻る前に最大300ミリ秒待ちます

試験結果が返される場合wait()要求されたスレッドが蓄積し,2000以上のスレッドがエラーを報告します."too many routine wait, max is 2000"- わかったサポートされている機能:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IOこれらの機能はすべて,同時に呼び出すときに現在の {@var/EXCHANGE exchange} 交換オブジェクトに基づいて実行されます. PythonとJavaScriptの違いはwait()Python言語の同時オブジェクトの関数は2つのパラメータを返します.最初のパラメータは,非同期 API コールによって返される結果で,第2パラメータは,非同期コールが完了しているかを示します.


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)

{@fun/Global/Mail_Go Mail_Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}, {@fun/Global/EventLoop イベントループ}

市場口座

2019 FMZ - すべての権利は保護されています.