एफएमजेड क्वांटः क्रिप्टोकरेंसी बाजार में सामान्य आवश्यकताओं के डिजाइन उदाहरणों का विश्लेषण (I)

क्रिप्टोक्यूरेंसी परिसंपत्ति व्यापार अंतरिक्ष में, बाजार डेटा प्राप्त करना और उनका विश्लेषण करना, क्वेरी दरें, और खाता परिसंपत्ति आंदोलनों की निगरानी करना सभी महत्वपूर्ण संचालन हैं। नीचे कुछ सामान्य आवश्यकताओं के लिए कार्यान्वयन के कोड उदाहरण दिए गए हैं।

1. मैं कैसे Binance स्पॉट पर 4 घंटे में उच्चतम वृद्धि के साथ मुद्रा पाने के बारे में कोड लिखने के लिए?

जब आप एफएमजेड प्लेटफॉर्म पर एक मात्रात्मक ट्रेडिंग रणनीति प्रोग्राम लिखते हैं, तो पहली चीज जो आपको करने की आवश्यकता है जब आप किसी आवश्यकता का सामना करते हैं तो इसका विश्लेषण करना है। इसलिए आवश्यकताओं के आधार पर, हमने निम्नलिखित सामग्री का विश्लेषण कियाः

• कौन सी प्रोग्रामिंग भाषा का प्रयोग करें? योजना इसे लागू करने के लिए जावास्क्रिप्ट का उपयोग करना है।
• सभी मुद्राओं में वास्तविक समय में स्पॉट उद्धरणों की आवश्यकता होती है जब हमने आवश्यकता देखी तो हमने सबसे पहले यह पता लगाने के लिए बिनेंस एपीआई दस्तावेज़ देखा कि क्या कोई एकत्रित उद्धरण थे (एक साथ एकत्रित उद्धरण होना सबसे अच्छा है, एक-एक करके देखना बहुत काम है) । हमने संकलित उद्धरण इंटरफ़ेस पाया:GET https://api.binance.com/api/v3/ticker/price. एफएमजेड प्लेटफॉर्म पर,HttpQueryएक्सचेंज टिकर इंटरफेस (सार्वजनिक इंटरफेस जिसके लिए हस्ताक्षर की आवश्यकता नहीं है) तक पहुँचने के लिए कार्य।
• 4 घंटे की रोलिंग विंडो अवधि के लिए डेटा गिनने की आवश्यकता है सांख्यिकीय कार्यक्रम की संरचना को कैसे डिजाइन किया जाए, इसकी कल्पना करें।
• मूल्य उतार-चढ़ाव की गणना करें और उन्हें क्रमबद्ध करें मूल्य उतार-चढ़ाव एल्गोरिथ्म के बारे में सोच, यह हैःprice fluctuations (%) = (current price - initial price) / initial price * 100% में।

समस्या का पता लगाने के बाद, साथ ही कार्यक्रम को परिभाषित करने के बाद, हम कार्यक्रम को डिजाइन करने के व्यवसाय में उतर आए।

कोड डिजाइन

var dictSymbolsPrice = {}

function main() {
    while (true) {
        // GET https://api.binance.com/api/v3/ticker/price
        try {
            var arr = JSON.parse(HttpQuery("https://api.binance.com/api/v3/ticker/price"))
            if (!Array.isArray(arr)) {
                Sleep(5000)
                continue 
            }
            
            var ts = new Date().getTime()
            for (var i = 0; i < arr.length; i++) {
                var symbolPriceInfo = arr[i]
                var symbol = symbolPriceInfo.symbol
                var price = symbolPriceInfo.price

                if (typeof(dictSymbolsPrice[symbol]) == "undefined") {
                    dictSymbolsPrice[symbol] = {name: symbol, data: []}
                }
                dictSymbolsPrice[symbol].data.push({ts: ts, price: price})
            }
        } catch(e) {
            Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
        }
        
        // Calculate price fluctuations
        var tbl = {
            type : "table",
            title : "Price fluctuations",
            cols : ["trading pair", "current price", "price 4 hours ago", "price fluctuations", "data length", "earliest data time", "latest data time"],
            rows : []
        }
        for (var symbol in dictSymbolsPrice) {
            var data = dictSymbolsPrice[symbol].data
            if (data[data.length - 1].ts - data[0].ts > 1000 * 60 * 60 * 4) {
                dictSymbolsPrice[symbol].data.shift()
            }

            data = dictSymbolsPrice[symbol].data
            dictSymbolsPrice[symbol].percentageChange = (data[data.length - 1].price - data[0].price) / data[0].price * 100
        }

        var entries = Object.entries(dictSymbolsPrice)
        entries.sort((a, b) => b[1].percentageChange - a[1].percentageChange)

        for (var i = 0; i < entries.length; i++) {
            if (i > 9) {
                break
            }   
            var name = entries[i][1].name
            var data = entries[i][1].data
            var percentageChange = entries[i][1].percentageChange
            var currPrice = data[data.length - 1].price
            var currTs = _D(data[data.length - 1].ts)
            var prePrice = data[0].price
            var preTs = _D(data[0].ts)
            var dataLen = data.length

            tbl.rows.push([name, currPrice, prePrice, percentageChange + "%", dataLen, preTs, currTs])
        }
        
        LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
        Sleep(5000)
    }
}

कोड विश्लेषण

• 1. डेटा संरचनाvar dictSymbolsPrice = {}: प्रत्येक ट्रेडिंग जोड़ी के लिए मूल्य जानकारी संग्रहीत करने के लिए एक खाली वस्तु। कुंजी ट्रेडिंग जोड़ी का प्रतीक है, और मूल्य एक वस्तु है जिसमें ट्रेडिंग जोड़ी का नाम, मूल्य डेटा का एक सरणी, और मूल्य उतार-चढ़ाव के बारे में जानकारी है।
• 2. मुख्य कार्य मुख्य 2.1. अनंत लूप

while (true) {
    // ...
}

यह प्रोग्राम एक अनंत लूप के माध्यम से बिनेंस एपीआई ट्रेडिंग जोड़ी की कीमतों की निरंतर निगरानी करता है। 2.2 मूल्य जानकारी प्राप्त करें

var arr = JSON.parse(HttpQuery("https://api.binance.com/api/v3/ticker/price"))

बिनेंस एपीआई के माध्यम से ट्रेडिंग जोड़ी की वर्तमान मूल्य जानकारी प्राप्त करें. यदि रिटर्न एक सरणी नहीं है, तो 5 सेकंड प्रतीक्षा करें और पुनः प्रयास करें. 2.3। मूल्य आंकड़ों का अद्यतन

for (var i = 0; i < arr.length; i++) {
    // ...
}

प्राप्त मूल्य जानकारी के सरणी के माध्यम से पुनरावृत्ति करें और dictSymbolsPrice में डेटा अपडेट करें। प्रत्येक ट्रेडिंग जोड़ी के लिए, वर्तमान समयस्टैम्प और मूल्य को संबंधित डेटा सरणी में जोड़ें। 2.4। अपवाद प्रसंस्करण

} catch(e) {
    Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
}

अपवादों को पकड़ें और यह सुनिश्चित करने के लिए अपवाद जानकारी लॉग करें कि प्रोग्राम निष्पादित करना जारी रख सके. 2.5. मूल्य उतार-चढ़ाव की गणना करें

for (var symbol in dictSymbolsPrice) {
    // ...
}

dictSymbolsPrice के माध्यम से दोहराएं, प्रत्येक ट्रेडिंग जोड़ी के मूल्य उतार-चढ़ाव की गणना करें, और यदि यह 4 घंटे से अधिक है तो सबसे पुराने डेटा को हटा दें। 2.6. तालिकाओं को क्रमबद्ध और उत्पन्न करें

var entries = Object.entries(dictSymbolsPrice)
entries.sort((a, b) => b[1].percentageChange - a[1].percentageChange)

for (var i = 0; i < entries.length; i++) {
    // ...
}

ट्रेडिंग जोड़े को उनकी कीमतों के उतार-चढ़ाव के क्रम में क्रमबद्ध करें और ट्रेडिंग जोड़े के बारे में जानकारी युक्त तालिका उत्पन्न करें। 2.7. लॉग आउटपुट और देरी

LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(5000)

तालिका और वर्तमान समय को लॉग के रूप में आउटपुट करें और लूप के अगले दौर को जारी रखने के लिए 5 सेकंड तक प्रतीक्षा करें।

यह प्रोग्राम बिनेंस एपीआई के माध्यम से ट्रेडिंग जोड़ी की वास्तविक समय की मूल्य जानकारी प्राप्त करता है, फिर मूल्य उतार-चढ़ाव की गणना करता है, और इसे तालिका के रूप में लॉग में आउटपुट करता है। यह प्रोग्राम ट्रेडिंग जोड़े की कीमतों की वास्तविक समय की निगरानी के कार्य को महसूस करने के लिए एक निरंतर लूप में निष्पादित किया जाता है। ध्यान दें कि कार्यक्रम में यह सुनिश्चित करने के लिए अपवाद प्रसंस्करण शामिल है कि मूल्य जानकारी प्राप्त करते समय अपवादों द्वारा निष्पादन बाधित न हो।

लाइव ट्रेडिंग रनिंग टेस्ट

चूंकि प्रारंभ में डेटा को केवल बिट-बाइट एकत्र किया जा सकता है, इसलिए चार घंटे की खिड़की के लिए पर्याप्त डेटा एकत्र किए बिना चलती आधार पर मूल्य उतार-चढ़ाव की गणना करना संभव नहीं है। इसलिए, गणना के लिए आधार के रूप में प्रारंभिक मूल्य का उपयोग किया जाता है, और चार घंटे के लिए पर्याप्त डेटा एकत्र करने के बाद, मूल्य उतार-चढ़ाव की गणना के लिए चार घंटे की खिड़की को बनाए रखने के लिए सबसे पुराने डेटा को समाप्त कर दिया जाएगा।

2. बिनेंस यू-मुद्रांकित अनुबंधों के लिए वित्तपोषण दरों की पूरी विविधता की जाँच करें

फंडिंग दर की जाँच करना उपरोक्त कोड के समान है, सबसे पहले, हमें फंडिंग दर से संबंधित इंटरफ़ेस खोजने के लिए बाइनेंस एपीआई प्रलेखन की जांच करने की आवश्यकता है। बाइनेंस के कई इंटरफ़ेस हैं जो हमें धन की दर की क्वेरी करने की अनुमति देते हैं, यहां हम यू-डेनोमिनेटेड अनुबंध के इंटरफ़ेस को एक उदाहरण के रूप में लेते हैंः

GET https://fapi.binance.com/fapi/v1/premiumIndex

कोड कार्यान्वयन

चूंकि इतने सारे अनुबंध हैं, इसलिए हम यहां शीर्ष 10 सबसे बड़ी वित्तपोषण दरों का निर्यात कर रहे हैं।

function main() {
    while (true) {
        // GET https://fapi.binance.com/fapi/v1/premiumIndex
        try {
            var arr = JSON.parse(HttpQuery("https://fapi.binance.com/fapi/v1/premiumIndex"))
            if (!Array.isArray(arr)) {
                Sleep(5000)
                continue 
            }
            
            arr.sort((a, b) => parseFloat(b.lastFundingRate) - parseFloat(a.lastFundingRate))
            var tbl = {
                type: "table",
                title: "Top 10 funding rates for U-denominated contracts",
                cols: ["contracts", "funding rate", "marked price", "index price", "current rate time", "next rate time"],
                rows: []
            }
            for (var i = 0; i < 9; i++) {
                var obj = arr[i]
                tbl.rows.push([obj.symbol, obj.lastFundingRate, obj.markPrice, obj.indexPrice, _D(obj.time), _D(obj.nextFundingTime)])
            }
            LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
        } catch(e) {
            Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
        }
        Sleep(1000 * 10)
    }
}

लौटाया डेटा संरचना इस प्रकार है, और Binance प्रलेखन की जाँच करें, यह पता चलता है कि lastFundingRate हम चाहते हैं वित्त पोषण दर है।

{
    "symbol":"STMXUSDT",
    "markPrice":"0.00883606",
    "indexPrice":"0.00883074",
    "estimatedSettlePrice":"0.00876933",
    "lastFundingRate":"0.00026573",
    "interestRate":"0.00005000",
    "nextFundingTime":1702828800000,
    "time":1702816229000
}

लाइव ट्रेडिंग रनिंग टेस्टः

पायथन संस्करण के OKX विनिमय अनुबंध वित्त पोषण दरें प्राप्त करना

एक उपयोगकर्ता ने उदाहरण के पायथन संस्करण के लिए कहा है, और यह OKX विनिमय के लिए है. यहाँ एक उदाहरण हैः

इंटरफ़ेस द्वारा लौटाए गए डेटाhttps://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1:

{
    "code":"0",
    "data":[
        {
            "fundingTime":1702828800000,
            "fundingList":[
                {
                    "instId":"BTC-USDT-SWAP",
                    "nextFundingRate":"0.0001102188733642",
                    "minFundingRate":"-0.00375",
                    "fundingRate":"0.0000821861465884",
                    "maxFundingRate":"0.00375"
                } ...

विशिष्ट कोड:

import requests
import json
from time import sleep
from datetime import datetime

def main():
    while True:
        # https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1
        try:
            response = requests.get("https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1")
            arr = response.json()["data"][0]["fundingList"]
            Log(arr) 
            if not isinstance(arr, list):
                sleep(5)
                continue

            arr.sort(key=lambda x: float(x["fundingRate"]), reverse=True)

            tbl = {
                "type": "table",
                "title": "Top 10 funding rates for U-denominated contracts",
                "cols": ["contracts", "next rate", "minimum", "current", "maximum"],
                "rows": []
            }

            for i in range(min(9, len(arr))):
                obj = arr[i]
                row = [
                    obj["instId"],
                    obj["nextFundingRate"],
                    obj["minFundingRate"],
                    obj["fundingRate"],
                    obj["maxFundingRate"]
                ]
                tbl["rows"].append(row)
            
            LogStatus(_D(), "\n", '`' + json.dumps(tbl) + '`')

        except Exception as e:
            Log(f"Error: {str(e)}")

        sleep(10)

लाइव ट्रेडिंग रनिंग टेस्टः

अंत

इन उदाहरणों में बुनियादी डिजाइन विचार और कॉलिंग विधियां प्रदान की गई हैं, वास्तविक परियोजना को विशिष्ट आवश्यकताओं के आधार पर उचित परिवर्तन और विस्तार करने की आवश्यकता हो सकती है। उम्मीद है, ये कोड आपको क्रिप्टोक्यूरेंसी डिजिटल परिसंपत्ति व्यापार में विभिन्न आवश्यकताओं को बेहतर ढंग से पूरा करने में मदद कर सकते हैं।