Syntaxführer

Die Ressourcen sind geladen. Beförderung...

Futures

exchange.GetPositions

Dieexchange.GetPositions()Die Funktion wird verwendet, um die Positionsinformationen zu erhalten.GetPositions()Die Funktion ist eine Mitgliederfunktion des Austauschobjekts {@var/EXCHANGE exchange}.GetPositions()Funktion erhält die Positionsinformationen des mit dem Austauschobjekt verbundenen Austauschkontosexchange. Zweck der Funktionen der Mitglieder (Methoden) derexchangeObjekt ist nur mitexchangeund wird sich hier nicht wiederholen.

Dieexchange.GetPositions()Funktion gibt ein Array von {@struct/Position Position}-Strukturen zurück, wenn die Datenanfrage erfolgreich ist, und nullwert, wenn die Datenanfrage fehlschlägt. {@struct/Position Position} Arrays, Nullwerte

Erhalten Sie Positionen. Wechsel.GetPositions (Symbol)

Der Parametersymbolwird verwendet, um dieHandelszeichenoderHandelssymbolbereichSie werden befragt. Wenn diesymbolWenn der Parameter nicht übergeben wird, werden standardmäßig die Positionsdaten aller Symbole im Dimensionsbereich des aktuellen Handelspaares und des Vertragscodes angefordert.

Symbol falsche String

/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"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) {
        exchange.CreateOrder(symbol, "buy", -1, 1)
        exchange.CreateOrder(symbol, "sell", -1, 1)
    }

    var defaultPositions = exchange.GetPositions()
    var swapPositions = exchange.GetPositions("USDT.swap")
    var futuresPositions = exchange.GetPositions("USDT.futures")
    var btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")

    var tbls = []
    var arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
    var tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
    for (var index in arr) {
        var positions = arr[index]
        var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], rows: [] }
        for (var pos of positions) {
            tbl.rows.push([pos.Symbol, pos.MarginLevel, pos.Amount, pos.FrozenAmount, pos.Price, pos.Profit, pos.Type, pos.ContractType, pos.Margin])
        }
        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:
        exchange.CreateOrder(symbol, "buy", -1, 1)
        exchange.CreateOrder(symbol, "sell", -1, 1)

    defaultPositions = exchange.GetPositions()
    swapPositions = exchange.GetPositions("USDT.swap")
    futuresPositions = exchange.GetPositions("USDT.futures")
    btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap")

    tbls = []
    arr = [defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions]
    tblDesc = ["defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"]
    for index in range(len(arr)):
        positions = arr[index]
        tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"], "rows": []}
        for pos in positions:
            tbl["rows"].append([pos["Symbol"], pos["MarginLevel"], pos["Amount"], pos["FrozenAmount"], pos["Price"], pos["Profit"], pos["Type"], pos["ContractType"], pos["Margin"]])

        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) {
        exchange.CreateOrder(symbol, "buy", -1, 1);
        exchange.CreateOrder(symbol, "sell", -1, 1);
    }
    
    auto defaultPositions = exchange.GetPositions();
    auto swapPositions = exchange.GetPositions("USDT.swap");
    auto futuresPositions = exchange.GetPositions("USDT.futures");
    auto btcUsdtSwapPositions = exchange.GetPositions("BTC_USDT.swap");
    
    json tbls = R"([])"_json;
    std::vector<std::vector<Position>> arr = {defaultPositions, swapPositions, futuresPositions, btcUsdtSwapPositions};
    std::string tblDesc[] = {"defaultPositions", "swapPositions", "futuresPositions", "btcUsdtSwapPositions"};
    for (int index = 0; index < arr.size(); index++) {
        auto positions = arr[index];
        json tbl = R"({
            "type": "table", 
            "cols": ["Symbol", "MarginLevel", "Amount", "FrozenAmount", "Price", "Profit", "Type", "ContractType", "Margin"],
            "rows": []
        })"_json;
        tbl["title"] = tblDesc[index];
    
        for (const auto& pos : positions) {
            json arrJson = R"([])"_json;
    
            arrJson.push_back(pos.Symbol);
            arrJson.push_back(pos.MarginLevel);
            arrJson.push_back(pos.Amount);
            arrJson.push_back(pos.FrozenAmount);
            arrJson.push_back(pos.Price);
            arrJson.push_back(pos.Profit);
            arrJson.push_back(pos.Type);
            arrJson.push_back(pos.ContractType);
            arrJson.push_back(pos.Margin);
    
            tbl["rows"].push_back(arrJson);
        }
    
        tbls.push_back(tbl);
    }
    
    LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
    
    return; 
}

Verwenden Sie Futures-Börsenobjekte, um Marktaufträge für mehrere verschiedene Handelspare und Vertragscodes zu platzieren.

Kryptowährungs-Futures-Kontrakte unterscheiden sich von Kryptowährungs-Spot-Kontrakten, die nur das logische Konzept einer Position haben.Handelspaare, VertragskodeBitte beachten Sie die Funktionen {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}. In derGetPositionsFunktion, werden die Anwendungsszenarien des Symbolparameters wie folgt zusammengefasst:

Klassifizierung von Exchange-Objekten	Symbol Parameter	Umfang der Abfrage	Anmerkung
Futures	Symbolparameter nicht übergeben	Abfrage aller Handelsprodukte innerhalb des aktuellen Handelspaares und des Dimensionsabstands des Vertragscodes	Wenn das aktuelle Handelspaar BTC_USDT ist und der Vertragscode Swap ist, werden alle USDT-basierten Perpetual Contracts abgefragt.`GetPositions("USDT.swap")`
Futures	Angabe des Handelsprodukts, der Symbolparameter lautet: BTC_USDT.swap	Abfrage des USDT-basierten Dauerkontrakts eines bestimmten BTC	Für Futures-Börsenobjekte ist das Format des Parameter-Symbols:HandelspaarundVertragskodedurch die FMZ-Plattform definiert, getrennt durch die Zeichen`".`.
Futures	Angabe des Handelssortiments, der Symbolparameter lautet: USDT.swap	Abfrage aller USDT-basierten Daueraufträge	-
Futures-Börsen, die Optionen unterstützen	Symbolparameter nicht übergeben	Abfrage aller Optionskontrakte innerhalb des aktuellen Dimensionsbereichs des Handelspares	Wenn das aktuelle Handelspaar BTC_USDT ist, wird der Vertrag auf einen Optionsvertrag festgelegt, z. B. Binance-Optionvertrag: BTC-240108-40000-C
Futures-Börsen, die Optionen unterstützen	Spezifische Handelsprodukte angeben	Abfrage des angegebenen Optionskontrakts	Für die Binance Futures Exchange beispielsweise ist der Symbolparameter: BTC_USDT.BTC-240108-40000-C
Futures-Börsen, die Optionen unterstützen	Angabe des Handelssortiments, der Symbolparameter lautet: USDT.option	Abfrage aller USDT-basierten Optionskontrakte	-

In derGetPositionsFunktion, Objekt des Futures-Austauschs Der Abfrage-Dimensionsbereich wird wie folgt zusammengefasst:

Symbol Parameter	Definition des Antragsumfangs	Anmerkung
USDT.swap	USDT-basierte Dauervertragsspanne.	Für

Abmessungen, die von der Exchange-API-Schnittstelle nicht unterstützt werden, Ein Fehler wird gemeldet und ein Nullwert wird zurückgegeben, wenn Sie ruft.

♫ USDT.Futures ♫ ♫ USDT-basierte Liefervertragsspanne ♫ ♫ USDT-basierte Liefervertragsspanne ♫

USD.Swap. Umfang der währungsbasierten Verträge.

♫ USD.Futures ♫ ♫ Umfang der auf Währung basierenden Lieferung ♫ Verträge.

USDT.Option. USDT-basierte Optionskontrakt-Bereich.

USD.Option. Währungsbasierte Optionskontrakt-Range.

USDT.Futures_Combo. Eine Reihe von CFD-Kombinationen. Futures_Deribit-Börse

USD.Futures_ff. Umfang von Margin-Lieferverträgen. Die Futures_Kraken Exchange.

USD.Swap_pf. Gemischte Margin-Perpetual-Kontrakt-Bereich. Die Futures_Kraken Exchange.

Kompatibelexchange.GetPosition()Anrufen,GetPositionist genau das gleiche wieGetPositions.

Wenn das durch den Austauschgegenstand dargestellte Kontoexchangehat keine Positionen in derAbfragebereichoderbestimmte Handelsinstrumente, dieexchange.GetPositions()Funktion gibt ein leeres Array zurück, zum Beispiel:[].

{@struct/Position Position}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}

exchange.SetMarginLevel

Dieexchange.SetMarginLevel()Die Funktion wird verwendet, um den Hebelwert des von dersymbolKompatibel mit nur dem Übergeben des ParametersmarginLevelum den Hebelwert des aktuellen Handelspares oder des aktuellen Handelsvertrags des Austauschobjekts {@var/EXCHANGE exchange} festzulegen.

Die Angabe des MarginLevel (Symbol, MarginLevel) wird durch die Angabe des MarginLevel (MarginLevel) erfolgen. Wechselkurs.MarginLevel (MarginLevel) festlegen

DiesymbolDer Parameter wird verwendet, um das Handelspaar oder den Vertrag anzugeben, für den der Hebelwert angepasst werden muss.symbolParameter derSetMarginLevel()Die Funktion ist mit dem Format dersymbolParameter derGetTicker()Funktion. Symbol falsche String DiemarginLevelDer Parameter wird verwendet, um den Hebelwert festzulegen, der normalerweise eine ganze Zahl für Börsen ist, und unterstützt auch die Einstellung von Schwellenwertwerten für einige Börsen. MarginEbene - Das stimmt. Zahl

function main() {
    exchange.SetMarginLevel(10)
    // Set the leverage of BTC’s USDT-margined perpetual contract to 15
    exchange.SetMarginLevel("BTC_USDT.swap", 15)
}

def main():
    exchange.SetMarginLevel(10)
    exchange.SetMarginLevel("BTC_USDT.swap", 15)

void main() {
    exchange.SetMarginLevel(10);
    exchange.SetMarginLevel("BTC_USDT.swap", 15); 
}

Dieexchange.SetMarginLevel()Das Backtesting-System unterstützt die Anrufung der Kryptowährungs-Futures-Kontrakt-Austauschobjekte.exchange.SetMarginLevel()Funktion zur Festlegung des Hebelwerts. Für Kryptowährungs-Futures-Kontrakte ist der Hebelmechanismus aufgrund der Kryptowährungs-Futures-Kontraktbörsen nicht einheitlich.exchange.SetMarginLevel()Die Funktion erzeugt keine Netzwerkanfrage, sondern setzt lediglich die Hebelwirkung in das zugrunde liegende FMZ-System (verwendet zur Übermittlung von Parametern in der Auftragsplatzierungsoberfläche). Der Hebelwert von einigen Börsen-Futures-Kontrakten ist eine Einstellung der Börse, die auf der Webseite der Börse oder über die API-Oberfläche festgelegt werden muss.exchange.SetMarginLevel()Die Funktion wird eine Netzwerkanfrage generieren und kann den Hebel nicht setzen. Dafür können viele Gründe bestehen, zum Beispiel: Es gibt eine aktuelle Position oder eine ausstehende Order, die es unmöglich macht, einen neuen Hebelwert für dieses Handelspaar oder -kontrakt festzulegen. Die Ausgabe vonexchange.SetMarginLevel()Funktion:

Funktionsname	Nicht unterstützte Spotbörsen	Nicht abgesicherte Futures-Börsen
Margin-Level festlegen	–	Futures_dYdX / Futures_Deribit

{@var/EXCHANGE-Austausch}

exchange.SetDirection

Dieexchange.SetDirection()Diese Funktion wird verwendet, um die Auftragsrichtung der Funktion {@fun/Trade/exchange.Buy exchange.Buy}, der Funktion {@fun/Trade/exchange.Sell exchange.Sell} beim Auftragen von Futures-Kontrakten festzulegen.

Wechsel.SetDirection (Richtung)

DiedirectionDer Parameter wird verwendet, um die Richtung des Futures-Kontrakts bei der Auftragserteilung festzulegen."buy", "closesell", "sell", "closebuy"- Ich weiß. Richtung wahr String

function main(){
    // For example, set to OKX futures contract of this week
    exchange.SetContractType("this_week")    
    // Set leverage to 5 times
    exchange.SetMarginLevel(5)
    // Set the order type to long
    exchange.SetDirection("buy")
    // Place an order for 2 contracts at 10,000
    exchange.Buy(10000, 2)              
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(5)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)

void main() {
    exchange.SetContractType("this_week");
    exchange.SetMarginLevel(5);
    exchange.SetDirection("buy");
    exchange.Buy(10000, 2);
    exchange.SetMarginLevel(5);
    exchange.SetDirection("closebuy");
    exchange.Sell(1000, 2);
}

Dieexchange.SetDirection()Die Funktion stellt die Korrespondenz zwischen der Richtung des Futures-Kontraktgeschäfts und der Auftragsvergabefunktion fest:

Auftragsvergabefunktionen	Die von den Parametern der Funktion SetDirection festgelegte Richtung	Anmerkungen
exchange.Buy	kaufen	Kauf und Eröffnung von Long-Positionen
exchange.Buy	Schließverkäufe	Kauf und Schließung von Leerpositionen
exchange.Sell	verkaufen	Verkauf und Eröffnung von Leerpositionen
exchange.Sell	Kleiner Kauf	Verkauf und Schließung von Longpositionen

(Durchschnittliche Anzahl von Personen, die in einem Unternehmen tätig sind)

exchange.SetContractType

Dieexchange.SetContractType()Die Funktion wird verwendet, um den aktuellen Vertragscode des Exchange-Objekts {@var/EXCHANGE exchange} festzulegen.

Dieexchange.SetContractType()Funktion gibt eine Struktur zurück, die den gegenwärtigen Vertragskode entspricht.quarter, und die Rendite-Wertstruktur dieser Funktion ist:{"InstrumentID": "BTCUSD_230630", "instrument": "BTCUSD_230630"}- Ich weiß. Gegenstand

Die Angabe der Angabe der Angabe der Angabe der Angabe des Antrags

DiesymbolDer Parameter wird verwendet, um den Auftragscode festzulegen, die optionalen Werte sind:"this_week", "next_week", "quarter", "next_quarter", "swap", usw. Futures-Kontrakte für KryptowährungenLiefervertragdie Codes, sofern nicht spezifiziert, haben im Allgemeinen folgende Merkmale:

this_week: der Vertrag der laufenden Woche.
next_weekDer Vertrag für die nächste Woche.
quarter: vierteljährlicher Vertrag.
next_quarter: der nächste vierteljährliche Vertrag.DauerverträgeCodes in Kryptowährungs-Futures-Kontrakten, sofern nicht angegeben, haben in der Regel:
swap: Vertrag auf Dauer.

Symbol wahr String

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

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

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

Setzen Sie den aktuellen Vertrag als den aktuellen Wochenvertrag:

function main() {
    // The default trading pair is BTC_USD, set the contract for this week, and the contract is a currency standard contract
    exchange.SetContractType("this_week")
    Log("ticker:", exchange.GetTicker())
    
    // Switching trading pairs, then setting up contracts, switching to USDT as margin contracts, as opposed to currency standard contracts
    exchange.IO("currency", "BTC_USDT")   
    exchange.SetContractType("swap")
    Log("ticker:", exchange.GetTicker())
}

def main():
    exchange.SetContractType("this_week")
    Log("ticker:", exchange.GetTicker())
    exchange.IO("currency", "BTC_USDT")
    exchange.SetContractType("swap")
    Log("ticker:", exchange.GetTicker())

void main() {
    exchange.SetContractType("this_week");
    Log("ticker:", exchange.GetTicker());
    exchange.IO("currency", "BTC_USDT");
    exchange.SetContractType("swap");
    Log("ticker:", exchange.GetTicker());
}

Bei Vertragsabschluss mitUSDTals Margin müssen Sie das Handelspaar im Code wechseln (Sie können das Handelspaar auch direkt beim Hinzufügen des Tauschobjekts festlegen):

function main(){
    // Set the contract for this week
    var ret = exchange.SetContractType("this_week")     
    // Return information about the current week's contracts
    Log(ret)
}

def main():
    ret = exchange.SetContractType("this_week")
    Log(ret)

void main() {
    auto ret = exchange.SetContractType("this_week");
    Log(ret);
}

Drucken Sie den zurückgegebenen Wert derexchange.SetContractType()Funktion:

In der Kryptowährungs-Futures-Kontrakt-Strategie, nehmen Sie ein Beispiel der Umstellung auf dieBTC_USDTHandelspaar: Bei Wechseln von Handelspaaren unter Verwendung derexchange.SetCurrency("BTC_USDT")oderexchange.IO("currency", "BTC_USDT")Funktionen, nach dem Wechseln, müssen Sie dieexchange.SetContractType()Das System bestimmt, ob es sich um einenWährungsstandardvertragoder aUSDT-StandardvertragWenn ein Handelspaar beispielsweise aufBTC_USDT, verwendenexchange.SetContractType("swap")Funktion, um den Vertragskode aufswap. An dieser Stelle ist es aufBTCfür dieUSDT-StandardWenn das HandelspaarBTC_USD, verwendenexchange.SetContractType("swap")Funktion, um den Vertragskode aufswap. An dieser Stelle ist es aufBTCDas ist...Währungsstandard- Ein Vertrag auf Dauer. Einzelheiten der unterstützten Kryptowährungs-Futures-Kontraktbörsen mit den folgenden Vertragsnamen:

Futures_OKCoin (OKX) Auf dauerhafte Verträge:exchange.SetContractType("swap")Der Vertrag dieser Woche lautet:exchange.SetContractType("this_week")Auf den Vertrag für nächste Woche:exchange.SetContractType("next_week")Auf monatlichen Vertrag festgelegt:exchange.SetContractType("month")Auf den nächsten Monat:exchange.SetContractType("next_month")Auf vierteljährliche Verträge:exchange.SetContractType("quarter")Für das nächste Quartal:exchange.SetContractType("next_quarter")

OKX verfügt über Pre-Market-Handelskontrakte: Das Lieferdatum des Vertrags ist festgesetzt.HMSTR-USDT-250207. Das Handelspaar aufHMSTR_USDTauf der FMZ-Plattform und dannexchange.SetContractType("HMSTR-USDT-250207")um den Vertrag zu verfassen. Für Funktionen, die diesymbolParameter wie:exchange.GetTicker(), exchange.CreateOrder()Sie können diesymbolParameter wie:HMSTR_USDT.HMSTR-USDT-250207die Marktdaten dieses Auftrags zu erhalten oder einen Auftrag zu erteilen.
Futures_HuobiDM (Futures für Huobi) Der Vertrag dieser Woche lautet:exchange.SetContractType("this_week")- Ich weiß. Auf den Vertrag für nächste Woche:exchange.SetContractType("next_week")- Ich weiß. Auf vierteljährliche Verträge:exchange.SetContractType("quarter")- Ich weiß. Für das nächste Quartal:exchange.SetContractType("next_quarter")- Ich weiß. Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß. Es unterstützt Verträge mitUSDTals Marge, nehmenBTCVertrag als Beispiel:exchange.IO("currency", "BTC_USDT")Um zu einem Vertrag zu wechseln, derUSDTals Marge. Oder das aktuelle Handelspaar aufBTC_USDTNach dem Wechseln von Handelsparen müssen Sie die Anrufe vonexchange.SetContractType()Funktion wieder, um den Vertrag festzulegen.

Futures_BitMEX (BitMEX) Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß. Futures_BitMEX-Börsenlieferverträge sind monatliche Verträge mit folgenden Vertragscodes (von Januar bis Dezember):

"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"

Erstellung von Lieferverträgen:exchange.SetContractType("December"). Zum Beispiel, wenn das Handelspar aufXBT_USDT, dieexchange.SetContractType("December")Die Funktion wird aufgerufen, den Vertrag für die Lieferung im Dezember in USDT auf Basis von BTC festzulegen (entsprechend dem tatsächlichen Vertragskode vonXBTUSDTZ23).

Futures_BitMEX-Kontraktinformationszusammenfassung

Der von Futures_BitMEX definierte Vertragscode	Das entsprechende Handelspaar in FMZ	Entsprechender Vertragskode in FMZ	Anmerkung
Hunde	Der Wert des Zinses ist zu messen.	Swap	USD lautet, XBT abgewickelt.
Hundefleisch	Der Name des Herstellers	Swap	In USDT lautet, in USDT abgewickelt.
XBTETH	XBT_ETH	Swap	ETH lautet, XBT abgewickelt.
XBTEUR	XBT_EUR	Swap	In EUR lautet und in XBT abgewickelt.
USDTUSDC	USDT_USDC	Swap	USDC lautet, XBT abgewickelt.
ETHUSD_ETH	ETH_USD_ETH	Swap	USD lautet, ETH abgewickelt.
XBTH24	XBT_USD	März	Verfallsdatum: 24. März, Monatscode: H; in USD lautet, XBT abgewickelt.
ETHUSDZ23	ETH_USD	Dezember	Verfallsdatum: 23. Dezember Monatscode: Z; in USD lautet, XBT abgewickelt.
XBTUSDTZ23	XBT_USDT	Dezember	Ablaufdatum: 23. Dezember Monatscode: Z ; in USDT lautet, in USDT abgewickelt.
ADAZ23	ADA_XBT	Dezember	Ablaufdatum: 23. Dezember, Monatscode ist: Z ; Abrechnung in XBT, Abrechnung in XBT.
P_XBTETFX23	USDT_XXX	P_XBTETFX23	Verjährung: 23.11.23; ausgedrückt in Prozent und in USDT abgewickelt.

Futures_GateIO Der Vertrag dieser Woche lautet:exchange.SetContractType("this_week")- Ich weiß. Auf den Vertrag für nächste Woche:exchange.SetContractType("next_week")- Ich weiß. Auf vierteljährliche Verträge:exchange.SetContractType("quarter")- Ich weiß. Für das nächste Quartal:exchange.SetContractType("next_quarter")- Ich weiß. Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß. Es unterstützt Verträge mitUSDTals Marge, nehmenBTCVertrag als Beispiel:exchange.IO("currency", "BTC_USDT")Um zu einem Vertrag zu wechseln, derUSDTals Marge. Oder das aktuelle Handelspaar aufBTC_USDTNach dem Wechseln von Handelsparen müssen Sie die Anrufe vonexchange.SetContractType()Funktion wieder, um den Vertrag festzulegen.
Futures_Deribit Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß. Es unterstützt DeribitsUSDCVertrag. Die Lieferverträge sind:"this_week", "next_week", "month", "quarter", "next_quarter", "third_quarter", "fourth_quarter"- Ich weiß. Die Risikopositionen werden in der folgenden Tabelle aufgeführt:"this_week,swap", "next_week,swap", "next_quarter,this_week", "third_quarter,this_week", "month,next_week", gibt es viele Kombinationen. Für Optionsverträge müssen Sie den von der Börse definierten spezifischen Optionsvertragscode eingeben. Weitere Informationen finden Sie auf der Website von Deribit.
Futures_KuCoin Wenn beispielsweise das Handelspar aufBTC_USDund der Vertragscode festgelegt ist, handelt es sich um einen Währungsvertrag: Auf dauerhafte Verträge:exchange.SetContractType("swap")- Ich weiß. Auf vierteljährliche Verträge:exchange.SetContractType("quarter")- Ich weiß. Für das nächste Quartal:exchange.SetContractType("next_quarter").

USDT als Margin-Vertrag: Wenn beispielsweise das Handelspar aufBTC_USDTEs handelt sich um einen Vertrag mit USDT als Margin. Auf dauerhafte Verträge:exchange.SetContractType("swap").
Futures_Binance Binance Futures Exchange Standardbedingungen für den Dauervertrag des aktuellen Handelspares, Vertragskode:swap- Ich weiß. Auf dauerhafte Verträge:exchange.SetContractType("swap"), die dauerhaften Verträge von Binance haben Verträge, die verwendenUSDTZum Beispiel:USDTStandard-Perpetuum-Vertrag vonBTCkann als Margin-Kontrakt verwendet werden, und das Handelspaar ist aufBTC_USDTBinance unterstützt z.B. auch dauerhafte Verträge, bei denen Münzen als Marge verwendet werden.BTCBinance's Standard-Perpetual-Kontrakt, mit dem Handelspaar aufBTC_USD- Ich weiß. Auf vierteljährliche Verträge:exchange.SetContractType("quarter"), der Liefervertrag hat einen Währungsstandardvertrag (d. h. mit Währungen als Marge), z. B.BTCDer Quartalsvertrag des Handelspaares ist auf:BTC_USDund dann den Vertrag festlegenexchange.SetContractType("quarter"), ist aufBTCvierteljährlicher Vertrag mit einem Währungsstandardvertrag. Für das nächste Quartal:exchange.SetContractType("next_quarter"), zum Beispiel,BTCdes vierteljährlichen Währungsstandardkontrakts wird das Handelspaar auf:BTC_USD, und dann den Vertrag festlegenexchange.SetContractType("next_quarter")- Ich weiß. Binance unterstützt teilweiseUSDTals Margin-Liefervertrag, nehmenBTCzum Beispiel ein Handelspaar aufBTC_USDT, dann setzen Sie den Vertragskode.

Unterstützung für Binance-Optionskontrakte: Das Format des Optionsvertragscodes basiert auf dem von der Börse definierten Optionsvertragscode:BTC-241227-15000-C, XRP-240112-0.5-C, BTC-241227-15000-PNehmen Sie den Binance-Option-Kontraktcode.BTC-241227-15000-Pzum Beispiel: BTC ist die Optionswährungskode, 241227 ist das Ausübungsdatum, 15000 ist der Ausübungspreis, P eine Put-Option und C eine Call-Option. Für Einzelheiten über die Optionsart, ob es sich um eine europäische Option oder eine amerikanische Option handelt, lesen Sie bitte die einschlägigen Informationen des Optionsvertrags der Börse. Die Börse kann Optionsverkäufer einschränken und verlangen, dass sie sich separat für Qualifikationen bewerben.
Futures_Bibox Vertragskode für Bibox-Perpetualverträge:swap- Ich weiß. Auf dauerhafte Verträge:exchange.SetContractType("swap").
Futures_Bybit Der Standard ist der dauerhafte Vertrag für das aktuelle Handelspaar, Vertragskode:swap- Ich weiß. Der Vertragskode für diese Woche:this_week- Ich weiß. Der Vertragskode der nächsten Woche:next_week- Ich weiß. Vertragskode für die dritte Woche:third_week- Ich weiß. Monatlicher Vertragskode:month- Ich weiß. Vertragskode für den nächsten Monat:next_month- Ich weiß. Quartalsvertragskode:quarter- Ich weiß. Vertragskode für das nächste Quartal:next_quarter- Ich weiß. Vertragskode für das dritte Quartal:third_quarter.
Futures_Kraken Der Standard ist der Dauervertrag des aktuellen Handelspaares, Vertragskode:swap. swap: Vertrag auf Dauer.month: Vertrag für den laufenden Monat.quarter: vierteljährlicher Vertrag.next_quarterDer nächste Quartalsvertrag.swap_pf: Mixt Margin-Perpetual-Vertrag.quarter_ff: Vierteljährlicher Vertrag mit gemischter Marge.month_ff: Vertrag mit gemischter Marge für den laufenden Monat.next_quarter_ff: Gemischte Marge nächstes Quartal Vertrag.
Futures_Bitfinex Der Standardwert ist der für das aktuelle Handelspaar festgelegte Dauervertrag, Vertragskode:swap.
Futures_Bitget Der Standardwert ist der für das aktuelle Handelspaar festgelegte Dauervertrag, Vertragskode:swap- Ich weiß. Das Handelspaar ist aufBTC_USDfür Währungsstandardverträge und das Handelspar ist aufBTC_USDTfür Verträge, die vonUSDT. Demo-Kontrakte können mit Handelsparen wieSBTC_USD, BTC_SUSDT.
Futures_dYdX Vertragskode für dYdX-Perpetual Contracts:swap- Ich weiß. Auf dauerhafte Verträge:exchange.SetContractType("swap"), dYdX verfügt nur über USDT-Standardverträge.
Futures_MEXC Vertragskode für MEXC-Perpetuity-Verträge:swap- Ich weiß. Auf dauerhafte Verträge:exchange.SetContractType("swap"). Das Handelspaar aufBTC_USD, der ein Währungsstandardvertrag ist, und das Handelspaar aufBTC_USDT, wasUSDT- Vertrag vereinbart.
Futures_Crypto Token auf einem Konto auf dercrypto.comDer Wert der Margin kann in USD-Derivate umgerechnet werden, die als Margin für den Handel mit Verträgen verwendet werden. Auf dauerhaften Vertrag eingestellt:exchange.SetContractType("swap"). Beispiel für die Anrufung derexchange.SetContractType("swap")Funktion zur Festlegung eines Dauerkontrakts für BTC, wenn das Handelspaar aufBTC_USD- Ich weiß. Diecrypto.comWechsellieferverträge sind monatliche Verträge mit folgenden Vertragscodes (von Januar bis Dezember):
```
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
```
Festlegen des Liefervertrags:exchange.SetContractType("October"). Zum Beispiel, wenn das Handelspar aufBTC_USD, rufen Sie die Funktionexchange.SetContractType("October")Der Vertrag über die Lieferung von BTC im Oktober. Der entsprechende Auftragscode lautet derzeit:BTCUSD-231027.
Futures_WOO Futures_WOO-BörsenunterstützungUSDTdie in den Verträgen mit einem dauerhaften Vertragskodexswap. Zum Beispiel, wenn das Handelspar aufBTC_USDT, die Funktionexchange.SetContractType("swap")Der derzeitige Vertrag soll ein USDT-basierter Dauervertrag für BTC sein.

{@fun/Futures/exchange.GetContractType exchange.GetContractType}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}

exchange.GetContractType

Dieexchange.GetContractType()Die Funktion wird verwendet, um den Vertragskode für die aktuelle Einstellung des Exchange-Objekts {@var/EXCHANGE exchange} zu erhalten.

Dieexchange.GetContractType()Funktion gibt den vom FMZ-Plattform definierten Vertragskode zurück, z. B.:this_week, swap, usw. String

exchange.GetContractType (()

function main () {
    Log(exchange.SetContractType("this_week")) 
    Log(exchange.GetContractType())
}

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

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

{@fun/Futures/exchange.SetContractType exchange.SetContractType}

exchange.GetFundings

Dieexchange.GetFundings()Diese Funktion wird verwendet, um die Finanzierungsraten für den laufenden Zeitraum zu ermitteln.

Dieexchange.GetFundings()Funktion gibt ein Array von {@struct/Funding Funding} Strukturen zurück, wenn die Datenanfrage erfolgreich ist, und gibt einen Nullwert zurück, wenn die Datenanfrage fehlschlägt. {@struct/Funding Funding}-Array, Nullwert

Auswechselung.GetFundings Ausgleichszahlungen (Symbol)

Der Parametersymbolwird verwendet, um dieTransaktionssymboloderTransaktionssymbolbereichDie Kommission ist der Auffassung, daß diesymbolWenn der Parameter nicht übergeben wird, werden standardmäßig die aktuellen Finanzierungsquoten aller Instrumente im Dimensionsbereich des aktuellen Handelspaares und des Kontraktcodes angefordert.

Symbol falsche String

/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/

function main() {
    // LPT_USDT.swap 4-hour period
    var symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
    for (var symbol of symbols) {
        exchange.GetTicker(symbol)
    }
    
    var arr = []
    var arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
    for (p of arrParams) {
        if (p == "no param") {
            arr.push(exchange.GetFundings())
        } else {
            arr.push(exchange.GetFundings(p))
        }
    }
    
    var tbls = []
    var index = 0
    for (var fundings of arr) {
        var tbl = {
            "type": "table",
            "title": arrParams[index],
            "cols": ["Symbol", "Interval", "Time", "Rate"],
            "rows": [],
        }
    
        for (var f of fundings) {
            tbl["rows"].push([f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate * 100 + " %"])
        }
        tbls.push(tbl)
        index++
    }
    
    LogStatus(_D(), "\n Requested market types:", symbols, "\n`" + JSON.stringify(tbls) + "`")
}

'''backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
'''
    
import json
    
def main():
    # LPT_USDT.swap 4-hour period
    symbols = ["SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"]
    for symbol in symbols:
        exchange.GetTicker(symbol)
    
    arr = []
    arrParams = ["no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"]
    for p in arrParams:
        if p == "no param":
            arr.append(exchange.GetFundings())
        else:
            arr.append(exchange.GetFundings(p))
    
    tbls = []
    index = 0
    for fundings in arr:
        tbl = {
            "type": "table",
            "title": arrParams[index],
            "cols": ["Symbol", "Interval", "Time", "Rate"],
            "rows": [],
        }
    
        for f in fundings:
            tbl["rows"].append([f["Symbol"], f["Interval"] / 3600000, _D(f["Time"]), str(f["Rate"] * 100) + " %"])
    
        tbls.append(tbl)
        index += 1
    
    LogStatus(_D(), "\n Requested market types:", symbols, "\n`" + json.dumps(tbls) + "`")

/*backtest
start: 2024-10-01 00:00:00
end: 2024-10-23 00:05:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDC"}]
*/
    
void main() {
    // LPT_USDT.swap 4-hour period
    json arrSymbol = R"([])"_json;
    std::string symbols[] = {"SOL_USDT.swap", "ETH_USDT.swap", "LTC_USDT.swap", "SOL_USDC.swap", "ETH_USDC.swap", "BTC_USD.swap", "BTC_USDT.quarter", "LPT_USDT.swap"};
    for (const std::string& symbol : symbols) {
        exchange.GetTicker(symbol);
        arrSymbol.push_back(symbol);
    }
    
    std::vector<std::vector<Funding>> arr = {};
    std::string arrParams[] = {"no param", "LTC_USDT.swap", "USDT.swap", "USD.swap", "USDC.swap", "USDT.futures", "BTC_USDT.quarter"};
    for (const std::string& p : arrParams) {
        if (p == "no param") {
            arr.push_back(exchange.GetFundings());
        } else {
            arr.push_back(exchange.GetFundings(p));
        }
    }
    
    json tbls = R"([])"_json;
    int index = 0;
    for (int i = 0; i < arr.size(); i++) {
        auto fundings = arr[i];
    
        json tbl = R"({
            "type": "table", 
            "cols": ["Symbol", "Interval", "Time", "Rate"],
            "rows": []
        })"_json;
        tbl["title"] = arrParams[index];
    
        for (int j = 0; j < fundings.size(); j++) {
            auto f = fundings[j];
            // json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), string(f.Rate * 100) + " %"};
            json arrJson = {f.Symbol, f.Interval / 3600000, _D(f.Time), f.Rate};
            tbl["rows"].push_back(arrJson);
        }
        tbls.push_back(tbl);
        index++;
    }
    
    LogStatus(_D(), "\n Requested market types:", arrSymbol.dump(), "\n`" + tbls.dump() + "`");
}

Verwenden Sie das Futures Exchange Objekt, um dieexchange.GetFundings()Vor dem Aufruf einer Marktfunktion gibt GetFundings nur die Finanzierungsdaten des aktuellen Standard-Handelspaares zurück. Nach dem Aufruf der Marktfunktion gibt es die Finanzierungsdaten aller angeforderten Varianten zurück. Sie können sich auf das folgende Testbeispiel beziehen:

Für Futures-Börsen, die keine Chargenanfragen von Finanzierungsraten unterstützen, wenn diesymbolParameter wird als Abfragebereich angegeben, z. B.:USDT.swapoder dersymbolWenn der Parameter nicht übergeben wird, wird die Schnittstelle einen Fehler melden.GetFundings()Funktion mit dieser Art von Futures Exchange Objekt, müssen Sie diesymbolParameter als spezifische Dauervertragsart, um die aktuellen Finanzierungsquoten des Typs abzufragen. Dieexchange.GetFundings()Die Funktion unterstützt echte Handels- und Backtesting-Systeme. Börsen, die keine Chargenakquisition von Finanzierungsraten unterstützen: Futures_Bitget, Futures_OKX, Futures_MEXC, Futures_Deribit, Futures_Crypto.symbolParameter mit dem spezifischen Symbolcode, beispielsweise:ETH_USDT.swap.

Dieexchange.GetFundings()Funktion:

Funktionsname	Nicht unterstützte Spotbörsen	Nicht abgesicherte Futures-Börsen
GetFundings	–	Futures_DigiFinex

- Das ist nicht wahr.

Abrechnung Netzeinstellungen