FMZ-Quantifizierung: Analyse von Designbeispielen für häufige Bedürfnisse im Kryptowährungsmarkt

Im Bereich des Handels mit Kryptowährungs-Assets sind die Erfassung und Analyse von Marktdaten, Anfrageraten und die Überwachung von Kontovermögen Änderungen von entscheidender Bedeutung.

1. Wie schreibt man bitte die Währung, die in vier Stunden am stärksten gestiegen ist, um die Bargeldmenge zu erhalten?

Bei der Erstellung einer quantitativen Handelsstrategie auf FMZ müssen die Bedürfnisse zuerst analysiert werden.

• Welche Programmiersprache benutzt man, um Entwürfe zu schreiben? Das Projekt wird mit JavaScript realisiert.
• Wir brauchen Echtzeit-Marktdaten für alle Währungen Als wir diesen Bedarf sahen, schauten wir uns zuerst die API-Dokumentation von Binance an, um zu sehen, ob es Aggregat-Marktdaten gibt. Die Anfrage nach dem Aggregatmarkt-Interface:GET https://api.binance.com/api/v3/ticker/priceIch bin nicht derjenige. Auf der FMZ wird der Markt-Interface (öffentliche Schnittstelle ohne Unterschrift) verwendet, um auf die Börse zuzugreifenHttpQueryDie Funktion.
• Die Daten für die vierstündige Datenzeit der Rollfenster sind erforderlich. Es ist ein großes Problem, wie man die Struktur des Statistikprogramms gestaltet.
• Berechnen Sie den Anstieg, sortieren Sie Wenn man sich Gedanken über die Abwärtstrend-Algorithmen macht, dann ist es:涨跌幅百分比 =（当前价格 - 初始价格）/ 初始价格 * 100Die Einheit ist %.

Nach dem Problem und der Lösung beginnen wir mit dem Design.

Codeentwicklung

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

Code analysiert

• 1. Datenstrukturenvar dictSymbolsPrice = {}: ein leerer Objekt, der Preisinformationen für jedes Transaktionspaar speichert. Die Taste ist das Symbol für das Transaktionspaar, der Wert ist ein Objekt, der den Namen des Transaktionspaares, die Preisdatenarchitektur und die Abwärtstrendinformationen enthält.
• 2. Hauptfunktion main ((()
  • 2.1. Unendliche Kreisläufe

    while (true) {
        // ...
    }
    

    Der Prozess überwacht die Preise von Transaktionen in der Binance API in einem endlosen Kreislauf.
  • 2.2. Erhalten Sie Preisinformationen

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

    Die Binance API erhält aktuelle Preisinformationen über die Paare. Wenn keine Array zurückgegeben wird, warten Sie 5 Sekunden und versuchen Sie es erneut.
  • 2.3. Preisdaten aktualisieren

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

    Durchsuchen Sie die erhaltenen Preisinformationsarchive und aktualisieren Sie die Daten in dictSymbolsPrice. Für jedes Transaktionspaar werden die aktuellen Zeitfenster und Preise in die entsprechende Datarchive hinzugefügt.
  • 2.4. Abweichungen

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

    Er fängt Abweichungen ein und zeichnet Abweichungsmeldungen auf, um sicherzustellen, dass das Programm weiter ausgeführt werden kann.
  • 2.5. Berechnung des Kursverfalls

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

    Durchsuchen Sie die DictSymbolsPrice, berechnen Sie den Kursverfall für jedes Handelspärchen und entfernen Sie die frühesten Daten, wenn die Daten länger als 4 Stunden sind.
  • 2.6. Sortieren und generieren von Tabellen

    var entries = Object.entries(dictSymbolsPrice)
    entries.sort((a, b) => b[1].percentageChange - a[1].percentageChange)
    
    for (var i = 0; i < entries.length; i++) {
        // ...
    }
    

    Sie ordnet die Paare von oben nach unten nach dem Fall der Wellen und erzeugt eine Tabelle mit Informationen über die Paare.
  • 2.7. Ausgabe und Verzögerung von Logs

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

    Die Tabelle und die aktuelle Zeit werden in Form von Logs ausgeführt, und nach 5 Sekunden wird die nächste Runde fortgesetzt.

Das Programm erhält über die Binance API die Echtzeit-Preisinformationen über ein Handelspärchen, berechnet dann die Preisverluste und liefert sie in Tabellenform in das Protokoll. Das Programm ermöglicht die Echtzeit-Überwachung von Preisen durch ständige Loop-Ausführung.

Tests auf der Festplatte

Da die Daten zu Beginn nur an einzelnen Punkten gesammelt werden können, ist es unmöglich, die Steigerung zu berechnen, wenn nicht genug Daten für 4 Stunden gesammelt werden.

2. Suchen Sie nach den Preisen für alle Arten von Finanzmitteln, die in einem Bitcoin-Betriebsvertrag enthalten sind

Bei der Abfrage von Kapitalraten und dem oben genannten Code ist es ähnlich. Zunächst müssen Sie sich die API-Dokumentation von Binance ansehen, um die Interface zu finden. Binance hat mehrere Interfaces, mit denen Sie die Kapitalrate abfragen können.

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

Code-Implementierung

Da es zu viele Verträge gibt, sind wir in den Top 10 der Exporte mit den höchsten Kapitalpreisen.

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

Die Datenstruktur, die zurückgegeben wird, ist wie folgt: Wenn man sich die Binance-Dokumentation anschaut, kann man feststellen, dass die LastFundingRate das ist, was wir wollen.

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

Tests auf der Festplatte:

Kryptowährungen für die Python-Version von OKX

Ein Benutzer stellte ein Beispiel für eine Python-Version vor, und das ist die OKX-Börse.

https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1Die Daten, die die Schnittstelle zurückgibt:

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

Der spezifische Code:

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)

Tests auf der Festplatte:

Ende

Diese Beispiele liefern grundlegende Design-Ideen, Anwendungsmethoden, die in den tatsächlichen Projekten entsprechend den spezifischen Bedürfnissen angepasst und erweitert werden müssen. Wir hoffen, dass diese Codes Ihnen helfen, die verschiedenen Bedürfnisse bei der Handel mit Kryptowährungen und digitalen Assets besser zu erfüllen.