ओकेकोइन ट्रांसप्लांट करें

लेखक:शून्य, दिनांकः 2017-01-30 19:38:25
टैगःउच्च आवृत्ति

ट्रांसप्लांटःhttps://github.com/richox/okcoin-leeks-reaper

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

नीचे मूल विवरण है

ओकेकोइन कपास कटाई मशीन

यह ओकेकोइन बिटकॉइन ट्रेडिंग प्लेटफॉर्म पर एक उच्च आवृत्ति ट्रेडिंग रोबोट प्रोग्राम है, जो जून 2016 में रणनीति के मूल रूप से तैयार किया गया था, और जनवरी 2017 के मध्य तक इस रणनीति ने सफलतापूर्वक अपने प्रारंभिक निवेश के 6,000 रुपये को 250,000 तक धकेल दिया। हाल ही में केंद्रीय बैंक द्वारा बिटकॉइन पर उच्च दबाव की नीति के कारण, सभी प्रमुख प्लेटफार्मों ने आवंटन बंद कर दिया और लेनदेन शुल्क वसूलना शुरू कर दिया। यह रणनीति वास्तव में विफल हो गई है।

इस रोबोट को दो मुख्य रणनीतियों पर आधारित किया गया हैः

ट्रेंडिंग रणनीतिः जब कीमतें ट्रेंडिंग हो जाती हैं, तो समय पर ऑर्डर दें और उनका पालन करें, जैसा कि कहा जाता है।शिकार में गिरना。
संतुलन रणनीतिः जब स्थिति 50% से विचलित हो जाती है, तो पट्टे को छोड़ दें ताकि स्थिति धीरे-धीरे 50% वापस आ जाए, और अंत में रुझान के पलटाव को पीछे हटाने से रोकें, यानीकमाई के लिए बैग, मछली का पूंछ नहीं。

इस प्रक्रिया में स्थिति को संतुलित करने की आवश्यकता होती है, यानी (पूंजी + वित्तपोषण = वित्तपोषण) ताकि स्थिति के 50% पर शुद्ध संपत्ति मूल्य में उतार-चढ़ाव के साथ नहीं चलती है, लेकिन यह भी गारंटी है कि जब प्रवृत्ति में उतार-चढ़ाव होता है।गिरने के बाद भी。

मैं इन दो परियोजनाओं के लिए आभारी हूंः

ओकेकोइन के लिए धन्यवादः

https://www.okcoin.cn

BTC: 3QFn1qfZMhMQ4FhgENR7fha3T8ZVw1bEeU

/*backtest
start: 2019-09-05 00:00:00
end: 2019-09-05 22:00:00
period: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT","fee":[0,0]}]
mode: 1
*/

function LeeksReaper() {
    var self = {}
    self.numTick = 0
    self.lastTradeId = 0
    self.vol = 0
    self.askPrice = 0
    self.bidPrice = 0
    self.orderBook = {Asks:[], Bids:[]}
    self.prices = []
    self.tradeOrderId = 0
    self.p = 0.5
    self.account = null
    self.preCalc = 0
    self.preNet = 0

    self.updateTrades = function() {
        var trades = _C(exchange.GetTrades)
        if (self.prices.length == 0) {
            while (trades.length == 0) {
                trades = trades.concat(_C(exchange.GetTrades))
            }
            for (var i = 0; i < 15; i++) {
                self.prices[i] = trades[trades.length - 1].Price
            }
        }
        self.vol = 0.7 * self.vol + 0.3 * _.reduce(trades, function(mem, trade) {
            // Huobi not support trade.Id
            if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
                self.lastTradeId = Math.max(trade.Id == 0 ? trade.Time : trade.Id, self.lastTradeId)
                mem += trade.Amount
            }
            return mem
        }, 0)

    }
    self.updateOrderBook = function() {
        var orderBook = _C(exchange.GetDepth)
        self.orderBook = orderBook
        if (orderBook.Bids.length < 3 || orderBook.Asks.length < 3) {
            return
        }
        self.bidPrice = orderBook.Bids[0].Price * 0.618 + orderBook.Asks[0].Price * 0.382 + 0.01
        self.askPrice = orderBook.Bids[0].Price * 0.382 + orderBook.Asks[0].Price * 0.618 - 0.01
        self.prices.shift()
        self.prices.push(_N((orderBook.Bids[0].Price + orderBook.Asks[0].Price) * 0.35 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.05))
    }
    self.balanceAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        var now = new Date().getTime()
        if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {
            self.preCalc = now
            var net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))
            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }
        }
        self.btc = account.Stocks
        self.cny = account.Balance
        self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)
        var balanced = false
        
        if (self.p < 0.48) {
            Log("开始平衡", self.p)
            self.cny -= 300
            if (self.orderBook.Bids.length >0) {
                exchange.Buy(self.orderBook.Bids[0].Price + 0.00, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.01, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.02, 0.01)
            }
        } else if (self.p > 0.52) {
            Log("开始平衡", self.p)
            self.btc -= 0.03
            if (self.orderBook.Asks.length >0) {
                exchange.Sell(self.orderBook.Asks[0].Price - 0.00, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.01, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.02, 0.01)
            }
        }
        Sleep(BalanceTimeout)
        var orders = exchange.GetOrders()
        if (orders) {
            for (var i = 0; i < orders.length; i++) {
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)
                }
            }
        }
    }

    self.poll = function() {
        self.numTick++
        self.updateTrades()
        self.updateOrderBook()
        self.balanceAccount()
        
        var burstPrice = self.prices[self.prices.length-1] * BurstThresholdPct
        var bull = false
        var bear = false
        var tradeAmount = 0
        if (self.account) {
            LogStatus(self.account, 'Tick:', self.numTick, ', lastPrice:', self.prices[self.prices.length-1], ', burstPrice: ', burstPrice)
        }
        
        if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -1)) > burstPrice ||
            self.prices[self.prices.length-1] - _.max(self.prices.slice(-6, -2)) > burstPrice && self.prices[self.prices.length-1] > self.prices[self.prices.length-2]
            )) {
            bull = true
            tradeAmount = self.cny / self.bidPrice * 0.99
        } else if (self.numTick > 2 && (
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -1)) < -burstPrice ||
            self.prices[self.prices.length-1] - _.min(self.prices.slice(-6, -2)) < -burstPrice && self.prices[self.prices.length-1] < self.prices[self.prices.length-2]
            )) {
            bear = true
            tradeAmount = self.btc
        }
        if (self.vol < BurstThresholdVol) {
            tradeAmount *= self.vol / BurstThresholdVol
        }
        
        if (self.numTick < 5) {
            tradeAmount *= 0.8
        }
        
        if (self.numTick < 10) {
            tradeAmount *= 0.8
        }
        
        if ((!bull && !bear) || tradeAmount < MinStock) {
            return
        }
        var tradePrice = bull ? self.bidPrice : self.askPrice
        while (tradeAmount >= MinStock) {
            var orderId = bull ? exchange.Buy(self.bidPrice, tradeAmount) : exchange.Sell(self.askPrice, tradeAmount)
            Sleep(200)
            if (orderId) {
                self.tradeOrderId = orderId
                var order = null
                while (true) {
                    order = exchange.GetOrder(orderId)
                    if (order) {
                        if (order.Status == ORDER_STATE_PENDING) {
                            exchange.CancelOrder(orderId)
                            Sleep(200)
                        } else {
                            break
                        }
                    }
                }
                self.tradeOrderId = 0
                tradeAmount -= order.DealAmount
                tradeAmount *= 0.9
                if (order.Status == ORDER_STATE_CANCELED) {
                    self.updateOrderBook()
                    while (bull && self.bidPrice - tradePrice > 0.1) {
                        tradeAmount *= 0.99
                        tradePrice += 0.1
                    }
                    while (bear && self.askPrice - tradePrice < -0.1) {
                        tradeAmount *= 0.99
                        tradePrice -= 0.1
                    }
                }
            }
        }
        self.numTick = 0
    }
    return self
}

function main() {
    var reaper = LeeksReaper()
    while (true) {
        reaper.poll()
        Sleep(TickInterval)
    }
}

संबंधित

अधिक

हप-हप का राजायह रणनीति विफल हो गई है, और लाभ शून्य प्रसंस्करण शुल्क के साथ उच्च आवृत्ति वाले छोटे अंतर राजस्व से आता है।

कोंगबाई979 self.vol到底是个啥？是一个ticker期间内所有交易量的总和吗？

dayTrader2018for (var i = 0; i < 15; i++) { self.prices[i] = trades[trades.length - 1].Price }; क्या यह एक समस्या है, क्या यह नहीं है कि मूल्य सरणी में प्रत्येक तत्व नवीनतम लेनदेन मूल्य है?

कुयू7035मेरे पास कई ऐसे एक्सचेंज हैं, जहां कोई शुल्क नहीं है, और मैं अच्छी तरह से ट्रेड कर सकता हूं। क्या आप इस रणनीति का प्रयास कर सकते हैं? क्या भगवान का मार्गदर्शन है, मैं एक्सचेंज खाते के लिए आवेदन करने में मदद कर सकता हूं।

बिजासुओबहुत बढ़िया, अफसोस की बात है कि यह काम नहीं करता है, क्या यह अब काम करता है?

स्काईफायरनोटरी संस्करण बिक्री मूल्यः 2000 प्रतियां, अनौपचारिक, संपर्क करने के लिए इच्छुक

रजायाकक्या किसी ने परीक्षण किया है और क्या लाभ के बारे में चर्चा करने के लिए आया है?

वैलेंनकब आएगी टिप्पणी?

वुकियानमिंगकैसे botvs के बिना समर्थित, मुक्त व्यापार एक्सचेंज चलाने के लिए, कैसे एक एक्सचेंज एपीआई लिखने की जरूरत है?

Jबहुत बहुत धन्यवाद इस महान रणनीति को साझा करने के लिए! exchange.CancelOrder ((orders[i].Id) यहाँ रद्द करने का कोड थोड़ा समस्याग्रस्त है, सत्यापन के दौरान लगातार रद्द करना। इस तरह के लोगों के लिए, यह बहुत अच्छा है कि वे एक दूसरे के साथ एक अच्छा समय बिताते हैं। यह एक बहुत अच्छा अनुभव है, क्योंकि मैंने इसे एक एक्सचेंज पर रख दिया है, जो कि बिना किसी शुल्क के चल रहा है।

किमीस्टूडियो 66行prices需加.length

बर्फ का मटरयह कौन सी भाषा है?

शून्य 平衡那里下单忘加上Price属性了。。已更正，有发现bug请及时提交.

जलीय जीवयह भी लगता है कि पैसे कमाने के लिए एक रणनीति है, या बेचने के लिए नहीं, और अपने पैसे के लिए रखो।

1213761768इसे जल्दी मत निकालो।

चांग बेहिसाबनहीं, bid price कम होना चाहिए ask price से, एक है buy price, एक है sell price

ब्वक्सियाककृपया, जब हम bid price और ask price की गणना करते हैं, तो हम ऑर्डर करते हैं जैसे कि हम bid price को ask price से बड़ा नहीं समझते हैं, इसलिए अगर हम बहुत करीब हैं, तो हम यह अनुमान लगाते हैं कि यह बहुत अधिक है, तो क्या यह समस्या होगी?

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

मुझे मोमबत्तियाँ पसंद हैं।असली चेहरे की त्वचा पर्याप्त मोटी होती है।

छोटे कोयला के गोलेकौन से एक्सचेंज?

शून्ययह सबसे हाल की कीमत के लिए इंस्टॉल किया जाना चाहिए, और इसके पीछे शिफ्ट ऑपरेशन है।

पुनर्विक्रय का चमत्कारयह पहले से ही विफल हो गया है। अब यह रोबोट युद्ध है।

सुस्कीठीक है, यह सलाद बेहतर काटता है ^_^

स्काईफायरबेचने वाला बेच दे, और खरीदने वाला खरीद ले, और तुमसे बहस न करे।

मंगेतर भीसभी लोगों ने स्रोत कोड को सार्वजनिक किया है, आप टिप्पणी करें, 2000 बेचने के लिए? बहुत अच्छा।

अकुक 请问zaif.jp现在还是免手续费吗？怎么通过认证呢

शियाओहुआन001आईडी देखें

J 在Zaif.jp上测试，买一卖一间经常就没有空间，用这个策略有什么问题吗？

Jक्या यह सच है? बाहर आओ और सबको सिखाओ।

शियाओहुआन001आश्चर्यजनक लेखक

Jठीक है, कुछ और सवाल हैं, कृपया, एक और पोस्टः https://www.botvs.com/bbs-topic/677

शून्ययदि आपके पास इस रणनीति के बारे में सीखने के लिए कुछ है या कोई प्रश्न है, तो कृपया इसे मंच पर पोस्ट करें, समर्थन के लिए धन्यवाद!

शून्यसुझाव के लिए धन्यवाद, मैंने एक पैरामीटर जोड़ा है, ऑर्डर प्रतीक्षा समय को संतुलित करना, यदि आप समवर्ती प्रसंस्करण चाहते हैं, तो आप प्रत्येक ऑर्डर की आईडी को ऑर्डर के समय के साथ रिकॉर्ड कर सकते हैं, और फिर चयनित रूप से रद्द कर सकते हैं, जिससे देरी कम हो सकती है, हालांकि, तार्किक रूप से, पहले संतुलन को फिर से खोला जाना चाहिए, क्योंकि सभी एक्सचेंजों ने ऑर्डर प्राप्त करने के लिए समय विशेषता का समर्थन नहीं किया है, इसलिए प्लेटफॉर्म ने ऑर्डर में यह विशेषता नहीं जोड़ी है, अपने स्वयं के आंकड़ों की आवश्यकता है।

शियाओहुआन001मुझे लगता है कि यह एक अजीब रणनीति है, मुझे यह पसंद है।

शून्यमैंने इसे कभी नहीं किया है, और मुझे यह अपने आप से जांचने की जरूरत है।

ओरियन1708कठिन Z बड़े ट्रांसपोर्ट - कृपया, क्या नीति पैरामीटर के डिफ़ॉल्ट मान में बदलाव से नीति पर बहुत प्रभाव पड़ता है?

शून्यहाहा, धन्यवाद, इसे जोड़ा गया है।

शून्यजावास्क्रिप्ट

शून्यव्यापार की आवृत्ति

छोटे सपनेइस लेख का मूल लेखक भी उन दिनों सार्वजनिक किया गया था जब वह शुल्क वसूल रहा था।

शियाओहुआन001एक ट्रेंडिंग रणनीतिकार को झटके की लागत से क्यों डरना चाहिए?

2019 FMZ - सभी अधिकार सुरक्षित