Strategie zur Erfassung und Überwachung von Finanzierungszinssätzen für mehrere Plattformen


Erstellungsdatum: 2024-10-24 17:28:55 zuletzt geändert: 2024-10-24 18:36:42
Kopie: 0 Klicks: 887
11
konzentrieren Sie sich auf
607
Anhänger

Strategie zur Erfassung und Überwachung von Finanzierungszinssätzen für mehrere Plattformen

beschreiben:

Diese Strategie wird verwendet, um Finanzierungsraten von mehreren Futures-Plattformen wie OKCoin, Binance, Bitget usw. zu erhalten und zu überwachen. Befragen Sie die Märkte für unbefristete Verträge verschiedener Börsen über parallele Threads und erhalten Sie Daten zu den Finanzierungsraten, während Sie einen Verzögerungsmechanismus verwenden, um die Anforderungshäufigkeit zu optimieren.

Funktion:

  • Multiplattform-Unterstützung: Synchronisieren Sie die Finanzierungsraten über mehrere Börsen hinweg und legen Sie für jede unterschiedliche Anforderungsverzögerungen fest.
  • Spezifischer Symbolerwerb: Unterstützt das Erhalten von Finanzierungsraten für bestimmte Handelspaare (wie BTC/USDT, ETH/USDT).
  • Optimiert für verschiedene Plattformen: Unterscheiden Sie zwischen Plattformen, die nicht jeden Markt einzeln abfragen müssen (wie Binance), und Plattformen, die alle Märkte durchlaufen müssen (wie OKCoin).

Anwendung:

Sie können die Plattformliste, Symbolliste und das Abfrageintervall nach Bedarf anpassen, um Ihren spezifischen Handelsanforderungen gerecht zu werden.

Strategiequellcode

function startFundingWorker() {
    exchanges.forEach((_, pos) => {
        __Thread(function (pos) {
            let e = exchanges[pos]
            let eName = e.GetName()
            let delaySettings = {
                'Futures_OKCoin': 20,
                'Futures_Binance': 500,
            }
            let needInterate = ['Futures_OKCoin', 'Futures_Bitget','Futures_OKX', 'Futures_KuCoin', 'Futures_MEXC', 'Futures_Crypto', 'Futures_Deribit']
            let delay = function () {
                let n = delaySettings[eName]
                if (n) {
                    Sleep(n)
                }
            }
            let epoch = 60000*2;
            let ts = 0;
            let fundings = {}
            while (true) {
                let now = new Date().getTime()
                if (now - ts < epoch) {
                    Sleep(1000)
                    continue
                }
                let markets = e.GetMarkets()
                if (!markets) {
                    Sleep(1000)
                    continue
                }
                if (needInterate.includes(eName)) {
                    for (let symbol in markets) {
                        if (symbol.includes('.swap')) {
                            let ret = e.GetFundings(symbol)
                            if (ret) {
                                for (let r of ret) {
                                    fundings[r.Symbol] = r
                                }
                            }
                            delay();
                        }
                    }
                } else {
                    let zones = []
                    for (let symbol in markets) {
                        if (symbol.includes('.swap') && !zones.includes(markets[symbol].QuoteAsset)) {
                            zones.push(markets[symbol].QuoteAsset)
                            let ret = e.GetFundings(markets[symbol].QuoteAsset + '.swap')
                            if (ret) {
                                for (let r of ret) {
                                    fundings[r.Symbol] = r
                                }
                            }
                            delay();
                        }
                    }
                }
                ts = now
                __threadSetData(0, eName+"_funding", fundings)
            }
        }, pos)
    })
}

function getFundings(eName, symbols) {
    let fundings = __threadGetData(0, eName+"_funding")
    if (!fundings) {
        return null
    }

    if (typeof(symbols) === 'undefined') {
        return fundings
    }

    let ret = {}
    symbols.forEach((s) => {
        if (fundings[s]) {
            ret[s] = fundings[s]
        }
    })
    return ret
}

function main() {
    startFundingWorker()
    while (true) {
        exchanges.forEach((e) => {
            let eName = e.GetName()
            let fundings = getFundings(eName, ['BTC_USDT.swap', 'ETH_USDT.swap'])
            Log(eName, fundings)
        })
        Sleep(5000)
    }
}