En réponse au commentaire du lecteur dans l’article précédent, un exemple de programme de surveillance des transferts de comptes contractuels est nécessaire. Dans ce numéro, nous utiliserons Binance Exchange comme objet de test pour répondre à cette exigence et apprendre à le concevoir.

Les échanges de crypto-monnaie traitent chaque jour un grand nombre de transactions, y compris les transferts d’actifs entre différents portefeuilles. Le suivi de ces transferts en temps réel est essentiel pour les traders et les développeurs. Cet article explorera un morceau de code JavaScript conçu pour surveiller les transferts d’actifs récents sur une bourse de crypto-monnaie et discutera de ses composants clés.

Analyser les besoins

Après avoir consulté la documentation de Binance Exchange, j’ai découvert qu’il existe une interface d’historique des transferts qui peut interroger toutes les informations de transfert. Étant donné que nous surveillons uniquement les enregistrements de transfert possibles, nous n’avons pas besoin d’obtenir tous les historiques de transfert. Nous devons seulement vérifier les enregistrements de transfert récents dans une certaine plage à une certaine fréquence. Si de nouveaux enregistrements de transfert sont trouvés, ils seront mis à jour et notifiés.

Utilisez cette interface :

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

Alors, comment vérifier les enregistrements de transfert nouvellement ajoutés ? Après avoir lu la documentation de Binance, j’ai constaté que les données renvoyées par cette interface contiennent des horodatages. Il est très simple d’utiliser les horodatages pour juger. Tant qu’il existe un enregistrement avec un horodatage plus grand que l’enregistrement actuel, cela signifie qu’un nouveau transfert s’est produit. . Utilisez simplement ceci pour le déclencher.

/sapi/v1/asset/transferL’interface demande un maximum de 100 données à chaque fois. Cette détection ne posera pas de problème pour les transferts à faible fréquence, sauf si le compte a plus de 100 opérations de transfert entre la fin d’une détection et le début de la détection suivante. À l’heure actuelle, certains nouveaux enregistrements d’opérations peuvent être manquants, ce qui est suffisant pour les scénarios de demande générale (généralement, il n’y aura pas de stratégies pour transférer des fonds de manière folle…).

Bien sûr, il y a beaucoup de détails dans la conception réelle. Par exemple, lors de la vérification du document, nous constatons qu’il existe de nombreux sens de rotation, nous devons donc surveiller chaque sens de rotation. Le code définitvar dicType = {...}Pour gérer toutes les directions de transfert.

Afin de mieux afficher le contenu, nous utilisons une table de barre d’état pour afficher les cinq dernières informations de transfert dans l’interface de stratégie, nous construisons donc une table appelée :monitorObjet utilisé pour enregistrer des données. Bien entendu, vous ne pouvez pas enregistrer indéfiniment les informations de transfert, c’est pourquoi nous ne conservons que 100 enregistrements pour chaque sens de transfert. S’il y a plus de 100 enregistrements, les enregistrements prématurés seront supprimés.

Exemples de code

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, "查询失败", ret)
    }
    
    return rows
}

var monitor = {}
function monitorTransfers() {
    var dicType = {
        "MAIN_UMFUTURE": "现货钱包 --> U本位合约钱包",
        "MAIN_CMFUTURE": "现货钱包 --> 币本位合约钱包",
        "UMFUTURE_MAIN": "U本位合约钱包 --> 现货钱包",
        "UMFUTURE_MARGIN": "U本位合约钱包 --> 杠杆全仓钱包",
        "CMFUTURE_MAIN": "币本位合约钱包 --> 现货钱包",
        "MARGIN_UMFUTURE": "杠杆全仓钱包 --> U本位合约钱包",
        "MARGIN_CMFUTURE": "杠杆全仓钱包 --> 币本位合约钱包",
        "CMFUTURE_MARGIN": "币本位合约钱包 --> 杠杆全仓钱包",
        "FUNDING_UMFUTURE": "资金钱包 --> U本位合约钱包",
        "UMFUTURE_FUNDING": "U本位合约钱包 --> 资金钱包",
        "FUNDING_CMFUTURE": "资金钱包 --> 币本位合约钱包",
        "CMFUTURE_FUNDING": "币本位合约钱包 --> 资金钱包",
        "UMFUTURE_OPTION": "U本位合约钱包 --> 期权钱包",
        "OPTION_UMFUTURE": "期权钱包 --> U本位合约钱包",
        // 统一账户
        "MAIN_PORTFOLIO_MARGIN": "现货钱包 --> 统一账户钱包",
        "PORTFOLIO_MARGIN_MAIN": "统一账户钱包 --> 现货钱包"
    }
    
    Log("开始检测")
    _.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("检测到新增划转记录", 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("开始结束")
}


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

Présentation du code :

Le code JavaScript fourni comprend plusieurs fonctions qui, ensemble, créent un système de surveillance des transferts d’actifs récents. Décomposons les principaux composants :

• Fonction getRecentTransferHistory :

Objectif : obtenir l’historique récent des transferts d’actifs à partir de l’API d’échange en fonction des paramètres spécifiés. Paramètres : TransType (type de transfert), typeDesc (description du type). Point de terminaison API : /sapi/v1/asset/transfer.

• Fonction monitorTransfers :

Objectif : itère sur les types de transfert prédéfinis, récupère l’historique des transferts les plus récents et enregistre tous les nouveaux transferts. Utilisez un dictionnaire (dicType) pour mapper les types de transfert à des descriptions lisibles par l’homme. Mettez à jour l’objet moniteur pour suivre le dernier transfert de chaque type.

• fonction principale:

Objectif : exécuter une boucle infinie qui surveille en permanence les transferts et affiche les données les plus récentes. Utilisez périodiquement la fonction monitorTransfers. Générez un tableau pour chaque type de transfert, y compris des colonnes telles que l’actif, le montant, le statut, l’ID de transaction et l’horodatage.

Caractéristiques principales :

• Mappage des types de transfert dynamique :

Le code utilise un dictionnaire (dicType) pour mapper les types de transfert à des noms descriptifs, fournissant une description claire de la nature de chaque transfert.

• Surveillance en temps réel :

Le système vérifie en permanence les nouveaux transferts, met à jour l’objet de surveillance et enregistre toutes les modifications détectées.

• Présentation des données :

Utilisez un tableau pour présenter chaque type de données de transfert, y compris les détails pertinents tels que l’actif, le montant, le statut, l’ID de transaction et l’horodatage.

• Gestion de l’historique des transferts récents :

Maintient une liste déroulante des transferts les plus récents pour chaque type, garantissant un affichage concis et rapide.

Test réel

Un transfert a été effectué manuellement et le programme a détecté l’opération de transfert.

END:

Le code JavaScript fourni fournit une solution puissante pour surveiller les transferts d’actifs récents sur les échanges de crypto-monnaie. Sa nature dynamique et en temps réel en fait un outil précieux pour les traders et les développeurs cherchant à comprendre le mouvement des actifs entre différents portefeuilles. Ce code peut être modifié et personnalisé pour répondre à des besoins spécifiques, offrant une base solide pour ceux qui cherchent à améliorer leurs stratégies de trading de crypto-monnaie ou à développer des capacités de surveillance supplémentaires.

Cet article n’est qu’un point de départ pour vous proposer une idée de conception. J’espère que votre entreprise de crypto-monnaie sera à la fois informative et fructueuse !