Conception d'un système de gestion synchrone basé sur les ordres FMZ (2)

Conception d'un système de gestion synchrone basé sur les ordres FMZ (2)

Système de gestion synchrone des commandes (serveur synchrone)

Continuons la discussion dans l'article précédent:Conception d'un système de gestion synchrone basé sur les ordres FMZ (1), de concevoir une stratégie de surveillance synchrone des ordres. Veuillez considérer les questions de conception suivantes:

• 1.Si vous ne souhaitez pas superviser les commandes de manière synchrone pendant un certain temps, peut-il être arrêté?Une fois arrêté, désactivez le redémarrage à partir de l'API étendue et utilisez la vérification par mot de passe. Pour mettre en œuvre cette fonction, ajoutez 2 variables globales:

  var isStopFollow = false   // used to mark whether to currently supervise orders or not 
  var reStartPwd = null      // used to record the restart password 
  

Ensuite, ajoutez des commandes interactives sur la page de modification de stratégie pour arrêter / redémarrer la stratégie (il ne s'agit pas d'arrêter le bot, il suffit d'arrêter la logique, de ne pas suivre et de superviser les ordres, sans rien faire).Order Synchronous Management System Library (Single Server)Lorsque vous redémarrez pour superviser les commandes, entrez le mot de passe prédéfini pour invoquer la fonction de supervision des commandes. Code de mise en œuvre de la fonction connexe:

...
          // Judge the interactive command
          if (arr.length == 2) {
          	// Buttons with controls
          	if (arr[0] == "stop/restart") {
          		// Stop/restart to supervise orders 
          		if (!isStopFollow) {
          		    isStopFollow = true
          		    reStartPwd = arr[1]
          		    Log("stopped to supervise orders,", "the set restart password is:", reStartPwd, "#FF0000")
          		} else if (isStopFollow && arr[1] == reStartPwd) {
          			isStopFollow = false 
          			reStartPwd = null 
          			Log("restarted to supervise orders,", "clear the restart password.", "#FF0000")
          		} else if (isStopFollow && arr[1] != reStartPwd) {
          			Log("Wrong restart password!")
          		}
          	}
          	continue 
          }

• 2.Le montant de l'ordre supervisé peut être spécifié ou réduit en fonction du ratio:

  

  spécifiéAmount: spécifier le montant de l'ordre supervisé; défaut est -1, c'est-à-dire non spécifié. zoomAmountRatio: zoom en fonction de la quantité d'ordre du signal envoyé.ETH_USDT,swap,buy,1, puis multiplier la valeur du montant de commande par zoomAmountRatio; par défaut, c'est -1, c'est-à-dire pas zoomé.

      var amount = specifiedAmount == -1 ? action.amount : specifiedAmount
      amount = zoomAmountRatio == -1 ? amount : amount * zoomAmountRatio
  

  C'est là que nous avons réaliséle zoomle montant de la commande ouspécifier une certaine valeur, selon le signal reçu.

• 3.Ecrire des codes aussi simples que possible et utiliser d'autres bibliothèques de modèles pour traiter les commandes.

  Bibliothèque de modèles utilisée pour placer des ordres au comptant:https://www.fmz.com/strategy/10989Bibliothèque de modèles utilisée pour placer des ordres à terme:https://www.fmz.com/strategy/203258

    function trade(action) {
        // Switch the trading pair, and set contract 
        exchange.SetCurrency(action.symbol)
        if (action.ct != "spot") {
            exchange.SetContractType(action.ct)        
        }        
  
        var retTrade = null 
        var amount = specifiedAmount == -1 ? action.amount : specifiedAmount
        amount = zoomAmountRatio == -1 ? amount : amount * zoomAmountRatio    
  
        if (action.direction == "buy") {
            retTrade = action.ct == "spot" ? $.Buy(amount) : $.OpenLong(exchange, action.ct, amount)
        } else if (action.direction == "sell") {
            retTrade = action.ct == "spot" ? $.Sell(amount) : $.OpenShort(exchange, action.ct, amount)
        } else if (action.direction == "closebuy") {
            retTrade = action.ct == "spot" ? $.Sell(amount) : $.CoverLong(exchange, action.ct, amount)
        } else if (action.direction == "closesell") {
            retTrade = action.ct == "spot" ? $.Buy(amount) : $.CoverShort(exchange, action.ct, amount)
        }
        return retTrade
    }
  

  On peut donc voir que pour passer une commande, il suffit d'une seule déclaration:$.Sell(amount), $.Buy(amount), $.OpenLong(exchange, action.ct, amount), etc.

Code de stratégie:

Le code provisoire dans le précédentOrder Synchronous Management System (Synchronous Server)est la suivante:

Maintenant, allons concevoir leOrder Synchronous Management System (Synchronous Server)Je répète:

// Global variables
var isStopFollow = false
var reStartPwd = null 

function trade(action) {
    // Switch the trading pair, and set contract
    exchange.SetCurrency(action.symbol)
    if (action.ct != "spot") {
        exchange.SetContractType(action.ct)        
    }    

    var retTrade = null 
    var amount = specifiedAmount == -1 ? action.amount : specifiedAmount
    amount = zoomAmountRatio == -1 ? amount : amount * zoomAmountRatio

    if (action.direction == "buy") {
        retTrade = action.ct == "spot" ? $.Buy(amount) : $.OpenLong(exchange, action.ct, amount)
    } else if (action.direction == "sell") {
    	retTrade = action.ct == "spot" ? $.Sell(amount) : $.OpenShort(exchange, action.ct, amount)
    } else if (action.direction == "closebuy") {
    	retTrade = action.ct == "spot" ? $.Sell(amount) : $.CoverLong(exchange, action.ct, amount)
    } else if (action.direction == "closesell") {
    	retTrade = action.ct == "spot" ? $.Buy(amount) : $.CoverShort(exchange, action.ct, amount)
    }
    return retTrade
}

function parseCmd(cmd) {
	var objAction = {}
	// Parse cmd, such as: ETH_USDT,swap,buy,1
    var arr = cmd.split(",")
    if (arr.length != 4) {
    	return null 
    }
    objAction.symbol = arr[0]
    objAction.ct = arr[1]
    objAction.direction = arr[2]
    objAction.amount = arr[3]
    return objAction
}

function main() {
	// Clear all logs 
    LogReset(1)  

    if (isSimulateOKEX) {
    	exchange.IO("simulate", true)
    	Log("Switch to OKEX simulated bot!")
    }

    // set precision 
    exchange.SetPrecision(pricePrecision, amountPrecision)

    // Check specifiedAmount and zoomAmountRatio, for they cannot be set at the same time 
    if (specifiedAmount != -1 && zoomAmountRatio != -1) {
    	throw "cannot set specifiedAmount and zoomAmountRatio at the same time"
    }

    while (true) {
        var cmd = GetCommand()
        if (cmd) {
            Log("cmd: ", cmd)
            var arr = cmd.split(":")

            // Judge the interactive command 
            if (arr.length == 2) {
            	// Buttons with controls 
            	if (arr[0] == "stop/restart") {
            		// Stop/restart to supervise orders 
            		if (!isStopFollow) {
            		    isStopFollow = true
            		    reStartPwd = arr[1]
            		    Log("stopped to supervise orders,", "the set restart password is:", reStartPwd, "#FF0000")
            		} else if (isStopFollow && arr[1] == reStartPwd) {
            			isStopFollow = false 
            			reStartPwd = null 
            			Log("restarted to supervise orders,", "Clear the restart password", "#FF0000")
            		} else if (isStopFollow && arr[1] != reStartPwd) {
            			Log("Wrong restart password!")
            		}
            	}
            	continue 
            }
            
            // Allow to supervise orders 
            if (!isStopFollow) {
                // Parse the interactive command of the order supervising signal
                var objAction = parseCmd(cmd)
                if (objAction) {
            	    // Parse correctly 
            	    var ret = trade(objAction)
                } else {
                	Log("Wrong signal cmd:", cmd)
                }
            }
        }
        
        // Display the order supervising status 
        LogStatus(_D(), isStopFollow ? "Stop synchronization" : "Maintain synchronization", "\n")

        Sleep(1000)
    }
}

Test de détection

Cette fois, le test de tick réel de Binance est utilisé pour le compte avec les ordres, et le compte OKEX est utilisé pour le bot de supervision des ordres.mainfonction dans leOrder Synchronous Management System Library (Single Server)le modèle).

Il est juste que nous avons changé la direction de la négociation à court, et le volume de négociation a été changé à 0,003 (Binance USDT-contrats à marge peuvent être placés en décimales).specifiedAmountcomme 1.

Le bot de la fonction de test dansOrder Synchronous Management System Library (Single Server)a déclenché le commerce.

L'ordre de supervision de la stratégie bot a reçu le signal, et exécuter l'action de supervision:

La plateforme a ouvert la commande correspondante.

Ensuite, testez les positions de clôture et changez la direction de l'ordre dans la fonction principale pour fermer la position courte, 0,003.

Puis redémarrez le bot qui est responsable de la réalisation des ordres (Order Synchronous Management System Library (Single Server)).

La même opération est également déclenchée dans le bot de supervision de commande:

Adresse de la stratégie:Bibliothèque du système de gestion synchrone de commande (serveur unique) Système de gestion synchrone des commandes (serveur synchrone)

Ces stratégies ne sont utilisées que pour la communication et l'étude; pour une utilisation réelle, vous devez les modifier, les ajuster et les optimiser par vous-même.