Multi-Börsen kurzfristige Differenz Swap Strategie Logik zu teilen

Die Strategie

Aufgrund von Liquiditätsgründen ist es unweigerlich, dass bei einem Markt mit großen Schubs große Preisschwankungen auftreten, die eine momentane Preisdifferenz zwischen den Börsen erzeugen. Die Strategie besteht darin, diese Momente zu erfassen, um schnelle Transaktionen durchzuführen, um niedrige Kauf- und Verkaufsabschlüsse zu erzielen. Einer meiner Kunden fragte mich, warum ich so viele Börsen hätte, und das war unumgänglich. Wir haben uns gefragt, ob es eine sofortige Preisdifferenz zwischen den Börsen gibt, und je mehr Börsen es gibt, desto größer ist die Chance, dass sich die Preisdifferenz nach der Kreuzung bildet.

Strategische Kernlogik

1. Gleichzeitige Zugriff auf Informationen von mehreren Börsen muss gleichzeitig erfolgen, um die Verzögerung zu reduzieren.Plug-ins für mehrere Börsen
2. Wenn man die Anfrage und das Angebot aller Börsen kombiniert, erhält man eine kombinierte Anfrageinformation, bei der der RealPrice der Preis nach Abzug der Handlungsgebühren 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;
    });
}

3. Aus der kombinierten Börseninformation berechnet man den höchsten Gewinnspanne. Da wir auf der Ein- und Ausschreibung sind, kaufen wir zum niedrigsten Ask-Preis und verkaufen zum höchsten Bid-Preis, solange der Gewinnspanne bei bid.RealPrice > ask.RealPrice besteht.

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;
}

4. Hier haben wir Informationen über die marktfähigen Differenzen in den Zinssätzen erhalten, wie man sich entscheiden kann, ob man eine Transaktion ausführt und wie viele wenige Transaktionen es gibt. Hier sind einige Urteile:

• Vermögensbestand
• Die Größe des Preisunterschieds (zu klein, um die Anzahl der Währungen auszugleichen, zu groß, um die Anzahl der Transaktionen zu maximieren)
• Anzahl der aufgeschlagenen Aufträge

    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());
                }
            }
        }
    }

5. Es wird die Anzahl der Bestellungen berechnet, um die Transaktionen auszuführen, wobei die Strategie die Art des direkten Schaltpunktes verwendet, um gleichzeitig zu bestellen.

            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()

6. Die Logik bleibt, die Gewinne zu berechnen und mit Fehlbestellungen umzugehen.

Die praktischen Vorteile dieser Strategie

Die aktuelle Plattform zeigt, dass die Kernlogik unverändert ist und die Unterstützung von Multi-Währungen optimiert wird.

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

Schließlich begrüßen wir Sie herzlich zu unserem Quantifizierungs-Austausch mit Old Autumn:https://t.me/laoqiu_arbitrage