Strategieprinzip

Aus Liquiditätsgründen kommt es bei einem großen Verkaufs- oder Ziehungsvolumen auf dem Markt zwangsläufig zu großen Preisschwankungen und zu einem vorübergehenden Preisunterschied zwischen den Börsen. Die Strategie besteht darin, diese Momente zu nutzen und schnelle Transaktionen auszuführen, um Schließen Sie den Prozess des günstigen Kaufens und hohen Verkaufens ab. . Einige Kunden fragten mich, warum ich so viele Börsen habe. Das ist unvermeidlich. Wir verdienen unser Geld mit den sofortigen Preisunterschieden zwischen den Börsen. Je mehr Börsen es gibt, desto mehr Möglichkeiten für Preisunterschiede gibt es nach dem Crossover.

Kernlogik der Strategie

1. Erhalten Sie gleichzeitig die Marktinformationen mehrerer Börsen. Dies ist notwendig, um die Verzögerung beim Erhalt der Marktinformationen zu verringern. Für den gleichzeitigen Erhalt können Sie auf das von mir freigegebene Tool-Plug-In zurückgreifen.Plugin für gleichzeitigen Multi-Exchange
2. Kombinieren Sie die Brief- und Gebotskurse aller Börsen, um eine kombinierte Kursinformation zu erhalten, wobei der RealPrice der Preis nach Abzug der Bearbeitungsgebühr ist.

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. Berechnen Sie den profitabelsten Arbitrage-Spread aus den kombinierten Marktinformationen. Da wir Aufträge annehmen, das heißt, vom niedrigsten Briefkurs aus kaufen und vom höchsten Gebotskurs aus verkaufen, besteht Spielraum für Gewinne, solange bid.RealPrice > ask.RealPrice

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. Nachdem wir nun die Arbitrage-Spread-Informationen auf dem Markt erhalten haben, wie entscheiden wir, ob wir die Transaktion ausführen und wie viel wir handeln? Hier sind einige wichtige Punkte, die zu berücksichtigen sind:

• Derzeitiges Restvermögen
• Die Größe des Spreads (ist der Spread zu klein, gleicht er lediglich den Währungsbetrag aus, ist der Spread groß genug, maximiert er die Anzahl der Transaktionen)
• Anzahl ausstehender Bestellungen

    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. Sobald die Auftragsmenge berechnet ist, kann die Transaktion ausgeführt werden. Die Strategie verwendet die Methode, Slippage direkt hinzuzufügen, um Aufträge anzunehmen und gleichzeitig Aufträge zu erteilen.

            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. Was bleibt, ist die Logik der Gewinnberechnung, der Handhabung von Stop-Losses für fehlgeschlagene Aufträge usw.

Die tatsächlichen Vorteile dieser Strategie

Aktuelle Echtzeitanzeige, Kernlogik bleibt unverändert, optimiert für die Unterstützung mehrerer Währungen

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

Und schließlich: Herzlich willkommen bei Laoqiu Quantitative Exchange: https://t.me/laoqiu_arbitrage