v0D9V3nP

1"""
2    Подробная информация о боте на сайте bablofil.ru/bot-dlya-binance
3"""
4import sqlite3
5import logging
6import time
7import os
8
9from datetime import datetime
10
11from binance_api import Binance
12bot = Binance(
13    API_KEY='',
14    API_SECRET=''
15)
16
17"""
18    Пропишите пары, на которые будет идти торговля.
19    base - это базовая пара (BTC, ETH,  BNB, USDT) - то, что на бинансе пишется в табличке сверху
20    quote - это квотируемая валюта. Например, для торгов по паре NEO/USDT базовая валюта USDT, NEO - квотируемая
21"""
22pairs = [
23{
24        'base': 'BTC',
25        'quote': 'XVG',
26        'offers_amount': 5, # Сколько предложений из стакана берем для расчета средней цены
27                            # Максимум 1000. Допускаются следующие значения:[5, 10, 20, 50, 100, 500, 1000]
28        'spend_sum': 0.0015,  # Сколько тратить base каждый раз при покупке quote
29        'profit_markup': 0.005, # Какой навар нужен с каждой сделки? (0.001 = 0.1%)
30        'max_sell_orders': 0,
31
32    }, {
33        'base': 'USDT',
34        'quote': 'NEO',
35        'offers_amount': 5, # Сколько предложений из стакана берем для расчета средней цены
36                            # Максимум 1000. Допускаются следующие значения:[5, 10, 20, 50, 100, 500, 1000]
37        'spend_sum': 11,  # Сколько тратить base каждый раз при покупке quote
38        'profit_markup': 0.005, # Какой навар нужен с каждой сделки? (0.001 = 0.1%)
39        'max_sell_orders': 0,
40
41    }
42
43]
44
45BUY_LIFE_TIME_SEC = 180 # Сколько (в секундах) держать ордер на продажу открытым
46
47STOCK_FEE = 0.001  # Комиссия, которую берет биржа (0.001 = 0.1%)
48
49# Если вы решите не платить комиссию в BNB, то установите в False. Обычно делать этого не надо
50USE_BNB_FEES = True
51
52# Получаем ограничения торгов по всем парам с биржи
53local_time = int(time.time())
54limits = bot.exchangeInfo()
55server_time = int(limits['serverTime'])//1000
56
57# Ф-ция, которая приводит любое число к числу, кратному шагу, указанному биржей
58# Если передать параметр increase=True то округление произойдет к следующему шагу
59def adjust_to_step(value, step, increase=False):
60   return ((int(value * 100000000) - int(value * 100000000) % int(
61        float(step) * 100000000)) / 100000000)+(float(step) if increase else 0)
62
63# Подключаем логирование
64logging.basicConfig(
65    format="%(asctime)s [%(levelname)-5.5s] %(message)s",
66    level=logging.DEBUG,
67    handlers=[
68        logging.FileHandler("{path}/logs/{fname}.log".format(path=os.path.dirname(os.path.abspath(__file__)), fname="binance")),
69        logging.StreamHandler()
70    ])
71
72log = logging.getLogger('')
73
74# Бесконечный цикл программы
75
76shift_seconds = server_time-local_time
77bot.set_shift_seconds(shift_seconds)
78
79log.debug("""
80    Текущее время: {local_time_d} {local_time_u}
81    Время сервера: {server_time_d} {server_time_u}
82    Разница: {diff:0.8f} {warn}
83    Бот будет работать, как будто сейчас: {fake_time_d} {fake_time_u}
84""".format(
85    local_time_d = datetime.fromtimestamp(local_time), local_time_u=local_time,
86    server_time_d=datetime.fromtimestamp(server_time), server_time_u=server_time,
87    diff=abs(local_time-server_time),
88    warn="ТЕКУЩЕЕ ВРЕМЯ ВЫШЕ" if local_time > server_time else '',
89    fake_time_d=datetime.fromtimestamp(local_time+shift_seconds), fake_time_u=local_time+shift_seconds
90))
91
92while True:
93    try:
94        # Устанавливаем соединение с локальной базой данных
95        conn = sqlite3.connect('binance.db')
96        cursor = conn.cursor()
97
98        # Если не существует таблиц, их нужно создать (первый запуск)
99        orders_q = """
100          create table if not exists
101            orders (
102              order_type TEXT,
103              order_pair TEXT,
104
105              buy_order_id NUMERIC,
106              buy_amount REAL,
107              buy_price REAL,
108              buy_created DATETIME,
109              buy_finished DATETIME NULL,
110              buy_cancelled DATETIME NULL,
111
112              sell_order_id NUMERIC NULL,
113              sell_amount REAL NULL,
114              sell_price REAL NULL,
115              sell_created DATETIME NULL,
116              sell_finished DATETIME NULL
117            );
118        """
119        cursor.execute(orders_q)
120
121        log.debug("Получаем все неисполненные ордера по БД")
122
123        orders_q = """
124            SELECT
125              CASE WHEN order_type='buy' THEN buy_order_id ELSE sell_order_id END order_id
126              , order_type
127              , order_pair
128              , sell_amount
129              , sell_price
130              ,  strftime('%s',buy_created)
131              , buy_amount
132              , buy_price
133            FROM
134              orders
135            WHERE
136              buy_cancelled IS NULL AND CASE WHEN order_type='buy' THEN buy_finished IS NULL ELSE sell_finished IS NULL END
137        """
138        orders_info = {}
139
140
141        for row in cursor.execute(orders_q):
142            orders_info[str(row[0])] = {'order_type': row[1], 'order_pair': row[2], 'sell_amount': row[3], 'sell_price': row[4],
143                                         'buy_created': row[5], 'buy_amount': row[6], 'buy_price': row[7] }
144        # формируем словарь из указанных пар, для удобного доступа
145        all_pairs = {pair['quote'].upper() + pair['base'].upper():pair for pair in pairs}
146
147        if orders_info:
148            log.debug("Получены неисполненные ордера из БД: {orders}".format(orders=[order for order in orders_info]))
149
150            # Проверяем каждый неисполненный по базе ордер
151            for order in orders_info:
152                # Получаем по ордеру последнюю информацию по бирже
153                stock_order_data = bot.orderInfo(symbol=orders_info[order]['order_pair'], orderId=order)
154
155                order_status = stock_order_data['status']
156                if order_status == 'NEW':
157                    log.debug('Ордер {order} всё еще не выполнен'.format(order=order))
158
159                # Если ордер на покупку
160                if orders_info[order]['order_type'] == 'buy':
161                    # Если ордер уже исполнен
162                    if order_status == 'FILLED':
163                        log.info("""
164                            Ордер {order} выполнен, получено {exec_qty:0.8f}.
165                            Создаем ордер на продажу
166                        """.format(
167                            order=order, exec_qty=float(stock_order_data['executedQty'])
168                        ))
169
170                        # смотрим, какие ограничения есть для создания ордера на продажу
171                        for elem in limits['symbols']:
172                            if elem['symbol'] == orders_info[order]['order_pair']:
173                                CURR_LIMITS = elem
174                                break
175                        else:
176                            raise Exception("Не удалось найти настройки выбранной пары " + pair_name)
177
178                        # Рассчитываем данные для ордера на продажу
179
180                        # Имеющееся кол-во на продажу
181                        has_amount = orders_info[order]['buy_amount']*((1-STOCK_FEE) if not USE_BNB_FEES else 1)
182                        # Приводим количество на продажу к числу, кратному по ограничению
183                        sell_amount = adjust_to_step(has_amount, CURR_LIMITS['filters'][1]['stepSize'])
184                        # Рассчитываем минимальную сумму, которую нужно получить, что бы остаться в плюсе
185                        need_to_earn = orders_info[order]['buy_amount']*orders_info[order]['buy_price']*(1+all_pairs[stock_order_data['symbol']]['profit_markup'])
186                        # Рассчитываем минимальную цену для продажи
187                        min_price = (need_to_earn/sell_amount)/((1-STOCK_FEE) if not USE_BNB_FEES else 1)
188                        # Приводим к нужному виду, если цена после срезки лишних символов меньше нужной, увеличиваем на шаг
189                        cut_price = max(
190                            adjust_to_step(min_price, CURR_LIMITS['filters'][0]['tickSize'], increase=True),
191                            adjust_to_step(min_price, CURR_LIMITS['filters'][0]['tickSize'])
192                        )
193                        # Получаем текущие курсы с биржи
194                        curr_rate = float(bot.tickerPrice(symbol=orders_info[order]['order_pair'])['price'])
195                        # Если текущая цена выше нужной, продаем по текущей
196                        need_price = max(cut_price, curr_rate)
197
198                        log.info("""
199                            Изначально было куплено {buy_initial:0.8f}, за вычетом комиссии {has_amount:0.8f},
200                            Получится продать только {sell_amount:0.8f}
201                            Нужно получить как минимум {need_to_earn:0.8f} {curr}
202                            Мин. цена (с комиссией) составит {min_price}, после приведения {cut_price:0.8f}
203                            Текущая цена рынка {curr_rate:0.8f}
204                            Итоговая цена продажи: {need_price:0.8f}
205                        """.format(
206                            buy_initial=orders_info[order]['buy_amount'], has_amount=has_amount,sell_amount=sell_amount,
207                            need_to_earn=need_to_earn, curr=all_pairs[orders_info[order]['order_pair']]['base'],
208                            min_price=min_price, cut_price=cut_price, need_price=need_price,
209                            curr_rate=curr_rate
210                        ))
211
212                        # Если итоговая сумма продажи меньше минимума, ругаемся и не продаем
213                        if (need_price*has_amount) <float(CURR_LIMITS['filters'][2]['minNotional']):
214                            raise Exception("""
215                                Итоговый размер сделки {trade_am:0.8f} меньше допустимого по паре {min_am:0.8f}. """.format(
216                                trade_am=(need_price*has_amount), min_am=float(CURR_LIMITS['filters'][2]['minNotional'])
217                            ))
218
219                        log.debug(
220                            'Рассчитан ордер на продажу: кол-во {amount:0.8f}, курс: {rate:0.8f}'.format(
221                                amount=sell_amount, rate=need_price)
222                        )
223
224                        # Отправляем команду на создание ордера с рассчитанными параметрами
225                        new_order = bot.createOrder(
226                            symbol=orders_info[order]['order_pair'],
227                            recvWindow=5000,
228                            side='SELL',
229                            type='LIMIT',
230                            timeInForce='GTC',  # Good Till Cancel
231                            quantity="{quantity:0.{precision}f}".format(
232                                quantity=sell_amount, precision=CURR_LIMITS['baseAssetPrecision']
233                            ),
234                            price="{price:0.{precision}f}".format(
235                                price=need_price, precision=CURR_LIMITS['baseAssetPrecision']
236                            ),
237                            newOrderRespType='FULL'
238                        )
239                        # Если ордер создался без ошибок, записываем данные в базу данных
240                        if 'orderId' in new_order:
241                            log.info("Создан ордер на продажу {new_order}".format(new_order=new_order))
242                            cursor.execute(
243                                """
244                                  UPDATE orders
245                                  SET
246                                    order_type = 'sell',
247                                    buy_finished = datetime(),
248                                    sell_order_id = :sell_order_id,
249                                    sell_created = datetime(),
250                                    sell_amount = :sell_amount,
251                                    sell_price = :sell_initial_price
252                                  WHERE
253                                    buy_order_id = :buy_order_id
254
255                                """, {
256                                    'buy_order_id': order,
257                                    'sell_order_id': new_order['orderId'],
258                                    'sell_amount': sell_amount,
259                                    'sell_initial_price': need_price
260                                }
261                            )
262                            conn.commit()
263                        # Если были ошибки при создании, выводим сообщение
264                        else:
265                            log.warning("Не удалось создать ордер на продажу {new_order}".format(new_order=new_order))
266
267                    # Ордер еще не исполнен, частичного исполнения нет, проверяем возможность отмены
268                    elif order_status == 'NEW':
269                        order_created = int(orders_info[order]['buy_created'])
270                        time_passed = int(time.time()) - order_created
271                        log.info("passed {passed:0.2f}".format(passed=time_passed))
272                        # Прошло больше времени, чем разрешено держать ордер
273                        if time_passed > BUY_LIFE_TIME_SEC:
274                            log.info("""Ордер {order} пора отменять, прошло {passed:0.1f} сек.""".format(
275                                order=order, passed=time_passed
276                            ))
277                            # Отменяем ордер на бирже
278                            cancel = bot.cancelOrder(
279                                symbol=orders_info[order]['order_pair'],
280                                orderId=order
281                            )
282                            # Если удалось отменить ордер, скидываем информацию в БД
283                            if 'orderId' in cancel:
284                                log.info("Ордер {order} был успешно отменен".format(order=order))
285                                cursor.execute(
286                                    """
287                                      UPDATE orders
288                                      SET
289                                        buy_cancelled = datetime()
290                                      WHERE
291                                        buy_order_id = :buy_order_id
292                                    """, {
293                                        'buy_order_id': order
294                                    }
295                                )
296                                conn.commit()
297                            else:
298                                log.warning("Не удалось отменить ордер: {cancel}".format(cancel=cancel))
299                    elif order_status == 'PARTIALLY_FILLED':
300                        log.debug("Ордер {order} частично исполнен, ждем завершения".format(order=order))
301
302                # Если это ордер на продажу, и он исполнен
303                if order_status == 'FILLED' and orders_info[order]['order_type'] == 'sell':
304                    log.debug("Ордер {order} на продажу исполнен".format(
305                        order=order
306                    ))
307                    # Обновляем информацию в БД
308                    cursor.execute(
309                        """
310                          UPDATE orders
311                          SET
312                            sell_finished = datetime()
313                          WHERE
314                            sell_order_id = :sell_order_id
315
316                        """, {
317                            'sell_order_id': order
318                        }
319                    )
320                    conn.commit()
321
322                    for i, d in enumerate(pairs):
323                        if d['quote'].upper() + d['base'] == orders_info[order]['order_pair']:
324                           pairs[i]['max_sell_orders'] = pairs[i]['max_sell_orders'] - 1
325
326        else:
327            log.debug("Неисполненных ордеров в БД нет")
328
329        log.debug('Получаем из настроек все пары, по которым нет неисполненных ордеров')
330
331        orders_q = """
332            SELECT
333              distinct(order_pair) pair
334            FROM
335              orders
336            WHERE
337              buy_cancelled IS NULL AND CASE WHEN order_type='buy' THEN buy_finished IS NULL ELSE sell_finished IS NULL END
338        """
339        # Получаем из базы все ордера, по которым есть торги, и исключаем их из списка, по которому будем создавать новые ордера
340        for row in cursor.execute(orders_q):
341            del all_pairs[row[0]]
342
343        all_pairs = {pair['quote'].upper() + pair['base'].upper():pair for pair in pairs if pair['max_sell_orders'] > 0}
344        # Если остались пары, по которым нет текущих торгов
345        if all_pairs:
346            log.debug('Найдены пары, по которым нет неисполненных ордеров: {pairs}'.format(pairs=list(all_pairs.keys())))
347            # for pair_name, pair_obj in all_pairs.items():
348            for pair_name, pair_obj in all_pairs.items():
349                log.debug("Работаем с парой {pair}".format(pair=pair_name))
350
351                # Получаем лимиты пары с биржи
352                for elem in limits['symbols']:
353                    if elem['symbol'] == pair_name:
354                        CURR_LIMITS = elem
355                        break
356                else:
357                    raise Exception("Не удалось найти настройки выбранной пары " + pair_name)
358
359                # Получаем балансы с биржи по указанным валютам
360                balances = {
361                    balance['asset']: float(balance['free']) for balance in bot.account()['balances']
362                    if balance['asset'] in [pair_obj['base'], pair_obj['quote']]
363                }
364                log.debug("Баланс {balance}".format(balance=["{k}:{bal:0.8f}".format(k=k, bal=balances[k]) for k in balances]))
365                # Если баланс позволяет торговать - выше лимитов биржи и выше указанной суммы в настройках
366                if balances[pair_obj['base']] >= pair_obj['spend_sum']:
367                    # Получаем информацию по предложениям из стакана, в кол-ве указанном в настройках
368                    offers = bot.depth(
369                        symbol=pair_name,
370                        limit=pair_obj['offers_amount']
371                    )
372
373                    # Берем цены покупок (для цен продаж замените bids на asks)
374                    prices = [float(bid[0]) for bid in offers['bids']]
375
376                    try:
377                        # Рассчитываем среднюю цену из полученных цен
378                        avg_price = sum(prices) / len(prices)
379                        # Среднюю цену приводим к требованиям биржи о кратности
380                        my_need_price = adjust_to_step(avg_price, CURR_LIMITS['filters'][0]['tickSize'])
381                        # Рассчитываем кол-во, которое можно купить, и тоже приводим его к кратному значению
382                        my_amount = adjust_to_step(pair_obj['spend_sum']/ my_need_price, CURR_LIMITS['filters'][1]['stepSize'])
383                        # Если в итоге получается объем торгов меньше минимально разрешенного, то ругаемся и не создаем ордер
384                        if my_amount < float(CURR_LIMITS['filters'][1]['stepSize']) or my_amount < float(CURR_LIMITS['filters'][1]['minQty']):
385                            log.warning("""
386                                Минимальная сумма лота: {min_lot:0.8f}
387                                Минимальный шаг лота: {min_lot_step:0.8f}
388                                На свои деньги мы могли бы купить {wanted_amount:0.8f}
389                                После приведения к минимальному шагу мы можем купить {my_amount:0.8f}
390                                Покупка невозможна, выход. Увеличьте размер ставки
391                            """.format(
392                                wanted_amount=pair_obj['spend_sum']/ my_need_price,
393                                my_amount=my_amount,
394                                min_lot=float(CURR_LIMITS['filters'][1]['minQty']),
395                                min_lot_step=float(CURR_LIMITS['filters'][1]['stepSize'])
396                            ))
397                            continue
398
399                        # Итоговый размер лота
400                        trade_am = my_need_price*my_amount
401                        log.debug("""
402                                Средняя цена {av_price:0.8f}, 
403                                после приведения {need_price:0.8f}, 
404                                объем после приведения {my_amount:0.8f},
405                                итоговый размер сделки {trade_am:0.8f}
406                                """.format(
407                            av_price=avg_price, need_price=my_need_price, my_amount=my_amount, trade_am=trade_am
408                        ))
409                        # Если итоговый размер лота меньше минимального разрешенного, то ругаемся и не создаем ордер
410                        if trade_am < float(CURR_LIMITS['filters'][2]['minNotional']):
411                            raise Exception("""
412                                Итоговый размер сделки {trade_am:0.8f} меньше допустимого по паре {min_am:0.8f}. 
413                                Увеличьте сумму торгов (в {incr} раз(а))""".format(
414                                trade_am=trade_am, min_am=float(CURR_LIMITS['filters'][2]['minNotional']),
415                                incr=float(CURR_LIMITS['filters'][2]['minNotional'])/trade_am
416                            ))
417                        log.debug(
418                            'Рассчитан ордер на покупку: кол-во {amount:0.8f}, курс: {rate:0.8f}'.format(amount=my_amount, rate=my_need_price)
419                        )
420                        # Отправляем команду на бирже о создании ордера на покупку с рассчитанными параметрами
421                        new_order = bot.createOrder(
422                            symbol=pair_name,
423                            recvWindow=5000,
424                            side='BUY',
425                            type='LIMIT',
426                            timeInForce='GTC',  # Good Till Cancel
427                            quantity="{quantity:0.{precision}f}".format(
428                                quantity=my_amount, precision=CURR_LIMITS['baseAssetPrecision']
429                            ),
430                            price="{price:0.{precision}f}".format(
431                                price=my_need_price, precision=CURR_LIMITS['baseAssetPrecision']
432                            ),
433                            newOrderRespType='FULL'
434                        )
435                        # Если удалось создать ордер на покупку, записываем информацию в БД
436                        if 'orderId' in new_order:
437                            log.info("Создан ордер на покупку {new_order}".format(new_order=new_order))
438                            cursor.execute(
439                                """
440                                  INSERT INTO orders(
441                                      order_type,
442                                      order_pair,
443                                      buy_order_id,
444                                      buy_amount,
445                                      buy_price,
446                                      buy_created
447
448                                  ) Values (
449                                    'buy',
450                                    :order_pair,
451                                    :order_id,
452                                    :buy_order_amount,
453                                    :buy_initial_price,
454                                    datetime()
455                                  )
456                                """, {
457                                    'order_pair': pair_name,
458                                    'order_id': new_order['orderId'],
459                                    'buy_order_amount': my_amount,
460                                    'buy_initial_price': my_need_price
461                                }
462                            )
463                            conn.commit()
464                        else:
465                            log.warning("Не удалось создать ордер на покупку! {new_order}".format(new_order=str(new_order)))
466
467                    except ZeroDivisionError:
468                        log.debug('Не удается вычислить среднюю цену: {prices}'.format(prices=str(prices)))
469                else:
470                    log.warning('Для создания ордера на покупку нужно минимум {min_qty:0.8f} {curr}, выход'.format(
471                        min_qty=pair_obj['spend_sum'], curr=pair_obj['base']
472                    ))
473
474        else:
475            log.debug('По всем парам есть неисполненные ордера')
476
477    except Exception as e:
478        log.exception(e)
479    finally:
480        conn.close()