Finans, Kripto Para, Programlama, Python

Binance üzerinde listelenen yeni kripto paraları tespit edip işlem yapan bot

Binance borsasına eklendikleri anda pump yapan bazı kripto paraları görmüşsünüzdür. Peki kaç tanesini öncesinden fark ettiniz? O ilk yükselişlerden faydalanabilseniz harika olmaz mıydı? Bu bot tam da bunu hedefliyor. Çalıştığı andan itibaren Binance borsasını tarıyor ve Binance’de listelenir listelenmez o kripto varlığı satın alıyor.

Gereksinimler

  • Bir Binance hesabı (belli ki)
  • Bazı piton becerileri
  • Biraz zaman

Öncelikle botu çalıştırmak için bir Binance hesabınızın olması gerekiyor. Oluşturulan Binance hesabıyla, bazı API Anahtarları oluşturacağız.

API oluşturduktan sonra popüler Python kütüphanelerinden pyaml ve Python-binance ı yüklüyoruz.

pip install python-binance
pip install pyaml

Kimlik bilgileri dosyası oluştur

Daha sonra auth adında bir dizin ve bu dizinin içinde auth.yml adında yeni bir .yml dosyası oluşturun. Binance borsasında oluşturduğunuz api key ile birlikte secret kodunuzu buraya ekleyin. 

---
  # API DETAYLARI
  binance_api: "BINANCE_API_KEY"
  binance_secret: "BINANCE_SECRET"

Bir kimlik doğrulama dosyası oluşturun

Aynı dizinde devam edin ve binance_auth.py  adlı yeni bir dosya oluşturun, bu dosyayı Binance API aracılığıyla Binance istemcisine bağlanmak için kullanacağız.

import yaml

from binance.client import Client
from binance.exceptions import BinanceAPIException


def load_binance_creds(file):
    with open(file) as file:
        auth = yaml.load(file, Loader=yaml.FullLoader)

    return Client(auth['binance_api'], auth['binance_secret'])

Bir yapılandırma dosyası oluşturun

Bu, botumuza ne yapacağını ve nasıl al-sat yapacağını söyleyen dosyadır. Stratejimizi optimize edebilmemiz için birkaç yapılandırılabilir seçenek oluşturacağız. Ana dizinde ( auth dizininden bir üst seviye ) aşağıdaki gibi bir config.yml dosyası oluşturun :

---
  TRADE_SEÇENEKLERİ:
    # Alacağınız miktar
    QUANTITY: 15
    # Örneğin BTCUSDT satın alınacak
    PAIRING: USDT
    # Gönderileri kontrol etme ve komut dosyasını çalıştırma sıklığı
    # dakikada yapacağı işlem aralığı
    RUN_EVERY: 0.3
    # Test modu, canlı Binance hesabını kullanmak için false olarak ayarlayın
    TEST: True
    #Stop loss yüzdesi %
    SL: 3
    # Kar alma yüzdesi %
    TP: 9
    # Takip Kaybını Durdurmayı Etkinleştir
    ENABLE_TSL: True
    # Geçerli fiyattan % olarak İzleyen Durdurma
    TSL: 0.5
    # Mevcut fiyattan % olarak takip eden kâr
    TTP: 1

Yapılandırmayı Yükle

Az önce oluşturduğumuz konfigürasyonu yüklememize yardımcı olacak bir dosya oluşturalım ve onu load_config.py olarak adlandıralım.

import yaml

def load_config(file):
    with open(file) as file:
        return yaml.load(file, Loader=yaml.FullLoader)

Emir İşlemleri

Emirlerimizi ve fiyat, zaman, hacim ve sembol gibi emir detaylarını takip edebilmek için yaptığımız her işlemin yerel bir dosyaya kaydedilmesi gerekir. Canlı alım satımlarınız Binance raporlarında görünecek, ancak test alım satımları görünmeyecek, bu nedenle yerel bir dosya, test modu kazançlarını ve kayıplarını takip etmenin en iyi yoludur. Devam edin ve ana dizinde bir store_order.py dosyası oluşturun Aşağıdaki işlevler, hem test hem de canlı işlemleri yüklememize ve saklamamıza yardımcı olacaktır.

import json


def store_order(file, order):
        """
        Emri yerel json dosyasına kaydet
        """
        with open(file, 'w') as f:
            json.dump(order, f, indent=4)

def load_order(file):
    """
    Json dosyasını güncelle
    """
    with open(file, "r+") as f:
        return json.load(f)

Trade işlemimize başlayalım

Bu dosyanın amacı, kripto ticaret botumuz için iki önemli işlemi gerçekleştirmeye yardımcı olmaktır. Bu nedenle ana dosyada çağrılacak iki işlevi içerir. İlk fonksiyon, eşleştirilmiş kripto paramızın hacmini, satın almak üzere olduğumuz kripto paranın hacmine çevirecektir. Yapılandırma dosyasının altındaki yapılandırma seçeneklerini hatırlıyorsanız, PAIRING adlı bir seçeneği hatırlayacaksınız . Bu, ticaret botumuza temel varlığı neyle eşleştireceğini söyler. Örneğin, eşleştirme USDT olarak ayarlanmışsa, bot yalnızca coinUSDT’de (yani: BTCUSDT) işlem yapacaktır.

İlk işlev, USDT’deki ticaret hacminin temel varlıktaki eşdeğerine dönüştürülmesini sağlar. Örneğin, 15USDT yaklaşık 0,000330 BTC’ye dönüşecektir – ve bu, Binance’in bizim için otomatik olarak bir işlem yapması için bilmesi gereken değerdir. İkinci fonksiyon, sembol çifti, hacim ve taraf (AL veya SAT) ile bir emir talebi yaratır.

Şimdi ana dizinde, trade_client.py  adında bir dosya oluşturun ve aşağıdaki gibi iki işlevi tanımlayın:

from auth.binance_auth import *

client = load_binance_creds('auth/auth.yml')


def convert_volume(coin, quantity, last_price):
        """QUANTITY cinsinden verilen hacmi USDT'den her bir kripto paranın hacmine dönüştürür"""

        try:
            info = client.get_symbol_info(coin)
            step_size = info['filters'][2]['stepSize']
            lot_size = {coin:step_size.index('1') - 1}

            if lot_size[coin] < 0:
                lot_size[coin] = 0

        except:
            pass

        # USDT cinsinden QUANTITY'den kripto para cinsinden hacmi hesaplar(varsayılan)
        volume = float(quantity / float(last_price))

        # define the volume with the correct step size
        if coin not in lot_size:
            volume = float('{:.1f}'.format(volume))

        else:

            if lot_size[coin] == 0:
                volume = int(volume)
            else:
                volume = float('{:.{}f}'.format(volume, lot_size[coin]))

        return volume


def create_order(coin, quantity, type):
    """
    Basit satın alma emri oluşturur ve emri iade eder
    """
    return client.create_order(
        symbol = coin,
        side = type,
        type = 'MARKET',
        quantity = quantity
    )

Dönüştürme işlevimizin beklediğinizden biraz daha karmaşık görünmesinin nedeni, Binance’in hacim sırasının biçimi konusunda oldukça titiz olmasıdır. Örneğin, BTCUSDT 6 ondalık basamağa kadar doğruluğa sahip olabilirken, diğer birçok kripto paranın farklı adım boyutları vardır. Örneğin, bir XRPUSDT ticaretinin doğruluğu yalnızca 1 ondalık noktadır (yani: 1.1). XRPUSDT’ye başka bir formatta (1.1000) bir istek göndermek bir hata döndürür.

Kripto bot mantığını kodlama

İşte bu kadar, artık gerekli tüm altyapıya sahibiz, artık alış ve satış mantığını yazıp çalıştırmanın zamanı geldi. 

Ana dizinimizin içinde bir main.py dosyası oluşturacağız . İlk adım, oluşturduğumuz tüm dosyaları ve diğer bağımlılıkları içe aktarmaktır. ve Binance istemcimizi şu şekilde tanımlayın:

from trade_client import *
from store_order import *
from load_config import *

from datetime import datetime, time
import time

import json
import os.path


# yerel yapılandırmayı yükler
config = load_config('config.yml')

Ardından, iki fonksiyon yazacağız. Binance’deki takas edilebilir tüm paraların bir listesini döndürecek olan ve listeyi bir kez daha döndüren ve ayrıca iki liste arasındaki farklılıkları karşılaştıran ikinci bir işlev. İkinci listede yeni paralar bulunursa, onları da iade edeceğiz.

def get_all_coins():

    return client.get_all_tickers()


def get_new_coins(all_coins):

    all_coins_recheck = get_all_coins()
    return [new_coins for new_coins in all_coins_recheck if new_coins['symbol'] not in [coin['symbol'] for coin in all_coins]], all_coins_recheck

şimdi ticaret botumuz için Binance’deki bir coin için en son fiyatı bize geri verecek bir fonksiyona ihtiyacımız var.

def get_price(coin, pairing):
    """
    Bir Coin için en son fiyatı alın
    """
    return client.get_ticker(symbol=coin+pairing)['lastPrice']

Bu noktada, yerel olarak istediğimiz herhangi bir trade verisini satın almak, satmak, mantıksal işlemler gerçekleştirmek ve depolamak için gerekli tüm fonksiyonlara sahibiz. Şimdi geriye kalan tek şey, tüm bunları mantıklı bir şekilde bir araya getirmek ve senaryoyu yürütmek.

Satış kontrolleri yaparak ve satın alma kontrollerine geçerek başlayacağımız bir main()  fonksiyonu tanımlayacağız . Bu son kod bloğu yukarıda gördüğümüzden çok daha uzun olacak.

def main():
    """
   TP ve SL'yi satar, takip eden değer ve göre ayarlara
     ve yeni kripto satın alır
    """
    # yapılandırma bilgilerini depola
    tp = config['TRADE_OPTIONS']['TP']
    sl = config['TRADE_OPTIONS']['SL']
    enable_tsl = config['TRADE_OPTIONS']['ENABLE_TSL']
    tsl = config['TRADE_OPTIONS']['TSL']
    ttp = config['TRADE_OPTIONS']['TTP']
    pairing = config['TRADE_OPTIONS']['PAIRING']
    qty = config['TRADE_OPTIONS']['QUANTITY']
    frequency = config['TRADE_OPTIONS']['RUN_EVERY']
    test_mode = config['TRADE_OPTIONS']['TEST']

    all_coins = get_all_coins()

    while True:

        # emir dosyasının mevcut olup olmadığını kontrol eder ve mevcut emirleri yükler
        # temelde satış bloğu ve güncelleme TP ve SL mantığı
        if os.path.isfile('order.json'):
            order = load_order('order.json')

            for coin in list(order):

                # bir satış için gerekli bazı trade bilgilerini saklar
                stored_price = float(order[coin]['price'])
                coin_tp = order[coin]['tp']
                coin_sl = order[coin]['sl']
                volume = order[coin]['volume']

                last_price = get_price(coin, pairing)

                # zararı durdur güncelle ve eşiğe ulaşılırsa kar değerlerini al
                if float(last_price) > stored_price + (stored_price*coin_tp /100) and enable_tsl:
                    # TP için mutlak değer olarak artış
                    new_tp = float(last_price) + (float(last_price)*ttp /100)
                    # coin satın alındığındaki % farka geri dönüştürün
                    new_tp = float( (new_tp - stored_price) / stored_price*100)
                    new_sl = float(last_price) - (float(last_price)*tsl /100)
                    new_sl = float((new_sl - stored_price) / stored_price*100)

                    # json dosyasına eklenecek yeni değerler
                    order[coin]['tp'] = new_tp
                    order[coin]['sl'] = new_sl
                    store_order('order.json', order)

                    print(f'Güncellenen tp: {round(new_tp, 3)} and sl: {round(new_sl, 3)}')

                elif float(last_price) < stored_price - (stored_price*sl /100) or float(last_price) > stored_price + (stored_price*tp /100) and not enable_tsl:

                    try:

                        if not test_mode:
                            sell = create_order(coin+pairing, coin['volume'], 'SELL')


                        print(f"sold {coin} at {(float(last_price) - stored_price) / float(stored_price)*100}")

                        order.pop(coin)
                        store_order('order.json', order)

                    except Exception as e:
                        print(e)

                    else:
                        if os.path.isfile('sold.json'):
                            sold_coins = load_order('sold.json')

                        else:
                            sold_coins = {}

                        if not test_mode:
                            sold_coins[coin] = sell
                            store_order('sold.json', sold_coins)
                        else:
                            sold_coins[coin] = {
                                        'symbol':coin+pairing,
                                        'price':last_price,
                                        'volume':volume,
                                        'time':datetime.timestamp(datetime.now()),
                                        'profit': float(last_price) - stored_price,
                                        'relative_profit': round((float(last_price) - stored_price) / stored_price*100, 3)
                                        }

                            store_order('sold.json', sold_coins)

        else:
            order = {}

        new_coins, all_coins_recheck = get_new_coins(all_coins)

        if len(new_coins) > 0:

            all_coins = all_coins_recheck
            print(f'Tespit edilen kripto: {new_coins}')

            for coin in new_coins:

                # kripto para henüz satın alınmadıysa satın alın
                if coin['symbol'] not in order:
                    print(f"Alım işlemi gerçekleşiyor {coin['symbol']}")

                    price = get_price(coin['symbol'], pairing)
                    volume = convert_volume(coin['symbol']+pairing, qty, price)

                    try:
                        if config['TRADE_OPTIONS']['TEST']:
                            order[coin['symbol']] = {
                                        'symbol':coin['symbol']+config['TRADE_OPTIONS']['PAIRING'],
                                        'price':price,
                                        'volume':volume,
                                        'time':datetime.timestamp(datetime.now()),
                                        'tp': tp,
                                        'sl': sl
                                        }

                            print('PLACING TEST ORDER')

                        else:
                            order[coin['symbol']] = create_order(coin['symbol']+config['TRADE_OPTIONS']['PAIRING'], volume, 'BUY')
                            order[coin['symbol']]['tp'] = tp
                            order[coin['symbol']]['sl'] = sl

                    except Exception as e:
                        print(e)

                    else:
                        print(f"Order created with {volume} on {coin['symbol']}")

                        store_order('order.json', order)
                else:
                    print(f"Yeni coin tespit edildi, fakat {coin['symbol']} portföyde zaten var!")

        else:
            print(f"Yeni coin tespit edilemedi, tekrar kontrol ediliyor {frequency} minute(s)..")

        time.sleep(60*frequency)


if __name__ == '__main__':
    main()

Sonuç itibari ile bu kripto botu sayesinde Binance borsasında listelendikleri gibi yeni kriptolar satın alabileceksiniz.

11680cookie-checkBinance üzerinde listelenen yeni kripto paraları tespit edip işlem yapan bot

Bir cevap yazın

E-posta hesabınız yayımlanmayacak.