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

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

Système de gestion des commandes synchrone (Synchronous Server)

Nous continuons avec l'article précédent:Conception d'un système de gestion synchrone des commandes basé sur la quantification FMZ (1)Les discussions ont commencé et une stratégie de synchronisation des listes a été mise en place.

Il y a aussi des questions de conception:

• Si vous ne souhaitez pas synchroniser les comptes, vous pouvez suspendre. Une fois suspendu, il est interdit de démarrer à partir de l'API d'extension et d'utiliser la vérification de mot de passe. Pour cette fonctionnalité, deux variables globales sont ajoutées:

  var isStopFollow = false   // 用于标记当前是否跟单
  var reStartPwd = null      // 用于记录重启密码
  

  

  Ensuite, sur la page d'édition de la politique, un contrôle interactif est ajouté pour suspendre/relancer la politique (pas arrêter ce disque, juste suspendre logiquement, ne pas suivre, rien ne se passe) ; un mot de passe de suspension peut être défini lors de la suspension, de sorte que même si vous avez votre extension API KEY订单同步管理系统类库（Single Server）Le disque dur ne peut pas non plus vous réveiller. Lors du redémarrage de la liste de suivi, entrez le mot de passe prédéfini pour réveiller la fonction de suivi. Le code d'implémentation des fonctionnalités:

  ...
            // 判断交互指令
            if (arr.length == 2) {
            	// 带控件的按钮
            	if (arr[0] == "stop/restart") {
            		// 暂停/重启跟单
            		if (!isStopFollow) {
            		    isStopFollow = true
            		    reStartPwd = arr[1]
            		    Log("已经停止跟单，", "设置的重启密码为：", reStartPwd, "#FF0000")
            		} else if (isStopFollow && arr[1] == reStartPwd) {
            			isStopFollow = false 
            			reStartPwd = null 
            			Log("已经重启跟单，", "清空重启密码。", "#FF0000")
            		} else if (isStopFollow && arr[1] != reStartPwd) {
            			Log("重启密码错误！")
            		}
            	}
            	continue 
            }
  

• 2° Vous pouvez spécifier le volume de la liste de commandes, ou vous pouvez augmenter le nombre de fois. Ajouter des paramètres à la stratégie:

  

  specifiedAmount: spécifie le nombre de listes, par défaut -1, c'est-à-dire pas spécifié. zoomAmountRatio: la réduction de la taille du signal envoyé en fonction de sa taille, par exemple:ETH_USDT,swap,buy,1Si le nombre d'éléments est inférieur à 0, on multiplie le nombre d'éléments par zoomAmountRatio. Par défaut, −1, c'est-à-dire sans agrandissement.

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

  C'est la quantité d'un signal reçu qui est nécessaire à la commande.La mise à grande échelleOu alorsDonner une valeur spécifique。

• 3° Le code est aussi simple que possible et le traitement des commandes est effectué à l'aide d'autres bibliothèques de modèles.

  La bibliothèque est disponible en téléchargement:https://www.fmz.com/strategy/10989Les classes utilisées pour les sous-traitants sont:https://www.fmz.com/strategy/203258

    function trade(action) {
        // 切换交易对，设置合约
        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
    }
  

  Vous voyez, il suffit d'une phrase pour écrire:$.Sell(amount) 、$.Buy(amount) 、 $.OpenLong(exchange, action.ct, amount)Je ne sais pas.

Le code de la stratégie:

Précédent订单同步管理系统（Synchronous Server）Le code provisoire est le suivant:

Maintenant, on commence à redessiner.订单同步管理系统（Synchronous Server）：

// 全局变量
var isStopFollow = false
var reStartPwd = null 

function trade(action) {
    // 切换交易对，设置合约
    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 = {}
	// 解析cmd ，例如：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() {
	// 清除所有日志
    LogReset(1)  

    if (isSimulateOKEX) {
    	exchange.IO("simulate", true)
    	Log("切换到OKEX模拟盘！")
    }

    // 设置精度
    exchange.SetPrecision(pricePrecision, amountPrecision)

    // 检查缩放、指定不能同时设置
    if (specifiedAmount != -1 && zoomAmountRatio != -1) {
    	throw "不能同时指定同步量和缩放量"
    }

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

            // 判断交互指令
            if (arr.length == 2) {
            	// 带控件的按钮
            	if (arr[0] == "stop/restart") {
            		// 暂停/重启跟单
            		if (!isStopFollow) {
            		    isStopFollow = true
            		    reStartPwd = arr[1]
            		    Log("已经停止跟单，", "设置的重启密码为：", reStartPwd, "#FF0000")
            		} else if (isStopFollow && arr[1] == reStartPwd) {
            			isStopFollow = false 
            			reStartPwd = null 
            			Log("已经重启跟单，", "清空重启密码。", "#FF0000")
            		} else if (isStopFollow && arr[1] != reStartPwd) {
            			Log("重启密码错误！")
            		}
            	}
            	continue 
            }
            
            // 允许跟单
            if (!isStopFollow) {
                // 解析跟单信号交互指令
                var objAction = parseCmd(cmd)
                if (objAction) {
            	    // 解析正确
            	    var ret = trade(objAction)
                } else {
                	Log("错误的信号指令 cmd:", cmd)
                }
            }
        }
        
        // 显示跟单情况
        LogStatus(_D(), isStopFollow ? "停止同步" : "保持同步", "\n")

        Sleep(1000)
    }
}

Le test

Cette fois, le compte de bande utilisera le disque dur de Binance et le disque dur du compte de bande utilisera le compte OKEX.订单同步管理系统类库（Single Server）Dans le modèlemainLa fonction est la suivante:

Mais nous avons changé la direction de la transaction à zéro et le volume de la transaction à 0.003 ((Binance USDT les contrats locaux peuvent être commandés par des nombres décimaux)). Mais le compte de compte OKEX doit être un entier (le compte d'échange OKEX doit être un entier), donc le paramètre Je spécifie le paramètre de stratégiespecifiedAmountIl y a 1 ∞.

订单同步管理系统类库（Single Server）Le disque dur de la fonction de test déclenche la transaction.

La stratégie du disque réel de l'ordinateur reçoit un signal et exécute l'action suivante:

Les échanges ont lancé des ordres correspondants.

Ensuite, essayez l'équilibre, en changeant la direction de l'ordre inférieur de la fonction principale de test en l'équilibre de l'emplacement de la tête blanche 0.003.

Le disque dur qui est chargé de la bande est alors redémarré.订单同步管理系统类库（Single Server））。

La même opération a été déclenchée sur le disque dur:

L'adresse de la stratégie:Système de gestion de synchronisation des commandes (Single Server) Système de gestion des commandes synchrone (Synchronous Server)

La conception de la stratégie est uniquement destinée à l'apprentissage en échange, la production réelle nécessite des modifications, des ajustements et des optimisations personnelles.