Prinsip Strategi

Karena alasan likuiditas, ketika ada sejumlah besar penjualan atau penarikan di pasar, pasti akan ada fluktuasi harga yang besar, dan akan ada perbedaan harga sesaat antara bursa. Strateginya adalah untuk menangkap momen-momen ini dan melakukan transaksi cepat untuk menyelesaikan proses membeli saat harga rendah dan menjual saat harga tinggi. Beberapa klien bertanya kepada saya mengapa saya memiliki begitu banyak bursa. Ini tidak dapat dihindari. Yang menghasilkan uang bagi kami adalah perbedaan harga instan antara bursa. Semakin banyak bursa, semakin banyak peluang perbedaan harga setelah crossover.

Logika inti strategi

1. Memperoleh informasi pasar dari beberapa bursa secara bersamaan. Memperoleh informasi secara bersamaan diperlukan untuk mengurangi keterlambatan dalam memperoleh informasi pasar. Untuk perolehan secara bersamaan, Anda dapat merujuk ke plug-in alat yang saya bagikan.Plugin Multi-Pertukaran Bersamaan
2. Gabungkan harga permintaan dan penawaran dari semua bursa untuk mendapatkan informasi pasar gabungan, di mana Harga Nyata adalah harga setelah dikurangi biaya penanganan.

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. Hitung spread arbitrase yang paling optimal dari gabungan informasi pasar. Karena kita menerima order, yaitu membeli dari harga ask terendah dan menjual dari harga bid tertinggi, selama bid.RealPrice > ask.RealPrice, maka ada ruang 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. Sekarang setelah kita memperoleh informasi tentang spread arbitrase di pasar, bagaimana kita memutuskan apakah akan mengeksekusi transaksi dan berapa banyak yang akan diperdagangkan? Berikut adalah beberapa poin penting yang perlu dipertimbangkan:

• Aset yang tersisa saat ini
• Ukuran spread (jika spread terlalu kecil, maka spread hanya akan menyeimbangkan jumlah mata uang, dan jika spread cukup besar, maka spread akan memaksimalkan jumlah transaksi)
• Jumlah pesanan yang tertunda

    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. Setelah jumlah pesanan dihitung, transaksi dapat dilakukan. Strategi ini menggunakan metode penambahan slippage secara langsung untuk menerima pesanan dan melakukan pemesanan pada saat yang bersamaan.

            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. Yang tersisa adalah logika perhitungan keuntungan, penanganan stop loss untuk order yang gagal, dll.

Manfaat nyata dari strategi ini

Tampilan waktu nyata saat ini, logika inti tetap tidak berubah, dioptimalkan untuk mendukung berbagai mata uang

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

Akhirnya, selamat datang untuk bergabung dengan Laoqiu Quantitative Exchange: https://t.me/laoqiu_arbitrage