Strategi pemerolehan dan pemantauan kadar pembiayaan niaga hadapan berbilang platform


Tarikh penciptaan: 2024-10-24 17:28:55 Akhirnya diubah suai: 2024-10-24 18:36:42
Salin: 0 Bilangan klik: 887
11
fokus pada
607
Pengikut

Strategi pemerolehan dan pemantauan kadar pembiayaan niaga hadapan berbilang platform

huraikan:

Strategi ini digunakan untuk mendapatkan dan memantau kadar pembiayaan daripada pelbagai platform niaga hadapan seperti OKCoin, Binance, Bitget, dsb. Tinjau pasaran kontrak berterusan pelbagai bursa melalui rangkaian selari dan dapatkan data kadar pembiayaan, sambil menggunakan mekanisme kelewatan untuk mengoptimumkan kekerapan permintaan.

Fungsi:

  • Sokongan berbilang platform: Segerakkan kadar pembiayaan merentas berbilang bursa dan tetapkan kelewatan permintaan yang berbeza untuk setiap satu.
  • Pemerolehan simbol khusus:Menyokong mendapatkan kadar pembiayaan untuk pasangan dagangan tertentu (seperti BTC/USDT, ETH/USDT).
  • Dioptimumkan untuk platform yang berbeza: Bezakan antara platform yang tidak perlu menanyakan setiap pasaran satu demi satu (seperti Binance) dan platform yang perlu merentasi semua pasaran (seperti OKCoin).

Arah:

Anda boleh melaraskan senarai platform, senarai simbol dan selang pengundian mengikut keperluan untuk memenuhi keperluan perdagangan khusus anda.

Kod sumber strategi

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