হেজিং স্ট্র্যাটেজি ডিজাইন রিসার্চ & পেন্ডিং স্পট এবং ফিউচার অর্ডারের উদাহরণ

হেজিং স্ট্র্যাটেজি ডিজাইন রিসার্চ & পেন্ডিং স্পট এবং ফিউচার অর্ডারের উদাহরণ

দীর্ঘদিন ধরে, ফিউচার এবং স্পট হেজিং সাধারণত মূল্যের স্প্রেড সনাক্ত করতে এবং মূল্যের স্প্রেড পূরণ হলে হেজিংয়ের অর্ডার গ্রহণের জন্য ডিজাইন করা হয়। একটি অপেক্ষমান অর্ডার হেজিং ডিজাইন করা যেতে পারে? উত্তর হ্যাঁ। আজ, আমি পাঠকদের একটি নকশা ধারণা এবং কোড প্রোটোটাইপ আনব।

অপেক্ষমান অর্ডার হেজিংয়ের চিন্তাভাবনা

একই বা একই ধরণের বিষয়বস্তুর বিভিন্ন বাজারে, যখন দুটি বাজারের মধ্যে ক্রয় এবং বিক্রয় অর্ডারের মধ্যে একটি বড় পার্থক্য থাকে তখন হেজিংয়ের সুযোগ দেখা দেয়। সাধারণভাবে, আমরা দেরী অর্ডারগুলি গ্রহণ করব যা দামের স্প্রেড পূরণ করে এবং তারপরে হেজিং পজিশন ধরে রাখবে। অতএব, হেজিংয়ের দুটি উদ্দেশ্য রয়েছে। প্রথমটি হ'ল অর্ডার পজিশনের বিরুদ্ধে হেজিং করা এবং দ্বিতীয়টি হ'ল নিশ্চিত করা যে ক্রয় এবং বিক্রয়ের মধ্যে দামের স্প্রেড আমাদের প্রত্যাশা সর্বাধিক পূরণ করে। এই ক্ষেত্রে দেরী অর্ডার ট্রেডিংয়ের সুবিধা হ'ল ফি কম। অসুবিধাটি হ'ল অর্ডারগুলি কার্যকর করা সহজ নয় এবং একক অবস্থান অর্ডারগুলি কার্যকর করা সহজ।

তারপর, আমরা ট্রেডিং ধারণা ডিজাইন করি যে মার্কেট এ অর্ডার বইয়ের ক্রয় অর্ডারে কেনা অর্ডারটি অপেক্ষা করছে, এবং মার্কেট বি অর্ডার বইয়ের বিক্রয় অর্ডারে বিক্রি অর্ডারটি অপেক্ষা করছে, এবং তারপরে আমাদের অ্যাকাউন্টের অপেক্ষমান অর্ডারগুলি সনাক্ত করে, এবং সনাক্ত হওয়া অপেক্ষমান অর্ডার কার্যকরকরণের জন্য পরবর্তী ধাপে এগিয়ে চলেছি। উদাহরণস্বরূপ, যখন একটি অপেক্ষমান অর্ডার পরিবর্তন সনাক্ত করা হয়, তখন অবিলম্বে ফিউচার এবং স্পট বর্তমান হেজ অবস্থানগুলি ভারসাম্য করে। ফিউচার এবং স্পট অবস্থানের ওভারফ্লো জন্য, খোলা কিনুন বা বন্ধ করুন। হেজিং অবস্থানের বৃদ্ধি অনুযায়ী, বাজারে পরবর্তী অপেক্ষমান অর্ডার এবং বাজারের প্রথম স্তরের মধ্যে দূরত্ব সামঞ্জস্য করুন, ধীরে ধীরে বৃহত্তম স্প্রেড পেতে হেজ করুন।

হেজিং লজিক

কোড ডিজাইন

মন্তব্যগুলি সরাসরি কোডে লেখা আছে। এই উদাহরণটি শুধুমাত্র নকশা রেফারেন্সের জন্য ব্যবহৃত হয় এবং শুধুমাত্র OKEX V5 সিমুলেটেড বটে সংক্ষিপ্তভাবে পরীক্ষা করা হয়েছে। উদাহরণটি একটি সম্পূর্ণ কৌশল নয়, তাই দয়া করে এটি শুধুমাত্র রেফারেন্সের জন্য ব্যবহার করুন।

// temporary parameters 
var fuContractType = "quarter"    // futures contract
var fuSymbol = "ETH_USDT"         // futures trading pair 
var spSymbol = "ETH_USDT"         // spot trading pair 
var minAmount = 0.1               // trading amount of each time, minimum trading amount, currency amount 
var step = 40                     // step length of spread 
var buff = 5                      // buffer spread 
var balanceType = "open"          // when the single-position execution is balanced, open buy or close  

var depthManager = function(fuEx, spEx, fuCt, fuSymbol, spSymbol) {
    var self = {}
    self.fuExDepth = null
    self.spExDepth = null 
    self.plusPrice = null
    self.minusPrice = null 

    self.update = function() {        
        spEx.SetCurrency(spSymbol)
        if (!IsVirtual()) {
            fuEx.SetCurrency(fuSymbol)
        }        
        fuEx.SetContractType(fuCt)

        var fuRoutine = fuEx.Go("GetDepth")
        var spRoutine = spEx.Go("GetDepth")
        var fuDepth = fuRoutine.wait()
        var spDepth = spRoutine.wait()
        if (!fuDepth || !spDepth) {
            return false 
        }
        self.fuExDepth = fuDepth
        self.spExDepth = spDepth

        if (fuDepth.Bids.length == 0 || fuDepth.Asks.length == 0 || spDepth.Bids.length == 0 || spDepth.Asks.length == 0) {
            return false 
        }
        self.plusPrice = fuDepth.Bids[0].Price - spDepth.Asks[0].Price   // futures Bid - spot Ask
        self.minusPrice = fuDepth.Asks[0].Price - spDepth.Bids[0].Price  // futures Ask - spot Bid
        return true 
    }

    self.getData = function() {       
        return {
            "fuExDepth" : self.fuExDepth,
            "spExDepth" : self.spExDepth,
            "plusPrice" : self.plusPrice,
            "minusPrice" : self.minusPrice
        }
    }
    return self 
}

var positionManager = function(fuEx, spEx, fuCt, fuSymbol, spSymbol, step, buffDiff, balanceType, initSpAcc) {
    var self = {}
    self.balanceType = balanceType
    self.depth = null 
    self.level = 1
    self.lastUpdateTs = 0
    self.fuPos = []
    self.spPos = []
    self.initSpAcc = initSpAcc
    self.spAcc = null
    self.hedgePos = null
    self.hedgePosPrice = 0
    self.minAmount = 0.01
    self.offset = ["", 0]

    self.update = function() {
        spEx.SetCurrency(spSymbol)
        if (!IsVirtual()) {
            fuEx.SetCurrency(fuSymbol)
        }        
        fuEx.SetContractType(fuCt)

        self.offset = ["", 0]
        var fuRoutine = fuEx.Go("GetPosition")
        var spRoutine = spEx.Go("GetAccount")
        var fuPos = fuRoutine.wait()
        var spAcc = spRoutine.wait()
        if (!fuPos || !spAcc) {
            return false 
        }
        self.fuPos = fuPos
        self.spAcc = spAcc
        if (!self.initSpAcc) {
            return false 
        }
        self.spPos = (spAcc.Stocks + spAcc.FrozenStocks) - (self.initSpAcc.Stocks + self.initSpAcc.FrozenStocks)   // the current one minus the initial one; if the result is a positive number, make long
        // detect fuPos
        if (fuPos.length > 1) {
            return false 
        }
        fuPosAmount = fuPos.length == 0 ? 0 : (fuPos[0].Type == PD_LONG ? fuPos[0].Amount : -fuPos[0].Amount)
        if ((fuPosAmount > 0 && self.spPos > 0) || (fuPosAmount < 0 && self.spPos < 0)) {
            return false 
        }

        fuPosAmount = self.piece2Coin(fuPosAmount)

        self.hedgePos = (fuPosAmount == 0 || self.spPos == 0) ? 0 : (fuPosAmount < 0 && self.spPos > 0 ? Math.min(Math.abs(fuPosAmount), Math.abs(self.spPos)) : -Math.min(Math.abs(fuPosAmount), Math.abs(self.spPos)))
        var diffBalance = (spAcc.Balance + spAcc.FrozenBalance) - (self.initSpAcc.Balance + self.initSpAcc.FrozenBalance)
        if (self.hedgePos == 0) {
            self.hedgePosPrice = 0    
        } else {
            self.hedgePosPrice = fuPos[0].Price - (Math.abs(diffBalance) / Math.abs(self.spPos))
        }
        self.offset[1] = fuPosAmount + self.spPos  // positive number represents long position overflow; negative number represents short position overflow  
        if (fuPosAmount > 0 && self.spPos < 0) {   // reverse arbitrage 
            self.offset[0] = "minus"
        } else if (fuPosAmount < 0 && self.spPos > 0) {
            self.offset[0] = "plus"
        } else if (fuPosAmount == 0 && self.spPos < 0) {
            self.offset[0] = "minus"
        } else if (fuPosAmount > 0 && self.spPos == 0) {
            self.offset[0] = "minus"
        } else if (fuPosAmount == 0 && self.spPos > 0) {
            self.offset[0] = "plus"
        } else if (fuPosAmount < 0 && self.spPos == 0) {
            self.offset[0] = "plus"
        }
        return true 
    }

    self.getData = function() {
        return {
            "fuPos" : self.fuPos,
            "spPos" : self.spPos,
            "initSpAcc" : self.initSpAcc,
            "spAcc" : self.spAcc,
            "hedgePos" : self.hedgePos,
            "hedgePosPrice" : self.hedgePosPrice,
        }
    }

    self.keepBalance = function(depth) {
        var fuDepth = depth.fuExDepth
        var spDepth = depth.spExDepth
        if (self.offset[0] == "plus") {
            if (self.offset[1] >= self.minAmount) {
                if (self.balanceType == "close") {
                    // the spot long position amount is large; close spot long positions 
                    spEx.Sell(-1, self.offset[1])
                } else if (self.balanceType == "open") {
                    // the spot long position amount is large; open futures short positions 
                    fuEx.SetDirection("sell")
                    fuEx.Sell(-1, self.coin2Piece(Math.abs(self.offset[1])))
                }
            } else if (self.offset[1] <= -self.minAmount) {
                if (self.balanceType == "close") {
                    // the futures short position amount is large; close futures short positions  
                    fuEx.SetDirection("closesell")
                    fuEx.Buy(-1, self.coin2Piece(Math.abs(self.offset[1])))
                } else if (self.balanceType == "open") {
                    // the futures short position amount is large; open spot long positions  
                    spEx.Buy(-1, spDepth.Asks[0].Price * Math.abs(self.offset[1]))
                }
            }
            return false 
        } else if (self.offset[0] == "minus") {
            if (self.offset[1] >= self.minAmount) {
                if (self.balanceType == "close") {
                    // the futures long position amount is large; close futures long positions 
                    fuEx.SetDirection("closebuy")
                    fuEx.Sell(-1, self.coin2Piece(self.offset[1]))
                } else if (self.balanceType == "open") {
                    // the futures long position amount is large; open spot short positions 
                    spEx.Sell(-1, self.offset[1])
                }
            } else if (self.offset[1] <= -self.minAmount) {
                if (self.balanceType == "close") {
                    // the spot short position amount is large; close spot short positions 
                    spEx.Buy(-1, spDepth.Asks[0].Price * Math.abs(self.offset[1]))
                } else if (self.balanceType == "open") {
                    // the spot short position amount is large; open futures long positions 
                    fuEx.SetDirection("buy")
                    fuEx.Buy(-1, self.coin2Piece(Math.abs(self.offset[1])))
                }
            }
            return false 
        }
        return true 
    }

    self.process = function(depthManager) {
        var ts = new Date().getTime()
        var depth = depthManager.getData()
        var orders = self.getOrders()
        if (!orders) {
            return 
        }
        self.depth = depth
        var fuOrders = orders[0]
        var spOrders = orders[1]
        
        if (fuOrders.length == 0 && spOrders.length == 0) {
            // reset level
            if (self.hedgePos == 0) {
                self.level = 1
            } else {
                self.level = Math.max(1, _N(self.hedgePos / self.minAmount, 0))
            }

            // limit the maximum position amount 
            if (Math.abs(self.hedgePos) > 1) {
                return 
            }

            // pend orders 
            var fuDepth = depth.fuExDepth
            var spDepth = depth.spExDepth
            self.update()

            if (self.hedgePos >= 0 && fuDepth.Bids[0].Price - spDepth.Asks[0].Price > 0) {        // positive arbitrage 
                var distance = (step * self.level - (fuDepth.Asks[0].Price - spDepth.Bids[0].Price)) / 2          
                fuEx.SetDirection("sell")
                fuEx.Sell(fuDepth.Asks[0].Price + distance, self.coin2Piece(self.minAmount), fuDepth.Asks[0].Price, "pending order spread:", fuDepth.Asks[0].Price + distance - (spDepth.Bids[0].Price - distance))
                spEx.Buy(spDepth.Bids[0].Price - distance, self.minAmount, spDepth.Bids[0].Price)
            } else if (self.hedgePos <= 0 && spDepth.Bids[0].Price - fuDepth.Asks[0].Price > 0) { // reverse arbitrage
                var distance = (step * self.level - (spDepth.Asks[0].Price - fuDepth.Bids[0].Price)) / 2          
                fuEx.SetDirection("buy")
                fuEx.Buy(fuDepth.Bids[0].Price - distance, self.coin2Piece(self.minAmount), fuDepth.Bids[0].Price, "pending order spread:", spDepth.Asks[0].Price + distance - (fuDepth.Bids[0].Price - distance))
                spEx.Sell(spDepth.Asks[0].Price + distance, self.minAmount, spDepth.Asks[0].Price)
            }
        } else if (fuOrders.length == 1 && spOrders.length == 1) {
            var fuDepth = depth.fuExDepth
            var spDepth = depth.spExDepth            
            // judge location
            var isCancelAll = false 
            if (self.hedgePos >= 0 && fuDepth.Bids[0].Price - spDepth.Asks[0].Price > 0) {        // positive arbitrage
                var distance = (step * self.level - (fuDepth.Asks[0].Price - spDepth.Bids[0].Price)) / 2
                if (Math.abs(fuOrders[0].Price - (fuDepth.Asks[0].Price + distance)) > buffDiff || Math.abs(spOrders[0].Price - (spDepth.Bids[0].Price - distance)) > buffDiff) {
                    isCancelAll = true 
                }
            } else if (self.hedgePos <= 0 && spDepth.Bids[0].Price - fuDepth.Asks[0].Price > 0) { // reverse arbitrage
                var distance = (step * self.level - (spDepth.Asks[0].Price - fuDepth.Bids[0].Price)) / 2
                if (Math.abs(spOrders[0].Price - (spDepth.Asks[0].Price + distance)) > buffDiff || Math.abs(fuOrders[0].Price - (fuDepth.Bids[0].Price - distance)) > buffDiff) {
                    isCancelAll = true 
                }
            } else {
                isCancelAll = true 
            }
            if (isCancelAll) {
                self.cancelAll(fuEx, fuOrders)
                self.cancelAll(spEx, spOrders)
                self.lastUpdateTs = 0
            }
        } else {            
            self.cancelAll(fuEx, fuOrders)
            self.cancelAll(spEx, spOrders)       
            self.lastUpdateTs = 0
        }

        if (ts - self.lastUpdateTs > 1000 * 60 * 2) {
            self.update()
            self.keepBalance(depth)
            self.update()
            self.lastUpdateTs = ts 
        }
        LogStatus(_D())   // the status bar can be designed to export the data and the information that need to be observed 
    }

    self.getOrders = function() {
        spEx.SetCurrency(spSymbol)
        if (!IsVirtual()) {
            fuEx.SetCurrency(fuSymbol)
        }        
        fuEx.SetContractType(fuCt)

        var fuRoutine = fuEx.Go("GetOrders")
        var spRoutine = spEx.Go("GetOrders")
        var fuOrders = fuRoutine.wait()
        var spOrders = spRoutine.wait()
        if (!fuOrders || !spOrders) {
            return false 
        }
        return [fuOrders, spOrders]
    }
    
    // convert currency into contract amount
    self.coin2Piece = function(amount) {
        if (IsVirtual()) {
            if (fuEx.GetName() == "Futures_Binance") {
                return amount
            } else if (fuEx.GetName() == "Futures_OKCoin") {
                var price = (self.depth.fuExDepth.Bids[0].Price + self.depth.fuExDepth.Asks[0].Price) / 2
                return _N(amount / (100 / price), 0)
            } else {
                throw "not support"
            }            
        }
        if (fuEx.GetName() == "Futures_OKCoin") {
            if (fuEx.GetQuoteCurrency() == "USDT") {
                return _N(amount * 10, 0)
            } else if (fuEx.GetQuoteCurrency() == "USD") {
                var price = (self.depth.fuExDepth.Bids[0].Price + self.depth.fuExDepth.Asks[0].Price) / 2
                return _N(amount / (100 / price), 0)
            } else {
                throw "not support"
            }
        } else {
            throw "not support"
        }
    }
    
    // convert contract amount to currency 
    self.piece2Coin = function(amount) {
        if (IsVirtual()) {
            if (fuEx.GetName() == "Futures_Binance") {
                return amount
            } else if (fuEx.GetName() == "Futures_OKCoin") {
                var price = (self.depth.fuExDepth.Bids[0].Price + self.depth.fuExDepth.Asks[0].Price) / 2
                return amount * 100 / price
            } else {
                throw "not support"
            }            
        }
        if (fuEx.GetName() == "Futures_OKCoin") {
            if (fuEx.GetQuoteCurrency() == "USDT") {
                return amount * 0.1
            } else if (fuEx.GetQuoteCurrency() == "USD") {
                var price = (self.depth.fuExDepth.Bids[0].Price + self.depth.fuExDepth.Asks[0].Price) / 2
                return amount * 100 / price
            } else {
                throw "not support"
            }
        } else {
            throw "not support"
        }
    }

    self.cancelAll = function(e, orders) {
        var isFirst = true 
        while (true) {
            Sleep(500)
            if (orders && isFirst) {
                isFirst = false 
            } else {
                orders = e.GetOrders()
            }
            if (!orders) {
                continue
            } else {
                for (var i = 0 ; i < orders.length ; i++) {
                    e.CancelOrder(orders[i].Id, orders[i])
                }
            }
            if (orders.length == 0) {
                break
            }
        }
    }

    self.CoverAll = function() {
        // close all 
        // the one-click function of closing positions can be realized here
    }

    self.setMinAmount = function(minAmount) {
        self.minAmount = minAmount
    }

    self.init = function() {
        while(!self.spAcc) {
            self.update()
            Sleep(1000)
        }
        if (!self.initSpAcc) {  
            var positionManager_initSpAcc = _G("positionManager_initSpAcc")
            if (!positionManager_initSpAcc) {
                self.initSpAcc = self.spAcc
                _G("positionManager_initSpAcc", self.initSpAcc)
            } else {
                self.initSpAcc = positionManager_initSpAcc
            }
        } else {
            _G("positionManager_initSpAcc", self.initSpAcc)
        }
        // print the initial information
        Log("self.initSpAcc:", self.initSpAcc.Balance, self.initSpAcc.FrozenBalance, self.initSpAcc.Stocks, self.initSpAcc.FrozenStocks)
    }
    self.init()
    return self
}

function main() {
    _G(null)       // vacuum the persistent data  
    LogReset(1)    // rest logs 

    // use the following code to switch to OKEX simulated bot
    // exchanges[0].IO("simulate", true)
    // exchanges[1].IO("simulate", true)

    var dm = depthManager(exchanges[0], exchanges[1], fuContractType, fuSymbol, spSymbol)
    var pm = positionManager(exchanges[0], exchanges[1], fuContractType, fuSymbol, spSymbol, step, buff, balanceType)
    pm.setMinAmount(minAmount)

    while (true) {
        if (!dm.update()) {
            Sleep(3000)
            continue
        }

        var cmd = GetCommand()
        if (cmd) {
            // handle interaction 
            Log("interactive command:", cmd)
            var arr = cmd.split(":") 
            if (arr[0] == "") {
                pm.CoverAll()
            }            
        }

        pm.process(dm)
        Sleep(5000)
    }
}

ব্যাকটেস্ট বিশ্লেষণ

এটি দেখা যায় যে অপেক্ষমান আদেশ এবং বাতিলকরণ খুব ঘন ঘন হয়। ব্যাকটেস্ট সিস্টেমের পরিসংখ্যান থেকে, ফিউচার প্ল্যাটফর্ম অ্যাকাউন্টটি 0.01666 ETH হারিয়েছে, এবং স্পট এক্সচেঞ্জটি 842.23758 ইউএসডিটি মুনাফা করেছে। ব্যাকটেস্টের শেষে 4252 ইউএসডিটি এর ইটিএইচ স্পট মূল্য অনুসারে, যথাঃ-0.01666 * 4252 = -70.83832000000001ফলাফল এবং স্পট মুনাফা মোটামুটি লাভজনক।

যাইহোক, এটি শুধুমাত্র একটি ব্যাকটেস্ট, এবং আরো বিস্তারিত সমস্যা একটি বাস্তব বট মধ্যে পরিচালিত হবে।