80 पंक्तियों के कोड में उच्च आवृत्ति रणनीति के साथ मस्तिष्क रहित बिक्री बॉट्स का शोषण कैसे करें

अवसर का अवलोकन

हाल ही में, मैंने पाया कि बिनेंस में एक मुद्रा है STORJ बाजार बहुत अजीब है अनजाने में जब मैं बाजार देख रहा था, व्यापार की मात्रा बहुत बड़ी है, और व्यापार की आवृत्ति बहुत तेज है, निम्नलिखित चार्ट के विशिष्ट एक मिनट के-लाइन, हम देख सकते हैं कि व्यापार की मात्रा प्रत्येक मिनट के अनुरूप हैं, और मिनट के-लाइन एक लंबे निचले छाया रेखा में देखा जा सकता है।

Binance 1 सेकंड के-लाइन के साथ अवलोकन करें, मुझे कहानी का अंत पता चला, किसी को हर 5-7s में 10,000-20,000 STORJs का विपणन किया जाता है, लागत की परवाह किए बिना, और सीधे K-लाइन में एक छोटा छेद तोड़ देता है, जबकि कीमत अल्पकालिक में ठीक हो जाती है। यह ऑपरेशन स्पष्ट रूप से एक आइसबर्ग कमीशन पर एक रोबोट के कारण हुआ था। यह बिक्री ऑपरेशन बहुत लंबे समय तक चला, कुल अनुमानित $ 10 मिलियन का स्तर, और कई मामलों में 0.1% तक की फिसलने का कारण बना, जिसका अर्थ है कि इस रणनीति के निष्पादक ने केवल व्यापार पर फिसलने में हजारों डॉलर खो दिए। लेकिन इस तरह के यांत्रिक संचालन और सक्रिय ट्रेडिंग के साथ, बाजार बनाने के लिए एक स्पष्ट अवसर था।

मूल स्पॉट एचएफ रणनीति के लिए एक सरल परिवर्तन, और कुछ ही मिनटों में मैं इस बॉट है कि इस बर्फ के टुकड़े के कमीशन के इस बेवकूफ बिक्री का दोहन करने में विशेषज्ञता प्राप्त है।

रणनीतिक विचार

चूंकि बाजार बाजार मूल्य में हर कुछ सेकंड में बेचता है, इसलिए हमें बस खरीद ऑर्डर बुक में 10k गहराई खोजने की जरूरत है और इसके सामने ऑर्डर लटका देना है। ताकि जब आइसबर्ग बेचता है, तो एक उच्च संभावना है कि बाजार बनाने वाला रोबोट सिर्फ प्राप्त कर सकता है, और इस समय लेनदेन बहुत सक्रिय है, क्षणिक मूल्य में गिरावट ने कुछ खरीद ऑर्डर को भी ट्रिगर किया। उसी टोकन से, लटकने वाले बिक्री ऑर्डर को प्रवृत्ति में फेंक दिया जा सकता है, इसलिए दोहराए गए संचालन। लेनदेन की आवृत्ति बहुत अधिक है, भले ही हर बार उपज काफी बड़ी न हो, कुल रिटर्न भी पर्याप्त हो। बेशक, सब कुछ का आधार एक कम शुल्क खाता होना चाहिए, यदि खरीद और बिक्री दोनों शुल्क 0.1% हैं, तो शुल्क का भुगतान करने के लिए जगह पर्याप्त नहीं है।

रणनीति का प्रदर्शन

रणनीति इस प्रकार काम कर रही है, सबसे पहले, कोई भी लाभ प्रिंट नहीं कर रहा था, इसलिए मैंने इसे आज दोपहर बदल दिया, और लाभ प्रिंट किया, पागल बिक्री रोबोटों ने मात्रा को एक समय में लगभग 5000 तक बदल दिया है, इसलिए यह मध्यस्थता के लिए इष्टतम समय से पहले है। मैं शायद पहले प्रति घंटे 100-200U बना रहा हूं, कुंजी जोखिम मुक्त और कम लागत है। दूसरी ओर, आइसबर्ग कमीशन में वास्तव में बहुत सारे कौशल हैं, यदि आप एक रणनीति लिखना जानते हैं, तो आप एफएमजेड पर आइसबर्ग कमीशन रणनीति लिखने के लिए दस मिनट बिता सकते हैं जो ऑर्डर के आकार और मूल्य का फैसला करने के लिए खरीद ऑर्डर की गहराई का निरीक्षण करता है, लंबित ऑर्डर के आकार को समायोजित करने और बाजार और अन्य विशेषताओं को लेने के लिए सक्रिय खरीद ऑर्डर के आकार का निरीक्षण करता है, आसानी से हजारों डॉलर की निगरानी करता है।

रणनीति स्रोत कोड

रणनीति कोड बहुत सरल है, केवल 80 पंक्तियाँ, जो शुरुआती लोगों के लिए उपयुक्त है, यहाँ कुछ पैरामीटर हैं जैसे कि आदेश सटीकता और इतने पर प्रोग्राम में लिखे गए हैं, आप पैरामीटर को निम्नानुसार बदल सकते हैं। इसे सहेजने की सिफारिश की जाती है, किसी भी एक्सचेंज ट्रेडिंग जोड़े या व्यापारियों के मामले में नियंत्रण से बाहर हैं, आप किसी भी समय उन्हें कुछ ब्याज चार्ज करने के लिए स्वतंत्र हो सकते हैं।

function CancelPendingOrders() {
    var orders = _C(exchange.GetOrders)
    for (var j = 0; j < orders.length; j++) {
        exchange.CancelOrder(orders[j].Id, orders[j])
    }
}

function onexit(){
    CancelPendingOrders()
}

function GetPrice(Type, Depth) {
    var sumAmount = 0
    var checkAmount = Type == "Buy" ? CheckBuyAmount : CheckSellAmount
    var deep = Type == "Buy" ? Depth.Bids : Depth.Asks
    for(var i = 0; i < Math.min(20, deep.length); i++) {
        if(Type == "Buy"  && deep[i].Price == lastBuyPrice && buyId){
            sumAmount += deep[i].Amount - amountBuy //Subtract your own pending orders here
        }else if(Type == "Sell"  && deep[i].Price == lastSellPrice && sellId){
            sumAmount += deep[i].Amount - amountSell
        }else{
            sumAmount += deep[i].Amount
        }
        if(sumAmount >= checkAmount){
            return deep[i].Price
        }
    }
    return deep[19].Price
}

function OnTick() {
    var depth = _C(exchange.GetDepth)
    var buyPrice = _N(Math.min(GetPrice("Buy", depth) + 0.0001, depth.Asks[0].Price-0.0001) , 4) //Guaranteed at the market
    var sellPrice = _N(Math.max(GetPrice("Sell", depth) - 0.0001, depth.Bids[0].Price+0.0001), 4)
    LogStatus('buy_price:'+buyPrice, '  sell price: '+sellPrice)
    if ((sellPrice - buyPrice) < DiffPrice) {
        buyPrice = 0
    }
    if(sellPrice != lastSellPrice && sellId){
        exchange.CancelOrder(sellId);
        sellId = 0
        lastSellPrice = 0
    }
    if(buyPrice != lastBuyPrice && buyId){
        exchange.CancelOrder(buyId);
        buyId = 0
        lastBuyPrice = 0
    }   
    var acc = _C(exchange.GetAccount)
    if(account.Stocks+account.FrozenStocks != acc.Stocks+acc.FrozenStocks){
        LogProfit((acc.Stocks+acc.FrozenStocks)*depth.Bids[0].Price+acc.Balance+acc.FrozenBalance - 2000)
        Log('free '+acc.Stocks, ' lock: '+ acc.FrozenStocks, ' total: ' , (acc.Stocks+acc.FrozenStocks)*depth.Bids[0].Price+acc.Balance+acc.FrozenBalance)
    }
    account = acc
    amountBuy = _N(Math.min(account.Balance / buyPrice - 0.1, Amount), 0)
    amountSell = _N(account.Stocks, 0)
    if (sellPrice > 0 && amountSell > 40 && sellId == 0) {
        sellId = exchange.Sell(_N(sellPrice,4), amountSell)
        lastSellPrice = sellPrice
    }
    if (buyPrice>0 && amountBuy > 40 && buyId == 0) {
        buyId = exchange.Buy(_N(buyPrice,4), amountBuy)
        lastBuyPrice = buyPrice
    }
    Sleep(Interval)
}
var account = {Stocks:0, FrozenStocks:0, Balance:0, FrozenBalance:0}
var buyId = 0
var sellId = 0
var lastBuyPrice = 0
var lastSellPrice = 0
var amountSell = 0
var amountBuy = 0
var log_account_time = 0
function main() {
    CancelPendingOrders()
    while (true) {
        OnTick()
    }
}