Como criar um bot de arbitragem de criptomoedas na BityPreço com Node.js – Parte 2

Recentemente eu publiquei um tutorial aqui no blog falando sobre a BityPreço, um marketplace de exchanges de criptomoedas. Isso por si só já é um serviço bem bacana e útil e eles possuem uma stream de dados no melhor estilo WebSocket que ajuda a consumir a informação deles e monitorar o mercado e é isso que ensinei na parte 1 deste tutorial.

No entanto, a parte mais legal eu acabei não contando na ocasião: eles possuem um serviço de compra e venda de criptomoedas que permite fazer arbitragem entre as corretoras presentes no marketplace deles. Ou seja, ao invés de apenas você monitorar qual a exchange que está com o BTC mais barato ou caro do mercado (por exemplo), você pode realizar a compra ou venda, conforme sua estratégia.

E esse é justamente o mote da parte 2: vou te ensinar como de fato fazer a compra e venda de criptomoedas em diferentes exchanges usando a API de trade da BityPreço.

Importante salientar, no entanto, que o serviço de compra e venda possui limitações. Ele não te dá muita liberdade de escolha, principalmente entendendo como ele funciona por trás: a BityPreço mantém contas nas exchanges com fundos suficientes para intermediar as compras/vendas para os usuários. Obviamente eles não conseguem ter fundos infinitos em todas elas, então além da questão do preço em si, internamente a BityPreço faz a gestão das carteiras para que as ofertas possam ser realizadas, o que infelizmente não deixa muito flexível pra gente na ponta.

Em resumo, você não vai poder escolher a exchange de onde quer comprar/vender a criptomoeda. Você vai escolher comprar ou vender e a BityPreço vai te oferecer o melhor preço que ela pode fechar negócio em seu nome.

Dito isso, vamos ao tutorial. Caso prefira, você pode assistir ao vídeo abaixo ao invés de ler o texto, o conteúdo é o mesmo (com exceção da função call, a do post está mais atualizada).

Setup da Parte 2

Durante a parte 1 nós já deixamos pronto os principais elementos da estrutura incluindo as variáveis de ambiente que vamos usar nesta parte 2. Também falei sobre a criação de conta, que é importante que a esta altura você já tenha concluído e que também tenha saldo na sua conta suficiente para fazer os testes. Recomendo pelo menos uns R$10.

Nosso setup agora, é mais no sentido de reorganizar algumas coisas e carregar algumas variáveis que vamos precisar. Bem no topo do seu index.js, comece realocando a chamada ao pacote DotEnv e fazendo o carregamento de todas variáveis de ambiente que vamos precisar.


require("dotenv").config();

const AUTH_TOKEN = process.env.SIGNATURE + process.env.API_KEY;
const COINPAIR = process.env.COINPAIR;
const BUY_TRIGGER = parseFloat(process.env.BUY_TRIGGER);
const PROFITABILITY = parseFloat(process.env.PROFITABILITY);
const SELL_TRIGGER = BUY_TRIGGER * PROFITABILITY;

require("dotenv").config();

const AUTH_TOKEN = process.env.SIGNATURE + process.env.API_KEY;

const COINPAIR = process.env.COINPAIR;

const BUY_TRIGGER = parseFloat(process.env.BUY_TRIGGER);

const PROFITABILITY = parseFloat(process.env.PROFITABILITY);

const SELL_TRIGGER = BUY_TRIGGER * PROFITABILITY;

A maioria dessas variáveis foram explicadas na parte 1, volte lá caso não se recorde para que servem. Abaixo, a explicação do que é novo ou que mudou:

AUTH_TOKEN: esta não é uma variável de ambiente em si, mas uma combinação de duas: SIGNATURE e API_KEY. A BityPreço exige que o token de autenticação nas chamadas das API privadas deva ser construído dessa forma, conforme documentação oficial.
COINPAIR: antes esta constante estava definida mais embaixo no código, recomendo trazer para o início do arquivo por uma questão de organização.
SELL_TRIGGER: este é o gatilho de venda da criptomoeda, usando o seu gatilho de compra e a lucratividade (PROFITABILITY) desejada. Será usado mais tarde para o bot decidir quando vender.

Repare também que converti algumas variáveis para float, pois serão usadas tanto em comparações numéricas quanto no cálculo do SELL_TRIGGER.

Agora vamos declarar mais algumas variáveis que nosso bot vai precisar, logo abaixo das constantes anteriores.


let isOpened = false;
let amountToBuy = parseFloat(process.env.BUY_AMOUNT)
let amountToSell = 0;

let isOpened = false;

let amountToBuy = parseFloat(process.env.BUY_AMOUNT)

let amountToSell = 0;

A variável ‘isOpened’ serve para indicar se a posição do bot está aberta (comprado) ou fechada (vendido). Inicialmente começamos com ela fechada, embora não tenhamos vendido nada ainda, mas isso indica que precisamos comprar.

A variável ‘amountToBuy’ usa a variável de ambiente BUY_AMOUNT para dizer quantos Reais serão usados na compra. Esse carregamento ocorre uma vez a partir da variável de ambiente, mas mais tarde ele será obtido através do resultado dos trades, por isso que optei por uma variável aqui (let) ao invés de constante (const).

Com isso concluímos a etapa de setup, agora é hora de começarmos a trabalhar nos trades.

Lógica de Compra e Venda

Antes de fazer os trades de fato, algo extremamente delicado já que envolve gastos reais, é importante entendermos e implementarmos alguma lógica de compra e venda “fake”, isto é, que apenas simule os trades ao invés de realizá-los. Essa lógica é o que mais vai variar dentre as possíveis implementações desse bot, já que envolve a estratégia do robô, algo que não posso ensinar e que cada um deve criar a sua para ser responsável por seus próprios riscos. Trarei uma abordagem didática abaixo, longe de ser uma recomendação de estratégia, ok?

No tratamento do evento de price do canal de comunicação vamos adicionar uma lógica que usa das informações do monitoramento para decidir quando comprar e quanto vender, explicada na sequência.


channel.on('price', payload => {
    console.clear();
    //console.log(payload);

    const coinPair = payload[COINPAIR];
    console.log(coinPair);
    console.log(`Is Opened? ${isOpened}`);

    if (!isOpened) {
        console.log(`Buy Trigger: ${BUY_TRIGGER}`);
        if (coinPair.buy <= BUY_TRIGGER) {
            isOpened = true;
            console.log("Comprar");
        }
    }
    else {
        console.log(`Sell Trigger: ${SELL_TRIGGER}`);
        if (coinPair.sell >= SELL_TRIGGER) {
            isOpened = false;
            console.log("Vender");
        }
    }
})

channel.on('price', payload => {

console.clear();

//console.log(payload);

const coinPair = payload[COINPAIR];

console.log(coinPair);

console.log(`Is Opened? ${isOpened}`);

if (!isOpened) {

console.log(`Buy Trigger: ${BUY_TRIGGER}`);

if (coinPair.buy <= BUY_TRIGGER) {

isOpened = true;

console.log("Comprar");

}

else {

console.log(`Sell Trigger: ${SELL_TRIGGER}`);

if (coinPair.sell >= SELL_TRIGGER) {

isOpened = false;

console.log("Vender");

}

})

As mudanças aqui começam logo após imprimir as informações de mercado do coinpair, onde aproveitei para imprimir também se o bot está com a posição aberta ou não. Essa informação aliás é crucial para a lógica a seguir, onde se não estiver aberto (!isOpened), podemos testar para comprar, do contrário podemos testar para vender.

No caso do teste para compra, imprimimos o gatilho de compra e fazemos o teste considerando o melhor preço de compra atualmente disponível na BityPreço (coinPair.buy). Se atender ao nosso gatilho de compra, mudamos a flag isOpened para true e imprimimos a mensagem de compra (simulação).

Com o isOpened invertido agora, no próximo evento de ‘price’, não entraremos mais no primeiro if, mas sim no segundo, onde testarmos o gatilho de venda (SELL_PRICE) com o melhor preço de venda disponível na BityPreço. Se atender ao nosso gatilho de venda, mudamos a flag isOpened novamente para false e simulamos a venda.

Uma dica que dou é testar essa lógica rodando por um tempo, pra garantir que ela está efetuando compras e vendas ‘fakes’ com sucesso, antes de avançar para a próxima e última etapa que é a de implementação dos trades reais.

Comprando e Vendendo

Agora vamos implementar uma função no index.js que será responsável por fazer os trades. Essa função será parametrizável para que possamos dizer a ela se queremos comprar ou vender, bem como a quantidade que queremos negociar.

Atenção: na documentação oficial fala de uma API do simulador, mas eu não consegui fazê-la funcionar, somente apontando para produção mesmo, como mostro abaixo. Deixe nos comentários se conseguir usar a API do simulador.

Segue código da função.


const axios = require("axios");

async function call(side, volume) {
    const url = `https://api.bitpreco.com/v1/trading/${side}`;

    const data = {
        market: COINPAIR,
        limited: false,
        auth_token: AUTH_TOKEN
    }

    if (side === "buy")
        data.volume = volume;
    else
        data.amount = volume;

    const result = await axios.post(url, data);
    return result.data;
}

const axios = require("axios");

async function call(side, volume) {

const url = `https://api.bitpreco.com/v1/trading/${side}`;

const data = {

market: COINPAIR,

limited: false,

auth_token: AUTH_TOKEN

}

if (side === "buy")

data.volume = volume;

else

data.amount = volume;

const result = await axios.post(url, data);

return result.data;

}

Começamos importando a biblioteca Axios, necessária para fazer as chamadas HTTP à API da BityPreço. Caso nunca tenha usado Axios antes e queira aprender o básico, recomendo o vídeo abaixo.

Com o Axios carregado, criamos a função call, que espera dois parâmetros:

side: se o trade é um buy ou um sell;
volume: o quanto você quer negociar, em BRL no caso de compra e em cripto no caso de venda.

Dentro da call, a primeira coisa que fazemos é montar a URL da requisição, usando o parâmetro side mais uma parte fixa.

Depois, montamos o payload que vai no body da request com o mercado que queremos negociar (market, sendo o nosso COINPAIR), o volume que quer negociar, se a ordem é a limite ou não (no nosso caso vamos fazer apenas ordens a mercado) e o auth_token, que é o token de autenticação composto pela SIGNATURE e API_KEY. Por fim, enviamos esta request para a BityPreço.

Agora, antes de sairmos usando esta função, convém criar mais duas. O objetivo destas duas novas funções é pré-configurar a chamada à função call e expondo funções buy e sell de fato, diminuindo drasticamente a quantidade de código que precisaremos colocar na lógica de trade do robô e também mitigando possíveis erros por parametrização errada.


async function buy() {
    const data = await call('buy', amountToBuy);
    console.log(data);
    amountToSell = data.exec_amount;
    return data;
}

async function sell() {
    const data = await call('sell', amountToSell);
    console.log(data);
    amountToBuy = data.exec_amount *  data.price;
    return data;
}

async function buy() {

const data = await call('buy', amountToBuy);

console.log(data);

amountToSell = data.exec_amount;

return data;

}

async function sell() {

const data = await call('sell', amountToSell);

console.log(data);

amountToBuy = data.exec_amount * data.price;

return data;

}

Repare que as funções são bem parecidas, mudando a parametrização da chamada à call, tanto no side (primeiro parâmetro) quanto no volume, ora utilizando amountToBuy, ora utilizando amountToSell. Da mesma forma, internamente pegamos o retorno da call e imprimimos no console, para em seguida pegar algum dado da resposta (data) para calcular o volume do próximo trade.

Agora é hora de finalizarmos nossa lógica de trade de exemplo. Volte na função do evento ‘price’ para trocar aquelas simulações por chamadas de compra e venda de verdade, como abaixo, com alguns detalhes que explico a seguir.


if (!isOpened) {
    console.log(`Buy Trigger: ${BUY_TRIGGER}`);
    if (coinPair.buy <= BUY_TRIGGER) {
        isOpened = true;
        console.log("Comprar");
        buy()
            .catch(err => {
                console.error(err);
                process.exit(0);
            });
    }
}
else {
    console.log(`Sell Trigger: ${SELL_TRIGGER}`);
    if (coinPair.sell >= SELL_TRIGGER) {
        console.log("Vender");
        sell()
            .then(response => isOpened = false)
            .catch(err => {
                console.error(err);
                process.exit(0);
            })
    }
}

if (!isOpened) {

console.log(`Buy Trigger: ${BUY_TRIGGER}`);

if (coinPair.buy <= BUY_TRIGGER) {

isOpened = true;

console.log("Comprar");

buy()

.catch(err => {

console.error(err);

process.exit(0);

});

}

else {

console.log(`Sell Trigger: ${SELL_TRIGGER}`);

if (coinPair.sell >= SELL_TRIGGER) {

console.log("Vender");

sell()

.then(response => isOpened = false)

.catch(err => {

console.error(err);

process.exit(0);

})

}

O primeiro detalhe é que na lógica de comprar, eu imediatamente seto a flag isOpened para true, antes mesmo de saber se a compra foi feita com sucesso. Isso é necessário pois como o trade leva alguns segundos, pode ser que chegue novo evento ‘price’ e com isso o processo de compra será duplicado acidentalmente. Então a primeira coisa que deve fazer é mudar o isOpened para que ele não faça mais do que uma compra antes de fazer uma venda.

Já no caso da lógica de venda, eu somente seto o isOpened para false, informando que acabei de vender e que posso comprar de novo, quando tenho o retorno positivo de que a venda foi feita com sucesso. Em ambos os casos, se der erro no trade, eu imprimo no console e encerro a execução do bot com process.exit.

Caso não conheça essa estrutura com then/catch, ela se chama Promises e é melhor explicada no vídeo abaixo.

E agora você pode avançar para os testes finais. Minha recomendação é que tenha ao menos uns R$10 na sua conta BityPreço a “fundo perdido”, sem se preocupar pois é o “custo do aprendizado”. Aí você deve mandar rodar o seu robô, ver o preço de um par de moedas que lhe interesse, e então ajustar seu bot para que ele compre com este mesmo preço, mesmo que não seja um bom momento para comprar. Da mesma forma, ajuste a PROFITABILITY para um valor bem baixo, mesmo que as taxas comam seu suposto lucro, só para ver o ciclo completo funcionando.

Abaixo, um exemplo do robô funcionando.

Agora basta implementar a sua estratégia no código e colocar o seu bot de arbitragem a rodar para ter ele monitorando oportunidades e fazendo entradas e saídas relâmpago para ganhar com arbitragem de moedas. Sugestões de evoluções incluem colocar ele a lhe mandar sinais/mensagens também, via email, SMS, Telegram ou WhatsApp, clique nos links para ver os tutoriais.

Qualquer dúvida que tenha ficado, deixe nos comentários e se quiser fazer o download dos fontes, use o form logo mais abaixo.

Até mais!