Mettre en œuvre un robot simple de trading spot de devises numériques

Il existe de nombreux traders manuels dans le cercle des crypto-monnaies qui ont besoin de robots imitateurs, mais ils sont troublés par le fait qu’il faut beaucoup de temps pour se lancer dans la conception programmatique lorsqu’ils n’ont aucune connaissance de base. Sur la base de ce type de demande, dans cet article, nous allons concevoir un simple robot de trading de copie au comptant pour aider les amis du cercle des crypto-monnaies qui n’ont aucune connaissance de base du trading algorithmique.

Commençons par analyser les besoins. La fonction de ce robot est de garantir que lorsqu’un compte effectue une opération d’achat ou de vente, d’autres comptes de copie suivront et exécuteront cette opération. C’est pourquoi nous clarifions d’abord deux sujets :

• Compte de référence : un compte surveillé qui surveille chaque mouvement de ce compte.
• Compte de copie : compte qui suit les commandes. Lorsqu’une action se produit dans le compte de référence, le compte de copie exécute la même action.

Maintenant que nous avons identifié ce besoin de manière préliminaire, nous devons continuer à réfléchir à l’étape suivante. Comment identifier les actions des comptes de référence ?

Le suivi des comptes de référence est très simple pour les comptes spot. Il suffit de comparer le nombre de pièces dans les données d’informations de compte les plus récentes avec le nombre de pièces dans les dernières données d’informations de compte actuellement obtenues. Si le nombre de pièces dans les dernières données d’informations de compte actuellement obtenues est supérieur à l’enregistrement précédent, cela prouve que le compte de référence a exécuté une opération d’achat et que l’achat a réussi. Au contraire, s’il y a moins de pièces, une opération de vente est effectuée pour le compte de référence. Après avoir découvert cette action, nous laissons simplement d’autres comptes d’échange effectuer la même opération.

Lorsqu’une transaction est constatée comme ayant été exécutée sur un compte de référence, l’enregistrement de données de compte le plus récent doit être mis à jour pour être comparé aux informations de compte obtenues la prochaine fois afin de déterminer s’il existe une nouvelle action de transaction.

La logique ci-dessus est décrite par le code de stratégie :

        // 检测跟单
        var amount = (nowAcc.Stocks + nowAcc.FrozenStocks) - (initAcc.Stocks + initAcc.FrozenStocks)  // 检测币数发生的变化
        var func = null 
        if (amount > 0) {   // 币变多了
            func = $.Buy    // 买入
        } else if (amount < 0) {  // 币变少了
            func = $.Sell         // 卖出
        } else {
            continue
        }
        
        // 执行跟单
        Log("跟单！数量：", Math.abs(amount), "#FF0000")
        for (var i = 1 ; i < exchanges.length ; i++) {    // i 等于 0 时，是参考交易所，不处理，处理其它的跟单交易所        
            func(exchanges[i], Math.abs(amount))          // 执行具体的交易函数，可能是$.Buy 或者是 $.Sell ，具体看amount 是大于0，还是小于0
        }
        
        // 执行跟单之后更新参考交易所账户信息记录
        initAcc = nowAcc                                  // 更新参考交易所最近一次的账户信息，用于下次对比

La logique de détection principale de la stratégie est le code ci-dessus. Dans un souci de simplicité de conception, la stratégie utilise le modèle officiel FMZ [Digital Currency Trading Library].$.Buy , $.SellCe sont toutes des fonctions de ce modèle, et leur fonction est d’exécuter des opérations de commande.

Ajoutez quelques barres d’état à la stratégie pour faciliter le suivi des données de chaque compte. La stratégie complète est la suivante :

function test() { 
    // 测试函数
    var ts = new Date().getTime()    
    if (ts % (1000 * 60 * 60 * 6) > 1000 * 60 * 60 * 5.5) {
        Sleep(1000 * 60 * 10)
        var x = Math.random()
        if (x > 0.5) {
            $.Buy(exchange, x / 10)    
        } else {
            $.Sell(exchange, x / 10)    
        }        
    }
}

function main() {
    LogReset(1)
    if (exchanges.length < 2) {
        throw "没有跟单的交易所"
    }
    var exName = exchange.GetName()
    // 检测参考交易所
    if (exName.includes("Futures_")) {
        throw "仅支持现货跟单"
    }
    Log("开始监控", exName, "交易所", "#FF0000")
    
    // 检测跟单交易所
    for (var i = 1 ; i < exchanges.length ; i++) {
        if (exchanges[i].GetName().includes("Futures_")) {
            throw "不支持期货交易所跟单"
        }
    }
    
    var initAcc = _C(exchange.GetAccount)
    while(1) {
        if(IsVirtual()) {
           // 测试函数
           test()  
        }  
        Sleep(5000)
        
        // 更新参考账户当前的账户信息
        var nowAcc = _C(exchange.GetAccount)
        
        // 参考交易所账户信息
        var refTbl = {
            type : "table", 
            title : "参考交易所",
            cols : ["名称", "币", "冻结币", "钱", "冻结钱"],
            rows : []
        }
        refTbl.rows.push([exName, nowAcc.Stocks, nowAcc.FrozenStocks, nowAcc.Balance, nowAcc.FrozenBalance])
        
        // 跟单交易所账户信息
        var followTbl = {
            type : "table", 
            title : "跟单交易所",
            cols : ["名称", "币", "冻结币", "钱", "冻结钱"],
            rows : []        
        }
        for (var i = 1 ; i < exchanges.length ; i++) {
            var acc = _C(exchanges[i].GetAccount)
            var name = exchanges[i].GetName()
            followTbl.rows.push([name, acc.Stocks, acc.FrozenStocks, acc.Balance, acc.FrozenBalance])
        }
        
        // 状态栏显示
        LogStatus(_D(), "\n`" + JSON.stringify(refTbl) + "`", "\n`" + JSON.stringify(followTbl) + "`")
        
        // 检测跟单
        var amount = (nowAcc.Stocks + nowAcc.FrozenStocks) - (initAcc.Stocks + initAcc.FrozenStocks)
        var func = null 
        if (amount > 0) {
            func = $.Buy
        } else if (amount < 0) {
            func = $.Sell
        } else {
            continue
        }
        
        // 执行跟单
        Log("跟单！数量：", Math.abs(amount), "#FF0000")
        for (var i = 1 ; i < exchanges.length ; i++) {            
            func(exchanges[i], Math.abs(amount))
        }
        
        // 执行跟单之后更新参考交易所账户信息记录
        initAcc = nowAcc
    }
}

Réalisons un test en temps réel en utilisant le test d’échange simulé wexApp de FMZ. Ici, j’ai ajouté trois comptes wexApp, qui sont indépendants les uns des autres. L’un d’eux sert d’échange de référence et les deux autres servent d’échanges de copies.

Nous passons ensuite manuellement une commande à l’aide du terminal de trading de FMZ pour voir si le robot suivra automatiquement la commande.

Vous pouvez voir que le robot a détecté la transaction et exécuté l’opération de copie.

Stratégie complète : https://www.fmz.com/strategy/255182

La stratégie est uniquement destinée à l’apprentissage. Si vous avez des questions, n’hésitez pas à laisser un message.