nodejs – LuizTools

Atualizado em 23/01/21!

Desde a primeira vez que escrevi a primeira parte deste tutorial de criação de um bot para comprar e vender Bitcoins e outras criptomoedas usando a API do Mercado Bitcoin a valorização da moeda atingiu níveis históricos. Em 2017 comemoramos a marca de U$15 mil por 1 BTC e em 2021 já estamos em U$34 mil.

Na primeira parte foquei nos conceitos fundamentais, criação e configuração da conta na exchange, criação do projeto e codificação do algoritmo de monitoramento do mercado. Agora faremos a codificação do nosso bot para que ele consiga comprar e vender criptomoedas.

#1 – Ajustando o módulo API

Abra novamente o seu projeto (sugiro estar utilizando o Visual Studio Code) e vá até o seu arquivo api.js, que é nosso módulo que guardará as classes clientes para a API do Mercado Bitcoin. Caso não tenha feito a primeira parte do tutorial, você pode baixá-la no post anterior, no formulário ao fim do mesmo.

Logo no início do arquivo api.js, vamos modificar o original para adicionar dois novos módulos que serão necessários, o crypto e o querystring (o axios é do tutorial anterior):

//MERCADO BITCOIN
const axios = require('axios');
const crypto  = require('crypto');
const qs      = require('querystring');

//MERCADO BITCOIN

const axios = require('axios');

const crypto = require('crypto');

const qs = require('querystring');

O primeiro serve para criptografar mensagens e o segundo para concatenar variáveis no formato de querystring do HTTP. Precisaremos de ambos pois o endpoint que vamos acessar para efetuar transações exige criptografia e para algumas operações devemos enviar dados no body de um POST.

Para que estes módulos funcionem corretamente precisamos instalá-los no projeto usando o NPM via console (instale agora, caso ainda não tenha feito):

npm i crypto querystring

1	npm i crypto querystring

Ainda no arquivo api.js, logo abaixo dos requires, vamos definir duas novas constantes para o path da Trade API e para o endpoint da mesma (o outro endpoint é o de consulta de informações):

const ENDPOINT_API = 'https://www.mercadobitcoin.com.br/api/'
const ENDPOINT_TRADE_PATH = "/tapi/v3/"
const ENDPOINT_TRADE_API = 'https://www.mercadobitcoin.net' + ENDPOINT_TRADE_PATH

const ENDPOINT_API = 'https://www.mercadobitcoin.com.br/api/'

const ENDPOINT_TRADE_PATH = "/tapi/v3/"

const ENDPOINT_TRADE_API = 'https://www.mercadobitcoin.net' + ENDPOINT_TRADE_PATH

E por fim, logo abaixo da class da API de informações, vamos adicionar a class que representa a API de trading já com o seu constructor:

class MercadoBitcoinTrade {
    constructor(config) {
        this.config = {
            KEY: config.key,
            SECRET: config.secret,
            PIN: config.pin,
            CURRENCY: config.currency
        }
    }
}

class MercadoBitcoinTrade {

constructor(config) {

this.config = {

KEY: config.key,

SECRET: config.secret,

PIN: config.pin,

CURRENCY: config.currency

}

As configurações passadas por parâmetro são a chave da API, o segredo da API, o PIN da sua conta e a moeda que vai negociar com esse bot (BTC, BCH e LTC no caso do Mercado Bitcoin). Note que KEY, SECRET e PIN eu lhe ensinei como obter no post anterior, dentro da sua área de trader da exchange. Não informe estes dados a ninguém!

Logo abaixo desta função construtora, vamos adicionar as funções que fazem as chamadas à API de trading:

getAccountInfo() {
    return this.call('get_account_info', {});
}

listMyOrders(parameters) {
    return this.call('list_orders', parameters);
}

placeBuyOrder(qty, limit_price) {
    return this.call('place_buy_order', { coin_pair: `BRL${this.config.CURRENCY}`, quantity: `${qty}`.substr(0, 10), limit_price: `${limit_price}` });
}

placeSellOrder(qty, limit_price) {
    return this.call('place_sell_order', { coin_pair: `BRL${this.config.CURRENCY}`, quantity: `${qty}`.substr(0, 10), limit_price: `${limit_price}` });
}

cancelOrder(orderId) {
    return this.call('cancel_order', { coin_pair: `BRL${this.config.CURRENCY}`, order_id: orderId });
}

async call(method, parameters) {
   //implementar
}

getAccountInfo() {

return this.call('get_account_info', {});

}

listMyOrders(parameters) {

return this.call('list_orders', parameters);

}

placeBuyOrder(qty, limit_price) {

return this.call('place_buy_order', { coin_pair: `BRL${this.config.CURRENCY}`, quantity: `${qty}`.substr(0, 10), limit_price: `${limit_price}` });

}

placeSellOrder(qty, limit_price) {

return this.call('place_sell_order', { coin_pair: `BRL${this.config.CURRENCY}`, quantity: `${qty}`.substr(0, 10), limit_price: `${limit_price}` });

}

cancelOrder(orderId) {

return this.call('cancel_order', { coin_pair: `BRL${this.config.CURRENCY}`, order_id: orderId });

}

async call(method, parameters) {

//implementar

}

Aqui estou definindo diversas operações que a API nos permite realizar, apenas configurando as chamadas e passando-as para uma função call que não está implementada. Vale citar o que cada operação realiza:

getAccountInfo: pega informações da sua conta, especialmente o seu saldo atual em cada moeda, incluindo BRL;
listMyOrders: traz as suas últimas ordens no mercado, tanto de compra quanto de venda e incluindo as que estão pendentes e canceladas, sendo que você pode filtrar livremente pelos parâmetros que discutirei mais tarde;
placeBuyOrder: criar uma nova ordem de compra no livro de negociações. Caso haja disponibilidade (tem moedas sendo vendidas ao preço que deseja pagar), a ordem será executada imediatamente. Caso contrário, ela vai pro livro e seu saldo fica bloqueado para honrar a compra;
placeSellOrder: cria uma nova ordem de venda no livro de negociações. Caso haja disponibilidade (tem ordens de compra ao preço que você deseja vender), a ordem será executada imediatamente. Caso contrário, ela vai pro livro e seu saldo na criptomoeda fica bloqueado para honrar a venda;
cancelOrder: cancela uma ordem sua no livro de negociações;

Você deve ter notado que diversas chamadas concatenam ‘BRL’ à sigla da criptomoeda que vamos negociar, gerando strings como BRLBTC, que é o que chamamos de ‘coin pair’ ou ‘par de moedas’, o que indica que você está negociando Reais por Bitcoins.

Também deve ter notado que em algumas ocasiões eu uso Template Strings para forçar variáveis numéricas a serem strings, que é o formato que a API pede em diversos casos.

Da mesma forma que no caso da classe de API de informações, nossa call é async e teremos de usar await para lidar com a assincronicidade dela. Falando nela…

Ela é um pouquinho complexa, mas segue abaixo:

async call(method, parameters) {

    const now = Math.round(new Date().getTime() / 1000);
    let queryString = qs.stringify({ 'tapi_method': method, 'tapi_nonce': now });
    if (parameters) queryString += `&${qs.stringify(parameters)}`;

    const signature = crypto.createHmac('sha512', this.config.SECRET)
        .update(`${ENDPOINT_TRADE_PATH}?${queryString}`)
        .digest('hex');

    let config = {
        headers: {
            'TAPI-ID': this.config.KEY,
            'TAPI-MAC': signature
        }
    }

    const response = await axios.post(ENDPOINT_TRADE_API, queryString, config);
    if (response.data.error_message) throw new Error(response.data.error_message);
    return response.data;
}

async call(method, parameters) {

const now = Math.round(new Date().getTime() / 1000);

let queryString = qs.stringify({ 'tapi_method': method, 'tapi_nonce': now });

if (parameters) queryString += `&${qs.stringify(parameters)}`;

const signature = crypto.createHmac('sha512', this.config.SECRET)

.update(`${ENDPOINT_TRADE_PATH}?${queryString}`)

.digest('hex');

let config = {

headers: {

'TAPI-ID': this.config.KEY,

'TAPI-MAC': signature

}

const response = await axios.post(ENDPOINT_TRADE_API, queryString, config);

if (response.data.error_message) throw new Error(response.data.error_message);

return response.data;

}

A Trade API opera somente com requisições POST, cujos parâmetros da requisição devem estar no formato querystring no body. Para montar este body, conto com a ajuda do módulo querystring, concatenando os parâmetros, o nome da ação que esta request fará e um número único que identifica esta request, que aqui apenas estou pegando o timestamp atual, que sabemos que nunca se repetirá.

A Trade API também exige que cada requisição seja enviada com um cabeçalho TAPI-ID com a chave de API e um header TAPI-MAC, que é um hash HMAC-SHA512 que montamos usando o path completo desta requisição e o API secret como chave de criptografia. De acordo com o response da API, executamos o callback de success ou de error.

Para finalizar a nossa API, vamos apenas modificar o module.exports no final para expor ambas classes deste módulo api.js:

module.exports = {
    MercadoBitcoin,
    MercadoBitcoinTrade
}

module.exports = {

MercadoBitcoin,

MercadoBitcoinTrade

}

#2 – Comprando Bitcoins em Node.js

Uma vez que seu bot esteja monitorando o mercado e você tenha implementado a APIs de trading, você deverá definir a lógica de compra e venda de criptomoedas. Não há uma regra aqui, exceto que você deve procurar comprar em baixa e vender em alta, para lucrar com a oscilação da moeda.

Para começar, vamos criar uma regra bem simples, baseada em uma observação do gráfico candlestick do Bitcoin no momento que escrevo este post:

Podemos observar neste gráfico que o Bitcoin está valorizado em R$178.406 por unidade, o que é um valor mediano considerando a máxima e mínima dos últimos dias. Por exemplo, vamos modificar nosso index.js para ordenar uma compra quando o Bitcoin cair abaixo de R$170.000 a unidade:

//index.js
require("dotenv-safe").config();
const { MercadoBitcoin, MercadoBitcoinTrade } = require("./api");

const infoApi = new MercadoBitcoin({ currency: 'BTC' });

const tradeApi = new MercadoBitcoinTrade({
    currency: 'BTC',
    key: process.env.KEY,
    secret: process.env.SECRET,
    pin: process.env.PIN
});

setInterval(async () => {
    const response = await infoApi.ticker();
    console.log(response.ticker);
    if (response.ticker.sell > 170000)
        return console.log('Ainda muito alto, vamos esperar pra comprar depois.');

    try {
        const data = await tradeApi.placeBuyOrder(1, 170000);
        console.log('Ordem de compra inserida no livro. ', data);
    } catch (error) {
        console.error('Erro ao inserir ordem de compra no livro. ', error);
    }
},
    process.env.CRAWLER_INTERVAL
)

//index.js

require("dotenv-safe").config();

const { MercadoBitcoin, MercadoBitcoinTrade } = require("./api");

const infoApi = new MercadoBitcoin({ currency: 'BTC' });

const tradeApi = new MercadoBitcoinTrade({

currency: 'BTC',

key: process.env.KEY,

secret: process.env.SECRET,

pin: process.env.PIN

});

setInterval(async () => {

const response = await infoApi.ticker();

console.log(response.ticker);

if (response.ticker.sell > 170000)

return console.log('Ainda muito alto, vamos esperar pra comprar depois.');

try {

const data = await tradeApi.placeBuyOrder(1, 170000);

console.log('Ordem de compra inserida no livro. ', data);

} catch (error) {

console.error('Erro ao inserir ordem de compra no livro. ', error);

}

process.env.CRAWLER_INTERVAL

)

Neste código eu inicializo a trade API logo no topo, usando diversas variáveis de ambiente presentes no seu arquivo .env que criamos na parte 1 deste tutorial.

Agora após realizar o ticker para pegar as informações atuais do mercado, eu verifico o preço de venda mais barato do Bitcoin atualmente. Se ele for menor que o número que eu defini como bom para compra (170000), eu mando comprar. Note que você pode criar todo tipo de inteligência para calcular este número, como verificar o spread das últimas 24h para inferir variação, verificar volume de vendas e compras realizadas para inferir tendências de alta ou baixa, etc.

Uma vez que o preço esteja dentro do seu patamar considerado aceitável, é hora de criar a ordem de compra no livro de negociações. O primeiro parâmetro é quantos bitcoins você deseja comprar (1, mas podem ser frações com até 5 casas decimais) e o segundo parâmetro é o preço máximo que deseja pagar por uma unidade de bitcoin (170000). Diversas coisas podem acontecer neste momento.

Caso você não tenha saldo suficiente, você terá um erro como retorno. Já no caso de que não exista nenhuma ordem de venda compatível com o preço que deseja pagar, sua compra não será efetuada imediatamente. Ela vai parar no livro, seu saldo será bloqueado, e ela será executada assim que alguém estiver vendendo pelo valor que você deseja comprar (ou mais barato). Nestes casos de execução futura, você está sendo executado, e geralmente paga uma taxa de comissão menor para a exchange.

Caso você tenha saldo e exista uma ordem de venda no mercado compatível com a sua ordem de compra, ela será executada imediatamente. O seu saldo em BRL (R$) será liquidado, você receberá saldo em BTC e pagará a comissão de executador, que geralmente é mais alta do que a taxa de quem foi executado (o vendedor cuja ordem já estava no livro antes da sua).

#3 – Vendendo Bitcoins em Node.js

Da mesma forma que realizamos a compra, podemos criar uma condição de venda de criptomoedas em nosso robô. Aqui existem dois cenários: operar em STOP ou buscar a lucratividade máxima. Obviamente o risco da segunda alternativa é muito maior e não existe um algoritmo 100% eficiente.

Se optar por operar em STOP, você pode definir uma lucratividade padrão que deseja atingir em cada trade, como 3% por exemplo, e assim que realizar uma compra, você já emite uma ordem de venda com o ágio correspondente, como abaixo (substitua o código de compra anterior por este):

setInterval(async () => {
    const response = await infoApi.ticker();
    console.log(response.ticker);
    if (response.ticker.sell > 170000)
        return console.log('Ainda muito alto, vamos esperar pra comprar depois.');

    try {
        const data = await tradeApi.placeBuyOrder(1, 170000);
        console.log('Ordem de compra inserida no livro. ', data);

        //operando em STOP de 3%
        const data2 = await tradeApi.placeSellOrder(1, 170000 * 1.03);
        console.log('Ordem de venda inserida no livro. ', data2);

    } catch (error) {
        console.error('Erro ao inserir ordem no livro. ', error);
    }
},
    process.env.CRAWLER_INTERVAL
)

setInterval(async () => {

const response = await infoApi.ticker();

console.log(response.ticker);

if (response.ticker.sell > 170000)

return console.log('Ainda muito alto, vamos esperar pra comprar depois.');

try {

const data = await tradeApi.placeBuyOrder(1, 170000);

console.log('Ordem de compra inserida no livro. ', data);

//operando em STOP de 3%

const data2 = await tradeApi.placeSellOrder(1, 170000 * 1.03);

console.log('Ordem de venda inserida no livro. ', data2);

} catch (error) {

console.error('Erro ao inserir ordem no livro. ', error);

}

process.env.CRAWLER_INTERVAL

)

Com isso, você garante que venderá a um valor mínimo que lhe renda o lucro desejado (neste caso, vender a 170000 * 1.03 lhe renderá 2% líquido, por causa das comissões de compra e venda da exchange), tão logo o mercado atinja esse patamar. Eu gosto de operar assim, pois é uma forma de investimento de renda fixa com Bitcoin. Essa porcentagem deve ser relativa ao spread atual (diferença entre mínima e máxima dentro de um período) e deve ser sempre superior a 1% (por causa das comissões).

Note que esta venda está sendo posicionada no livro de negociações no mesmo instante que você está comprando a moeda. Ela não vai ser executada instantaneamente, mas assim que o mercado atingir aquele patamar, o que pode levar alguns minutos em dias de alta volatilidade, ou até mesmo semanas, em períodos de baixa volatilidade (ou caso tenha escolhido um valor muito alto).

Ordens de compra e de venda não executadas podem ser canceladas a qualquer momento usando a function apropriada e seu dinheiro é devolvido (seja ele BTC ou BRL).

Se optar por operar com lucratividade máxima, você não deverá posicionar sua ordem de venda imediatamente após a ordem de compra e sim, deverá continuar monitorando o mercado para entender qual o melhor momento de vender. Esse desafio eu deixo para você bolar.

#4 – Otimizando Compra e Venda de Bitcoin

Usei números fixos nos exemplos anteriores, mas é óbvio que essa estratégia não é lá muito boa pois cria um bot muito burro. O que sugiro é que você sempre realize uma consulta à sua conta para saber quanto possui de saldo da moeda que vai utilizar, para poder calcular quanto pode comprar/vender, evitando erros na API.

Para fazer isso, vamos criar uma function na index.js chamada getQuantity:

async function getQuantity(coin, price, isBuy) {
    price = parseFloat(price);
    coin = isBuy ? 'brl' : coin.toLowerCase();

    const data = await tradeApi.getAccountInfo();
    let balance = parseFloat(data.balance[coin].available).toFixed(5);
    balance = parseFloat(balance);

    if (isBuy && balance < 50) return console.log('Sem saldo disponível para comprar!');
    console.log(`Saldo disponível de ${coin}: ${balance}`);

    if (isBuy) balance = parseFloat((balance / price).toFixed(5));
    return parseFloat(balance) - 0.00001;//tira a diferença que se ganha no arredondamento
}

async function getQuantity(coin, price, isBuy) {

price = parseFloat(price);

coin = isBuy ? 'brl' : coin.toLowerCase();

const data = await tradeApi.getAccountInfo();

let balance = parseFloat(data.balance[coin].available).toFixed(5);

balance = parseFloat(balance);

if (isBuy && balance < 50) return console.log('Sem saldo disponível para comprar!');

console.log(`Saldo disponível de ${coin}: ${balance}`);

if (isBuy) balance = parseFloat((balance / price).toFixed(5));

return parseFloat(balance) - 0.00001;//tira a diferença que se ganha no arredondamento

}

Esta function espera a moeda que estamos negociando, o preço de uma unidade dela e se é uma compra ou venda (true/false).

Após algumas conversões usamos a Trade API para pegar informações da conta do indivíduo e descobrir o saldo dele da moeda que vamos criar a ordem. Se for uma compra (isBuy === true), estaremos operando em BRL e temos de ter no mínimo R$50 na conta para poder gastar, comprando uma quantidade igual a saldo / preço. Se for uma venda de criptomoeda, o próprio saldo (balance) da criptomoeda é a quantidade que queremos negociar.

Aqui considero que você sempre deseja usar todo o seu saldo na transação o que, em volumes altos, pode ser muito arriscado (ajuste a seu critério).

Agora vamos usar esta getQuantity nas nossas chamadas de compra, para deixá-las dinâmicas, adaptadas ao saldo atual na sua conta do Mercado Bitcoin:

setInterval(async () => {
    const response = await infoApi.ticker();
    console.log(response.ticker);
    if (response.ticker.sell > 170000)
        return console.log('Ainda muito alto, vamos esperar pra comprar depois.');

    try {
        const qty = await getQuantity('BRL', response.ticker.sell, true);
        const data = await tradeApi.placeBuyOrder(qty, response.ticker.sell);
        console.log('Ordem de compra inserida no livro. ', data);

        //operando em STOP de 3%
        const data2 = await tradeApi.placeSellOrder(data.quantity, response.ticker.sell * parseFloat(process.env.PROFITABILITY));
        console.log('Ordem de venda inserida no livro. ', data2);

    } catch (error) {
        console.error('Erro ao inserir ordem no livro. ', error);
    }
},
    process.env.CRAWLER_INTERVAL
)

setInterval(async () => {

const response = await infoApi.ticker();

console.log(response.ticker);

if (response.ticker.sell > 170000)

return console.log('Ainda muito alto, vamos esperar pra comprar depois.');

try {

const qty = await getQuantity('BRL', response.ticker.sell, true);

const data = await tradeApi.placeBuyOrder(qty, response.ticker.sell);

console.log('Ordem de compra inserida no livro. ', data);

//operando em STOP de 3%

const data2 = await tradeApi.placeSellOrder(data.quantity, response.ticker.sell * parseFloat(process.env.PROFITABILITY));

console.log('Ordem de venda inserida no livro. ', data2);

} catch (error) {

console.error('Erro ao inserir ordem no livro. ', error);

}

process.env.CRAWLER_INTERVAL

)

Também usei a quantidade retornada pelo response da compra para passar ao request de venda, evitando chamadas desnecessárias à API. E por fim, usei o valor de venda do mercado (tick.sell) e multipliquei pela rentabilidade desejada que eu deixei configurada no arquivo .env na primeira parte do tutorial, lembra? Assim, fica fácil de mudar isso depois conforme a sua análise do mercado, até que tenha capacidade para montar uma fórmula em cima do spread corrente.

A única otimização que eu não tenho como lhe ajudar é a de determinar quando é o melhor momento para compra, deixei o 170000 chumbado ali no código e depois você deve mudar conforme o mercado. Parece um problema simples, mas não é, é tão complicado descobrir a mínima de compra quanto a máxima de venda e se eu tivesse essa fórmula já estaria rico.

Espero que tenham gostado deste tutorial e tendo qualquer dúvida, deixe nos comentários!

Curtiu o post? Que tal aprender mais sobre como criar aplicações incríveis usando Node.js? Então clica no banner abaixo e dá uma conferida no meu livro sobre programação web com Node.js!

Tag: nodejs

Como criar um bot de compra e venda de Bitcoin usando Node.js – Parte 2

#1 – Ajustando o módulo API

#2 – Comprando Bitcoins em Node.js

#3 – Vendendo Bitcoins em Node.js

#4 – Otimizando Compra e Venda de Bitcoin