Un robot de trading de crypto-monnaie simple

Bonjour à tous! Aujourd'hui, nous écrirons notre premier robot de trading de combat pour jouer en bourse. Cryptoexchange. Pourquoi l'échange de crypto-monnaie?

a) thème de battage médiatique;
b) ils sont en quelque sorte plus simples.

Tout d'abord, je tiens à avertir immédiatement les fans du casino Three Axes: vous ne gagnerez pas de voiture demain. L'article est plus sur la façon de commencer à écrire vos robots, donc l'algorithme sera primitif, mais fonctionne.

Deuxièmement, vous gagnerez. Un tout petit peu.

Pour les plus impatients, tout le code sur le github exmo-exchange-trade-bot .

Étape 1: échange.

Nous négocierons sur l'échange EXMO. Il y a plusieurs raisons. L'échange est populaire dans la CEI, il est russophone et prend en charge l'entrée de roubles, il a la possibilité de créer des paires pour le rouble.

Parmi les inconvénients, il y a le processus peu pratique de déposer des roubles, une commission décente, quelques paires échangées.

Pour nous, l'essentiel est qu'il dispose de solutions toutes faites pour travailler avec leur API. Cela facilitera certainement notre travail.

Commençons donc.

Bien sûr, vous devez vous inscrire en bourse et déposer de l'argent. Par exemple, j'ai contribué 5 $.

Plus loin dans votre compte, vous recevrez des clés pour accéder à l'API.

J'utiliserai le client pour NodeJS (vous devrez donc installer nodejs et npm).

Sur votre ordinateur, créez un nouveau dossier et un fichier dans lequel se trouvera notre robot de trading (par exemple exmo / index.js), ouvrez la console et effectuez les dernières préparations standard.

Nous allons dans le dossier avec notre projet et écrivons - npm init, puis appuyez sur Entrée pour toutes les questions.

Ensuite, nous écrivons

npm install exmo-api 

Pendant l'installation des packages, créez un autre fichier, appelez-le exmo.js et remplissez-le avec ce contenu.

 var CryptoJS = require("crypto-js") http = require('http'), querystring = require('querystring'), request = require('request'), config = { url: 'https://api.exmo.me/v1/' }; function sign(message){ return CryptoJS.HmacSHA512(message, config.secret).toString(CryptoJS.enc.hex); } exports.init_exmo = function (cfg) { config.key = cfg.key; config.secret = cfg.secret; config.nonce = Math.floor(new Date().getTime()*1000); }; exports.api_query = function(method_name, data, callback){ data.nonce = config.nonce++; var post_data = querystring.stringify(data); var options = { url: config.url + method_name, method: 'POST', headers: { 'Key': config.key, 'Sign': sign(post_data) }, form:data }; request(options, function (error, response, body) { if (!error && response.statusCode == 200) { callback(body); }else{ callback(error); } }); }; exports.api_query2 = function(method_name, data, callback){ data.nonce = config.nonce++; var post_data = querystring.stringify(data); var post_options = { host: 'api.exmo.me', port: '80', path: '/v1/' + method_name, method: 'POST', headers: { 'Key': config.key, 'Sign': sign(post_data), 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(post_data) } }; var post_req = http.request(post_options, function(res) { res.setEncoding('utf8'); res.on('data', function (chunk) { callback(chunk); }); }); post_req.write(post_data); post_req.end(); }; exports.test = function(){ return config.key; }; 

Ce fichier contient l'adresse de l'API, la connexion des bibliothèques supplémentaires dont nous avons besoin pour travailler avec l'API et la fonction principale pour les demandes à l'API.

C'est tout, nous avons tout préparé et maintenant nous pouvons directement commencer à créer une «machine à gagner de l'argent» personnelle;)

Étape 2: Code

Ouvrez notre index.js et connectez le fichier exmo.js:

 const exmo = require("./exmo"); 

Ensuite, allez à l'échange dans votre compte personnel à l'endroit où nous avons créé nos clés pour accéder à l'API. Nous les copions et les sauvegardons dans des variables:

 const apiKey = ' '; const apiSecret = ' '; 

Créez maintenant deux variables:
currency1 est CE QUE nous achetons;
currency2 - devise pour laquelle nous achetons.

Je veux acheter des bitcoins pour des dollars:

 const currency1 = 'BTC'; const currency2 = 'USD'; 

Ensuite, un point important - nous créons une variable avec un montant de mise minimum. L'échange ne permet pas d'acheter moins que ce montant.

Nous allons à l'adresse https://api.exmo.com/v1/pair_settings/ cherchez votre paire (pour moi c'est BTC_USD) et regardons le premier paramètre - min_quantity - 0,001

 const currency1MinQuantity = 0.001; 

Et quelques autres variables:

le nombre de minutes après lequel un bon de commande non exécuté sera annulé devise1

 const orderLifeTime = 3; 

commission de change (0,002 = 0,2%)

 const stockFee = 0.002; 

période de temps (en minutes) pour le calcul du prix moyen (cela sera nécessaire pour notre algorithme)

 const avgPricePeriod = 1; 

le montant de devise2 pour acheter de la devise1 dans une transaction unique (j'ai jeté 5 $ - je vais opérer avec eux)

 const canSpend = 5; 

le montant souhaité de profit de chaque transaction (0,001 = 0,1%)

 const profit = 0.001; 

Si le temps d'échange s'écarte du courant

 const stockTimeOffset = 0; 

Pour plus de commodité, nous combinons notre paire à travers _

 let currentPair = currency1+'_'+currency2; 

Initialisez la connexion.

 exmo.init_exmo({key:apiKey, secret:apiSecret}); 

Pour le test, vous pouvez demander des informations vous concernant:

 exmo.api_query("user_info", { }, result => console.log(result);); 

Accédez à la console et exécutez

 node index.js 

Si tout est fait correctement, vous verrez des informations vous concernant!

Tout fonctionne et vous pouvez passer à la partie la plus intéressante - la fonction que les mamies vont générer pour nous.

Donc, j'ai déjà dit plus haut que notre algorithme serait stupide, maintenant vous comprendrez combien)

L'astuce consiste à prendre l'historique des transactions terminées pour n'importe quelle période - nous avons la variable avgPricePeriod responsable de cela - et de calculer le prix moyen pour lequel la devise1 a été vendue. Pour ce prix moyen, nous passerons notre commande.

Commençons donc. Nous écrivons notre fonction trade ()

 function trade(){} 

Nous obtenons d'abord une liste de nos commandes ouvertes:

1) nous vérifions si nous avons des commandes ouvertes pour notre paire en utilisant la méthode api user_open_orders. S'il y en a aussi à vendre,

alors nous attendons juste qu'ils se réalisent (parfois jusqu'à la fin des temps). S'il y a des bons de commande, souvenez-vous-en.

 exmo.api_query("user_open_orders", { }, result => { let res = JSON.parse(result); if(res[currentPair] == undefined) console.log('  '); let buyOrders = []; for(let i in res[currentPair]){ console.log(res[currentPair][i]); if(res[currentPair][i].type == 'sell'){ console.log(',    /    '); }else{ buyOrders.push(res[currentPair][i]); } } 

2) Nous vérifions si nous avons des bons de commande ouverts.

Nous trions toutes les commandes et en obtenons un historique à l'aide de la méthode order_trades , en y passant l'id de la commande.

Il peut y avoir 3 options:

 if(buyOrders.length > 0){ for(let key in buyOrders){ console.log(',     ', buyOrders[key]['order_id']); exmo.api_query('order_trades', {"order_id": buyOrders[key]['order_id']}, result => { let res = JSON.parse(result); 

1) nous pouvons acheter la monnaie nécessaire non pas en totalité, mais en partie sur commande du vendeur.
Par conséquent, si nous avons déjà acheté au prix souhaité, nous attendons l'achat de la totalité du montant.

 if(res.result !== false){ console.log(',       ,     '); } 

2) avec la deuxième option, nous devons vérifier si notre commande est trop longue. Les prix changent rapidement et peut-être que le prix moyen n'est plus pertinent. Pour ce faire, nous avons créé la variable orderLifeTime, où nous indiquons combien notre commande doit se bloquer en quelques minutes.

Si le temps est écoulé, annulez la commande à l'aide de la méthode order_cancel , en lui passant l'ID de la commande.

 let timePassed = (new Date().getTime() / 1000) + stockTimeOffset * 60 * 60 - (buyOrders[key]['created']); if(timePassed > orderLifeTime * 60){ exmo.api_query('order_cancel',{"order_id":buyOrders[key]['order_id']}, res => { let result = JSON.parse(res); if(result.error) console.log(result.error); console.log(`   ${orderLifeTime}     ${currency1}`); }); }else{ 

3) si le temps n'est pas encore venu, nous espérons simplement pouvoir acheter à notre prix.

 console.log(`,        ,      ${timePassed} `); } } }); } }else{ 

Tout, nous avons compris les commandes ouvertes, maintenant notre robot sait quoi faire avec les commandes lorsqu'il les crée. La moitié du travail fait.

Donc, un bloc si nous n'avons pas de commandes.

Nous obtenons des informations sur notre compte en utilisant la méthode user_info :

 exmo.api_query('user_info',{},(result)=>{ let res = JSON.parse(result); 

Pour plus de commodité, nous notons les soldes de nos paires:

 let balance = res.balances[currency1]; let balance2 = res.balances[currency2]; 

Vérifiez s'il y a de la monnaie1 qui peut être vendue?

 if(balance >= currency1MinQuantity){} 

Si oui, nous devons calculer le taux de vente.

Vous devez vendre toute la devise que vous avez achetée, le montant que vous avez acheté plus le profit moins la commission de change.

Un point important! Nous avons moins de devises que nous en avons achetées - l'échange a pris une commission.

 let wannaGet = canSpend + canSpend * (stockFee+profit); console.log('sell', balance, wannaGet, (wannaGet/balance)); 

Lors de la création de commandes, la méthode order_create doit recevoir les paramètres:

• la paire est notre paire actuelle pour le trading;
• quantité - quantité;
• prix - prix;
• type - type de l'ordre créé (achat / vente);

Nous voulons vendre - dans le type que nous spécifions vendre .

 let options = { "pair": currentPair, "quantity": balance, "price": wannaGet / balance, "type": 'sell' }; 

et envoyer une demande, si tout est correct, alors vous verrez l'entrée "Un ordre de vente a été créé"

 exmo.api_query("order_create", options,(result)=>{ if(result.error) console.log(result.error); console.log("   ", currency1, result.order_id); }); 

C’est tout. Si nous avions une monnaie, nous avons simplement créé un ordre de vente.

Passons maintenant au bloc le plus intéressant: le cas si nous n'avons pas de devise1 (btc) et que nous voulons l'acheter pour notre devise2 (usd).

Vérifiez d'abord s'il y a suffisamment d'argent au bilan en devise2.

 if(balance2 >= canSpend){} 

Si tel est le cas, nous devons obtenir le prix moyen pour lequel la devise1 (btc) est vendue pour la période de temps que nous avons spécifiée dans avgPricePeriod .

Un peu de paroles:
Exmo a une méthode de ticker avec des statistiques et des volumes d'échange pour les paires de devises. Les statistiques montrent le prix moyen des dernières 24 heures. Cependant, la différence entre le prix moyen et celui auquel se déroule actuellement l'enchère peut être très différente.

De ce fait, nous pouvons attendre longtemps pour l'exécution d'un ordre de vente.

Nous ferons notre vélo.

Exmo a une méthode de transactions , il retourne une liste de transactions pour une paire de devises.

Nous prendrons l'offre parfaite pour la période moyenne qui nous intéresse et à partir d'eux, nous calculerons le prix moyen.

Ce n'est pas une option idéale, mais cela montrera les prix réels auxquels ils vendent et achètent.

Par exemple, au moment de la rédaction, le prix moyen de BTC_USD est de 8314, tandis que l'achat en bourse est effectué au prix de 7970.

Si nous passons un ordre à un prix moyen, il sera immédiatement exécuté au prix minimum indiqué dans les ordres de vente.

Mais en ajoutant le profit et la commission d'échange, nous attendrons probablement très longtemps la vente.

Alors, passons à la méthode des métiers et lui demandons des statistiques sur notre paire CurrentPair :

 exmo.api_query("trades",{"pair":currentPair}, result => { let res = JSON.parse(result); let prices = []; let summ = 0; 

Nous passerons en revue tous les résultats et ne laisserons que ceux qui conviennent à notre période de temps.

 for(deal in res[currentPair]){ let timePassed = (new Date().getTime() / 1000) + stockTimeOffset * 60 * 60 - res[currentPair][deal].date; if(timePassed < avgPricePeriod * 60){ summ += parseInt(res[currentPair][deal].price); prices.push(parseInt(res[currentPair][deal].price)); } } 

Et calculez le prix moyen.

 let avgPrice = summ2 / prices.length; 

Nous avons un prix moyen, mais nous devons le fixer un peu - soustrayez la commission d' échange de stockFee et ajoutez le bénéfice souhaité. Ainsi, après avoir reçu un prix inférieur au prix moyen du marché, nous achèterons un peu plus de devises, puisque la bourse en fera par la suite partie;

 let needPrice = avgPrice - avgPrice * (stockFee + profit); 

Nous obtenons le montant final que nous devons acheter.

 let ammount = canSpend / needPrice; console.log('Buy', ammount, needPrice); 

Nous vérifions s'il est possible d'acheter une telle quantité de devises (le montant d'achat minimum n'est-il pas violé).

 if(ammount >= currency1MinQuantity){} 

Si notre quantité est plus grande, nous formons les paramètres de la méthode order_create , mais cette fois avec le type d' achat .

  let options = { "pair": currentPair, "quantity": ammount, "price": needPrice, **"type": 'buy'** }; exmo.api_query('order_create', options, res => { let result = JSON.parse(res); if(result.error) console.log(result.error); console.log('   ', result.order_id); }); }else{ console.log(',      '); } }); }else{ console.log(',   '); } 

Maintenant, nous devons mettre notre fonction sur la minuterie (la plage est une fois toutes les 5 secondes, par exemple) et nous pouvons l'exécuter.

 var timerId = setTimeout(function tick() { trade(); timerId = setTimeout(tick, 5000); }, 5000); 

 node index.js 

Félicitations, vous avez écrit votre premier robot de trading: vous pouvez terminer l'algorithme et gagner beaucoup d'argent) je plaisante .

Je pense que vous avez une question raisonnable: "Combien d'argent pouvez-vous gagner de cette façon?"

Pour une opération avec 5 $, je gagne environ 2-3 cents. Cela est dû à la primitivité de l'algorithme, qui fonctionne si le prix fluctue dans une certaine plage (et ce n'est presque toujours pas le cas sur les échanges de crypto-monnaie). Environ 10 à 20 opérations ont lieu par jour (avec de bonnes mains). Vous pouvez vous compter;)

Mais nous ne maîtrisons pas le code pour de l'argent)

Encore une fois, un lien vers le github avec la version complète du bot et des commentaires.
https://github.com/v-florinskiy/exmo-exchange-trade-bot

Ceci est mon premier article - ne jugez pas strictement)

Tout profit.

PS: Pour ceux qui n'ont pas travaillé avec node, votre script fonctionnera naturellement lorsque la console est ouverte.

Pour que votre robot fonctionne 24h / 24 et 7j / 7, vous avez besoin d'une sorte de vps: vous y mettez nodejs, npm et, par exemple, pm2. À l'aide de cet utilitaire, le script continuera de fonctionner, même si la console est fermée.