Principe de stratégie

Pour des raisons de liquidité, lorsqu’il y a un grand nombre de ventes ou de retraits sur le marché, il y aura inévitablement de grandes fluctuations de prix et une différence de prix momentanée entre les bourses. La stratégie consiste à saisir ces moments et à exécuter des transactions rapides pour terminer le processus d’achat à bas prix et de vente à prix élevé. . Certains clients m’ont demandé pourquoi j’avais autant d’échanges. C’est inévitable. Ce qui nous permet de gagner de l’argent, c’est la différence de prix instantanée entre les échanges. Plus il y a d’échanges, plus il y aura de possibilités de différence de prix après le croisement.

Logique de base de la stratégie

1. Obtenez simultanément les informations de marché de plusieurs bourses. Il est nécessaire de les obtenir simultanément pour réduire le délai d’obtention des informations de marché. Pour une acquisition simultanée, vous pouvez vous référer au plug-in d’outil que j’ai partagé.Plugin simultané multi-échange
2. Combinez la demande et l’offre de toutes les bourses pour obtenir des informations de cotation combinées, où RealPrice est le prix après déduction des frais de traitement.

function createOrders(depths, askOrders, bidOrders) {
    let asksIndex = 0;
    let bidIndex = 0;
    for (let i = 0; i < depths.length; i++) {
        let exchangeTariff = getExchangeTariff(i);
        let asks = depths[i].Asks;
        let bids = depths[i].Bids;
        for (let j = 0; j < Math.min(asks.length, bids.length, 20); j++) {
            if (asks[j].Amount >= minTakerAmount) {
                askOrders[asksIndex] = {
                    "Price": asks[j].Price,
                    "Amount": asks[j].Amount,
                    "Fee": asks[j].Price * exchangeTariff,
                    "RealPrice": asks[j].Price * (1 + exchangeTariff),
                    "Index": i,
                };
                asksIndex++;
            }
            if (bids[j].Amount >= minTakerAmount) {
                bidOrders[bidIndex] = {
                    "Price": bids[j].Price,
                    "Amount": bids[j].Amount,
                    "Fee": bids[j].Price * exchangeTariff,
                    "RealPrice": bids[j].Price * (1 - exchangeTariff),
                    "Index": i,
                };
                bidIndex++;
            }
        }
    }
    askOrders.sort(function (a, b) {
        return a.RealPrice - b.RealPrice;
    });
    bidOrders.sort(function (a, b) {
        return b.RealPrice - a.RealPrice;
    });
}

1. Calculez le spread d’arbitrage le plus rentable à partir des informations de marché combinées. Étant donné que nous prenons des ordres, c’est-à-dire que nous achetons au prix demandé le plus bas et que nous vendons au prix offert le plus élevé, tant que bid.RealPrice > ask.RealPrice, il y a une marge de profit

function getArbitrageOrders(askOrders, bidOrders) {
    let ret = [];
    for (let i = 0; i < askOrders.length; i++) {
        for (let j = 0; j < bidOrders.length; j++) {
            let bidOrder = bidOrders[j];
            let askOrder = askOrders[i];
            if (bidOrder.Index === askOrder.Index) {
                continue
            }
            let minMigrateDiffPrice = ((askOrder.Price + bidOrder.Price) / 2 * minMigrateDiffPricePercent / 100);
            if (bidOrder.RealPrice - askOrder.RealPrice > minMigrateDiffPrice) {
                ret.push({
                    "Ask": askOrder,
                    "Bid": bidOrder,
                })
            }
        }
    }
    if (ret.length === 0) {
        ret.push({
            "Ask": askOrders[0],
            "Bid": bidOrders[0],
        });
    }
    //按最优价差排序
    ret.sort((a, b) => {
        return (b.Bid.RealPrice - b.Ask.RealPrice) - (a.Bid.RealPrice - a.Ask.RealPrice);
    });
    return ret;
}

1. Maintenant que nous avons obtenu les informations sur le spread d’arbitrage sur le marché, comment pouvons-nous décider d’exécuter ou non la transaction et quel montant négocier ? Voici quelques points clés à prendre en compte :

• Actifs restants actuels
• La taille du spread (si le spread est trop petit, il équilibrera uniquement le montant de la devise, et si le spread est suffisamment grand, il maximisera le nombre de transactions)
• Nombre de commandes en attente

    var askOrder = arbitrageOrder.Ask;
    var bidOrder = arbitrageOrder.Bid;
    var perAmountFee = arbitrageOrder.Ask.Fee + arbitrageOrder.Bid.Fee;
    var minRealDiffPrice = (askOrder.Price + bidOrder.Price) / 2 * minDiffPricePercent / 100;
    var minMigrateDiffPrice = ((askOrder.Price + bidOrder.Price) / 2 * minMigrateDiffPricePercent / 100);
    var curRealDiffPrice = arbitrageOrder.Bid.RealPrice - arbitrageOrder.Ask.RealPrice;
    var buyExchange = exchanges[arbitrageOrder.Ask.Index];
    var sellExchange = exchanges[arbitrageOrder.Bid.Index];
    var buySellAmount = 0;
    if (curRealDiffPrice > minRealDiffPrice) {
        buySellAmount = math.min(
            bidOrder.Amount,
            askOrder.Amount,
            maxTakerAmount,
            runningInfo.Accounts[bidOrder.Index].CurStocks,
            runningInfo.Accounts[askOrder.Index].CurBalance / askOrder.Price
        );
    } else if (bidOrder.Index !== askOrder.Index) {
        if (migrateCoinEx == -1) {
            if (curRealDiffPrice > minMigrateDiffPrice && runningInfo.Accounts[bidOrder.Index].CurStocks - runningInfo.Accounts[askOrder.Index].CurStocks > maxAmountDeviation) {
                buySellAmount = math.min(
                    bidOrder.Amount,
                    askOrder.Amount,
                    maxTakerAmount,
                    runningInfo.Accounts[bidOrder.Index].CurStocks,
                    runningInfo.Accounts[askOrder.Index].CurBalance / askOrder.Price,
                    runningInfo.Accounts[bidOrder.Index].CurStocks - ((runningInfo.Accounts[bidOrder.Index].CurStocks + runningInfo.Accounts[askOrder.Index].CurStocks) / 2)
                );
                if (buySellAmount >= minTakerAmount) {
                    Log("启动交易所平衡！");
                }
            }
        } else if (migrateCoinEx == askOrder.Index) {
            if (curRealDiffPrice > minMigrateDiffPrice && runningInfo.Accounts[bidOrder.Index].CurStocks > 0) {
                buySellAmount = math.min(
                    bidOrder.Amount,
                    askOrder.Amount,
                    maxTakerAmount,
                    runningInfo.Accounts[bidOrder.Index].CurStocks,
                    runningInfo.Accounts[askOrder.Index].CurBalance / askOrder.Price
                );
                if (buySellAmount >= minTakerAmount) {
                    Log("启动货币迁移:", exchanges[bidOrder.Index].GetName(), "-->", exchanges[askOrder.Index].GetName());
                }
            }
        }
    }

1. Une fois la quantité commandée calculée, la transaction peut être exécutée. La stratégie utilise la méthode consistant à ajouter directement le glissement pour prendre des commandes et à placer des commandes en même temps

            var buyWait = buyExchange.Go("Buy", _N(askOrder.Price * (1.01), pricePrecision), buySellAmount);
            var sellWait = sellExchange.Go("Sell", _N(bidOrder.Price * (0.99), pricePrecision), buySellAmount);
            var startWaitTime = new Date().getTime()
            Sleep(3000);
            var buyOrder = buyWait.wait()
            var sellOrder = sellWait.wait()

1. Il reste la logique de calcul des profits, de gestion des stop loss pour les ordres échoués, etc.

Les avantages réels de cette stratégie

Affichage actuel en temps réel, la logique de base reste inchangée, optimisée pour prendre en charge plusieurs devises

https://www.fmz.com/robot/464965

Enfin, bienvenue sur Laoqiu Quantitative Exchange : https://t.me/laoqiu_arbitrage