Système d'arbitrage pour débutants, partie 1

Il y a environ 7 ans, j'avais de l'expérience en écrivant un terminal pour la Bourse de Moscou. Une partie de l'équipe aimait le trading algorithmique, moi y compris. Cependant, il n'a jamais perçu cette entreprise comme une véritable source de revenus, bien que cela n'ait guère réussi. Il est clair que pour concurrencer les banques et divers fonds, avec leurs équipes de mathématiciens et de programmeurs, il est difficile et plus facile à mettre en œuvre dans d'autres domaines.

Maintenant que les crypto-monnaies sont entendues, un grand nombre d'échanges sont apparus. Partant de l'hypothèse qu'il est possible de gagner de l'argent sur la différence de taux de change sur différents échanges, j'ai décidé d'étudier la possibilité de créer un robot d'arbitrage. Mais en gros, pour commencer à apprendre python avec un vrai exemple. Commençons donc.

Tout d'abord, il est nécessaire de détecter les paires de devises pour lesquelles un arbitrage est possible. Nous avons besoin de paires qui, en première approximation, se négocient activement, et les prix sur différents échanges divergent et convergent.

D'un côté, le plan de travail devrait être comme ceci:

• Création d'une base de données où les prix des paires de devises seront stockés.
• Un serveur qui enregistrera les données dans la base de données.
• Analyse primaire.

Les sources sont disponibles sur arb_analysis .

Création de base de données

Pour stocker des données, vous avez besoin de 3 tables.

Ce tableau stockera une liste d'échanges.

CREATE TABLE `exchange` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(50) NOT NULL, PRIMARY KEY (id) ) ENGINE=MyISAM; 

Liste des paires de crypto-monnaies.

 CREATE TABLE `market` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` char(50) NOT NULL, `id_exchange` int(11) NOT NULL, PRIMARY KEY (id) ) ENGINE=MyISAM; CREATE INDEX id_exchange ON market (id_exchange); 

Un tableau avec les transactions, les informations seront également stockées ici, selon les données du verre de la bourse.

 CREATE TABLE `ticker` ( `id` int(11) NOT NULL AUTO_INCREMENT, `id_market` int(5) NOT NULL, `local_time` int(9) NOT NULL, `timestamp` int(9) NOT NULL, `last` DECIMAL (11,11) NOT NULL, `low` DECIMAL (11,11), `high` DECIMAL (11,11), `bid` DECIMAL (11,11), `ask` DECIMAL (11,11), PRIMARY KEY (id) ) ENGINE=MyISAM; CREATE INDEX id_market ON ticker (id_market); 

Obtention des données des échanges

Pour un accès pratique aux échanges, il existe un projet open source ccxt. A l'aide duquel il est possible de postuler à différents échanges dans un même style. Cependant, il s'est avéré que tout n'était pas si rose, pour un certain nombre d'échanges, des informations n'ont pas pu être obtenues et certaines méthodes n'ont pas fonctionné.

Dans le fichier create_markets.py, l'initialisation a lieu, nous obtenons une liste de paires de crypto-monnaie, par échange. Dans ce cas, la méthode load_markets () est utilisée, qui renvoie une liste de paires pour l'échange.

 name_exchange = ["acx", "binance", "bitfinex", "bitfinex2", "wex"] def create_exchange_and_market_in_db(): exchanges = {} for id in name_exchange: exchange = getattr(ccxt, id) exchanges[id] = exchange() id_exchage = db_helper.insert_exchage_to_db(exchanges[id],cnx,cursor) markets = exchanges[id].load_markets() for mark in markets: id_market = db_helper.insert_market_to_db( id_exchage, mark, cnx,cursor) 

Ensuite, dans le fichier ex_data_saver.py, nous commençons à enregistrer la modification des prix des paires:

 def save(): markets = db_helper.get_data_exch() exchanges = {} for id in name_exchange: exchange = getattr(ccxt, id) #isHas = exchange.hasFetchTickers #if isHas: exchanges[id] = exchange({ 'enableRateLimit': True, # or .enableRateLimit = True later }) cnx = db_helper.CreateConnection() cursor = cnx.cursor() loop = asyncio.get_event_loop() while True: start_time = time.time() input_coroutines = [fetch_ticker(exchanges, name) for name in exchanges] exch_tickers = loop.run_until_complete(asyncio.gather(*input_coroutines, return_exceptions=True)) count_exchange = 0 delta = time.time() - start_time for tickers in exch_tickers: if tickers is not None: count_exchange+=1 inserted_start = time.time() db_helper.insert_tick(markets,exch_tickers,cnx,cursor) inserted_time = time.time() print(count_exchange," ", delta, ' ', inserted_start - inserted_time) 

La réception asynchrone des ticks pour une paire spécifique se produit à l'aide de la méthode ccxt fetchTickers ().

 async def fetch_ticker(exchanges, name): item = exchanges[name] try: ticker = await item.fetchTickers() return {name:ticker} 

Analyse préliminaire des données

Tout d'abord, il est intéressant de savoir sur quels échanges et sur quelles paires se déroule le trading le plus actif, nous nous intéressons aux paires liquides. Pour ce faire, vous devez calculer le nombre de transactions regroupées par échanges et paires spécifiques. En conséquence, nous obtenons des paires qui se négocient activement.

 SELECT ex.name as exchange_name, m.name as market_name, count(*) as count_deals FROM exchange ex LEFT JOIN market m ON m.id_exchange = ex.id LEFT JOIN ticker t ON t.id_market =m.id GROUP BY ex.id, t.id_market ORDER BY m.name HAVING count_deals > 10000; 

À l'aide de requêtes SQL, vous pouvez trouver divers modèles et filtrer les données.Cependant, pour une analyse détaillée, vous devez créer un robot de test qui fonctionne sur les données accumulées à partir de divers échanges.

Le prochain article sera consacré à la création de ce robot. Et le serveur de test - émuler le travail d'un véritable échange. Je veux poser les points suivants dans le serveur de test:

• Retards.
• Glissement.
• Commissions.