Introdução à arbitragem de lead-lag em criptomoedas (2)

Introdução ao Brick Moving Arbitragem

No primeiro artigo, introduzimos brevemente como usar o fenômeno Lead-Lag para arbitragem. Neste artigo, introduziremos principalmente a arbitragem cross-exchange brick-moving. O princípio básico é aproveitar o atraso de preços entre diferentes exchanges (efeito Lead-Lag). Como a liquidez de mercado, a velocidade de transação e o atraso da rede de cada exchange são diferentes, os preços da mesma moeda em diferentes exchanges geralmente estão fora de sincronia.

Como utilizar o efeito lead-lag para arbitragem?

1. Monitorizar as diferenças de preços

Em primeiro lugar, os árbitros precisam monitorar as diferenças de preço entre diferentes bolsas em tempo real, especialmente o preço de compra e o preço de compra. Ao rastrear o preço de compra da troca A e o preço de compra da troca B, se o preço de compra da troca A for menor do que o preço de compra da troca B, pode-se considerar que há uma oportunidade de arbitragem. Por exemplo, o preço de compra da troca A é de 10.000 USDT, e o preço de compra da troca B é de 10.100 USDT, a diferença de preço é de 100 USDT, então há uma oportunidade de arbitragem potencial. É claro que a faixa de diferença de preço histórica recente também deve ser levada em conta como referência para a diferença de preço de abertura e fechamento, e o tempo de espera também é um dos custos.

2. Execução de intercâmbio cruzado

Uma vez que uma oportunidade de arbitragem é encontrada, o árbitro deve comprar o ativo em uma bolsa com um preço de compra mais baixo (como Exchange A) e vendê-lo em uma bolsa com um preço de lance mais alto (como Exchange B). Esta operação pode ser automatizada através da API para garantir uma execução rápida e maximizar a diferença de preço. No entanto, ao executar um comércio, os custos de transação (como taxas e deslizamento) bem como os choques de preço devem ser considerados. Suponha que a taxa da Exchange A é de 0,1%, enquanto a taxa da Exchange B é de 0,2%, e há deslizamento no mercado. Por exemplo, ao comprar 1 Bitcoin na Exchange A, o preço da transação real pode aumentar devido à execução de ordens de grande deslizamento, assumindo que o deslizamento seja de 0,1%.

Se forem tidos em conta os deslizamentos e as taxas, o custo de compra e o rendimento de venda reais serão diferentes das expectativas.

3. Feche a posição

O último passo da arbitragem é fechar a posição. Por exemplo, após um período de tempo, o preço de compra da troca A é de 10.100 USDT, e o preço de venda da troca B é de 10.150 USDT. Quando a diferença de preço se estreita de 100 USDT para 50 USDT, o programa fechará a posição automaticamente e tirará lucros.

Problemas e soluções na prática

1. Nenhuma oportunidade de abrir uma posição

Devido à existência de um grande número de árbitros e criadores de mercado, as diferenças de preço entre as diferentes bolsas não serão muito grandes, caso contrário, elas serão niveladas rapidamente.

Soluções: - Espera que as diferenças de preços se formem naturalmente:O mercado de criptomoedas é altamente volátil e geralmente ocorrem diferenças de preço de curto prazo.- Use a estratégia do criador:comprar e vender ordens em um livro de ordens de troca ativamente, e cancelar ordens e ajustá-las à medida que os preços mudam. Se uma parte concluir a transação, a outra parte receberá a ordem. Isso resultará em taxas de transação mais baixas, um spread menor e garantirá uma transação imediata.- Monitorar mais pares de negociação:Não se concentre apenas nas moedas tradicionais, pois suas oportunidades de arbitragem geralmente foram capturadas por um grande número de arbitrageiros, fazendo com que as diferenças de preço diminuam.- Escolha trocas pequenas:As pequenas bolsas geralmente têm baixa liquidez e ajustes de preços lentos, o que facilita a ocorrência de grandes diferenças de preço.- Escolha trocas de limiar alto:Algumas casas de câmbio exigem certificação KYC rigorosa, como a casa de câmbio coreana Upbit. Estes lugares são difíceis de entrar para os comerciantes comuns, e há mais oportunidades de arbitragem.

2. A diferença entre o diferencial de transacção e o diferencial de monitorização é demasiado grande

Quando o programa encontra a diferença de preço e coloca uma ordem para arbitragem, a diferença de preço real não é tão grande, e geralmente há uma perda.

Soluções: - Otimize a rede e a localização do servidor:Escolha um nó próximo ao servidor de troca para reduzir a latência. Por exemplo, escolher uma pequena troca com baixa liquidez para operar pode reduzir a velocidade de reação do mercado e aproveitar a oportunidade.- Processamento assíncrono e WebSocket:Usando código assíncrono e WebSocket para se conectar às condições do mercado pode receber informações de preços em tempo real e responder rapidamente para evitar oportunidades perdidas devido a atrasos de informação.

3. Transacção unidireccional

Uma transação de direção única é quando um lado da ordem é concluído, mas o outro lado não consegue concluir a transação, o que geralmente ocorre em um mercado em rápida flutuação.

Soluções: - Configurar um mecanismo razoável de stop-loss:Quando ocorre uma transacção unidirecional, pode definir um stop loss.- Use o preço de mercado para fazer uma encomenda:O preço de mercado pode garantir a transacção, mas o problema é que a diferença no preço de transacção é incontrolável e pode resultar em uma perda.

4. Posição total numa única troca

Quando a diferença de preço existe por um longo tempo, os fundos de uma determinada bolsa serão comprados rapidamente, e os arbitragens podem não ser capazes de continuar as operações de arbitragem.

Soluções: - Operação de transferência de moeda:Utilize a transferência de moeda de câmbio cruzado para transferir fundos e continuar a arbitragem.- À espera que a diferença de preço se volte:Considerando o custo de tempo da retirada, esperar que a diferença de preço retorne também é uma opção.

Código Demo

O código não é um código de negociação ao vivo e é apenas para fins de demonstração.

// Symbol is the arbitrage trading pair, such as BTC/USDT
let symbol = "BTC_USDT";

// Set commissions, slippage, profit margins for opening and closing positions
let fee = 0.1 / 100;      // 0.1% Fee
let slippage = 0.1 / 100; // 0.1% slippage
let entryThreshold = 0.005; // Opening threshold: Opening a position when the price difference is greater than 0.5%
let exitThreshold = 0.001;  // Closing threshold: Closing when the price difference returns to 0.1%

// The specific operations performed in each loop
function OnTick() {
    // Get ticker data from various exchanges
    let tickers = exchanges.map(exchange => exchange.GetTicker(symbol));

    // Calculate arbitrage opportunities (based on profit margins)
    // profitAB: Buy from exchange 0, sell from exchange 1
    const profitAB = (tickers[1].bid - tickers[0].ask) / tickers[0].ask - fee * 2 - slippage * 2;
    // profitBA: Buy from exchange 1, sell from exchange 0
    const profitBA = (tickers[0].bid - tickers[1].ask) / tickers[1].ask - fee * 2 - slippage * 2;

    // Print log
    Log(`Tickers: Exchange0 Buy: ${tickers[0].ask}, Exchange1 Sell: ${tickers[1].bid}, Profit AB: ${profitAB} USDT`);
    Log(`Tickers: Exchange1 Buy: ${tickers[1].ask}, Exchange0 Sell: ${tickers[0].bid}, Profit BA: ${profitBA} USDT`);

    // Determine whether to perform arbitrage operations based on profits
    if (profitAB > entryThreshold) {  // Open a position when the profit is greater than the opening threshold
        Log(`Arbitrage opportunity: Buy BTC from exchange 0, sell from exchange 1, profit: ${profitAB} USDT`);
        executeArbitrage(0, 1, tickers[0].ask, tickers[1].bid, profitAB);  // Buy from exchange 0 and sell from exchange 1
    } else if (profitBA > entryThreshold) {
        Log(`Arbitrage opportunity: Buy BTC from exchange 1, sell from exchange 0, profit: ${profitBA} USDT`);
        executeArbitrage(1, 0, tickers[1].ask, tickers[0].bid, profitBA);  // Buy from exchange 1 and sell from exchange 0
    } else if (profitAB < exitThreshold) {  // If the spread reverts, close the position
        Log(`Close position: Arbitrage opportunity bought from exchange 0 and sold on exchange 1, profit has returned to the close threshold`);
        closeArbitrage(0, 1, tickers[0].ask, tickers[1].bid); // Execute the closing operation
    } else if (profitBA < exitThreshold) { 
        Log(`Close position: Arbitrage opportunity bought from exchange 1 and sold on exchange 0, profit has returned to the closing threshold`);
        closeArbitrage(1, 0, tickers[1].ask, tickers[0].bid); // Execute the closing operation
    } else {
        Log("Not enough profit to take profit or close the position");
    }
}

// Executing arbitrage trades
function executeArbitrage(buyExchangeIndex, sellExchangeIndex, buyPrice, sellPrice) {
    let buyExchange = exchanges[buyExchangeIndex];
    let sellExchange = exchanges[sellExchangeIndex];

    // Get account balance (assuming BTC balance)
    let accountBuy = buyExchange.GetAccount();
    let accountSell = sellExchange.GetAccount();
    
    let amountBTC = Math.min(accountBuy.Balance / buyPrice, accountSell.Amount);

    // Assume that the transaction volume is 0.1 BTC per transaction
    let amount = Math.min(amountBTC, 0.1);

    // Ensure sufficient trading volume
    if (amount <= 0) {
        Log("Insufficient balance to conduct arbitrage");
        return;
    }

    // Place a buy order on the buying exchange
    Log(`Place an order to buy ${amount} BTC @ ${buyPrice} on exchange ${buyExchangeIndex}`);
    buyExchange.Buy(symbol, buyPrice * (1 + slippage), amount);

    // Place a sell order on the selling exchange
    Log(`Place an order to sell ${amount} BTC @ ${sellPrice} on exchange ${sellExchangeIndex}`);
    sellExchange.Sell(symbol, sellPrice * (1 - slippage), amount);
}

// Closing position operation
function closeArbitrage(buyExchangeIndex, sellExchangeIndex, buyPrice, sellPrice) {
    let buyExchange = exchanges[buyExchangeIndex];
    let sellExchange = exchanges[sellExchangeIndex];

    // Get account balance (assuming BTC balance)
    let accountBuy = buyExchange.GetAccount();
    let accountSell = sellExchange.GetAccount();

    let amountBTC = Math.min(accountBuy.Balance / buyPrice, accountSell.Amount);
    let amount = Math.min(amountBTC, 0.1);

    // Place a sell order on the buying exchange
    Log(`Close and sell ${amount} BTC @ ${buyPrice} on exchange ${buyExchangeIndex}`);
    buyExchange.Sell(symbol, buyPrice * (1 - slippage), amount);

    // Place a buy order on the selling exchange
    Log(`Close buy ${amount} BTC @ ${sellPrice} on exchange ${sellExchangeIndex}`);
    sellExchange.Buy(symbol, sellPrice * (1 + slippage), amount);
}

// Main loop
function main() {
    while (true) {
        OnTick();
        Sleep(1000); // Execute once every second
    }
}

Resumo

A arbitragem de mudança de tijolos é uma estratégia de arbitragem cruzada baseada na reação de atraso do mercado. Ao analisar as diferenças de preço no mercado com precisão e executar transações rapidamente, os arbitragens podem obter lucros estáveis no mercado de criptomoedas. No entanto, o sucesso da estratégia depende não apenas do design da própria estratégia, mas também de uma boa execução e compreensão sensível do tempo do mercado. À medida que a concorrência no mercado se intensifica, os arbitragens precisam otimizar estratégias e técnicas continuamente, melhorar a velocidade e a capacidade de resposta, a fim de manter a eficácia contínua das oportunidades de arbitragem.