Un modèle de stratégie vous permet d'utiliser WebSocket Market de manière transparente

Ceci est un modèle de marché WebSocket officiellement développé par FMZ. Bienvenue à tous les utilisateurs pour le copier et l'utiliser:https://www.fmz.com/strategy/470349

Pourquoi avons-nous besoin de WebSocket?

À l'heure actuelle, la stratégie FMZ est principalement basée sur l'encapsulation traditionnelle de l'API REST. Chaque étape de l'accès à l'API nécessite l'établissement d'une connexion réseau et les données de marché sont obtenues par sondage. Cette méthode est simple et facile à utiliser et elle est complètement suffisante pour la plupart des besoins.

Cependant, le protocole REST a un problème de retard inhérent. Lorsque plusieurs paires de négociation et plusieurs stratégies d'échange sont requises, le problème de retard sera amplifié. Bien que la fonction Go de la plate-forme puisse être exécutée simultanément, le problème de retard existe toujours, ce qui rend difficile de répondre aux besoins du trading de stratégie à fréquence relativement élevée.

Actuellement, les serveurs des bourses sont également sous lourd fardeau. Ils fournissent tous un protocole WebSocket complet et le recommandent aux utilisateurs d'API. Par rapport au protocole REST, WebSocket fournit une méthode de connexion bidirectionnelle persistante, qui permet aux bourses de pousser les données vers le client en temps réel, évitant les demandes et réponses fréquentes, réduisant ainsi considérablement la latence.

Introduction au modèle WebSocket

FMZ Quant Trading plateforme a pris en charge le protocole WebSocket depuis longtemps, et il est relativement pratique d'appeler, mais pour les utilisateurs novices, il est encore trop compliqué de gérer plusieurs abonnements, souscrire à plusieurs tickers d'échange, et les intégrer efficacement et facilement dans l'ensemble du processus de stratégie. Ce modèle public d'accélération de données WebSocket en temps réel résout ce problème. Il est très facile à utiliser et est entièrement compatible avec l'appel API encapsulé actuel. Pour la plupart des stratégies REST originales, vous pouvez simplement les modifier et les utiliser directement pour accélérer votre stratégie.

Principales caractéristiques:

• Soutien multi-échanges: Cette stratégie prend en charge les connexions WebSocket de plusieurs échanges, tels que Binance, OKX, Bybit, Bitget, etc. Les utilisateurs peuvent suivre la méthode d'emballage de ce modèle pour prendre en charge eux-mêmes plus d'échanges.
• Abonnements personnalisables: Il permet de s'abonner à des canaux de marché spécifiques (tels que la profondeur, les transactions, etc.) et de traiter efficacement les données reçues pour une utilisation immédiate dans les stratégies de négociation.
• Gestion avancée des erreurs: suivi intégré des erreurs et mécanisme de reconnexion WebSocket pour assurer la fiabilité et la continuité du flux de données.

Une brève introduction au principe de mise en œuvre

Notez que cette stratégie utilise TypeScript. Si vous n'êtes familiarisé qu'avec JavaScript, cela peut sembler un peu étrange. TypeScript introduit un système de types et des fonctionnalités linguistiques plus riches basées sur JavaScript. Pour les applications telles que le trading quantitatif qui doivent gérer une logique complexe, l'utilisation de TypeScript peut réduire les erreurs potentielles et améliorer la lisibilité et la maintenance du code. Par conséquent, il est recommandé de l'apprendre brièvement.

En outre, la stratégie utilise le mécanisme asynchrone de la plate-forme FMZ. Le thread enfant peut envoyer des messages au thread principal via la fonction __threadPostMessage. Cette méthode est asynchrone et convient pour notifier au thread principal les mises à jour de données générées dans le thread enfant. Le thread principal et le thread enfant peuvent partager des données via les fonctions __threadGetData et __threadSetData. Cette méthode permet aux threads d'accéder et de modifier les états partagés.

Le principe principal de cette stratégie est de se connecter aux principaux échanges de devises numériques via WebSocket et de recevoir des données de marché (telles que des informations de profondeur et des informations de transaction) en temps réel pour fournir un support de données pour les décisions commerciales quantitatives.

1. Paramètres de connexion WebSocketLa fonctionsetupWebsocketest utilisé pour initialiser une connexion WebSocket et recevoir des données de marché.main_exchanges, indiquant l'échange à connecter.

• MyDial fonction: Créez une connexion WebSocket, enregistrez le temps de connexion et sortez l'heure de fermeture lors de la fermeture de la connexion.
• updateSymbols fonction: Vérifiez régulièrement s'il y a de nouvelles demandes de souscription et mettez à jour la liste actuelle des paires de négociation au besoin.

2. Traitement des donnéesL' objetsupportsdéfinit les échanges pris en charge et leur fonction de traitement (commeBinanceLa fonction de traitement de chaque échange est responsable de l'analyse du message reçu et de l'extraction des données pertinentes.

• processMsg fonction: Traiter les messages des échanges, identifier les différents types de données (tels que les mises à jour de profondeur, les transactions, etc.) et les formater en un objet événement unifié.

3. Données sur les abonnementsÀ chaque connexion, le système s'abonne aux canaux de données de marché pertinents basés sur la paire de négociation en cours.

• getFunction fonctionObtenez la fonction de traitement correspondante selon le nom de l'échange.
• this.wssPublic fonction: Initialisez la connexion WebSocket et commencez à recevoir des données.

4. Gestion des filsDémarrez un fil pour chaque échange, recevez des données en temps réel et traitez les données via des fonctions de rappel.

• threadMarket fonction: Recevoir des données dans un fil enfant, analyser et stocker les dernières informations de profondeur et de transaction.

5. Réécrire la méthode d'acquisition des donnéesRéécrire les méthodes d'obtention d'informations de profondeur et de négociation pour chaque bourse, en donnant la priorité à la restitution de données mises à jour en temps réel.

Comment utiliser le modèle

1. Initialisation: Utilisation$.setupWebsocket()pour initialiser la connexion WebSocket de l'échange cible.
2. Abonnement: Le système s'abonnera automatiquement aux canaux pertinents (tels que la profondeur, le trading, etc.) pour les produits que vous négociez.
3. Acquisition de données: En appelant leGetDepth()etGetTrades()les fonctions, la profondeur du marché et les enregistrements de transactions sont automatiquement renvoyés à l'aide de données WebSocket en temps réel.
4. Gestion des erreurs: La stratégie comprend un mécanisme de suivi pour enregistrer les erreurs de connexion et de données, et des tentatives de reconnexion automatique en cas de perte de connexion.

Si la fonction EventLoop() est ajoutée à la stratégie, elle sera changée en mécanisme de déclenchement. Lorsqu'il y a une mise à jour de données wss, elle l'obtiendra automatiquement immédiatement, et attend si il n'y a pas de données récentes. C'est l'équivalent d'une fonction de sommeil intelligent. Bien sûr, vous pouvez également utiliser le sommeil directement.

function main() {
    $.setupWebsocket()
    while (true) {
        exchanges.map(e=>{
            Log(e.GetName(), e.GetDepth())
            Log(e.GetName(), e.GetTrades())
        })
        EventLoop(100) // trigger by websocket
    }
}

Consultez mon précédent guide de stratégie de trading multi-monnaie:https://www.fmz.com/bbs-topic/10508, qui peut être facilement modifié pour prendre en charge WebSocket:

function MakeOrder() {
    for (let i in Info.trade_symbols) {
        let symbol = Info.trade_symbols[i];
        let buy_price = exchange.GetDepth(symbol + '_USDT').Asks[0].Price;
        let buy_amount = 50 / buy_price;
        if (Info.position[symbol].value < 2000){
            Trade(symbol, "buy", buy_price, buy_amount, symbol);
        }
    }
}

function OnTick() {
    try {
        UpdatePosition();
        MakeOrder();
        UpdateStatus();
    } catch (error) {
        Log("loop error: " + error);
    }
}

function main() {
    $.setupWebsocket()
    InitInfo();
    while (true) {
        let loop_start_time = Date.now();
        if (Date.now() - Info.time.last_loop_time > Info.interval * 1000) {
            OnTick();
            Info.time.last_loop_time = Date.now();
            Info.time.loop_delay = Date.now() - loop_start_time;
        }
        Sleep(5);
    }
}