FMZ Quant: Eine Analyse von gemeinsamen Anforderungen Designbeispielen auf dem Kryptowährungsmarkt (II)

Als Antwort auf die Kommentare von Lesern im vorherigen Artikel haben sie ein Programmbeispiel zur Überwachung von Kontoüberweisungen angefordert.

Kryptowährungsbörsen verarbeiten täglich eine große Anzahl von Transaktionen, einschließlich der Übertragung von Vermögenswerten zwischen verschiedenen Brieftaschen. Die Überwachung dieser Übertragungen in Echtzeit ist für Händler und Entwickler von entscheidender Bedeutung. In diesem Artikel werden wir ein Stück JavaScript-Code untersuchen, das entwickelt wurde, um die jüngsten Vermögensübertragungen an einer Kryptowährungsbörse zu überwachen und seine wichtigsten Komponenten zu diskutieren.

Analyse der Anforderungen

Ich habe die Dokumentation der Binance-Börse überprüft und festgestellt, dass es eine Schnittstelle für den Transferverlauf gibt, die alle Transferinformationen abfragen kann. Da wir nur die möglicherweise auftretenden Transferrekorde überwachen, müssen wir nicht alle Transferverläufe erhalten. Wir müssen nur die letzten Transferrekorde innerhalb eines bestimmten Bereichs auf der Grundlage einer bestimmten Häufigkeit überprüfen. Wenn neue Transferrekorde gefunden werden, werden sie aktualisiert und benachrichtigt.

Nutzen Sie die Schnittstelle:

// GET /sapi/v1/asset/transfer type, size : 100

Wie kann ich also den neu hinzugefügten Transferrekord überprüfen? Nachdem ich die Dokumentation von Binance gelesen habe, habe ich festgestellt, dass in den von dieser Schnittstelle zurückgegebenen Daten ein Zeitstempel ist. Es ist sehr einfach, anhand des Zeitstempels zu beurteilen. Solange es einen Rekord gibt, der größer ist als der maximale Zeitstempel, der derzeit aufgezeichnet wird, bedeutet dies, dass eine neue Transferaktion stattgefunden hat. Verwenden Sie einfach diesen, um ihn auszulösen.

Die/sapi/v1/asset/transferDie Erfassung kann bis zu 100 Daten auf einmal anfordern. Die Erfassung wird keine Probleme für Niederfrequenzübertragungen verursachen, es sei denn, das Konto hat mehr als 100 Übertragungsvorgänge zwischen dem Ende einer Erfassung und dem Beginn der nächsten Erfassung. Zu diesem Zeitpunkt können einige neue Betriebsdatensätze verpasst werden, was für allgemeine Nachfrage-Szenarien ausreicht (im Allgemeinen gibt es keine Strategie, um Gelder verrückt zu überweisen...).

Natürlich gibt es viele Details im eigentlichen Design. Zum Beispiel, überprüft die Dokumentation, fanden wir, dass es viele Übertragungsrichtungen, so müssen wir jede Übertragungsrichtung zu überwachen.var dicType = {...}für die Verwaltung aller Übertragungsrichtungen.

Um die Inhalte besser anzuzeigen, verwenden wir eine Statusleiste Tabelle, um die letzten 5 Transfer-Informationen in der Strategie-Schnittstelle auszugeben, so bauten wir ein Objekt namensmonitorNatürlich können Sie die Datenübertragungsdaten nicht unbegrenzt aufzeichnen, also führen wir nur 100 Aufzeichnungen für jede Übertragungsrichtung.

Beispielcode

function getRecentTransferHistory(TransType, typeDesc) {
	// GET /sapi/v1/asset/transfer type, size : 100
    
    var rows = null 
    var ret = exchange.IO("api", "GET", "/sapi/v1/asset/transfer", `type=${TransType}&size=100`)
    Log("/sapi/v1/asset/transfer" + `type=${TransType}&size=100`)
    if (ret && typeof(ret.rows) != "undefined" && Array.isArray(ret.rows)) {
        rows = ret.rows
    } else if (ret && typeof(ret.total) != "undefined" && ret.total == 0) {
        rows = []
    } else {
    	Log(TransType, typeDesc, "inquiry failure", ret)
    }
    
    return rows
}

var monitor = {}
function monitorTransfers() {
    var dicType = {
        "MAIN_UMFUTURE": "Spot wallet --> U-based contract wallet",
        "MAIN_CMFUTURE": "Spot wallet --> Currency-based contract wallet",
        "UMFUTURE_MAIN": "U-based contract wallet --> Spot wallet",
        "UMFUTURE_MARGIN": "U-based contract wallet --> Leveraged full position wallet",
        "CMFUTURE_MAIN": "Currency-based contract wallet --> Spot wallet",
        "MARGIN_UMFUTURE": "Leveraged full position wallet --> U-based contract wallet",
        "MARGIN_CMFUTURE": "Leveraged full position wallet --> Currency-based contract wallet",
        "CMFUTURE_MARGIN": "Currency-based contract wallet --> Leveraged full position wallet",
        "FUNDING_UMFUTURE": "Funds wallet --> U-based contract wallet",
        "UMFUTURE_FUNDING": "U-based contract wallet --> Funds wallet",
        "FUNDING_CMFUTURE": "Funds wallet --> Currency-based contract wallet",
        "CMFUTURE_FUNDING": "Currency-based contract wallet --> Funds wallet",
        "UMFUTURE_OPTION": "U-based contract wallet --> Options wallet",
        "OPTION_UMFUTURE": "Options wallet --> U-based contract wallet",
        // integrated account
        "MAIN_PORTFOLIO_MARGIN": "Spot wallet --> Unified accounts wallet",
        "PORTFOLIO_MARGIN_MAIN": "Unified accounts wallet --> Spot wallet"
    }
    
    Log("start testing")
    _.each(dicType, function(v, k) {
        var rows = getRecentTransferHistory(k, v)
        var maxTS = 0
        _.each(rows, function(row) {
            if (typeof(monitor[k]) == "undefined") {
            	monitor[k] = {"transType": k, "typeDesc": v, "recentRecords": [], "lastTS": 0}            	
            }

            if (row["timestamp"] > monitor[k]["lastTS"]) {
                monitor[k]["recentRecords"].push(row)
                
                if (monitor[k]["lastTS"] != 0) {
                	Log("New transfer records detected", k, v, row, "#FF0000")
                }                
            }
            maxTS = Math.max(maxTS, row["timestamp"])     
        })
        if (rows && rows.length == 0) {
            return 
        }
        monitor[k]["lastTS"] = maxTS

        var sortedArrayAscending = monitor[k]["recentRecords"].slice().sort((a, b) => a.timestamp - b.timestamp)
        monitor[k]["recentRecords"] = sortedArrayAscending

        if (monitor[k]["recentRecords"].length > 100) {
        	monitor[k]["recentRecords"].shift()
        }
        Sleep(1000)
    })
    Log("commencement and termination")
}


function main() {
    LogReset()
    while (true) {
        monitorTransfers()

        var tbls = []
        _.each(monitor, function(v, k) {
        	var tbl = {
        		"type": "table", 
        		"title": v["typeDesc"], 
        		"cols": ["asset", "amount", "status", "tranId", "time"], 
        		"rows": []
        	}

            var arr = v["recentRecords"].slice().sort((a, b) => b.timestamp - a.timestamp)
            for (var i = 0; i < arr.length; i++) {
            	if (i < 5) {
            		tbl["rows"].push([arr[i]["asset"], arr[i]["amount"], arr[i]["status"], arr[i]["tranId"], _D(arr[i]["timestamp"])])
            	}            	
            }
            tbls.push(tbl)
        })        

    	LogStatus(_D(), "\n", "`" + JSON.stringify(tbls) + "`")
    	Sleep(1000 * 30)
    }
}

Codeübersicht:

Der bereitgestellte JavaScript-Code umfasst mehrere Funktionen, die ein System zur Überwachung aktueller Vermögensübertragungen zusammenstellen.

• Funktion getRecentTransferHistory:

  Purpose: Obtain the recent asset transfer history from the exchange API according to the specified parameters.
  Parameters: TransType (transfer type), typeDesc (type description).
  API endpoint: /sapi/v1/asset/transfer.
  

• Übertragung von Daten:

  Purpose: Iterate over predefined transfer types, retrieve recent transfer history, and record any new transfers.
  Use a dictionary (dicType) to map transfer types to human-readable descriptions.
  Update the monitor object to track the latest transfers of each type.
  

• Hauptfunktion:

  Purpose: Run an infinite loop that monitors transfers continuously and displays the latest data.
  Use the monitorTransfers function regularly.
  Generate a table for each transfer type, including columns such as asset, amount, status, transaction ID, and timestamp.
  

Hauptmerkmale:

• Dynamische Übertragungsart-Mapping:

  The code uses a dictionary (dicType) to map transfer types to descriptive names, providing a clear explanation of the nature of each transfer.
  

• Echtzeitüberwachung:

  The system checks for new transfers continuously, updates the monitor object and records any detected changes.
  

• Darstellung der Daten:

  Use tables to present each type of transfer data, including relevant details such as assets, amounts, status, transaction IDs, and timestamps.
  

• Verwaltung der Transferhistorie:

  Maintain a scrolling list of recent transfer records for each type, ensuring a concise and timely display.
  

Bot-Test

Die Übertragung erfolgte manuell und das Programm erkannte die Übertragung.

Ende:

Der bereitgestellte JavaScript-Code bietet eine leistungsstarke Lösung zur Überwachung der jüngsten Vermögensübertragungen an Kryptowährungsbörsen. Seine dynamische und Echtzeit-Natur macht ihn zu einem wertvollen Werkzeug für Händler und Entwickler, die Vermögensbewegungen zwischen verschiedenen Brieftaschen verstehen möchten. Dieser Code kann an spezifische Bedürfnisse angepasst und angepasst werden und bietet eine solide Grundlage für diejenigen, die ihre Kryptowährungshandelsstrategien verbessern oder zusätzliche Überwachungsfunktionen entwickeln möchten.

Dieser Artikel wirft ein wenig Licht auf das Thema und bietet eine Designidee. Möge Ihre Kryptowährungskarriere sowohl informativ als auch erfolgreich sein!