डेरिबिट विकल्पों की गतिशील डेल्टा हेजिंग

डेरिबिट विकल्पों की गतिशील डेल्टा हेजिंग

इस बार एफएमजेड क्वांट की रणनीति यह है किडेरिबिट विकल्पों की गतिशील डेल्टा हेजिंग, संक्षिप्त रूप से डीडीएच।

विकल्प व्यापार के अध्ययन के लिए, हमें आमतौर पर कई पहलुओं में अवधारणाओं में महारत हासिल करने की आवश्यकता होती हैः

• विकल्प मूल्य निर्धारण मॉडल; बी-एस मॉडल; विकल्प मूल्य अंतर्निहित मूल्य, स्ट्राइक मूल्य, अवधि समाप्त होने तक के दिन, अर्थात्) अस्थिरता और गैर-जोखिम ब्याज दर के आधार पर निर्धारित किया जाता है।

• विकल्प जोखिम के लिए जोखिमः

  • डेल्टा ऑप्शन दिशात्मक जोखिम. यदि डेल्टा मान +0.5 है, तो अंतर्निहित मूल्य के बढ़ने और गिरने पर ऑप्शन का लाभ और हानि प्रदर्शन 0.50 स्पॉट माना जा सकता है.
  • गामा दिशात्मक जोखिम की त्वरित गति। उदाहरण के लिए, एक कॉल विकल्प। गामा के कारण, जहां से अंतर्निहित मूल्य स्ट्राइक मूल्य पर है, डेल्टा मूल्य की बढ़ती प्रक्रिया में +0.50 से +1.00 के करीब हो जाएगा।
  • थेटा समय क्षय. जब आप विकल्प खरीदते हैं, यदि अंतर्निहित मूल्य निरंतर रहता है, तो प्रत्येक गुजरते दिन के साथ, आप थेटा मूल्य द्वारा प्रदर्शित शुल्क का भुगतान करेंगे (डेरबिट की कीमत अमरीकी डालर में है). जब आप विकल्प बेचते हैं, और अंतर्निहित मूल्य स्थिर रहता है, प्रत्येक गुजरते दिन के साथ, आप एक शुल्क प्राप्त होगा Theta मूल्य द्वारा प्रदर्शित.
  • वेगा अस्थिरता जोखिम। जब आप विकल्प खरीदते हैं, तो वेगा को एक सकारात्मक मूल्य के रूप में व्यक्त किया जाता है, अर्थात् लंबी निहित अस्थिरता। जब निहित अस्थिरता बढ़ जाती है, तो आप वेगा के संपर्क में आकर लाभ कमा सकते हैं। विपरीत स्थिति भी ऐसी ही है। जब आप विकल्प बेचते हैं, तो निहित अस्थिरता कम हो जाती है, और आपके पास लाभ होगा।

डीडीएच रणनीति स्पष्टीकरणः

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

  उदाहरण के लिए: जब हम एक कॉल ऑप्शन खरीदते हैं, तो हमारे पास एक तेजी की स्थिति होती है। इस समय, समग्र डेल्टा तटस्थता (0 या 0 के करीब) प्राप्त करने के लिए विकल्प डेल्टा को हेज करने के लिए वायदा को छोटा करना आवश्यक है। आइए उन कारकों को नजरअंदाज करें, जैसे कि समाप्ति के दिनों और विकल्प अनुबंध की निहित अस्थिरता। परिदृश्य 1: जब अंतर्निहित मूल्य बढ़ता है, तो विकल्प डेल्टा बढ़ता है, और समग्र डेल्टा एक सकारात्मक संख्या में चला जाता है। फ्यूचर्स को फिर से हेज करने की आवश्यकता होती है, और कुछ शॉर्ट पोजीशन को शॉर्ट फ्यूचर्स में जारी रखने के लिए खोला जाता है, ताकि समग्र डेल्टा फिर से संतुलित हो जाए। (पुनः संतुलन से पहले, विकल्प डेल्टा बड़ा होता है, वायदा डेल्टा अपेक्षाकृत छोटा होता है, कॉल विकल्प का सीमांत लाभ शॉर्ट कॉन्ट्रैक्ट के सीमांत नुकसान से अधिक होता है और पूरा पोर्टफोलियो लाभ कमाएगा) परिदृश्य 2: जब अंतर्निहित मूल्य गिरता है, तो विकल्प डेल्टा कम हो जाता है, और समग्र डेल्टा नकारात्मक संख्या में चला जाता है, और कुछ लघु वायदा पदों को फिर से समग्र डेल्टा संतुलन बनाने के लिए बंद कर दिया जाता है। (पुनः संतुलन से पहले, विकल्प डेल्टा छोटा होता है, वायदा डेल्टा अपेक्षाकृत बड़ा होता है, कॉल विकल्प का सीमांत हानि लघु अनुबंध के सीमांत लाभ से कम होती है, और पूरे पोर्टफोलियो में अभी भी लाभ होगा) ।

  इसलिए, आदर्श रूप से, अंतर्निहित की वृद्धि और गिरावट दोनों लाभ लाती है, जब तक कि बाजार में उतार-चढ़ाव होता है।

  हालांकि, अन्य कारकों पर विचार करने की आवश्यकता हैः समय मूल्य, व्यापार लागत और अन्य।

  तो, मैंने जिहू के एक मास्टर के स्पष्टीकरण का हवाला दिया:

  गामा स्केलिंग का फोकस डेल्टा नहीं है, गतिशील डेल्टा हेजिंग केवल प्रक्रिया में अंतर्निहित मूल्य जोखिम से बचने का एक तरीका है। गामा स्केलिंग अल्फा पर केंद्रित है। अल्फा स्टॉक चयन का अल्फा नहीं है। यहां, अल्फा = गामा / थेटा, यानी यूनिट थेटा के समय क्षय से कितना गामा का आदान-प्रदान किया जाता है। यही बात है। फ्लोटिंग मुनाफे के साथ बढ़ोतरी और गिरावट दोनों का संयोजन बनाना संभव है, निश्चित रूप से समय क्षय के साथ, और समस्या लागत प्रदर्शन का अनुपात है। लेखक: शु झे; मूल लेख का लिंकःhttps://www.zhihu.com/question/51630805/answer/128096385

डीडीएच रणनीति डिजाइन

• एकत्रित बाजार इंटरफेस का समावेशन, संरचना डिजाइन;
• रणनीति यूआई डिजाइन;
• रणनीतिक बातचीत डिजाइन;
• स्वचालित हेजिंग फ़ंक्शन डिजाइन।

स्रोत कोडः

// constructor 
function createManager(e, subscribeList, msg) {
	var self = {}
    self.supportList = ["Futures_Binance", "Huobi", "Futures_Deribit"]  // from the supported platforms

    // object attributes
    self.e = e
    self.msg = msg
    self.name = e.GetName()
    self.type = self.name.includes("Futures_") ? "Futures" : "Spot"
    self.label = e.GetLabel()
    self.quoteCurrency = ""  
    self.subscribeList = subscribeList   // subscribeList : [strSymbol1, strSymbol2, ...]
    self.tickers = []                    // all market data obtained by the interface; define the data format as: {bid1: 123, ask1: 123, symbol: "xxx"}}
    self.subscribeTickers = []           // the market data in need; define the data format as: {bid1: 123, ask1: 123, symbol: "xxx"}}
    self.accData = null 
    self.pos = null 

    // initialization function 
    self.init = function() { 
    	// judge whether the platform is supported 
        if (!_.contains(self.supportList, self.name)) {        	
        	throw "not support"
        }
    }

    self.setBase = function(base) {
        // switch base address, used to switch to the simulated bot 
        self.e.SetBase(base)
        Log(self.name, self.label, "switch to simulated bot:", base)
    }

    // judge the data precision 
    self.judgePrecision = function (p) {
        var arr = p.toString().split(".")
        if (arr.length != 2) {
            if (arr.length == 1) {
                return 0
            }
            throw "judgePrecision error, p:" + String(p)
        }
        
        return arr[1].length
    }

    // update assets 
    self.updateAcc = function(callBackFuncGetAcc) {
        var ret = callBackFuncGetAcc(self)
        if (!ret) {
        	return false 
        }
        self.accData = ret 
        return true 
    }

    // update positions 
    self.updatePos = function(httpMethod, url, params) {
        var pos = self.e.IO("api", httpMethod, url, params)
        var ret = []
        if (!pos) {
            return false 
        } else {
            // arrange data 
            // {"jsonrpc":"2.0","result":[],"usIn":1616484238870404,"usOut":1616484238870970,"usDiff":566,"testnet":true}
            try {
                _.each(pos.result, function(ele) {
                    ret.push(ele)
                })
            } catch(err) {
                Log("error:", err)
                return false 
            }
            self.pos = ret
        }
        return true 
    }

    // update the market data 
    self.updateTicker = function(url, callBackFuncGetArr, callBackFuncGetTicker) {
    	var tickers = []
    	var subscribeTickers = []
    	var ret = self.httpQuery(url)
    	if (!ret) {
    		return false 
    	}
    	// Log("test", ret)// test
    	try {
            _.each(callBackFuncGetArr(ret), function(ele) {
            	var ticker = callBackFuncGetTicker(ele)
            	tickers.push(ticker)
                if (self.subscribeList.length == 0) {
                    subscribeTickers.push(ticker)
                } else {
                	for (var i = 0 ; i < self.subscribeList.length ; i++) {                        
                    	if (self.subscribeList[i] == ticker.symbol) {
                    		subscribeTickers.push(ticker)
                    	}
                	}
                }
            })
        } catch(err) {
        	Log("error:", err)
        	return false 
        }

        self.tickers = tickers
        self.subscribeTickers = subscribeTickers
        return true 
    }

    self.getTicker = function(symbol) {
    	var ret = null 
    	_.each(self.subscribeTickers, function(ticker) {
    		if (ticker.symbol == symbol) {
    			ret = ticker
    		}
    	})
    	return ret 
    }

    self.httpQuery = function(url) {
    	var ret = null
        try {
            var retHttpQuery = HttpQuery(url)
            ret = JSON.parse(retHttpQuery)
        } catch (err) {
            // Log("error:", err)
            ret = null
        }
        return ret 
    }

    self.returnTickersTbl = function() {
        var tickersTbl = {
        	type : "table", 
        	title : "tickers",
        	cols : ["symbol", "ask1", "bid1"], 
        	rows : []
        }
        _.each(self.subscribeTickers, function(ticker) {        
        	tickersTbl.rows.push([ticker.symbol, ticker.ask1, ticker.bid1])
        })
        return tickersTbl
    }
    
    // return the positon table 
    self.returnPosTbl = function() {
        var posTbl = {
            type : "table", 
            title : "pos|" + self.msg,
            cols : ["instrument_name", "mark_price", "direction", "size", "delta", "index_price", "average_price", "settlement_price", "average_price_usd", "total_profit_loss"], 
            rows : []
        }
        /* the position data format returned by the interface 
        {
            "mark_price":0.1401105,"maintenance_margin":0,"instrument_name":"BTC-25JUN21-28000-P","direction":"buy",
            "vega":5.66031,"total_profit_loss":0.01226105,"size":0.1,"realized_profit_loss":0,"delta":-0.01166,"kind":"option",
            "initial_margin":0,"index_price":54151.77,"floating_profit_loss_usd":664,"floating_profit_loss":0.000035976,
            "average_price_usd":947.22,"average_price":0.0175,"theta":-7.39514,"settlement_price":0.13975074,"open_orders_margin":0,"gamma":0
        }
        */
        _.each(self.pos, function(ele) {
        	if(ele.direction != "zero") {
                posTbl.rows.push([ele.instrument_name, ele.mark_price, ele.direction, ele.size, ele.delta, ele.index_price, ele.average_price, ele.settlement_price, ele.average_price_usd, ele.total_profit_loss])
            }
        })
        return posTbl
    }

    self.returnOptionTickersTbls = function() {
        var arr = []
        var arrDeliveryDate = []
        _.each(self.subscribeTickers, function(ticker) {
            if (self.name == "Futures_Deribit") {
                var arrInstrument_name = ticker.symbol.split("-")
                var currency = arrInstrument_name[0]
                var deliveryDate = arrInstrument_name[1]
                var deliveryPrice = arrInstrument_name[2]
                var optionType = arrInstrument_name[3]

                if (!_.contains(arrDeliveryDate, deliveryDate)) {
                    arr.push({
                        type : "table", 
                        title : arrInstrument_name[1],
                        cols : ["PUT symbol", "ask1", "bid1", "mark_price", "underlying_price", "CALL symbol", "ask1", "bid1", "mark_price", "underlying_price"], 
                        rows : []
                    })
                    arrDeliveryDate.push(arrInstrument_name[1])
                }
                // traverse arr
                _.each(arr, function(tbl) {
                    if (tbl.title == deliveryDate) {
                        if (tbl.rows.length == 0 && optionType == "P") {
                            tbl.rows.push([ticker.symbol, ticker.ask1, ticker.bid1, ticker.mark_price, ticker.underlying_price, "", "", "", "", ""])
                            return 
                        } else if (tbl.rows.length == 0 && optionType == "C") {
                            tbl.rows.push(["", "", "", "", "", ticker.symbol, ticker.ask1, ticker.bid1, ticker.mark_price, ticker.underlying_price])
                            return 
                        }                        
                        for (var i = 0 ; i < tbl.rows.length ; i++) {
                            if (tbl.rows[i][0] == "" && optionType == "P") {
                                tbl.rows[i][0] = ticker.symbol
                                tbl.rows[i][1] = ticker.ask1
                                tbl.rows[i][2] = ticker.bid1
                                tbl.rows[i][3] = ticker.mark_price
                                tbl.rows[i][4] = ticker.underlying_price
                                return 
                            } else if(tbl.rows[i][5] == "" && optionType == "C") {
                                tbl.rows[i][5] = ticker.symbol
                                tbl.rows[i][6] = ticker.ask1
                                tbl.rows[i][7] = ticker.bid1
                                tbl.rows[i][8] = ticker.mark_price
                                tbl.rows[i][9] = ticker.underlying_price
                                return 
                            }
                        }
                        if (optionType == "P") {
                            tbl.rows.push([ticker.symbol, ticker.ask1, ticker.bid1, ticker.mark_price, ticker.underlying_price, "", "", "", "", ""])
                        } else if(optionType == "C") {
                            tbl.rows.push(["", "", "", "", "", ticker.symbol, ticker.ask1, ticker.bid1, ticker.mark_price, ticker.underlying_price])
                        }
                    }
                })
            }
        })
        return arr 
    }

    // initialize 
    self.init()
	return self 
}


function main() {
    // initialize, and vacuum logs
    if(isResetLog) {
    	LogReset(1)
    }

    var m1 = createManager(exchanges[0], [], "option")
    var m2 = createManager(exchanges[1], ["BTC-PERPETUAL"], "future")

    // switch to the simulated bot 
    var base = "https://www.deribit.com"
    if (isTestNet) {    
        m1.setBase(testNetBase)    
        m2.setBase(testNetBase)
        base = testNetBase
    }

    while(true) {
        // options 
        var ticker1GetSucc = m1.updateTicker(base + "/api/v2/public/get_book_summary_by_currency?currency=BTC&kind=option", 
            function(data) {return data.result}, 
            function(ele) {return {bid1: ele.bid_price, ask1: ele.ask_price, symbol: ele.instrument_name, underlying_price: ele.underlying_price, mark_price: ele.mark_price}}) 
        
        // perpetual futures 
        var ticker2GetSucc = m2.updateTicker(base + "/api/v2/public/get_book_summary_by_currency?currency=BTC&kind=future", 
            function(data) {return data.result}, 
            function(ele) {return {bid1: ele.bid_price, ask1: ele.ask_price, symbol: ele.instrument_name}})
        if (!ticker1GetSucc || !ticker2GetSucc) {
            Sleep(5000)
            continue
        }

        // update positions 
        var pos1GetSucc = m1.updatePos("GET", "/api/v2/private/get_positions", "currency=BTC&kind=option")
        var pos2GetSucc = m2.updatePos("GET", "/api/v2/private/get_positions", "currency=BTC&kind=future")

        if (!pos1GetSucc || !pos2GetSucc) {
            Sleep(5000)
            continue
        }

        // interaction 
        var cmd = GetCommand()
        if(cmd) {
            // process interaction 
            Log("interactive command:", cmd)
            var arr = cmd.split(":")
            // cmdClearLog 
            if(arr[0] == "setContractType") {
                // parseFloat(arr[1])
                m1.e.SetContractType(arr[1])
                Log("exchanges[0] sets contract:", arr[1])
            } else if (arr[0] == "buyOption") {
                var actionData = arr[1].split(",")
                var price = parseFloat(actionData[0])
                var amount = parseFloat(actionData[1])
                m1.e.SetDirection("buy")
                m1.e.Buy(price, amount)
                Log("executed price:", price, "executed amount:", amount, "executed direction:", arr[0])
            } else if (arr[0] == "sellOption") {
                var actionData = arr[1].split(",")
                var price = parseFloat(actionData[0])
                var amount = parseFloat(actionData[1])
                m1.e.SetDirection("sell")
                m1.e.Sell(price, amount)                
                Log("executed price:", price, "executed amount:", amount, "executed direction:", arr[0])
            } else if (arr[0] == "setHedgeDeltaStep") {
                hedgeDeltaStep = parseFloat(arr[1])
                Log("set hedgeDeltaStep：", hedgeDeltaStep)
            } 
        }
        
        // obtain futures contract price 
        var perpetualTicker = m2.getTicker("BTC-PERPETUAL")
        var hedgeMsg = " PERPETUAL:" + JSON.stringify(perpetualTicker)

        // obtain the total delta value from the account data        
        var acc1GetSucc = m1.updateAcc(function(self) {
        	self.e.SetCurrency("BTC_USD")        
        	return self.e.GetAccount()
        })
        if (!acc1GetSucc) {
        	Sleep(5000)
        	continue
        }
        var sumDelta = m1.accData.Info.result.delta_total

        if (Math.abs(sumDelta) > hedgeDeltaStep && perpetualTicker) {
            if (sumDelta < 0) {
                // delta value is more than 0, hedge futures and make short                   
                var amount = _N(Math.abs(sumDelta) * perpetualTicker.ask1, -1)                
                if (amount > 10) {
                    Log("exceeding the hedging threshold value, the current total delta:", sumDelta, "call futures")
                    m2.e.SetContractType("BTC-PERPETUAL")                    
                    m2.e.SetDirection("buy")
                    m2.e.Buy(-1, amount)
                } else {
                	hedgeMsg += ", hedging order amount is less than 10"
                }
            } else {
                // delta value is less than 0, hedge futures and make long
                var amount = _N(Math.abs(sumDelta) * perpetualTicker.bid1, -1)
                if (amount > 10) {
                    Log("exceeding the hedging threshold value, the current total delta:", sumDelta, "put futures")
                    m2.e.SetContractType("BTC-PERPETUAL")
                    m2.e.SetDirection("sell")
                    m2.e.Sell(-1, amount)
                } else {
                	hedgeMsg += ", hedging order amount is less than 0"
                }
            }
        }

        LogStatus(_D(), "sumDelta:", sumDelta, hedgeMsg, 
        	"\n`" + JSON.stringify([m1.returnPosTbl(), m2.returnPosTbl()]) + "`", "\n`" + JSON.stringify(m2.returnTickersTbl()) + "`", "\n`" + JSON.stringify(m1.returnOptionTickersTbls()) + "`")
        Sleep(10000)
    }
}

रणनीतिक मापदंडः

रणनीतिक पता:https://www.fmz.com/strategy/265090

रणनीतिक अभियान:

रणनीति एक ट्यूटोरियल है, मुख्य रूप से अध्ययन के लिए प्रयोग किया जाता है, इसलिए कृपया एक बॉट में उपयोग करने के लिए सावधान रहें।