संसाधन लोड हो रहा है... लोड करना...

कई धागे प्राप्त धनराशि प्रतीक

लेखक:आविष्कारक मात्रा, दिनांकः 2024-10-24 17:28:55
टैगः

मल्टी-प्लेटफ़ॉर्म फ्यूचर्स फंडिंग रेट रिकवरी और मॉनिटरिंग रणनीति

विवरण:

यह रणनीति कई वायदा प्लेटफार्मों (जैसे, ओकेकोइन, बिनेंस, बिटगेट) में फंडिंग दरों को पुनर्प्राप्त और निगरानी करती है। यह विभिन्न एक्सचेंजों पर स्थायी अनुबंध बाजारों को पोल करने और अनुरोध आवृत्ति को अनुकूलित करने के लिए देरी तंत्र के साथ फंडिंग दर डेटा पुनर्प्राप्त करने के लिए समानांतर धागे का उपयोग करती है।

विशेषताएं:

  • मल्टी-प्लेटफ़ॉर्म समर्थन: कई ट्रेडिंग प्लेटफार्मों से फंडिंग दरों को सिंक्रनाइज़ करता है, प्रत्येक के अनुकूलित अनुरोध देरी के साथ।
  • प्रतीक विशिष्ट पुनर्प्राप्ति: विशिष्ट ट्रेडिंग जोड़े (जैसे, BTC/USDT, ETH/USDT) के लिए फंडिंग दरों की पुनर्प्राप्ति की अनुमति देता है।
  • विभिन्न प्लेटफार्मों के लिए अनुकूलित: उन प्लेटफार्मों के बीच अंतर करता है जिन्हें व्यक्तिगत बाजारों पर पुनरावृत्ति की आवश्यकता होती है (उदाहरण के लिए, ओकेकोइन) और जो नहीं करते हैं (उदाहरण के लिए, बाइनेंस) ।

उपयोगः

आप अपनी विशिष्ट ट्रेडिंग आवश्यकताओं के अनुरूप प्लेटफ़ॉर्म सूची, प्रतीक सूची और मतदान अंतराल को समायोजित कर सकते हैं।



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

अधिक