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

1. मैं वह कोड कैसे लिखूं जो 4 घंटे के भीतर Binance स्पॉट ट्रेडिंग में सबसे बड़ी वृद्धि दिखाता है?

FMZ पर मात्रात्मक ट्रेडिंग रणनीति कार्यक्रम लिखते समय, आपको सबसे पहले आवश्यकताओं का विश्लेषण करना होगा। अतः आवश्यकतानुसार हम निम्नलिखित बिन्दुओं का विश्लेषण करते हैं:

• डिज़ाइन लिखने के लिए किस प्रोग्रामिंग भाषा का उपयोग किया जाता है जावास्क्रिप्ट का उपयोग करके योजनाबद्ध कार्यान्वयन.
• सभी मुद्राओं के लिए वास्तविक समय स्पॉट बाजार डेटा की आवश्यकता है जब हमने यह आवश्यकता देखी, तो सबसे पहले हमने बिनेंस के एपीआई दस्तावेज़ को देखा, यह देखने के लिए कि क्या कोई समेकित बाज़ार डेटा है (समेकित बाज़ार डेटा सबसे अच्छा होगा, क्योंकि प्रत्येक उत्पाद को एक-एक करके जांचना समय लेने वाला और श्रमसाध्य होगा) एक)। समेकित बाजार सूचना इंटरफ़ेस पर क्वेरी करें:GET https://api.binance.com/api/v3/ticker/price。 FMZ पर, एक्सचेंज कोटेशन इंटरफ़ेस (सार्वजनिक इंटरफ़ेस जिसे हस्ताक्षर की आवश्यकता नहीं होती है) तक पहुंचेंHttpQueryसमारोह।
• 4 घंटे की रोलिंग विंडो अवधि के डेटा की गणना करने की आवश्यकता है इस सांख्यिकीय कार्यक्रम की संरचना कैसे की जाए, इस पर विचार करें।
• वृद्धि और गिरावट की गणना करें, क्रमबद्ध करें उत्थान और पतन एल्गोरिथ्म के बारे में सोचें, क्या यह है:涨跌幅百分比 =（当前价格 - 初始价格）/ 初始价格 * 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)
        }
        
        // 计算涨跌幅
        var tbl = {
            type : "table",
            title : "涨跌幅",
            cols : ["交易对", "当前价格", "4小时前价格", "涨跌幅", "数据长度", "最早数据时间", "最新数据时间"],
            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 = {}: प्रत्येक ट्रेडिंग जोड़ी के लिए मूल्य जानकारी संग्रहीत करने के लिए उपयोग की जाने वाली एक खाली वस्तु। कुंजी, ट्रेडिंग जोड़ी का प्रतीक है, और मूल्य एक ऑब्जेक्ट है जिसमें ट्रेडिंग जोड़ी का नाम, मूल्य डेटा की एक सरणी और परिवर्तन जानकारी शामिल होती है।

• 1. मुख्य फ़ंक्शन main()
  • 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 सेकंड तक प्रतीक्षा करें।

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

वास्तविक डिस्क संचालन परीक्षण

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

2. सभी बिनेंस यू-मार्जिन वायदा अनुबंधों की फंडिंग दरों की जांच करें

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

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

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

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

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: "U本位合约资金费率前十",
                cols: ["合约", "资金费率", "标记价格", "指数价格", "当期费率时间", "下期费率时间"],
                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": "U本位合约资金费率前十",
                "cols": ["合约", "下期费率", "最小", "当期", "最大"],
                "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)

वास्तविक डिस्क संचालन परीक्षण:

END

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