Algoritmo para arbitragem triangular com bot

O mercado de criptomoedas é extremamente volátil e todo mundo sabe disso. O que nem todo mundo parou para reparar é que o preço de um par de moedas, como por exemplo o Bitcoin/Tether pode não ser proporcional ao par de Bitcoin com outra moeda, no mesmo minuto, na mesma corretora. Com isso em mente, será que é possível criar um bot que compra Bitcoin no par mais barato e vende no mais caro?

Neste artigo/tutorial eu vou lhe explicar o que é a arbitragem triangular, como ela funciona e exercitaremos uma versão inicial de um algoritmo para explorar este tipo de oportunidades usando bots de criptomoedas. Se preferir, você pode assistir ao vídeo abaixo, ele tem o mesmo conteúdo.

É importante frisar que este não é um tutorial recomendado para quem não tem experiência alguma com programação. Meus conteúdos exigem que você já saiba o básico de programação, em especial com a linguagem JavaScript. Não é obrigatório ter experiência prévia com investimentos, mas ajuda bastante se você já usou a exchange Binance antes, embora a técnica ensinada possa ser usada em outras exchanges também.

Se preferir, você pode acompanhar o mesmo conteúdo neste vídeo abaixo, que é o primeiro de uma série. Ao final do vídeo, sempre é recomendado o próximo.

O que é Arbitragem Triangular?

Arbitragem triangular é um tipo especial de arbitragem.

Enquanto que na arbitragem tradicional você compra uma moeda em uma corretora por um preço e a revende em outra corretora por outro preço mais alto, na arbitragem triangular nós fazemos triangulações entre as moedas na mesma corretora, explorando anomalias de preços entre os diferentes pares.

Considere o cenário fictício de que o par BTC/USDT esteja cotado em 10.000. Ou seja, para comprar 1 BTC você deve investir 10.000 USDT e vamos dizer que você faz exatamente isso, zerando a sua carteira.

Agora imagine que você compre com esse 1 BTC, Ethers (ETH), pela cotação de 20. Ou seja, posso comprar 20 ETH com 1 BTC.

Para fecharmos o triângulo, precisamos vender agora nossos ETH para voltarmos a ter USDT, na esperança de terminarmos a triangulação com mais USDT do que começamos, certo? Se a cotação do ETH/USDT estiver superior a 500, é possível que eu tenha lucro com esta triangulação, pois 20 x 500 = 10.000.

O diagrama abaixo mostra este exemplo passo a passo.

Claro que sair comprando pra depois ver se vale a pena vender no lucro não é uma boa ideia. A boa ideia que eu quero lhe apresentar um possível algoritmo é validar as 3 etapas do triângulo antes de efetuar as operações, para ver se será lucrativo. E caso for, aí sim poderia ser feita a arbitragem manualmente ou automaticamente.

Para isso, precisaremos criar um algoritmo que analise o mercado da corretora, descubra os triângulos possíveis e um a um verifique o preço dos ativos em tempo real para verificar se existe algum que seja lucrativo. Importante frisar que encontrar triângulos lucrativos não é garantia de sucesso pois uma vez que essas oportunidades são anomalias do mercado, elas surgem e desaparecem rapidamente, seja por ação natural do mercado, seja por robôs de devs investidores como você, que ficam buscando esse tipo de oportunidade.

Qualquer pessoa que lhe diga que é fácil ganhar dinheiro desta forma, que não tem riscos ou pior ainda: que existe alguma previsão de rentabilidade, rentabilidade média, etc está tentando lhe enrolar, pois não há, é investimento de risco!

Dito isso, vamos criar nosso projeto!

Setup do Projeto

Vou criar com você um projeto Node.js e escrever os códigos usando a linguagem JavaScript, mas se souber programar em outra linguagem, pode usá-la tranquilamente desde que saiba o que está fazendo e consiga traduzir meus códigos para a sua escolha. No entanto, devido às diferenças entre as linguagens, não posso garantir que irá funcionar.

Caso nunca tenha utilizado Node.js antes, no vídeo abaixo tem um tutorial de instalação.

E caso nunca tenha programado em JavaScript antes e queira aprender, o vídeo abaixo é o primeiro de uma playlist sobre programação em JS para iniciantes.

Mas voltando à criação do projeto em si, crie uma pasta para ele, abra o terminal de linha de comando, navegue até entrar nesta pasta e dentro dela rode o comando abaixo para inicializar um projeto Node.js nela.


npm init -y

npm init -y

Agora vamos instalar algumas dependências que vamos precisar, usando o comando abaixo.


npm i axios ws dotenv

npm i axios ws dotenv

O Axios é um cliente HTTP que vamos usar para chamar as APIs da corretora. Já o WS é um client WebSockets que vamos usar para receber dados de preço em tempo real da corretora. E por fim o DotEnv serve para configurarmos as variáveis de ambiente do nosso projeto, nossas configurações de arbitragem principalmente.

Vamos começar configurando um arquivo .env (sem nome, apenas a extensão) na pasta do nosso projeto, justamente para guardar estas configurações.


CRAWLER_INTERVAL=3000
PROFITABILITY=1.003
QUOTE=USDT
AMOUNT=10

CRAWLER_INTERVAL=3000

PROFITABILITY=1.003

QUOTE=USDT

AMOUNT=10

As variáveis acima são as que precisaremos, mas os valores você ajusta conforme quiser. A saber:

CRAWLER_INTERVAL: de quanto em quanto tempo o seu bot vai testar as triangulações possíveis (em milissegundos)?
PROFITABILITY: deve ser um valor acima de 1, já considerando as taxas da sua exchange x3 (uma vez para cada operação do triângulo);
QUOTE: qual o quote asset que você vai usar para comprar, dando início ao triângulo e que consequentemente você deseja terminar o triângulo com mais do que começou?
AMOUNT: qual a quantidade de quote que você tem e que será usada para a triangulação?

E agora para garantir que nosso bot vai carregar estas configurações logo que iniciar, vá no seu arquivo package.json, que foi criado quando inicializamos o projeto, e na seção de scripts, ajuste para que na inicialização, o dotenv entre em cena.


"scripts": {
  "start": "node -r dotenv/config index"
},

"scripts": {

"start": "node -r dotenv/config index"

Repare aqui que nesse script de start estou considerando que temos um arquivo index. O que ainda não é verdade, vamos criá-lo agora. Crie um arquivo index.js na sua pasta com o seguinte conteúdo.


const QUOTE = process.env.QUOTE;
const AMOUNT = parseInt(process.env.AMOUNT);
const INTERVAL = parseInt(process.env.CRAWLER_INTERVAL);
const PROFITABILITY = parseFloat(process.env.PROFITABILITY);

console.log('Hello World');

const QUOTE = process.env.QUOTE;

const AMOUNT = parseInt(process.env.AMOUNT);

const INTERVAL = parseInt(process.env.CRAWLER_INTERVAL);

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

console.log('Hello World');

Isso carrega as configurações pra memória do bot e imprime uma mensagem no console, indicando que está tudo funcionando até o momento. Para rodar nosso programa, use o comando abaixo sempre que precisar.


npm start

npm start

Com isso nosso robô está com o projeto preparado para ter suas funcionalidades adicionadas!

Descobrindo o Mercado

A primeira coisa que precisamos implementar é a descoberta do mercado. Precisamos descobrir todos os pares de moeda que a corretora que vamos usar nos disponibiliza para trade, para logo adiante podermos descobrir as possibilidades de triângulos com eles. Aqui entra a decisão da corretora com a qual iremos trabalhar.

É possível fazer arbitragem triangular em qualquer corretora que tenha ao menos 3 moedas diferentes, nem que seja de forma manual. No entanto para fazermos qualquer tipo de automação é necessário que a corretora disponibilize APIs para isso. Além disso, considerando que cada triangulação vai executar 3 operações, é importante que as taxas sejam baixas. E por último, mas não menos importante, a velocidade com a qual a corretora permite que você busque, ou até mesmo se ela te envia as informações de preço rapidamente, é algo muito importante pois timing é crucial nesse tipo de oportunidade.

Por esses e outros motivos como solidez e diversidade que eu fico com a Binance atualmente, quando o assunto é arbitragem triangular. Mas não se preocupe, o que vou mostrar pode ser adaptado por você para outras exchanges e sequer você precisa de conta na Binance para avançar aqui com o nosso tutorial.

Para ajudar nesta tarefa de descoberta do mercado a Binance disponibiliza uma API pública de informações da exchange, chamada Exchange Info e documentada neste link. Vamos criar um módulo que consome esta API usando Axios, vamos chamá-lo de api.js, como abaixo.


const axios = require('axios');

async function exchangeInfo() {
    const response = await axios.get("https://api.binance.com/api/v3/exchangeInfo");
    return response.data.symbols.filter(s => s.status === 'TRADING').map(s => {
        return {
            symbol: s.symbol,
            base: s.baseAsset,
            quote: s.quoteAsset
        }
    });
}

module.exports = { exchangeInfo }

const axios = require('axios');

async function exchangeInfo() {

const response = await axios.get("https://api.binance.com/api/v3/exchangeInfo");

return response.data.symbols.filter(s => s.status === 'TRADING').map(s => {

return {

symbol: s.symbol,

base: s.baseAsset,

quote: s.quoteAsset

}

});

}

module.exports = { exchangeInfo }

No código acima nós criamos e exportamos uma função exchangeInfo. Ela faz um HTTP GET na API da Binance em produção, filtra os symbols que estejam sendo negociados no momento e retorna um array contendo os symbols com as informações de base e quote de cada um (base é a moeda à esquerda do par, enquanto quote é a moeda à direita).

Para usar este módulo que criamos nós vamos voltar ao index.js. Comece importando o módulo novo no topo do arquivo.


const { exchangeInfo } = require("./api");

const { exchangeInfo } = require("./api");

Agora ao final do arquivo vamos criar uma função que inicia o processamento e chamaremos ela.


async function start() {
    //pega todas moedas que estão sendo negociadas
    console.log('Loading Exchange Info...');
    const allSymbols = await exchangeInfo();
    console.log(allSymbols);
}

start();

async function start() {

//pega todas moedas que estão sendo negociadas

console.log('Loading Exchange Info...');

const allSymbols = await exchangeInfo();

console.log(allSymbols);

}

start();

Execute o seu programa e verá que ele vai se conectar na Binance, pegar os symbols e imprimir o resultado no console, indicando que funciona.

Descobrindo as Possibilidades

Agora que temos as informações dos pares sendo negociados no mercado, o próximo passo é entender as combinações possíveis que levem a uma triangulação válida. Para fazer isso, existem duas possibilidades de triangulação.

A primeira possibilidade é a Buy-Buy-Sell (Compra-Compra-Vende), como abaixo.

E a segunda possibilidade é a Buy-Sell-Sell (Compra-Vende-Vende), como abaixo.

Nossa missão agora é, dado todos os pares negociados na corretora e entendendo que temos USDT para gastar, quais as combinações possíveis considerando estas duas possibilidades de triangulação?

Para descobrir a resposta para esta pergunta vamos criar uma função getBuyBuySell no index.js.


function getBuyBuySell(buySymbols, allSymbols, symbolsMap) {
    const buyBuySell = [];
    for (let i = 0; i < buySymbols.length; i++) {
        const buy1 = buySymbols[i];

        const right = allSymbols.filter(s => s.quote === buy1.base);

        for (let j = 0; j < right.length; j++) {
            const buy2 = right[j];

            const sell1 = symbolsMap[buy2.base + buy1.quote];
            if (!sell1) continue;

            buyBuySell.push({ buy1, buy2, sell1 });
        }
    }
    return buyBuySell;
}

function getBuyBuySell(buySymbols, allSymbols, symbolsMap) {

const buyBuySell = [];

for (let i = 0; i < buySymbols.length; i++) {

const buy1 = buySymbols[i];

const right = allSymbols.filter(s => s.quote === buy1.base);

for (let j = 0; j < right.length; j++) {

const buy2 = right[j];

const sell1 = symbolsMap[buy2.base + buy1.quote];

if (!sell1) continue;

buyBuySell.push({ buy1, buy2, sell1 });

}

return buyBuySell;

}

Esta função espera os pares que eu posso comprar (buySymbols) em virtude do QUOTE que tenho, ela espera o array com todos pares (allSymbols) e também um mapa de symbols.

Uma vez com estes três parâmetros, a gente itera sobre os symbols que podemos comprar e um a um tentamos montar as possibilidades de triângulos, seguindo os diagramas que mostrei antes. Para obtermos aquele symbolsMap, vamos precisar de uma função que converta o array de symbols para um mapa de symbols, como segue.


function getSymbolMap(symbols) {
    const map = {};
    symbols.map(s => map[s.symbol] = s);
    return map;
}

function getSymbolMap(symbols) {

const map = {};

symbols.map(s => map[s.symbol] = s);

return map;

}

Função bem direta: recebe um array de symbols e transforma em mapa de symbols. Isso é especialmente útil para ter mais performance na função getBuyBuySell que criamos antes.

Agora é hora de juntar os pedaços, lá na nossa função start.


async function start() {
    //pega todas moedas que estão sendo negociadas
    console.log('Loading Exchange Info...');
    const allSymbols = await exchangeInfo();

    //moedas que você pode comprar
    const buySymbols = allSymbols.filter(s => s.quote === QUOTE);
    console.log('There are ' + buySymbols.length + " pairs that you can buy with " + QUOTE);

    //organiza em map para performance
    const symbolsMap = getSymbolMap(allSymbols);

    //descobre todos os pares que podem triangular BUY-BUY-SELL
    const buyBuySell = getBuyBuySell(buySymbols, allSymbols, symbolsMap);
    console.log('There are ' + buyBuySell.length + " pairs that we can do BBS");
}

async function start() {

//pega todas moedas que estão sendo negociadas

console.log('Loading Exchange Info...');

const allSymbols = await exchangeInfo();

//moedas que você pode comprar

const buySymbols = allSymbols.filter(s => s.quote === QUOTE);

console.log('There are ' + buySymbols.length + " pairs that you can buy with " + QUOTE);

//organiza em map para performance

const symbolsMap = getSymbolMap(allSymbols);

//descobre todos os pares que podem triangular BUY-BUY-SELL

const buyBuySell = getBuyBuySell(buySymbols, allSymbols, symbolsMap);

console.log('There are ' + buyBuySell.length + " pairs that we can do BBS");

}

Aqui nós pegamos o array com todos symbols e dele queremos apenas aqueles cujo quote seja igual ao que temos em carteira. Isso gera o array buySymbols.

Depois, convertermos o array allSymbols para um mapa de symbols (symbolsMap).

E por fim, chamamos a nossa função getBuyBuySell passando as três coleções pra ela, que nos retornará com um array contendo todas as possibilidades de triangulação BBS possíveis. Se preferir, pode mandar imprimir no console para entender como ela ficou.

Na parte 2 deste tutorial, que você confere neste link, vamos fazer o mesmo processo para descobrir as possibilidades de triangulação Buy-Sell-Sell e vamos monitorar os preços para entender quais triangulações são viáveis.

Até lá!