La stratégie de partage logique de la différence de prix au comptant de plusieurs bourses

Les principes stratégiques

Pour des raisons de liquidité, il est inévitable que des fluctuations de prix importantes se produisent lorsque le marché se déplace à grande échelle, ce qui crée une différence de prix instantanée entre les bourses. La stratégie consiste à capturer ces instants d'exécution rapide des transactions afin de compléter le processus de vente à bas prix. Il y a des clients qui m'ont demandé pourquoi j'avais tant d'échanges, et c'est inévitable, nous avons eu une différence de prix instantanée entre les échanges, et plus il y a d'échanges, plus il y a d'opportunités de différence de prix après le croisement.

La logique de base de la stratégie

1. L'accès simultané aux informations de négociation de plusieurs bourses doit être simultané, ce qui réduit les retards de négociation, et l'accès simultané aux plugins que je partage avec vous.Plugin de partage multi-échanges
2. L'analyse de l'offre et de l'enchère est réalisée en combinant les enchères demandées et les enchères faites par toutes les bourses pour obtenir une information d'enchères combinée, dans laquelle le RealPrice est le prix après déduction des frais de transaction, et le RealPrice est le prix après déduction des frais de transaction.

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. L'information de l'enregistrement combinée est utilisée pour calculer la plus grande différence d'intérêt. Puisque nous sommes des acheteurs, nous achetons à partir du prix d'achat le plus bas et vendons à partir du prix d'achat le plus élevé, tant que bid.RealPrice > ask.RealPrice 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;
}

4. A ce stade, nous avons obtenu des informations sur les différences de taux d'intérêt disponibles sur le marché, sur la façon de décider si une transaction doit être exécutée ou non, et sur le nombre de transactions à effectuer.

• Actifs restants
• Taille de l'écart de prix (un écart de prix trop faible ne peut équilibrer que le nombre de devises et un prix assez grand pour maximiser le nombre de transactions)
• Nombre de factures en suspens

    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. Comptez le nombre de commandes que vous avez reçues et exécutez la transaction. La stratégie consiste à commander en même temps en utilisant le menu de commande en point de glissement direct.

            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. Il ne reste plus qu'à calculer les bénéfices et à gérer la logique des commandes manquantes.

Les avantages de cette stratégie

Le tableau de bord actuel montre que la logique de base n'a pas changé et a été optimisée pour prendre en charge la multi-monnaie

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

Pour finir, bienvenue à l'échange quantitatif:https://t.me/laoqiu_arbitrage