Introduction à l’arbitrage « Brick Moving »

Dans le premier article, nous avons brièvement présenté comment arbitrer en utilisant le phénomène Lead-Lag. Cet article présentera principalement l’arbitrage cross-exchange “brick moving”. Le principe de base consiste à utiliser le phénomène de décalage de prix (effet Lead-Lag) entre les différentes bourses. Étant donné que la liquidité du marché, la vitesse des transactions et le délai du réseau de chaque bourse sont différents, le prix de la même devise dans différentes bourses est souvent différent. . Les arbitragistes peuvent surveiller ces changements de prix en retard et procéder rapidement à un arbitrage pour obtenir des bénéfices sans risque.

Comment utiliser l’effet Lead-Lag pour l’arbitrage ?

1. Surveiller les différences de prix

Premièrement, les arbitragistes doivent surveiller les différences de prix entre les différentes bourses en temps réel, en particulier le prix demandé et le prix offert. En suivant le prix demandé de la bourse A et le prix acheteur de la bourse B, si le prix demandé de la bourse A est inférieur au prix acheteur de la bourse B, on peut considérer qu’il existe une opportunité d’arbitrage. Par exemple, le prix demandé de la bourse A est de 10 000 USDT et le prix offert de la bourse B est de 10 100 USDT. La différence de prix est de 100 USDT, ce qui constitue une opportunité d’arbitrage potentielle. Bien entendu, nous devons également prendre en compte la fourchette de différence de prix historique récente comme référence pour les différences de prix d’ouverture et de clôture, et le temps d’attente est également l’un des coûts.

2. Exécution de transactions croisées

Une fois qu’une opportunité d’arbitrage est trouvée, l’arbitragiste doit acheter l’actif sur une bourse avec un prix demandé inférieur (comme la bourse A) et le vendre sur une bourse avec un prix acheteur plus élevé (comme la bourse B). Cela peut être automatisé via API, garantissant une exécution rapide et maximisant l’utilisation des différences de prix. Toutefois, lors de l’exécution des transactions, les coûts de transaction (tels que les frais et les glissements) ainsi que les chocs de prix doivent être pris en compte. Supposons que les frais de transaction de l’échange A sont de 0,1 %, tandis que les frais de transaction de l’échange B sont de 0,2 %, et qu’il y a un dérapage sur le marché. Par exemple, lors de l’achat de 1 Bitcoin sur la bourse A, le prix réel de la transaction peut augmenter en raison de l’exécution d’ordres importants, en supposant que le glissement soit de 0,1 %. Le prix réel de la transaction sera alors de 0,1 % supérieur au prix prévu, ce qui entraînera une augmentation du coût d’achat.

Si l’on prend en compte les dérapages et les frais, le coût d’achat et le revenu de vente réels seront différents des attentes.

3. Fermer une position

La dernière étape de l’arbitrage consiste à fermer la position. Par exemple, après une période de temps, si le prix d’achat de la bourse A est de 10 100 USDT et le prix de vente de la bourse B est de 10 150 USDT, et que la différence de prix se réduit de 100 USDT à 50 USDT, le programme fermera automatiquement la position et réaliser un profit. Bien sûr, dans certains cas, le spread peut continuer à s’élargir et vous pouvez continuer à ouvrir des positions jusqu’à ce que vos fonds soient épuisés. Les arbitragistes sont à l’origine de la grande majorité des raisons pour lesquelles la différence de prix en bourse ne peut être maintenue.

Problèmes et solutions dans la pratique

1. Aucune possibilité d’ouvrir une position

En raison de l’existence d’un grand nombre d’arbitragistes et de teneurs de marché, les différences de prix entre les différentes bourses ne seront pas très différentes, sinon elles seront rapidement nivelées. C’est le plus gros problème auquel est confronté le carry trading.

Solution:

• Attendez que la divergence des prix se forme naturellement：Le marché des devises numériques est très volatil et les différences de prix à court terme sont généralement observées. La patience est le meilleur moyen de résoudre ce problème.
• Utiliser la stratégie du fabricant: Placez activement des ordres d’achat et de vente sur un carnet d’ordres d’échange, et annulez et ajustez continuellement les ordres en fonction des variations de prix. Si l’une des parties termine la transaction, l’autre partie reprendra l’ordre. De cette façon, les frais de transaction sont moins élevés, un spread plus petit peut être accepté et la transaction peut être garantie d’être effectuée du premier coup.
• Surveillez davantage de paires de trading：On ne peut pas se contenter de se concentrer sur les devises traditionnelles. Leurs opportunités d’arbitrage ont généralement été saisies par un grand nombre d’arbitragistes, ce qui a entraîné une réduction des écarts de prix. Les devises impopulaires et nouvellement cotées peuvent avoir des écarts de prix importants en raison d’une faible liquidité et d’une concurrence moindre, et constituent des opportunités d’arbitrage dignes d’attention.
• Choisissez un petit échange:Les petites bourses ont généralement une faible liquidité et des ajustements de prix plus lents, ce qui les rend plus sujettes à des différences de prix plus importantes. À ce stade, les arbitragistes peuvent choisir de passer des ordres et de les exécuter en premier pour réaliser des bénéfices.
• Choisissez un échange à seuil élevé:Certains échanges nécessitent une certification KYC stricte, comme l’échange coréen Upbit. Il existe davantage d’opportunités d’arbitrage dans ces endroits où il est difficile pour les traders ordinaires d’y accéder. Bien entendu, vous devez trouver vous-même les moyens de surmonter ces difficultés.

2. La différence entre le spread de transaction et le spread de surveillance est trop importante

L’échec de la saisie des commandes est un problème courant. Lorsque le programme détecte la différence de prix et place un ordre d’arbitrage, la différence de prix de transaction réelle n’est pas si importante et entraîne souvent une perte. À ce stade, la réponse la plus rapide et la vitesse d’exécution sont cruciales.

Solution:

• Optimiser les emplacements du réseau et des serveurs: Choisissez un nœud proche du serveur Exchange pour réduire la latence. Par exemple, choisir une petite bourse avec une faible liquidité pour opérer peut réduire la vitesse de réaction du marché et ainsi prendre l’initiative.
• Traitement asynchrone et WebSocket:En utilisant du code asynchrone et WebSocket pour vous connecter aux conditions du marché, vous pouvez recevoir des informations sur les prix en temps réel et réagir rapidement pour éviter de manquer des opportunités en raison de décalages d’information.

3. Accord à une seule étape

Une transaction à une seule étape fait référence à une transaction dans laquelle une partie termine la transaction tandis que l’autre partie ne parvient pas à terminer la transaction, ce qui se produit généralement lorsque le marché fluctue rapidement. Si un seul côté de l’ordre réussit, l’arbitragiste sera confronté à un risque d’exposition.

Solution:

• Mettre en place un mécanisme de stop loss raisonnable:Lorsqu’une transaction à un seul segment se produit, vous pouvez définir un stop loss. La clôture opportune des positions est un moyen efficace de réduire les risques.
• Utiliser l’ordre du marché:Le prix du marché peut garantir la transaction, mais le problème est que la différence de prix de transaction est incontrôlable et peut entraîner des pertes.

4. Entrepôt complet sur une seule bourse

Lorsque la différence de prix existe pendant une longue période, les fonds d’une certaine bourse seront rapidement rachetés et les arbitragistes risquent de ne pas être en mesure de poursuivre leurs opérations d’arbitrage. À ce stade, les arbitragistes doivent rapidement transférer des fonds ou ajuster leurs positions.

Solution:

• Opération de transfert de pièces:Utilisez les transferts de devises entre devises pour transférer des fonds et poursuivre l’arbitrage. De cette manière, il est possible d’éviter l’accumulation de fonds sur un marché unique et d’augmenter la liquidité des fonds.
• En attendant que la propagation s’inverse:Compte tenu du coût en temps du retrait, attendre que la différence de prix revienne est également une option.

Code de démonstration

Le code n’est pas du vrai code et est uniquement destiné à des fins de démonstration. Il ne prend pas en compte des problèmes tels que le nombre de marchés, les échecs d’accès à l’API, l’accélération des commandes asynchrones, 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); // 每秒钟执行一次
    }
}

Résumer

L’arbitrage Lead-Lag est une stratégie d’arbitrage inter-bourses basée sur la réaction du décalage du marché. En analysant avec précision les différences de prix sur le marché et en exécutant les transactions rapidement, les arbitragistes sont en mesure de réaliser des bénéfices stables sur le marché des crypto-monnaies. Cependant, le succès de cette stratégie ne dépend pas seulement de la conception de la stratégie elle-même, mais nécessite également une bonne exécution et une bonne maîtrise du timing du marché. À mesure que la concurrence sur le marché s’intensifie, les arbitragistes doivent continuellement optimiser leurs stratégies et leurs techniques et améliorer leur rapidité et leur réactivité pour maintenir l’efficacité continue des opportunités d’arbitrage.