Como criar um bot para lançamentos de criptomoedas na Binance em Node.js – Parte 2

E finalmente saiu a segunda parte do meu tutorial de como criar um bot para aproveitar os lançamentos de novos pares de criptomoedas na Binance. Na parte 1, que é obrigatória para conseguir acompanhar este tutorial, aprendemos como configurar o ambiente, o projeto e criamos o código que monitora em tempo real um ativo.

Agora que estamos com esse monitoramento rudimentar a postos, vamos evolui-lo para que consigamos pegar as informações que a gente deseja e façamos nossa lógica de trade. É importante ressaltar que trago sempre somente o conteúdo técnico e que ter resultados com investimentos e trades em criptomoedas exige também que você tenha criatividade para bolar as suas estratégias, baseadas no risco que você deseja correr e nos ganhos que deseja obter. Não leve nenhuma das lógicas que eu vou mostrar como recomendação de investimento ou estratégia pronta, também não imagine que exista qualquer garantia de lucro ou rentabilidade média pois não há, ok?

Dito isso, vamos voltar ao código!

#1 – Evoluindo o Monitoramento

Vamos começar nosso desenvolvimento de hoje evoluindo o nosso monitoramento. Isso porque a primeira versão que escrevemos já está monitorando um ativo, mas apenas joga as informações que recebe no console de qualquer jeito. Precisamos pegar estas informações, separar o “joio do trigo” e depois aplicar alguma lógica em cima delas para comprar e vender.

Então vamos voltar ao index.js, mais especificamente ao tratamento do evento onmessage do objeto ws para continuar a desenvolver ele.


ws.onmessage = async (event) => {

    try {
        const obj = JSON.parse(event.data);
        console.clear();

        console.log(`Symbol: ${obj.s}`);
        console.log(`Best ask: ${obj.a}`);
        console.log(`Best bid: ${obj.b}`);
        console.log(`Buy Price: ${buyPrice}`);
        console.log(`Qty: ${quantity}`);
        console.log(`Notional: ${buyPrice * quantity}`);
        console.log(`Target Price: ${buyPrice * PROFIT}`);
    } catch (err) {
        console.error(err);
        process.exit(1);
    }
}

ws.onmessage = async (event) => {

try {

const obj = JSON.parse(event.data);

console.clear();

console.log(`Symbol: ${obj.s}`);

console.log(`Best ask: ${obj.a}`);

console.log(`Best bid: ${obj.b}`);

console.log(`Buy Price: ${buyPrice}`);

console.log(`Qty: ${quantity}`);

console.log(`Notional: ${buyPrice * quantity}`);

console.log(`Target Price: ${buyPrice * PROFIT}`);

} catch (err) {

console.error(err);

process.exit(1);

}

Aqui eu comecei pegando os dados que vem no event.data e transformando em um objeto JavaScript, a fim de conseguir manipulá-lo mais facilmente. Aí então optei por limpar o console e imprimir na sequência as informações que quero monitorar:

symbol: contido no obj.s;
best ask: melhor preço de venda, no obj.a;
best bid: melhor preço de compra, no obj.b;
buy price: o preço pelo qual eu comprei, inicialmente em zero;
qty: a quantidade que consegui comprar, inicialmente em zero;
notional: o valor nominal transacionado na compra, inicialmente em zero;
target price: o valor-alvo mínimo que pretendo vender, após realizar a compra;

Note que são apenas impressões no console de valores que o bot já tem em memória. Coloquei ao redor de tudo um try/catch para tratar possíveis erros que poderiam derrubar nossa aplicação. Agora salve tudo e suba novamente a aplicação e você verá ela sendo atualizada diversas vezes por segundo com as informações que programamos.

#2 – Integrando com a API

Agora que já melhoramos o nosso monitoramento e entendemos onde estão as informações que vamos usar para montar a nossa lógica, é hora de aprender como nos integraremos com as APIs da Binance para fazer a compra e a venda no lançamento. Por uma questão de organização do código vou sugerir que façamos isso em outro arquivo, crie um api.js no seu projeto e vamos escrever nele, começando por algumas dependências e configurações.


const axios = require('axios');
const crypto = require('crypto');

const apiKey = process.env.API_KEY;
const apiSecret = process.env.SECRET_KEY;
const apiUrl = process.env.API_URL;

const axios = require('axios');

const crypto = require('crypto');

const apiKey = process.env.API_KEY;

const apiSecret = process.env.SECRET_KEY;

const apiUrl = process.env.API_URL;

O Axios é a biblioteca que usaremos para conversar com a API da Binance e crypto é uma biblioteca nativa do Node.js (não necessita instalação) para fazermos algumas criptografias exigidas pela corretora.

Logo abaixo das duas bibliotecas eu carreguei informações do nosso .env que já deixamos preenchidas anteriormente, lembra? Elas são o nosso par de chaves e o endereço da API da Binance que vamos usar (teste ou produção).

Agora com estas dependências configuradas, vamos escrever a função que envia uma ordem para a Binance, neste mesmo arquivo api.js. Este código é longo e complexo, então faça com bastante cuidado.


async function newOrder(data) {
    if (!apiKey || !apiSecret)
        throw new Error('Preencha corretamente sua API KEY e SECRET KEY');

    data.type = "MARKET";
    data.timestamp = Date.now();
    data.recvWindow = 60000;//máximo permitido, default 5000

    const signature = crypto
        .createHmac('sha256', apiSecret)
        .update(`${new URLSearchParams(data)}`)
        .digest('hex');

    const qs = `?${new URLSearchParams({ ...data, signature })}`;

    try {
        const result = await axios({
            method: "POST",
            url: `${apiUrl}/v3/order${qs}`,
            headers: { 'X-MBX-APIKEY': apiKey }
        });
        return result.data;
    } catch (err) {
        console.log(err);
    }
}

async function newOrder(data) {

if (!apiKey || !apiSecret)

throw new Error('Preencha corretamente sua API KEY e SECRET KEY');

data.type = "MARKET";

data.timestamp = Date.now();

data.recvWindow = 60000;//máximo permitido, default 5000

const signature = crypto

.createHmac('sha256', apiSecret)

.update(`${new URLSearchParams(data)}`)

.digest('hex');

const qs = `?${new URLSearchParams({ ...data, signature })}`;

try {

const result = await axios({

method: "POST",

url: `${apiUrl}/v3/order${qs}`,

headers: { 'X-MBX-APIKEY': apiKey }

});

return result.data;

} catch (err) {

console.log(err);

}

A função newOrder espera um objeto com os dados da ordem. Como dados entenda qual ativo será negociado, quantidade, etc. Darei mais detalhes à frente.

Depois, faço um teste para ver se o par de chaves de API está corretamente preenchido e injeto algumas propriedades no objeto data, como por exemplo o tipo de ordem que vamos enviar (MARKET). Também defino as propriedades para pegar o timestamp atual e para determinar a janela de tolerância para que uma ordem demore a ser aceita pela Binance (recvWindow). Estes dois últimos parâmetros causam muito problema se o relógio da sua máquina estiver adiantado ou atrasado, mesmo que por questão de segundos. Estes problemas de tempo e outros que pode ter são melhor explicados nesse artigo.

O próximo passo é fazer a assinatura da sua requisição, um processo de segurança exigido pela corretora a fim de garantir que é você mesmo que está submetendo a ordem para o book. Ele consiste em pegar a sua api secret e usar ela como chave de criptografia para gerar um hash dos dados da ordem, tendo então uma string hexadecimal criptografada ao final do processo (signature), o que usamos no envio da ordem.

Para o envio da ordem, o primeiro passo é montar uma querystring (qs) com os parâmetros da ordem + signature e fazer um POST no endereço na API usando essa querystring a API key em um cabeçalho específico exigido pela Binance (X-MBX-APIKEY). O resultado do envio é devolvido ou em caso de erro, impresso no console.

Esta é uma função genérica para envio de ordens à mercado e para usar ela adequadamente criaremos mais duas funções em nosso módulo api.js, uma focada em realizar compras e outra focada em realizar vendas, como abaixo.


function buy(symbol, quoteOrderQty) {
    const data = { symbol, side: 'BUY', quoteOrderQty };
    return newOrder(data);
}

function sell(symbol, quantity) {
    const data = { symbol, side: "SELL", quantity };
    return newOrder(data);
}

module.exports = { buy, sell }

function buy(symbol, quoteOrderQty) {

const data = { symbol, side: 'BUY', quoteOrderQty };

return newOrder(data);

}

function sell(symbol, quantity) {

const data = { symbol, side: "SELL", quantity };

return newOrder(data);

}

module.exports = { buy, sell }

A primeira função configura os dados da ordem para realizar uma compra (BUY), passando o quoteOrderQty que é um parâmetro one você deve definir o quanto deseja gastar na compra. Ou seja, se você está negociando BTCUSDT, estará comprando em USDT uma quantidade de BTC, certo? Mas quanto de USDT deseja gastar nessa operação? Essa quantia é o quoteOrderQty e essa abordagem é um dos grandes segredos deste robô já que quando um novo par de moedas é listado nós fazemos a mínima ideia do preço que a corretora vai fixar ou mesmo o preço que vai estar no momento que nossa ordem de comprar chegar lá. Mas você sempre sabe o quanto está disposto a investir, certo? Essa abordagem se chama Quote Order Quantity.

Já a segunda função, sell, é ainda mais simples e faz praticamente a mesma coisa mudando apenas a forma de lidar com a quantidade negociada. Como à essa altura já teremos comprado o ativo, nós sabemos exatamente a quantidade dele que conseguimos comprar e é essa quantidade que queremos vender e que é passada nessa função.

Ao término da implementação do módulo, devemos incluir a instrução module.exports para expor as duas funções que serão chamadas no index.js a seguir.

#3 – Comprando e Vendendo

Agora que temos todas as funções para fazer compra e venda corretamente implementadas é hora de usá-las junto a alguma lógica própria no monitoramento que decida quando chamar uma ou quando chamar outra.

Voltando ao index.js, vamos começar adicionando a importação ao api.js no topo do arquivo.


const api = require('./api');

const api = require('./api');

E agora dentro da função do evento onmessage do objeto ws, vamos programar a nossa lógica de compra e de venda, logo abaixo dos console.log que tínhamos deixado para imprimir as informações de maneira organizada.


if (quantity === 0) {
    quantity = -1;

    const order = await api.buy(SYMBOL, BUY_QTY);
    if (order.status !== 'FILLED') {
        console.log(order);
        process.exit(1);
    }

    quantity = parseFloat(order.executedQty);
    buyPrice = parseFloat(order.fills[0].price);
    return;
}
else if (quantity > 0 && parseFloat(obj.b) > (buyPrice * PROFIT)) {
    const order = await api.sell(SYMBOL, quantity);
    if (order.status !== 'FILLED')
        console.log(order);
    else
        console.log(`Sold at ${new Date()} by ${order.fills[0].price}`);
    process.exit(1);
}

if (quantity === 0) {

quantity = -1;

const order = await api.buy(SYMBOL, BUY_QTY);

if (order.status !== 'FILLED') {

console.log(order);

process.exit(1);

}

quantity = parseFloat(order.executedQty);

buyPrice = parseFloat(order.fills[0].price);

return;

}

else if (quantity > 0 && parseFloat(obj.b) > (buyPrice * PROFIT)) {

const order = await api.sell(SYMBOL, quantity);

if (order.status !== 'FILLED')

console.log(order);

else

console.log(`Sold at ${new Date()} by ${order.fills[0].price}`);

process.exit(1);

}

Aqui a lógica é a seguinte: comprar o mais rápido possível, vender assim que superar o nosso alvo de lucratividade. Não é uma recomendação, apenas explicando o que programei como exemplo, ok?

Usei a variável quantity, definida anteriormente, para saber se ainda não fizemos uma compra (quantidade === 0). Neste caso, vamos fazê-la imediatamente, supondo que esta lógica foi ativada assim que chegou a primeira informação de preço do ativo pra gente, após seu lançamento. Isso costuma ocorrer no primeiro ou segundo segundos após o lançamento acontecer, muito influenciado pelo delay da sua Internet.

Eu defino a quantidade como -1 para não entrar múltiplas vezes nesta função e envio a ordem de compra para a Binance usando a função que programamos no módulo api.js. Se tudo deu certo (FILLED) o fluxo segue por fora do if e atribui os valores obtidos no retorno da execução para as variáveis quantity e buyPrice, que serão úteis mais tarde para a venda. Agora se o status da negociação Não foi FILLED, então eu imprimo o erro e encerro o programa pois quando o assunto é relançamento, não rola retentar fazer uma compra.

Agora imagine que a compra já aconteceu, você sabe quanto comprou e o quanto pagou. No próximo estímulo da stream de book que recebermos (talvez no mesmo segundo ainda), a mesma lógica será acionada mas ela não entrará no if do topo, mas sim no else if mais abaixo que testa se temos uma quantidade já comprada e se o preço atual do ativo superou a nossa meta. Caso esse else if resulte em negativo, continuamos esperando pelo próximo estímulo.

Se o else if for verdadeiro, então enviamos imediatamente uma ordem de venda para a Binance usando a função que criamos antes e exibimos o resultado em tela.

E com isso o processo finaliza e espero que você tenha tido sucesso com a sua investida no lançamento de mais um novo par na Binance.

#4 – Considerações Finais

Uma consideração final que acho importante você saber é que não rola de abrir infinitas conexões, o limite é 1024, e que também não rola de você hospedar este robô nos EUA, pois eles possuem uma proibição à Binance por lá. Se não for deixar na sua máquina, use servidores no Brasil, Alemanha, Índia e acho que na Holanda rola também.

Outro ponto importante de ser citado, é que não é uma boa deixar este robô rodando por várias horas principalmente para novos pares de moeda. Isso porque não terá atividades acontecendo na stream até o lançamento do novo par e a Binance costuma derrubar conexões ociosas se não me engano a cada 1h. Então coloque-o a rodar o mais próximo possível do horário do lançamento para evitar surpresas. Você pode combinar estas ideias com a do timerbot, que é um robô baseado em agendamento que ensinei outro dia no meu canal do Youtube.