मल्टी एक्सचेंजों ने शेयरों के लिए मौद्रिक घाटे की रणनीति साझा की

रणनीतिक सिद्धांत

तरलता के कारण, जब बाजारों में बड़े पैमाने पर उतार-चढ़ाव होता है, तो बड़ी कीमतों में उतार-चढ़ाव होना अनिवार्य है, और एक्सचेंजों के बीच क्षणिक मूल्य अंतर होता है। रणनीति इन क्षणों को पकड़ने के लिए है। तेजी से निष्पादित ट्रेडों को पूरा करने के लिए कम खरीदें और बेचें। एक ग्राहक ने मुझसे पूछा कि आप इतने सारे एक्सचेंजों को क्यों चुनते हैं, यह अपरिहार्य है, हम एक्सचेंजों के बीच तत्काल मूल्य अंतर को चुनते हैं, और अधिक एक्सचेंजों के बाद, क्रॉसिंग के बाद कीमत अंतर का अवसर निश्चित रूप से अधिक होता है।

रणनीतिक मूल तर्क

1. एक साथ कई एक्सचेंजों के लेनदेन की जानकारी प्राप्त करें, एक साथ पहुंचना सुनिश्चित करें, लेनदेन में देरी को कम करें, एक साथ प्लगइन का उपयोग करें जिसे मैं साझा कर सकता हूं।बहु-विनिमय प्लगइन
2. सभी एक्सचेंजों के ऑक्स और बिड्स को मिलाकर, एक संयुक्त ऑक्स जानकारी प्राप्त की जाती है, जिसमें रियल प्राइस प्रसंस्करण शुल्क के बाद की कीमत है, और यह एक समान मूल्य है।

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. एकजुट किए गए कारोबार की जानकारी से, सबसे अधिक ब्याज दरों का अनुमान लगाया जाता है। चूंकि हम सबसे कम कीमत पर खरीदते हैं, इसलिए हम सबसे कम कीमत पर खरीदते हैं और सबसे अधिक कीमत पर बेचते हैं, जब तक कि हम 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;
}

4. इस बिंदु पर, हम बाजार में सुलभ ब्याज दर अंतर के बारे में जानकारी प्राप्त कर चुके हैं, तो ट्रेडों को निष्पादित करने के बारे में कैसे विचार करें, और ट्रेडों की संख्या कितनी कम है, यहां कुछ निर्णय दिए गए हैंः

• वर्तमान शेष संपत्ति
• मूल्य अंतर का आकार (बहुत कम मूल्य अंतर केवल मुद्राओं की संख्या को संतुलित करता है, मूल्य अधिकतम करने के लिए काफी बड़ा है)
• सूचीबद्ध किए गए आदेशों की संख्या

    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. आदेशों की संख्या का गणना करने के लिए, एक ही समय में आदेशों को निष्पादित करने के लिए सीधे स्लाइडिंग पॉइंट खाते हैं।

            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. यह केवल लाभ की गणना करने और असफल आदेशों को रोकने के लिए लॉजिक को संभालता है।

इस रणनीति का वास्तविक लाभ

वर्तमान वास्तविक प्रदर्शन, मूल तर्क अपरिवर्तित है, बहु मुद्राओं का समर्थन करने के लिए अनुकूलित

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

और अंत में, आपका स्वागत है और हमारे पुराने अक्षय के साथ जुड़ेंःhttps://t.me/laoqiu_arbitrage