Conception d'un système de gestion de la synchronisation des commandes basé sur FMZ Quant (2)

Conception d'un système de gestion de la synchronisation des commandes basé sur FMZ Quant (2)

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

Continuons la discussion de l'article précédent: Conception d'un système de gestion de la synchronisation des commandes basé sur la quantification FMZ (1) (https://www.fmz.com/digest-topic/9729) et commencer à concevoir une stratégie de suivi synchronisé des commandes.

Pensez à quelques-unes de ces questions de conception:

• 1. Si vous ne souhaitez pas effectuer le suivi synchrone des commandes temporairement, est-il possible de le mettre en pause? Une fois suspendu, il est interdit de démarrer à partir de l'API étendue, il doit être authentifié par le mot de passe. Mettre en œuvre cette fonction en ajoutant 2 variables globales:

var isStopFollow = false   // Used to mark whether the current order is being followed
var reStartPwd = null      // Used to record the restart password

Ensuite, nous ajoutons des commandes interactives sur la page d'édition de stratégie pour la stratégie pause / redémarrer (pas pour arrêter le vrai bot, juste la pause logique, pas plus de commande-suivant).Order Synchronization Management System Class Library (Single Server)Lorsque vous redémarrez la fonction de suivi des ordres, entrez le mot de passe prédéfini pour réveiller la fonction de suivi des ordres. Code pour la mise en œuvre des fonctions concernées:

...
          // Judge the interaction command
          if (arr.length == 2) {
          	// Buttons with controls
          	if (arr[0] == "stop/restart") {
          		// Pause/restart order-following
          		if (!isStopFollow) {
          		    isStopFollow = true
          		    reStartPwd = arr[1]
          		    Log("it has stopped the order-following,", "Set the restart password as:", reStartPwd, "#FF0000")
          		} else if (isStopFollow && arr[1] == reStartPwd) {
          			isStopFollow = false 
          			reStartPwd = null 
          			Log("it has restarted the order-following, ", "Clear the restart password.", "#FF0000")
          		} else if (isStopFollow && arr[1] != reStartPwd) {
          			Log("Restart password error!")
          		}
          	}
          	continue 
          }

• 2. Vous pouvez spécifier le nombre d'ordres à suivre ou peut être mis à l'échelle en multiples Ajouter des paramètres à la stratégie:

specifiedAmount: spécifier le nombre d'ordres suivis, par défaut -1, c'est-à-dire non spécifié. zoomAmountRatio: Mise à l'échelle en fonction du montant des ordres envoyés, par exemple, si le signal envoyé est: ETH_USDT,swap,buy,1, multipliez la valeur du montant des ordres par zoomAmountRatio.

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

Ici, il est mis en œuvre pour échelonner ou spécifier une valeur spécifique pour le nombre d'ordres à suivre dans le signal reçu.

• 3. Le code doit être aussi simple que possible, utiliser d'autres bibliothèques de modèles pour passer une commande.

La bibliothèque de classes utilisée par les commandes au comptant:https://www.fmz.com/strategy/10989La bibliothèque de classes utilisée par les commandes futures placées:https://www.fmz.com/strategy/203258

  function trade(action) {
      // Switch trading pairs and set up contracts
      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 voit donc que pour passer une commande, il suffit d'une phrase:$.Sell(amount), $.Buy(amount), $.OpenLong(exchange, action.ct, amount). etc.

Code de stratégie:

Le code provisoire de l'ancienOrder Synchronous Management System (Synchronous Server)était la suivante:

Maintenant, nous commençons à redessiner le système de gestion de la synchronisation des commandes (serveur synchrone):

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

function trade(action) {
    // Switch trading pairs and set up contracts
    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 demo!")
    }

    // Set accuracy
    exchange.SetPrecision(pricePrecision, amountPrecision)

    // Check zoom and specify it cannot be set at the same time
    if (specifiedAmount != -1 && zoomAmountRatio != -1) {
    	throw "it cannot specify simultaneous volume and scaling volume at the same time"
    }

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

            // Judge interaction commands
            if (arr.length == 2) {
            	// Buttons with controls
            	if (arr[0] == "stop/restart") {
            		// Pause/restart order-following
            		if (!isStopFollow) {
            		    isStopFollow = true
            		    reStartPwd = arr[1]
            		    Log("it has stopped the order-following.", "Set the restart password as.", reStartPwd, "#FF0000")
            		} else if (isStopFollow && arr[1] == reStartPwd) {
            			isStopFollow = false 
            			reStartPwd = null 
            			Log("it has restarted the order-following", "Clear the restart password.", "#FF0000")
            		} else if (isStopFollow && arr[1] != reStartPwd) {
            			Log("Restart password error!")
            		}
            	}
            	continue 
            }
            
            // Permission to follow orders
            if (!isStopFollow) {
                // Resolve the interaction instructions of order-following signal
                var objAction = parseCmd(cmd)
                if (objAction) {
            	    // The analysis is correct
            	    var ret = trade(objAction)
                } else {
                	Log("Wrong signal command cmd:", cmd)
                }
            }
        }
        
        // Display order-following status
        LogStatus(_D(), isStopFollow ? "Stop Synchronization" : "Keep Synchronization", "\n")

        Sleep(1000)
    }
}

Test de détection

Nous testons le compte de commandes en utilisant le Binance vrai bot pour ce temps, et nous utilisons le compte OKEX pour les ordres suivants vrai bot.mainfonction dans la fonction d'essai(Order Synchronization Management System Class Library (Single Server)dans le modèle) utilisé dans l'article précédent.

Ici, nous changeons la direction de la transaction en sell, et le volume de la transaction en 0,003 (les ordres peuvent être placés en chiffres décimaux pour les contrats standard Binance USDT). Mais le suivi des ordres pour le compte OKEX doit être un nombre entier (les ordres d'échange OKEX doivent être un nombre entier), nous spécifions donc le paramètre de stratégie specifiedAmount comme 1.

Ensuite, nous allons tester la fermeture de la position en changeant la direction de l'ordre dans la fonction principale de test pour fermer la position courte par 0,003.

Ensuite, nous l'exécutons à nouveau, qui est responsable de la commande-leading (Order Synchronization Management System Class Library (Single Server)).

La même opération a été déclenchée par un vrai robot.

L'adresse de la stratégie: La bibliothèque de classes du système de gestion de la synchronisation des commandes (serveur unique) (https://www.fmz.com/strategy/345171) Système de gestion de la synchronisation des commandes (serveur synchrone) (https://www.fmz.com/strategy/345172)

La stratégie est conçue uniquement pour la communication et l'apprentissage, s'il vous plaît ajuster et optimiser en fonction des besoins réels.