Com construir un bot de criptografia de negociació per a Binance (mitjançant Python)

>

Binance i bots comercials.

El món no ha vist un duo més emblemàtic des de Bert i Ernie. El llegendari intercanvi s’ha inundat de robots de negociació automatitzats de tota mena. Les institucions i les persones amb un alt valor net estan executant estratègies de negociació algorítmiques avançades mentre que els inversors automatitzen la seva cartera. S’ha convertit en un parc infantil emocionant per als constructors.

Tot i això, encara queda molt per construir. Fins aquest moment, només s’ha desenvolupat una fracció dels serveis necessaris i hi haurà un gran creixement l’any vinent.

Si voleu començar a participar en el desenvolupament de bots comercials, aquest és el millor lloc per començar. Al llarg d’aquest article, us ensenyarem a accedir a les dades del mercat des de l’intercanvi, a connectar-vos als comptes d’intercanvi per llegir les dades de saldo, executar operacions, representar els candelers i, fins i tot, connectar-vos a bases de dades en temps real per obtenir dades de ticker..

Hi ha molt a cobrir, així que comencem!

Començant

Els passos següents descomposaran els components necessaris per començar a programar els scripts Binance Python.

Instal·lació de Shrimpy Python

En primer lloc, haurem d’instal·lar la Shrimpy Python Library. Es pot trobar el GitHub oficial de Python Shrimpy aquí.

Mitjançant Pip, podeu instal·lar ràpidament la biblioteca mitjançant el següent.

pip instal·la shrimpy-python

Claus API Binance

Per connectar-nos a l’intercanvi Binance, haurem de generar una nova clau API a través de l’intercanvi. Això es pot fer seguint l’article d’ajuda de la clau de l’API de Binance.

Després d’arribar al pas en què copieu les claus de l’API de Binance, podeu aturar-les i emmagatzemar-les en un lloc segur (en lloc d’enganxar-les a l’aplicació Shrimpy Portfolio Management). Aquestes claus s’utilitzaran als nostres scripts assignant-les a una variable que podem passar al nostre client quan es creï.

exchange_public_key = ‘…’

exchange_secret_key = ‘…’

Claus API Shrimpy

Després de crear les claus de l’API d’intercanvi, també hem de generar claus d’API per a les API de Shrimpy Universal Crypto Trading. Aquestes claus es generen inscrivint-se al fitxer API per a desenvolupadors de Shrimpy a continuació, seguiu la guia descrita aquí.

Un cop creades les claus, emmagatzemeu-les en una ubicació segura i feu-les servir als vostres scripts Python de la següent manera.

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

Intercanviar dades

Obtenir dades de mercat precises és el primer pas per crear un bot de comerç criptogràfic que pugui executar estratègies basades en senyals, condicions del mercat i moviments de preus..

Normalment, es fa tant amb dades del llibre de comandes en viu com amb dades comercials. A les seccions següents, proporcionarem exemples de com recopilar aquests dos tipus d’informació mitjançant websockets i API REST.

Ticker de preus

Un indicador de preus és quelcom que actualitza el preu de manera coherent per obtenir el preu més recent de l’actiu en una borsa. Els exemples següents presentaran un parell d’exemples de com crear i accedir a indicadors de preus.

Un preu senzill

Aquest exemple proporcionarà un guió per al tipus més senzill d’indicador de preus. Aquest ticker utilitzarà les trucades de l’API REST per accedir a les dades de preus de l’intercanvi. Aquest punt final s’actualitza en un interval d’1 minut, de manera que significa que la freqüència més alta possible per actualitzar el marcador en aquest exemple és d’1 minut.

importar gambes

# Assigneu claus de l’API Shrimpy Master públiques i secretes

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Creeu el client de l’API REST de Shrimpy

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Sol·liciteu el marcador per a tots els actius de Binance

ticker = client.get_ticker (‘binance’)

Comprovador de preus Websocket

Més complex que el simple ticker de preus és el ticket en temps real. Aquest ticker utilitza els websockets en temps real per estar al dia amb el preu més recent de la borsa.

A diferència del simple indicador de preus que s’actualitza en un interval d’1 minut, aquest indicador de preus s’actualitzarà a l’instant. Tan aviat com canviï el preu de la borsa, el websocket enviarà l’actualització i aquest script rebrà el nou preu per mostrar-lo.

importar gambes

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Es tracta d’un gestor de mostra, simplement imprimeix el missatge entrant a la consola

def error_handler (err):

imprimir (err)

# Es tracta d’un gestor de mostra, simplement imprimeix el missatge entrant a la consola

gestor de def (msg):

imprimir (msg [‘content’] [0] [‘price’])

# Creeu el client de websocket mitjançant el testimoni brut recuperat per l’API REST

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

client = shrimpy.ShrimpyWsClient (error_handler, raw_token [‘token’])

# Les dades de subscripció per al websocket

subscribe_data = {

"tipus": "subscriu-te",

"intercanvi": "binance",

"parella": "eth-btc",

"canal": "comerç"}

# Comenceu a processar el flux de websocket Shrimpy!

client.connect ()

client.subscribe (subscribe_data, handler)

# Un cop finalitzada, atureu el client

client.disconnect ()

Llibres de comandes d’intercanvi

Els comerciants i els robots criptogràfics utilitzen llibres de comandes precisos en una borsa per determinar l’ordre exacte que voldrien fer a la borsa..

En fer comandes, sempre és beneficiós tenir actualitzacions en temps real de la llibreta de comandes. D’aquesta manera, sempre preneu decisions basades en la informació més actualitzada.

Instantània senzilla de llibre de comandes en viu

La forma més senzilla d’accedir als llibres de comandes d’un intercanvi és sol·licitar el llibre de comandes en el moment en què realitzeu una comanda..

Per exemple, si voleu executar una operació al parell de negociació ETH / BTC, podeu sol·licitar obtenir la darrera cartera de comandes d’aquest mercat trucant a l’API REST.

importar gambes

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Creeu el client API per a les trucades REST

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Recupereu el llibre de comandes en directe

orderbooks = client.get_orderbooks (

‘binance’, # exchange

“ETH”, # base_symbol

“BTC”, # quote_symbol

10 # límit

)

Llibre de comandes en viu de Websocket

En escenaris més avançats, seria ideal mantenir una còpia local de la llibreta de comandes que s’actualitza en temps real mitjançant websockets. Això es pot fer mitjançant el portàtil de llibres de comandes disponible a través de les API de portàtil.

La connexió al parell ETH / BTC tindria l’aspecte de l’exemple següent.

importar gambes

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Es tracta d’un gestor de mostra, simplement imprimeix el missatge entrant a la consola

def error_handler (err):

imprimir (err)

# Es tracta d’un gestor de mostra, simplement imprimeix el missatge entrant a la consola

gestor de def (msg):

imprimir (msg)

# Creeu el client de websocket obtenint el testimoni en brut.

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

ws_client = shrimpy.ShrimpyWsClient (error_handler, raw_token [‘token’])

subscribe_data = {

"tipus": "subscriu-te",

"intercanvi": "binance",

"parella": "eth-btc",

"canal": "llibre de comandes"}

# Comenceu a processar el flux de websocket Shrimpy!

ws_client.connect ()

ws_client.subscribe (subscribe_data, gestor)

# Un cop finalitzada, atureu el client

ws_client.disconnect ()

Tingueu en compte que aquest exemple no descriu com gestionar la llibreta de comandes localment, sinó només com accedir a les dades a través del portal web. L’organització de les dades s’hauria de fer mitjançant un codi personalitzat en funció de com voleu gestionar els llibres.

Bàsicament, per gestionar els llibres caldrà fer un seguiment de l’estat actual del llibre. D’aquesta manera podeu inserir comandes noves, actualitzar comandes antigues i eliminar comandes segons sigui necessari en funció de les actualitzacions a través del portal web.

Connectivitat de comptes d’intercanvi

Per operar, necessitem accedir a un compte d’intercanvi. Aquest compte d’intercanvi s’utilitzarà per recollir dades sobre els saldos disponibles i executar l’estratègia comercial.

Enllaç d’un compte de Binance

Shrimpy proporciona un còmode sistema de gestió d’usuaris on podeu enllaçar comptes individuals de Binance als usuaris. Cada usuari pot mantenir fins a 20 comptes d’intercanvi. D’aquesta manera, tots els vostres comptes d’intercanvi es poden gestionar conjuntament.

Enllaçar un compte d’intercanvi a Shrimpy és un esdeveniment puntual. Això vol dir que un cop enllaçat el compte, Shrimpy mantindrà la connexió a l’intercanvi d’aquest compte i no requereixen tornar a enllaçar en el futur. Sempre podeu obtenir els comptes enllaçats llistant els comptes que han estat connectats a un usuari.

En aquest exemple, crearem el nostre primer usuari i, a continuació, enllaçarem el compte d’intercanvi. Un cop creeu el vostre primer usuari, vosaltres no heu de tornar a crear un altre usuari. Sempre podeu accedir als vostres usuaris enumerant els usuaris que heu creat.

# importació de biblioteques necessàries

importar gambes

# assigneu les vostres claus de l’API Shrimpy Master per a un ús posterior

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# assigneu les vostres claus d’intercanvi per a les quals voleu accedir a les dades del saldo

nom_intercanvi = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# creeu el client Shrimpy

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Creeu un usuari que estarà enllaçat amb el nostre intercanvi

create_user_response = client.create_user (‘The Shrimp Master’)

user_id = create_user_response [‘id’]

# enllaceu el nostre primer intercanvi perquè puguem accedir a les dades de saldo

link_account_response = client.link_account (

ID d’usuari,

nom_intercanvi,

intercanvi_public_key,

clau_secret_intercanvi

)

account_id = link_account_response [‘id’]

Recuperació de saldos de comptes de Binance

Tan bon punt s’hagi enllaçat el compte, Shrimpy començarà a recollir dades de l’intercanvi sobre el compte d’intercanvi. Això pot trigar fins 5 segons, per tant, us recomanem que espereu uns segons (només per a l’enllaç inicial) abans d’utilitzar el següent script per accedir a les dades de saldo del compte d’intercanvi enllaçat.

Després de recollir les dades, Shrimpy actualitzarà el saldo contínuament a mesura que s’executin operacions, es facin dipòsits o retirades i es facin altres operacions al compte..

En aquest exemple, demostrem com recuperar el saldo del compte de Binance.

importar gambes

# utilitzeu les claus públiques i privades de l’API Shrimpy per crear el client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# nota: ja que vam crear un usuari al nostre darrer exemple de script,

# només podem recuperar la nostra llista d’usuaris.

usuaris = client.list_users ()

first_user_id = usuaris [0] [‘id’]

# recuperar els comptes associats a aquest usuari

accounts = client.list_accounts (

primer_usuari_id

)

first_account_id = comptes [0] [‘id’]

# dades de saldo d’accés al compte d’usuari que heu creat anteriorment

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

Fixeu-vos en com hem utilitzat els punts finals per “llistar usuaris” i “llistar comptes”. Si ja teniu els ID d’usuari i de compte, només podeu introduir aquests valors sense recuperar-los cada vegada.

Executar un comerç a Binance

Els intercanvis poden ser complicats. La confusió de la documentació, les normes comercials incoherents i les discrepàncies entre els punts finals poden fer que el procés de desenvolupament sigui caòtic.

En els exemples següents, desglossarem algunes de les maneres més senzilles d’executar operacions a Binance. Sense cap lògica complexa, Shrimpy us pot ajudar a executar una comanda en tots els intercanvis importants de la mateixa manera.

Comerç simple

La forma més senzilla d’executar un comerç amb Shrimpy és utilitzar el punt final “Create Trade”. Tot aquest punt final que requereixen són els identificadors de compte rellevants i els dos actius als quals canviarà “des” i “fins”.

S’assemblarà a la següent.

create_trade_response = client.create_trade (

user_id, # L’identificador de l’usuari

account_id, # L’identificador del compte enllaçat amb l’usuari

from_symbol, # L’actiu que voleu vendre

to_symbol, # L’actiu que voleu comprar

from_native_amount # Quant del "des de" actiu que voleu vendre

)

El resultat és una forma senzilla de comprar i vendre actius sense preocupar-se de les particularitats de com s’executen les operacions. No cal fer comandes límit individuals, determinar diferents parells de negociació ni encaminar manualment els actius a través de diferents divises de cotització. La gamba s’encarregarà de tot.

A continuació, podem posar en pràctica aquest punt final posant-lo en un exemple de script. En aquest exemple, examinarem tots els actius que teniu a la borsa. A continuació, repassarem la llista d’actius que teniu i els vendrem a un actiu de consolidació (en aquest cas BTC).

ATURA! L’execució d’aquest script literalment vendrà tot el que tingueu a la borsa i comprareu BTC. Aquest no és un guió hipotètic, és un exemple real que executa operacions reals al vostre compte de canvi real. No executis el guió si no vols vendre tot el que tens a Bitcoin.

importar gambes

# Utilitzeu les vostres claus públiques i privades de l’API Shrimpy per crear el client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Nota: ja que vam crear un usuari al nostre darrer exemple de script,

# Només podem recuperar la nostra llista d’usuaris.

usuaris = client.list_users ()

first_user_id = usuaris [0] [‘id’]

# Recupereu els comptes associats a aquest usuari

accounts = client.list_accounts (

primer_usuari_id

)

first_account_id = comptes [0] [‘id’]

# Accediu a les dades del saldo del compte d’usuari que heu creat anteriorment

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

holdings = saldo [‘saldos’]

# Seleccioneu el recurs per al qual voleu consolidar

consolidation_symbol = ‘BTC’

# Veneu tots els actius a més dels actius de consolidació

per a actius en participacions:

asset_symbol = asset [‘símbol’]

asset_amount = asset [‘nativeValue’]

si asset_symbol! = consolidation_symbol:

print (‘Selling’ + str (asset_amount) + ‘of’ + asset_symbol)

create_trade_response = client.create_trade (

primer_usuari_id,

first_account_id,

símbol_actiu,

símbol_consolidació,

quantitat_actiu

)

Encaminament de comandes intel·ligents

A l’exemple anterior, no vam utilitzar cap encaminament intel·ligent. Bàsicament, Shrimpy identificarà l’actiu “de” i “a”, després vendrà l’actiu “de” a BTC i, a continuació, comprarà l’actiu “de” a BTC. Això pot ser ineficient si hi ha divises de cotització alternatives que l’actiu podria utilitzar.

En molts casos, seria ideal utilitzar l’opció d’encaminament de comandes intel·ligents. Aquesta senzilla indicació indica a Shrimpy que avaluï totes les rutes possibles a l’hora de decidir com hem d’intercanviar l’actiu “de” i adquirir l’actiu “a”..

importar gambes

# Utilitzeu les vostres claus públiques i privades de l’API Shrimpy per crear el client

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

# Nota: ja que vam crear un usuari al nostre darrer exemple de script,

# Només podem recuperar la nostra llista d’usuaris.

usuaris = client.list_users ()

first_user_id = usuaris [0] [‘id’]

# Recupereu els comptes associats a aquest usuari

accounts = client.list_accounts (

primer_usuari_id

)

first_account_id = comptes [0] [‘id’]

# Accediu a les dades del saldo del compte d’usuari que heu creat anteriorment

balance = client.get_balance (

first_user_id, # user_id

first_account_id # account_id

)

# Executeu una comanda de mercat

smart_order_response = client.create_trade (

first_user_id, # user_id

first_account_id, # account_id

“BTC”, # from_symbol

“ETH”, # to_symbol

‘0,01’ # quantitat de símbol_de_

True # habilita smart_routing

)

Fixeu-vos en què l’única diferència és el senyalador addicional de la sol·licitud per habilitar l’encaminament intel·ligent i configurar-lo a “True”.

Aranya de canelobres

La creació d’una aplicació amb una interfície d’usuari significa que necessitarem altres components per il·lustrar l’estat actual del mercat als usuaris. Un exemple de dades que l’usuari pot desitjar rebre són els gràfics de canelobres.

Els gràfics de candelers ajuden els comerciants a decidir quan han de comprar o vendre un actiu.

Shrimpy proporciona accés a punts finals gratuïts per accedir a dades de canelobres en temps real. Cada vegada que s’executa un nou comerç a l’intercanvi, els canelobres s’actualitzen en temps real. Aquests canelobres es poden consultar en un interval regular per tal de mostrar-los a la interfície d’usuari de la vostra aplicació.

En el següent exemple, analitzarem els darrers canelobres del parell de negociació ETH / BTC a la borsa Binance. Aquest mateix punt final es pot utilitzar per a qualsevol altre intercanvi important, de manera que no hi ha diferència entre utilitzar Binance i altres intercanvis.

importar gambes

importar plotly.graph_objects com anar

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Recopileu les dades històriques de canelobres

client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

candles = client.get_candles (

‘binance’, # exchange

“ETH”, # base_trading_symbol

“BTC”, # quote_trading_symbol

Interval “1d” #

)

dates = []

open_data = []

dades_alta = []

low_data = []

close_data = []

# Formateu les dades perquè coincideixin amb la biblioteca de traçat

per a espelmes en espelmes:

dates.append (espelma [‘temps’])

open_data.append (candle [‘open’])

high_data.append (candle [‘high’])

low_data.append (candle [‘low’])

close_data.append (candle [‘close’])

# Trama els canelobres

fig = go.Figure (dades = [go.Candlestick (x = dates,

open = open_data, high = high_data,

baix = baix_dades, tancar = tancar_dades)])

fig.show ()

Posant-ho tot junt

Només ens queda una cosa per fer. Això és posar tot el que hem comentat fins ara en un mateix guió. Aquest script supervisarà el marcador del parell BTC / USDT a Binance i executarà una operació per vendre tots els vostres BTC quan el valor de BTC hagi superat els 10.000 USDT. Aquest és un exemple senzill de com podeu combinar les dades dels websockets per executar una estratègia comercial.

importar gambes

temps d’importació

shrimpy_public_key = ‘…’

shrimpy_secret_key = ‘…’

# Assigneu les vostres claus d’intercanvi per a les quals vulgueu accedir a les dades del saldo

nom_intercanvi = "binance"exchange_public_key = ‘…’

exchange_secret_key = ‘…’

# Creeu el client de websocket

api_client = shrimpy.ShrimpyApiClient (shrimpy_public_key, shrimpy_secret_key)

raw_token = api_client.get_token ()

ws_client = shrimpy.ShrimpyWsClient (error_handler, raw_token [‘token’])

# Creeu un usuari que estarà enllaçat amb el nostre bescanvi

# Omet aquest pas (o utilitza el fitxer "llista d’usuaris" punt final) si ja heu creat un usuari

create_user_response = api_client.create_user (‘The Shrimp Master’)

user_id = create_user_response [‘id’]

# Enllaceu el nostre primer intercanvi perquè puguem accedir a les dades de saldo

# Omet aquest pas (o utilitza el fitxer "llista de comptes" punt final) si ja heu enllaçat un compte

link_account_response = api_client.link_account (

ID d’usuari,

nom_intercanvi,

intercanvi_public_key,

clau_secret_intercanvi

)

account_id = link_account_response [‘id’]

# Espereu mentre Shrimpy recopila dades per al compte d’intercanvi

# Només es requereix la primera connexió

time.sleep (5)

# Accediu a les dades del saldo del compte d’usuari que heu creat anteriorment

balance = api_client.get_balance (

user_id, # user_id

account_id # account_id

)

btcAmount = 0

per a actiu en saldo [‘saldos’]:

if asset [‘symbol’] = ‘BTC’:

btcAmount = asset [‘nativeValue’]

# Es tracta d’un gestor de mostra, simplement imprimeix el missatge entrant a la consola

def error_handler (err):

imprimir (err)

# Es tracta d’un gestor de mostra, simplement imprimeix el missatge entrant a la consola

gestor de def (msg):

price = msg [‘content’] [0] [‘price’]

si int (preu) > 10000:

smart_order_response = api_client.create_trade (

user_id, # user_id

account_id, # account_id

“BTC”, # from_symbol

“USDT”, # to_symbol

btcAmount # quantitat de from_symbol

True # habilita smart_routing

)

subscribe_data = {

"tipus": "subscriu-te",

"intercanvi": "binance",

"parella": "btc-usdt",

"canal": "comerç"}

# Comenceu a processar el flux de connexió web Shrimpy!

ws_client.connect ()

ws_client.subscribe (subscribe_data, gestor)

Conclusions

Armat amb aquests scripts, és possible crear qualsevol número de bots comercials emocionants a Binance. A mesura que exploreu més coses sobre el comerç i les API de comerç de gambes, podeu trobar altres punts finals útils, com ara els punts finals de l’ordre límit. Aquests us proporcionen un control més precís sobre les comandes que feu a la borsa.

Animem a tothom a explorar tot allò que oferim i a fer suggeriments a la nostra Desenvolupador Telegram. El mercat de criptomonedes és apassionant i això és només el començament d’una nova forma de negociar actius.

Gamba és una aplicació per construir fons d’índex de criptomonedes personalitzats, reequilibrar i gestionar una diversa cartera d’actius digitals. Automatitzeu la vostra cartera enllaçant a qualsevol dels 16 intercanvis de criptografia que admetem.

API Universal Crypto Exchange de Shrimpy estan dissenyats per a desenvolupadors. La integració amb les nostres API unificades us proporciona accés instantani a punts finals uniformes per al comerç, la recopilació de dades, la gestió d’usuaris i molt més en tots els intercanvis de criptomonedes importants..

Per accedir a les biblioteques completes de Python i Node, seguiu aquests enllaços:

Node

Python

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me