डेरिबिट विकल्प डेल्टा डायनेमिक हेजिंग रणनीति

एफएमजेड क्वांट द्वारा पेश की गई रणनीति डेरिबिट ऑप्शन डेल्टा डायनेमिक हेजिंग रणनीति या संक्षेप में डीडीएच (डायनेमिक डेल्टा हेजिंग) रणनीति है।

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

· विकल्प मूल्य निर्धारण मॉडल, बी-एस मॉडल, विकल्प की कीमतें [विषय मूल्य], [शक्ति-प्रयुक्त मूल्य], [अवधि समाप्त होने तक शेष समय], [अर्थात्] अस्थिरता] और [जोखिम मुक्त दर] के आधार पर निर्धारित की जाती हैं।

· विकल्पों का जोखिमः

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

डीडीएच रणनीति की व्याख्याः

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

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

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

अतः आदर्श स्थिति में जब तक बाजार में उतार-चढ़ाव रहता है, तब तक विषय वस्तु का बढ़ना-घटना लाभदायक होगा।

हालाँकि, विचार करने के लिए कुछ कारक भी हैंः समय मूल्य, लेनदेन लागत और अन्य कारक।

इसलिए जिहू पर हॉटशॉट का स्पष्टीकरण उद्धृत किया गया हैः

The focus of Gamma Scalping is not on delta, dynamic delta hedging is just a way to avoid underlying price risk in the process.
Gamma Scaling focuses on alpha, which is not the alpha of stock selection. Here, alpha=gamma/theta, that is, how much gamma is exchanged for the time loss of unit Theta.
This is the point of concern. It is possible to construct a portfolio that floats both up and down, but it must be accompanied by time loss, and then the problem lies in the cost effectiveness.

Author: Xu Zhe
URL: https://www.zhihu.com/question/51630805/answer/128096385

डीडीएच रणनीति डिजाइन की व्याख्या

· संचयी बाजार इंटरफेस का समेकन, फ्रेमवर्क डिजाइन · रणनीति यूआई डिजाइन · रणनीतिक बातचीत डिजाइन · स्वचालित हेज फंक्शन डिजाइन स्रोत कोडः

// Construct functions
function createManager(e, subscribeList, msg) {
	var self = {}
    self.supportList = ["Futures_Binance", "Huobi", "Futures_Deribit"]  // of the supported exchanges

    // 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: {bid1: 123, ask1: 123, symbol: "xxx"}}
    self.subscribeTickers = []           // The required market data, define the data format: {bid1: 123, ask1: 123, symbol: "xxx"}}
    self.accData = null 
    self.pos = null 

    // Initialize the function
    self.init = function() { 
    	// Judge if the exchange is supported
        if (!_.contains(self.supportList, self.name)) {        	
        	throw "not support"
        }
    }

    self.setBase = function(base) {
        // Switching base address for switching to analog bot
        self.e.SetBase(base)
        Log(self.name, self.label, "switch to analog bot:", base)
    }

    // Judging 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 {
            // Organize 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
    }
    
    // Back to the position 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 : []
        }
        /* Format of the position data 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])
                }
                // Iterate through 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 
    }

    // Initialization
    self.init()
	return self 
}


function main() {
    // Initialization, clear logs
    if(isResetLog) {
    	LogReset(1)
    }

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

    // Switch to analog 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
        }

        // Interactions
        var cmd = GetCommand()
        if(cmd) {
            // Handle interactions
            Log("Interaction commands", cmd)
            var arr = cmd.split(":")
            // cmdClearLog 
            if(arr[0] == "setContractType") {
                // parseFloat(arr[1])
                m1.e.SetContractType(arr[1])
                Log("exchanges[0] contract set by exchange object.", 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("execution price: ", price, "execution amount: ", amount, "execution 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("execution price: ", price, "execution amount: ", amount, "execution direction: ", arr[0])
            } else if (arr[0] == "setHedgeDeltaStep") {
                hedgeDeltaStep = parseFloat(arr[1])
                Log("set the parameter hedgeDeltaStep:", hedgeDeltaStep)
            } 
        }
        
        // Obtain the future contract prices
        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) {
                // Hedging futures go short if delta is greater than 0                 
                var amount = _N(Math.abs(sumDelta) * perpetualTicker.ask1, -1)                
                if (amount > 10) {
                    Log("Exceed the hedging threshold, current total delta:", sumDelta, "Buy futures")
                    m2.e.SetContractType("BTC-PERPETUAL")                    
                    m2.e.SetDirection("buy")
                    m2.e.Buy(-1, amount)
                } else {
                	hedgeMsg += ", hedging order volume less than 10"
                }
            } else {
                // Hedging futures go long if delta is less than 0
                var amount = _N(Math.abs(sumDelta) * perpetualTicker.bid1, -1)
                if (amount > 10) {
                    Log("Exceed the hedging threshold, current total delta:", sumDelta, "Sell futures")
                    m2.e.SetContractType("BTC-PERPETUAL")
                    m2.e.SetDirection("sell")
                    m2.e.Sell(-1, amount)
                } else {
                	hedgeMsg += ", hedging order volume less than 10"
                }
            }
        }

        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

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

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