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

Commander un serveur synchrone

Continuons avec l’article précédent :Conception d’un système de gestion de synchronisation des commandes basé sur la quantification FMZ (1)Après avoir discuté avec les experts, nous avons commencé à concevoir une stratégie de copy trading synchrone.

Tenez compte de ces problèmes de conception :

• 1. Si vous ne souhaitez pas suivre les commandes de manière synchrone pour le moment, pouvez-vous les mettre en pause ? Une fois en pause, le lancement depuis l’API d’extension est interdit, en utilisant l’authentification par mot de passe. Pour implémenter cette fonction, ajoutez deux variables globales :

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

Ajoutez ensuite des contrôles interactifs sur la page d’édition de stratégie pour mettre en pause/redémarrer la stratégie (cela n’arrête pas le trading réel, mais met uniquement en pause la logique, arrête de suivre les ordres et ne fait rien). Lors de la pause, vous pouvez définir un mot de passe de pause afin que même si vous disposez de votre CLÉ API étendue订单同步管理系统类库（Single Server）Même un compte réel ne peut pas réveiller votre stratégie. Lors du redémarrage du copy trading, entrez le mot de passe prédéfini pour réactiver la fonction copy trading. Code d’implémentation des fonctions associées :

  ...
            // 判断交互指令
            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 la quantité commandée ou l’augmenter ou la diminuer Ajoutez des paramètres à la stratégie :

specifiedAmount : spécifie le montant de la commande de suivi. La valeur par défaut est -1, ce qui signifie qu’elle n’est pas spécifiée. zoomAmountRatio : zoom en fonction du montant de la commande dans le signal envoyé, par exemple, le signal envoyé est :ETH_USDT,swap,buy,1, multipliez la quantité commandée par zoomAmountRatio. La valeur par défaut est -1, ce qui signifie aucune mise à l’échelle.

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

Ici, nous implémentons la quantité de commande qui doit être suivie dans le signal reçuZoomouSpécifier des valeurs spécifiques。

• 3. Gardez le code aussi concis que possible et utilisez d’autres bibliothèques de modèles pour le traitement des commandes.

Commande ponctuelle à l’aide de la bibliothèque de classes : https://www.fmz.com/strategy/10989 Bibliothèque d’ordres à terme : 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 donc que passer une commande ne nécessite qu’une seule phrase :$.Sell(amount) 、$.Buy(amount) 、 $.OpenLong(exchange, action.ct, amount) .. attendez.

Code de stratégie :

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

Commencez à repenser maintenant订单同步管理系统（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)
    }
}

test

Cette fois, le compte avec les commandes utilisera le compte réel Binance pour les tests, et le compte réel pour la copie des commandes utilisera le compte OKEX. Nous utilisons toujours la fonction de test utilisée dans l’article précédent (订单同步管理系统类库（Single Server）Dans le modèlemainfonction).

Nous venons de changer le sens de la transaction vers la vente à découvert et le volume de la transaction à 0,003 (les contrats basés sur Binance USDT peuvent passer des commandes en décimales). Cependant, le compte OKEX doit être un entier (les ordres de change OKEX doivent être passés en nombres entiers), je précise donc les paramètres de stratégiespecifiedAmountest 1.

订单同步管理系统类库（Single Server）La fonction de test déclenche une transaction réelle.

La stratégie en temps réel de copie des ordres reçoit le signal et exécute l’action de copie :

La bourse a ouvert un ordre correspondant.

Ensuite, testons la fermeture de la position et modifions le sens de l’ordre dans la fonction principale de test pour fermer la position courte de 0,003 contrat.

Ensuite, exécutez à nouveau le vrai disque chargé de prendre les commandes (订单同步管理系统类库（Single Server））。

La même opération est également déclenchée en copiant la commande réelle :

Adresse de la politique : Bibliothèque de classes du système de gestion de la synchronisation des commandes (serveur unique) Commander un serveur synchrone

La conception de la stratégie est uniquement destinée à la communication et à l’apprentissage. Veuillez la modifier, l’ajuster et l’optimiser en fonction des besoins réels de production.