Introdução à arbitragem “Brick Moving”

No primeiro artigo, apresentamos brevemente como fazer arbitragem usando o fenômeno Lead-Lag. Este artigo apresentará principalmente a arbitragem “brick moving” entre bolsas. O princípio básico é usar o fenômeno de defasagem de preço (efeito Lead-Lag) entre diferentes exchanges. Como a liquidez do mercado, a velocidade da transação e o atraso da rede de cada exchange são diferentes, o preço da mesma moeda em diferentes exchanges costuma ser diferente. síncrono . Os arbitradores podem monitorar essas mudanças de preço tardias e conduzir rapidamente a arbitragem para obter lucros sem risco.

Como usar o efeito Lead-Lag para arbitragem?

1. Monitorar diferenças de preços

Primeiro, os arbitradores precisam monitorar as diferenças de preço entre diferentes bolsas em tempo real, especialmente o preço de venda e o preço de compra. Ao monitorar o preço de venda da bolsa A e o preço de compra da bolsa B, se o preço de venda da bolsa A for menor que o preço de compra da bolsa B, pode-se considerar que há uma oportunidade de arbitragem. Por exemplo, o preço de venda da bolsa A é 10.000 USDT, e o preço de compra da bolsa B é 10.100 USDT. A diferença de preço é 100 USDT, o que é uma oportunidade potencial de arbitragem. Claro, também precisamos considerar a recente variação histórica de preços como referência para as diferenças de preços de abertura e fechamento, e o tempo de espera também é um dos custos.

2. Execução de troca cruzada

Uma vez encontrada uma oportunidade de arbitragem, o arbitrador deve comprar o ativo em uma bolsa com um preço de venda mais baixo (como a Bolsa A) e vendê-lo em uma bolsa com um preço de compra mais alto (como a Bolsa B). Isso pode ser automatizado via API, garantindo execução rápida e maximizando o uso de diferenças de preços. Entretanto, ao executar negociações, os custos de transação (como taxas e deslizamentos), bem como choques de preços, devem ser considerados. Suponha que a taxa de transação da bolsa A seja de 0,1%, enquanto a taxa de transação da bolsa B seja de 0,2%, e que haja deslizamento no mercado. Por exemplo, ao comprar 1 Bitcoin na Bolsa A, o preço real da transação pode aumentar devido à execução de grandes ordens, supondo que o deslizamento seja de 0,1%. Então, o preço real da transação será 0,1% maior que o esperado, resultando em um aumento no custo de compra.

Se a derrapagem e as taxas forem levadas em consideração, o custo real de compra e a receita de venda serão diferentes das expectativas.

3. Fechar uma posição

O passo final na arbitragem é fechar a posição. Por exemplo, após um período de tempo, se o preço de compra da bolsa A for 10.100 USDT e o preço de venda da bolsa B for 10.150 USDT, e a diferença de preço diminuir de 100 USDT para 50 USDT, o programa fechará automaticamente a posição e realizar lucro. É claro que, em alguns casos, o spread pode continuar aumentando, e você pode continuar abrindo posições até que seus fundos se esgotem. Os arbitradores contribuem com a grande maioria dos motivos pelos quais a diferença de preço na bolsa não pode ser mantida.

Problemas e soluções na prática

1. Nenhuma oportunidade de abrir uma posição

Devido à existência de um grande número de arbitradores e formadores de mercado, as diferenças de preço entre diferentes bolsas não serão muito diferentes, caso contrário, elas serão niveladas rapidamente. Este é o maior problema enfrentado pelo carry trading.

Solução:

• Aguarde a formação natural da divergência de preços：O mercado de moeda digital é altamente volátil, e geralmente há diferenças de preço de curto prazo. Paciência é a melhor maneira de resolver esse problema.
• Usando a estratégia do criador: Coloque ativamente ordens de compra e venda em um livro de ordens de câmbio e cancele e ajuste ordens continuamente conforme os preços mudam. Se uma parte concluir a transação, a outra parte assumirá a ordem. Dessa forma, a taxa de transação é menor, um spread menor pode ser aceito e a transação pode ter a garantia de ser concluída na primeira vez.
• Monitore mais pares de negociação：Você não pode focar apenas em moedas tradicionais. Suas oportunidades de arbitragem geralmente foram capturadas por um grande número de arbitradores, fazendo com que as diferenças de preço se estreitassem. Moedas impopulares e recém-listadas podem ter grandes diferenças de preço devido à baixa liquidez e menor concorrência, e são oportunidades de arbitragem que merecem atenção.
• Escolha uma pequena troca：As pequenas bolsas geralmente têm baixa liquidez e ajustes de preços mais lentos, o que as torna mais propensas a diferenças de preços maiores. Neste momento, os arbitradores podem escolher colocar ordens e executá-las primeiro para obter lucros.
• Escolha uma troca de alto limite：Algumas bolsas exigem certificação KYC rigorosa, como a bolsa coreana Upbit. Há mais oportunidades de arbitragem nesses lugares que são difíceis para traders comuns entrarem. Claro, você precisa encontrar maneiras de superar as dificuldades sozinho.

2. A diferença entre o spread da transação e o spread de monitoramento é muito grande

A falha em pegar ordens é um problema comum. Quando o programa encontra a diferença de preço e coloca uma ordem de arbitragem, a diferença real do preço da transação não é tão grande e frequentemente resulta em perda. Neste momento, a maior rapidez de resposta e velocidade de execução são cruciais.

Solução:

• Otimizar a localização da rede e do servidor: Escolha um nó próximo ao servidor de troca para reduzir a latência. Por exemplo, escolher uma bolsa pequena com baixa liquidez para operar pode reduzir a velocidade de reação do mercado e, assim, tomar a iniciativa.
• Processamento Assíncrono e WebSocket：Usando código assíncrono e WebSocket para se conectar às condições de mercado, você pode receber informações de preços em tempo real e responder rapidamente para evitar perder oportunidades devido a atrasos de informações.

3. Acordo de perna única

Uma transação de perna única refere-se a uma transação na qual uma parte conclui a transação enquanto a outra parte não consegue concluí-la, o que geralmente ocorre quando o mercado flutua rapidamente. Se apenas um lado da ordem for bem-sucedido, o arbitrador enfrentará risco de exposição.

Solução:

• Crie um mecanismo de stop loss razoável: Quando uma transação de perna única ocorre, você pode definir um stop loss. O fechamento oportuno de posições é uma maneira eficaz de reduzir riscos.
• Usar ordem de mercado：O preço de mercado pode garantir a transação, mas o problema é que a diferença no preço da transação é incontrolável e pode resultar em perdas.

4. Armazém completo em uma única bolsa

Quando a diferença de preço existe por muito tempo, os fundos de uma determinada bolsa serão rapidamente comprados, e os arbitradores podem não conseguir continuar suas operações de arbitragem. Neste momento, os arbitradores precisam transferir fundos rapidamente ou ajustar suas posições.

Solução:

• Operação de transferência de moedas: Use transferências de moeda entre moedas para transferir fundos e continuar a arbitragem. Dessa forma, é possível evitar que os recursos fiquem acumulados em um único mercado e aumentar a liquidez dos fundos.
• Esperando a propagação mudar: Considerando o tempo gasto na retirada, esperar a diferença de preço retornar também é uma opção.

Código de demonstração

O código não é um código real e é apenas para fins de demonstração. Ele não leva em conta questões como o número de mercados, falhas de acesso à API, aceleração de ordens assíncronas, etc.

// symbol 是套利的交易对，比如 BTC/USDT
let symbol = "BTC_USDT";
exchanges[0].SetCurrency(symbol);
exchanges[0].SetPrecision(2, 4); //设置精度
exchanges[1].SetCurrency(symbol);
exchanges[1].SetPrecision(2, 4);

// 设置手续费、滑点、开仓和平仓的利润率
let fee = 0.1 / 100;      // 0.1% 手续费
let slippage = 0.1 / 100; // 0.1% 滑点
let entryThreshold = 0.005; // 开仓阈值：价差大于0.5%时开仓
let exitThreshold = 0.001;  // 平仓阈值：价差回归到0.1%时平仓

// 每次循环执行的具体操作
function OnTick() {
    // 获取各个交易所的行情数据
    let tickers = exchanges.map(exchange => exchange.GetTicker(symbol));
    //容错处理
    if(!tickers[1] || !tickers[0]){
        return;
    }
    // 计算套利机会（基于利润率）
    // profitAB: 从交易所0买入，从交易所1卖出
    const profitAB = (tickers[1].Buy - tickers[0].Sell) / tickers[0].Sell - fee * 2 - slippage * 2;
    // profitBA: 从交易所1买入，从交易所0卖出
    const profitBA = (tickers[0].Buy - tickers[1].Sell) / tickers[1].Sell - fee * 2 - slippage * 2;

    // 打印日志
    Log(`Tickers: Exchange0 Buy: ${tickers[0].Sell}, Exchange1 Sell: ${tickers[1].Buy}, Profit AB: ${profitAB} USDT`);
    Log(`Tickers: Exchange1 Buy: ${tickers[1].Sell}, Exchange0 Sell: ${tickers[0].Buy}, Profit BA: ${profitBA} USDT`);

    // 根据利润判断是否执行套利操作
    if (profitAB > entryThreshold) {  // 当利润大于开仓阈值时开仓
        Log(`套利机会：从交易所0买入BTC，从交易所1卖出，利润：${profitAB} USDT`);
        executeArbitrage(0, 1, tickers[0].Sell, tickers[1].Buy, profitAB);  // 从交易所0买入并在交易所1卖出
    } else if (profitBA > entryThreshold) {
        Log(`套利机会：从交易所1买入BTC，从交易所0卖出，利润：${profitBA} USDT`);
        executeArbitrage(1, 0, tickers[1].Sell, tickers[0].Buy, profitBA);  // 从交易所1买入并在交易所0卖出
    } else if (profitAB < exitThreshold) {  // 如果价差回归，平仓
        Log(`平仓：从交易所0买入并在交易所1卖出的套利机会，利润已回归至平仓阈值`);
        closeArbitrage(0, 1, tickers[0].Sell, tickers[1].Buy); // 执行平仓操作
    } else if (profitBA < exitThreshold) { 
        Log(`平仓：从交易所1买入并在交易所0卖出的套利机会，利润已回归至平仓阈值`);
        closeArbitrage(1, 0, tickers[1].Sell, tickers[0].Buy); // 执行平仓操作
    } else {
        Log("没有足够的利润进行套利或平仓");
    }
}

// 执行套利交易
function executeArbitrage(buyExchangeIndex, sellExchangeIndex, buyPrice, sellPrice) {
    let buyExchange = exchanges[buyExchangeIndex];
    let sellExchange = exchanges[sellExchangeIndex];

    // 获取账户余额（假设为BTC余额）
    let accountBuy = buyExchange.GetAccount();
    let accountSell = sellExchange.GetAccount();

    //容错处理
    if(!accountBuy || !accountSell){
        return;
    }
    let amountBTC = Math.min(accountBuy.Balance / buyPrice, accountSell.Amount);

    // 假设每次交易量为 0.1 BTC
    let amount = Math.min(amountBTC, 0.1);

    // 确保交易量充足
    if (amount <= 0) {
        Log("余额不足，无法进行套利");
        return;
    }

    // 在买入交易所下单买入
    Log(`在交易所${buyExchangeIndex} 下单买入 ${amount} BTC @ ${buyPrice}`);
    buyExchange.Buy(buyPrice * (1 + slippage), amount);

    // 在卖出交易所下单卖出
    Log(`在交易所${sellExchangeIndex} 下单卖出 ${amount} BTC @ ${sellPrice}`);
    sellExchange.Sell(sellPrice * (1 - slippage), amount);
}

// 平仓操作
function closeArbitrage(buyExchangeIndex, sellExchangeIndex, buyPrice, sellPrice) {
    let buyExchange = exchanges[buyExchangeIndex];
    let sellExchange = exchanges[sellExchangeIndex];

    // 获取账户余额（假设为BTC余额）
    let accountBuy = buyExchange.GetAccount();
    let accountSell = sellExchange.GetAccount();

    //容错处理
    if(!accountBuy || !accountSell){
        return;
    }

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

    // 在买入交易所吃单卖出
    Log(`在交易所${buyExchangeIndex} 平仓卖出 ${amount} BTC @ ${buyPrice}`);
    buyExchange.Sell(buyPrice * (1 - slippage), amount);

    // 在卖出交易所吃单买入
    Log(`在交易所${sellExchangeIndex} 平仓买入 ${amount} BTC @ ${sellPrice}`);
    sellExchange.Buy(sellPrice * (1 + slippage), amount);
}

// 主循环
function main() {
    while (true) {
        OnTick();
        Sleep(1000); // 每秒钟执行一次
    }
}

Resumir

Arbitragem Lead-Lag é uma estratégia de arbitragem entre bolsas baseada na reação ao atraso do mercado. Ao analisar com precisão as diferenças de preços no mercado e executar negociações rapidamente, os arbitradores conseguem obter lucros estáveis ​​no mercado de criptomoedas. No entanto, o sucesso dessa estratégia não depende apenas do design da estratégia em si, mas também requer uma boa execução e uma compreensão sensível do momento do mercado. À medida que a competição de mercado se intensifica, os arbitradores precisam otimizar continuamente suas estratégias e técnicas e melhorar sua velocidade e capacidade de resposta para manter a eficácia contínua das oportunidades de arbitragem.