Como funcionam as corretoras de criptomoedas (tecnicamente)?

Revisado em 14/04/2026!

Desde 2017, quando comecei a investir em criptomoedas, que as corretoras cripto me fascinam. Eu fui de mero investidor a desenvolvedor de integrações, como bots trader, e mais recentemente comecei a estudar mais a fundo a arquitetura e funcionamento das mesmas. Neste artigo, que é o primeiro de outros que pretendo escrever, eu quero trazer um pouco de luz aos elementos mais comuns e ao mesmo tempo mal compreendidos de todas exchanges: o Order Book e o Match Engine.

Importante ressaltar que me refiro aqui às corretoras centralizadas e em estilo “marketplace”, como a Binance, onde compradores e vendedores lançam suas ordens e fecham negócios intermediados pela mesma. Digo isso porque existem corretoras no estilo “casa de câmbio”, onde você compra e vende as moedas para a própria exchange, ao invés de para outras pessoas e também existem as corretoras descentralizadas (dex) que não possuem order books, mas liquidity pools ao invés disso, cuja mecânica é completamente diferente do que vou trazer aqui. Existe ainda um quarto tipo que são as corretoras P2P, que também não abordaremos hoje.

Além disso, ao invés de apenas trazer a teoria, este vai ser um artigo bem técnico e prático, onde construíremos protótipos de algumas partes interessantes para o aprendizado.

Para ter um overview da parte teórica, você pode conferir o vídeo abaixo.

Dito isso, vamos lá!

#1 – Ordens

O restante deste material pode ser visto no vídeo abaixo, que contém o mesmo conteúdo.

Imagine que você tem 1 BTC e quer vender ele a um valor x. Você poderia anunciar ele em algum site de classificados, tipo OLX, e esperar um interessado te chamar. No entanto, na hora de fechar o negócio, você iria transferir o BTC primeiro ou a pessoa iria transferir a grana? Temos aqui um claro risco de confiança, certo? Esse é um dos motivos que as exchanges de criptomoedas existem: para intermediar as transações (trades) de maneira segura, cobrando uma pequena taxa por este serviço. Ambos transferem seus recursos para contas na corretora e ela faz a troca dos valores, que depois podem ser sacados novamente.

Uma primeira forma de entender as exchanges é justamente como um site de classificados de compra e venda de criptomoedas. Esse classificado é organizado através de order books ou livros de ordens. Um order book possui duas páginas: uma para registrar as intenções de compra e outra para as intenções de venda, ambas a preço futuro. Assim, sempre que uma pessoa quer vender, ela envia uma ordem de venda para a página de vendas, declarando a sua intenção, e o mesmo para o caso de querer comprar.

Antes da gente entrar em mais detalhes do OrderBook, vamos falar um pouco dessas ordens em si, sejam de compra ou de venda. Abaixo um exemplo fictício em JS.


export default class Order {

    static orderId = 0;

    static getNextOrderId() {
        return ++Order.orderId;
    }

    constructor(side, amount, price = 0) {
        if(side !==  Side.BUY && side !== Side.SELL) {
            throw new Error("Invalid order side. Must be 'buy' or 'sell'.");
        }

        if(price && parseFloat(price) <= 0) {
            throw new Error("Price must be a positive number.");
        }

        if(parseFloat(amount) <= 0) {
            throw new Error("Amount must be a positive number.");
        }

        this.id = Order.getNextOrderId();
        this.side = side;
        this.price = price ? Number(price) : undefined;
        this.amount = Number(amount);
        this.timestamp = Date.now();
    }
}

export const Side = {
    BUY: "buy",
    SELL: "sell"
}

export default class Order {

static orderId = 0;

static getNextOrderId() {

return ++Order.orderId;

}

constructor(side, amount, price = 0) {

if(side !== Side.BUY && side !== Side.SELL) {

throw new Error("Invalid order side. Must be 'buy' or 'sell'.");

}

if(price && parseFloat(price) <= 0) {

throw new Error("Price must be a positive number.");

}

if(parseFloat(amount) <= 0) {

throw new Error("Amount must be a positive number.");

}

this.id = Order.getNextOrderId();

this.side = side;

this.price = price ? Number(price) : undefined;

this.amount = Number(amount);

this.timestamp = Date.now();

}

export const Side = {

BUY: "buy",

SELL: "sell"

}

Nesta classe para ordens, eu gero ids autoincrementais a cada nova ordem instanciada, além de pegar o instante da máquina para registrar quando ela foi criada. Já o usuário precisa informar o side (buy ou sell), a quantidade e o preço (opcional). Para simplificar, vamos ignorar aqui que uma corretora pode ter várias moedas e combinações entre elas, vou tratar aqui como se fosse apenas BTC negociado em dólar sempre, ok?

Eu adicionei algumas validações importantes nos inputs do usuário antes de guardar os valores nas propriedades e também criei uma constante para os sides das ordens, a fim de que não seja escrito errado por engano.

Toda vez que alguém quiser comprar ou vender uma moeda, o primeiro passo é instanciar uma nova ordem e enviá-la para a corretora. Essa ordem vai parar no order book, de venda ou de compra.

#2 – Livro de Ordens

Existem ordens de market making, ou seja, que ajudam a criar o mercado de negociação. Essas ordens são aquelas a preço futuro, ou seja, pessoas querendo vender mais caro do que o preço médio da moeda atual, ou pessoas querendo comprar mais barato do que o preço médio atual. Toda vez que uma ordem dessas é enviada, ela é registrada no book de compra e ou de venda daquele ativo, para que seja executada mais tarde, formando o mercado da exchange. Uma exchange sem mercado não atrai atenção de ninguém, por isso que muitas vezes elas dão incentivos para estes tipos de ordens, como descontos em taxas ou até isenção.

Importante ressaltar que o order book não é uma fila de ordens, mas sim uma pilha ordenada, onde as ordens mais relevantes ficam no topo e as menos relevantes ficam na base. No caso do order book de compras, as ordens mais relevantes são as que estão querendo pagar mais, enquanto que book de vendas, é a ordem que está mais barata. Havendo empate, a ordem de chegada no book resolve o impasse, com os mais antigos tendo prioridade. Assim, toda vez que chegar uma nova ordem, deve ser verificado em que posição da pilha do book ela deve ficar, conforme seu preço.

Vamos começar criando nossa classe OrderBook.js como abaixo:


import { Side } from "./Order.js";

export default class OrderBook {
    constructor() {
        this.buyOrders = [];
        this.sellOrders = [];
    }

    getTickerPrice() {
        if (this.buyOrders.length === 0 || this.sellOrders.length === 0) {
            return 0; // No trades possible, so no ticker price
        }

        const difference = this.sellOrders[0].price - this.buyOrders[0].price;
        const midPrice = (this.sellOrders[0].price + this.buyOrders[0].price) / 2;
        const tickerPrice = midPrice + difference * 0.1; // Adjust the ticker price slightly towards the sell side
        return tickerPrice;
    }

import { Side } from "./Order.js";

export default class OrderBook {

constructor() {

this.buyOrders = [];

this.sellOrders = [];

}

getTickerPrice() {

if (this.buyOrders.length === 0 || this.sellOrders.length === 0) {

return 0; // No trades possible, so no ticker price

}

const difference = this.sellOrders[0].price - this.buyOrders[0].price;

const midPrice = (this.sellOrders[0].price + this.buyOrders[0].price) / 2;

const tickerPrice = midPrice + difference * 0.1; // Adjust the ticker price slightly towards the sell side

return tickerPrice;

}

Aqui eu defini o construtor, que inicializa os books de compra e de venda e uma função getTickerPrice, que descobre o preço médio deste ativo no mercado atualmente. Como ele sabe isso? Olhando o ponto central entre a melhor oferta de compra e de venda!

Vamos criar agora a função que adiciona uma nova ordem do book correspondente.


addOrder(order) {
    if (order.side === Side.BUY) {
        this.buyOrders.push(order);
        this.buyOrders.sort((a, b) => b.price - a.price || a.timestamp - b.timestamp);
    } else {
        this.sellOrders.push(order);
        this.sellOrders.sort((a, b) => a.price - b.price || a.timestamp - b.timestamp);
    }
}

addOrder(order) {

if (order.side === Side.BUY) {

this.buyOrders.push(order);

this.buyOrders.sort((a, b) => b.price - a.price || a.timestamp - b.timestamp);

} else {

this.sellOrders.push(order);

this.sellOrders.sort((a, b) => a.price - b.price || a.timestamp - b.timestamp);

}

A adição das ordens é bem direta, no book correto, enquanto que a ordenação eu implementei aqui uma abordagem “ingênua”, que obviamente não possui uma boa performance pois ela reordena todo o book toda vez que chega uma nova ordem. Como uma melhoria futura, o book deveria ser uma lista encadeada (linked list), que mantém sequência e é muito melhor para inserir elementos em posições arbitrárias mantendo a ordenação correta.

No entanto, do jeito que está nosso order book ele serve apenas para registrar as ordens, certo? Quando que de fato elas deixam de ser apenas ordens e se tornam trades?

#3 -Match Maker ou Match Engine

Mas a função do order book não é apenas para registrar as ordens, mas para que um elemento crucial da arquitetura de qualquer exchange possa funcionar: o match maker ou match engine, como preferir. Isso porque toda vez que uma ordem chega no order book, ela pode disparar a execução de uma ordem que estava no book contrário. Ou seja, uma nova ordem de compra pode acabar executando uma venda que estava pendente e vice-versa. Tudo vai depender, é claro, do preço que a outra parte está pedindo.

A execução de um par de ordens resulta no que chamamos de Trade, como no exemplo abaixo, onde temos o id de ambas ordens, o preço acordado, a quantia executada e o timestamp em que o trade aconteceu. Importante ressaltar que a quantidade não precisa ser igual entre comprador e vendedor, pode haver execução parcial de ordens, com o restante sendo atualizado na ordem do book como veremos mais à frente.


export default class Trade {
    constructor(buyOrder, sellOrder, price, amount) {
        this.buyOrderId = buyOrder.id;
        this.sellOrderId = sellOrder.id;
        this.price = price;
        this.amount = amount;
        this.timestamp = Date.now();
    }
}

export default class Trade {

constructor(buyOrder, sellOrder, price, amount) {

this.buyOrderId = buyOrder.id;

this.sellOrderId = sellOrder.id;

this.price = price;

this.amount = amount;

this.timestamp = Date.now();

}

O match engine em si deve manter registro dos trades realizados (já que não estamos usando banco) e de algumas estatísticas de execução que são úteis aos investidores como volume total negociado, preço máximo e preço mínimo já executados, etc como abaixo. Também incluí uma função que retorna os últimos trades realizados.


import Trade from "./Trade.js";

export default class MatchEngine {
    constructor() {
        this.trades = [];
        this.totalVolume = 0;
        this.maxPrice = 0;
        this.minPrice = 0;
    }

    getLastTrades(size = 10) {
        return this.trades.slice(-size);
    }

import Trade from "./Trade.js";

export default class MatchEngine {

constructor() {

this.trades = [];

this.totalVolume = 0;

this.maxPrice = 0;

this.minPrice = 0;

}

getLastTrades(size = 10) {

return this.trades.slice(-size);

}

Agora o ponto alto do match engine é a função de match das ordens. É ela que vai procurar os possíveis casamentos do book de compra com o de venda, sempre olhando somente para as ordens ao topo dos books, onde sempre teremos quatro possibilidades:

a ordem de compra mais relevante não cobre o preço da ordem de venda mais relevante, nada acontece;
a ordem de compra possui preço igual ou superior à de venda e a quantidade é igual, o trade é realizado e ambas são removidas do book;
a ordem de compra possui preço aderente à de venda, mas a quantidade à venda é mais do que o comprador deseja. Neste caso, a ordem de compra é removida e a de venda é atualizada com a quantidade restante;
a ordem de compra possui preço aderente à de venda, mas a quantidade à venda é menos do que o comprador deseja. Neste caso, a ordem de venda é removida e a ordem de compra é atualizada com a quantidade restante e re-testada com a próxima ordem de venda mais relevante;

Os cenários de compras parciais que citei acima também podem acontecer ao inverso, com a ordem de venda chegando no match engine e não tendo gente suficiente querendo comprar tudo. Mas como traduzir isso em software? Vamos a um exemplo abaixo, na classe MatchEngine.


matchOrders(orderBook) {
    while (orderBook.buyOrders.length > 0 && orderBook.sellOrders.length > 0) {
        const buyOrder = orderBook.buyOrders[0];
        const sellOrder = orderBook.sellOrders[0];

        if (buyOrder.price >= sellOrder.price) {
            const tradeAmount = Math.min(buyOrder.amount, sellOrder.amount);

            buyOrder.amount -= tradeAmount;
            sellOrder.amount -= tradeAmount;

            if (buyOrder.amount === 0) {
                orderBook.buyOrders.shift();
            }
            if (sellOrder.amount === 0) {
                orderBook.sellOrders.shift();
            }

            this.trades.push(new Trade(buyOrder, sellOrder, sellOrder.price, tradeAmount));
            this.totalVolume += tradeAmount;

            if (this.maxPrice === 0 || sellOrder.price > this.maxPrice) {
                this.maxPrice = sellOrder.price;
            }
            if (this.minPrice === 0 || sellOrder.price < this.minPrice) {
                this.minPrice = sellOrder.price;
            }
        } else {
            break;
        }
    }
}

matchOrders(orderBook) {

while (orderBook.buyOrders.length > 0 && orderBook.sellOrders.length > 0) {

const buyOrder = orderBook.buyOrders[0];

const sellOrder = orderBook.sellOrders[0];

if (buyOrder.price >= sellOrder.price) {

const tradeAmount = Math.min(buyOrder.amount, sellOrder.amount);

buyOrder.amount -= tradeAmount;

sellOrder.amount -= tradeAmount;

if (buyOrder.amount === 0) {

orderBook.buyOrders.shift();

}

if (sellOrder.amount === 0) {

orderBook.sellOrders.shift();

}

this.trades.push(new Trade(buyOrder, sellOrder, sellOrder.price, tradeAmount));

this.totalVolume += tradeAmount;

if (this.maxPrice === 0 || sellOrder.price > this.maxPrice) {

this.maxPrice = sellOrder.price;

}

if (this.minPrice === 0 || sellOrder.price < this.minPrice) {

this.minPrice = sellOrder.price;

}

} else {

break;

}

Aqui temos a implementação das regras descritas anteriormente, com o adendo de registro do trade no array histórico e os cálculos das estatísticas de mercado, úteis aos investidores.

Agora como usamos essa função? Para isso, temos de voltar ao Order Book. Vamos receber uma instância de matchEngine no construtor, para usarmos inversão de controle e com isso diminuir o acoplamento entre os dois.


constructor(matchEngine) {
    this.buyOrders = [];
    this.sellOrders = [];

    if (!matchEngine || !matchEngine.matchOrders) {
        throw new Error("MatchEngine instance with matchOrders method is required.");
    }

    this.matchEngine = matchEngine;
}

constructor(matchEngine) {

this.buyOrders = [];

this.sellOrders = [];

if (!matchEngine || !matchEngine.matchOrders) {

throw new Error("MatchEngine instance with matchOrders method is required.");

}

this.matchEngine = matchEngine;

}

Agora vamos criar uma função getStats que traz os dados de mercado do order book e do match engine, juntos.


getStats() {
    return {
        numOfBuyOrders: this.buyOrders.length,
        numOfSellOrders: this.sellOrders.length,
        numOfTrades: this.matchEngine.trades.length,
        totalVolume: this.matchEngine.totalVolume,
        maxPrice: this.matchEngine.maxPrice,
        minPrice: this.matchEngine.minPrice
    }
}

getStats() {

return {

numOfBuyOrders: this.buyOrders.length,

numOfSellOrders: this.sellOrders.length,

numOfTrades: this.matchEngine.trades.length,

totalVolume: this.matchEngine.totalVolume,

maxPrice: this.matchEngine.maxPrice,

minPrice: this.matchEngine.minPrice

}

E por fim, no addOrder, vamos verificar quando o matchEngine precisa ser acionado, e então chamá-lo após a adição da ordem e rebalanceamento do book.


addOrder(order) {
    let shouldTest = false;
    if (order.side === Side.BUY) {
        this.buyOrders.push(order);
        this.buyOrders.sort((a, b) => b.price - a.price || a.timestamp - b.timestamp);

        shouldTest = this.buyOrders.length > 0 && this.buyOrders[0].id === order.id;
    } else {
        this.sellOrders.push(order);
        this.sellOrders.sort((a, b) => a.price - b.price || a.timestamp - b.timestamp);

        shouldTest = this.sellOrders.length > 0 && this.sellOrders[0].id === order.id;
    }

    if (shouldTest)
        this.matchEngine.matchOrders(this);
}

addOrder(order) {

let shouldTest = false;

if (order.side === Side.BUY) {

this.buyOrders.push(order);

this.buyOrders.sort((a, b) => b.price - a.price || a.timestamp - b.timestamp);

shouldTest = this.buyOrders.length > 0 && this.buyOrders[0].id === order.id;

} else {

this.sellOrders.push(order);

this.sellOrders.sort((a, b) => a.price - b.price || a.timestamp - b.timestamp);

shouldTest = this.sellOrders.length > 0 && this.sellOrders[0].id === order.id;

}

if (shouldTest)

this.matchEngine.matchOrders(this);

}

Repare a passagem do this para o matchOrders, para que ele consiga ter acesso aos books e fazer as verificações.

Com isso, agora temos todos os elementos para simular minimamente como uma exchange funciona. Claro, aqui não temos carteiras com fundos e nem diferentes ativos ou tipos de ordens, mas o núcleo está aqui.

#4 – Simulando a Exchange

Para vermos se está realmente funcionando, que tal criarmos uma aplicação console? Coloque as suas classes todas em uma pasta lib e crie um arquivo index.js na raiz da aplicação, com os imports abaixo.


import MatchEngine from "./lib/MatchEngine.js";
import OrderBook from "./lib/OrderBook.js";
import Order, { Side } from "./lib/Order.js";

import MatchEngine from "./lib/MatchEngine.js";

import OrderBook from "./lib/OrderBook.js";

import Order, { Side } from "./lib/Order.js";

Como vamos executar no terminal, eu vou criar algumas funções auxiliares para imprimir os dados minimamente formatados. Abaixo, uma função de impressão de order book e suas estatísticas.


async function printOrderBook(orderBook) {
    const buyOrders = Object.values(orderBook.buyOrders.slice(0, 10));
    const sellOrders = Object.values(orderBook.sellOrders.slice(0, 10));
    const maxRows = Math.max(buyOrders.length, sellOrders.length);
    const colWidth = 36;

    const formatOrder = (order) =>
        order ? `| ID: ${order.id}, Amt: ${order.amount.toFixed(4)}, $${order.price.toFixed(2)}`.padEnd(colWidth) : "";

    console.log("-".repeat(colWidth * 2));
    console.log(`| Buy Orders (${orderBook.buyOrders.length})`.padEnd(colWidth - 1) + ` | Sell Orders (${orderBook.sellOrders.length})`.padEnd(colWidth + 1) + "|");
    console.log("-".repeat(colWidth * 2));
    for (let i = 0; i < maxRows; i++) {
        const left = formatOrder(buyOrders[i]).padEnd(colWidth);
        const right = formatOrder(sellOrders[i]).padEnd(colWidth) + "|";
        console.log(left + right);
    }
    console.log("-".repeat(colWidth * 2));
}

async function printOrderBook(orderBook) {

const buyOrders = Object.values(orderBook.buyOrders.slice(0, 10));

const sellOrders = Object.values(orderBook.sellOrders.slice(0, 10));

const maxRows = Math.max(buyOrders.length, sellOrders.length);

const colWidth = 36;

const formatOrder = (order) =>

order ? `| ID: ${order.id}, Amt: ${order.amount.toFixed(4)}, $${order.price.toFixed(2)}`.padEnd(colWidth) : "";

console.log("-".repeat(colWidth * 2));

console.log(`| Buy Orders (${orderBook.buyOrders.length})`.padEnd(colWidth - 1) + ` | Sell Orders (${orderBook.sellOrders.length})`.padEnd(colWidth + 1) + "|");

console.log("-".repeat(colWidth * 2));

for (let i = 0; i < maxRows; i++) {

const left = formatOrder(buyOrders[i]).padEnd(colWidth);

const right = formatOrder(sellOrders[i]).padEnd(colWidth) + "|";

console.log(left + right);

}

console.log("-".repeat(colWidth * 2));

}

Agora uma função que imprime os últimos trades realizados.


async function printLastTrades(trades) {
    console.log("-".repeat(72));
    console.log("| Last Trades".padEnd(71) + "|");
    console.log("-".repeat(72));
    trades.forEach(trade => {
        const line = `| ${trade.amount.toFixed(4)} @ $${trade.price.toFixed(2)} (Buy ID: ${trade.buyOrderId}, Sell ID: ${trade.sellOrderId})`;
        console.log(line.padEnd(71) + "|");
    });
    console.log("-".repeat(72));
}

async function printLastTrades(trades) {

console.log("-".repeat(72));

console.log("| Last Trades".padEnd(71) + "|");

console.log("-".repeat(72));

trades.forEach(trade => {

const line = `| ${trade.amount.toFixed(4)} @ $${trade.price.toFixed(2)} (Buy ID: ${trade.buyOrderId}, Sell ID: ${trade.sellOrderId})`;

console.log(line.padEnd(71) + "|");

});

console.log("-".repeat(72));

}

Com as funções de formatação prontas, precisamos de algumas funções para gerar ordens aleatórias, simulando o funcionamento de uma exchange real. Abaixo eu propus funções para gerar preço aleatório, quantidade aleatórias e a ordem inteira.


function getRandomPrice(base, variance) {
    return (base + (Math.random() - 0.5) * variance).toFixed(2);
}

function getRandomAmount(min, max) {
    return (Math.random() * (max - min) + min).toFixed(4);
}

function getRandomSide() {
    return Math.random() < 0.5 ? Side.BUY : Side.SELL;
}

function getRandomOrder() {
    const basePrice = 50000;
    const variance = 5000;
    const price = getRandomPrice(basePrice, variance);
    const amount = getRandomAmount(0.01, 1);
    const side = getRandomSide();
    return new Order(side, amount, price);
}

function getRandomPrice(base, variance) {

return (base + (Math.random() - 0.5) * variance).toFixed(2);

}

function getRandomAmount(min, max) {

return (Math.random() * (max - min) + min).toFixed(4);

}

function getRandomSide() {

return Math.random() < 0.5 ? Side.BUY : Side.SELL;

}

function getRandomOrder() {

const basePrice = 50000;

const variance = 5000;

const price = getRandomPrice(basePrice, variance);

const amount = getRandomAmount(0.01, 1);

const side = getRandomSide();

return new Order(side, amount, price);

}

Agora vou criar uma função sleep, para ocasionar um atraso proposital no sistema. Sem esse recurso não, conseguiríamos ver as atualizações no terminal de tão rápido que ficaria. Também inicializo logo em seguida o order book e o match engine, que usaremos na simulação.


async function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

const matchEngine = new MatchEngine();
const orderBook = new OrderBook(matchEngine);

async function sleep(ms) {

return new Promise(resolve => setTimeout(resolve, ms));

}

const matchEngine = new MatchEngine();

const orderBook = new OrderBook(matchEngine);

Por fim, vamos fazer um laço de repetição para a geração e submissão das ordens aos order book, chamando as funções de impressão para o usuário ter algo para analisar na tela enquanto tudo é processado.


for (let i = 0; i < 50000; i++) {
    const order = getRandomOrder();
    orderBook.addOrder(order);

    console.clear();
    await printOrderBook(orderBook);
    await printLastTrades(matchEngine.getLastTrades());

    console.log(`Ticker Price: ${orderBook.getTickerPrice().toFixed(2)}`);
    const stats = orderBook.getStats();
    console.log(`Trades: ${stats.numOfTrades}, Volume: ${stats.totalVolume.toFixed(4)}, Max Price: $${stats.maxPrice.toFixed(2)}, Min Price: $${stats.minPrice.toFixed(2)}`);
    await sleep(50);
}

for (let i = 0; i < 50000; i++) {

const order = getRandomOrder();

orderBook.addOrder(order);

console.clear();

await printOrderBook(orderBook);

await printLastTrades(matchEngine.getLastTrades());

console.log(`Ticker Price: ${orderBook.getTickerPrice().toFixed(2)}`);

const stats = orderBook.getStats();

console.log(`Trades: ${stats.numOfTrades}, Volume: ${stats.totalVolume.toFixed(4)}, Max Price: $${stats.maxPrice.toFixed(2)}, Min Price: $${stats.minPrice.toFixed(2)}`);

await sleep(50);

}

Execute o programa e você terá após alguns segundos algo como abaixo.

Claro, muita coisa pode ser melhorada e esta abordagem tem alguns problemas crônicos de escala, mas espero que tenha sido uma boa introdução ao assunto e espero que em outra oportunidade eu possa me aprofundar mais neste tema.

Até a próxima!

TAGS:

Como criar um bot para copy trade na Binance Spot com Node.js

Bot Cripto

Olá, tudo bem?

O que você achou deste conteúdo? Conte nos comentários.

Como integrar ReactJS com programa Solana

Introdução à Context API (ReactJS)

Como criar um protocolo DeFi em Solana

Introdução ao Git e GitHub

Bot Cripto

Como funcionam as corretoras de criptomoedas (tecnicamente)?

Junte-se a mais de 34 mil devs

Entre para minha lista e receba conteúdos exclusivos e com prioridade

#1 – Ordens

#2 – Livro de Ordens

#3 -Match Maker ou Match Engine

#4 – Simulando a Exchange

Olá, tudo bem?

Entre para minha lista e receba conteúdos exclusivos e com prioridade

Categorias

Últimas Novidades

Tags