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

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

FMZ को क्वांटिफाइड करने की रणनीति यह है किडेरिबिट विकल्प डेल्टा गतिशील हेजिंग रणनीतियह डिनैमिक डेल्टा हेजिंग (DDH) रणनीति है।

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

• विकल्प मूल्य निर्धारण मॉडल, बी-एस मॉडल, विकल्प की कीमतों को चिह्नित वस्तु के मूल्य में उतार-चढ़ाव के आधार पर निर्धारित किया जाता है।

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

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

DDH की रणनीति का वर्णनः

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

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

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

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

  हालांकि, अन्य कारक भी हैं जिन पर विचार किया जाना चाहिएः समय मूल्य, लेनदेन लागत आदि।

  इस तरह से, यह एक बहुत ही दिलचस्प बात है कि हम क्या कर रहे हैं।

  Gamma Scalping 的关注点并不是delta，dynamic delta hedging 只是过程中规避underlying价格风险的一种做法而已。
  Gamma Scalping 关注的是Alpha，此Alpha不是选股的Alpha，这里的Alpha = Gamma/Theta也就是单位Theta的时间损耗换来多少Gamma，
  这个是关注的点。可以构建出上涨和下跌都浮盈的组合，但一定伴随时间损耗，那问题就在于性价比了。
  
  作者：许哲
  链接：https://www.zhihu.com/question/51630805/answer/128096385
  

डीडीएच की रणनीति

• एकीकृत बाजार इंटरफ़ेस पैकेजिंग, फ्रेमवर्क डिजाइन
• रणनीतिक यूआई डिजाइन
• रणनीतिक इंटरैक्टिव डिजाइन
• ऑटोहेजिंग फ़ंक्शन डिजाइन

स्रोतः

// 构造函数
function createManager(e, subscribeList, msg) {
	var self = {}
    self.supportList = ["Futures_Binance", "Huobi", "Futures_Deribit"]  // 支持的交易所的

    // 对象属性
    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 = []                    // 接口获取的所有行情数据，定义数据格式：{bid1: 123, ask1: 123, symbol: "xxx"}}
    self.subscribeTickers = []           // 需要的行情数据，定义数据格式：{bid1: 123, ask1: 123, symbol: "xxx"}}
    self.accData = null 
    self.pos = null 

    // 初始化函数
    self.init = function() { 
    	// 判断是否支持该交易所
        if (!_.contains(self.supportList, self.name)) {        	
        	throw "not support"
        }
    }

    self.setBase = function(base) {
        // 切换基地址，用于切换为模拟盘
        self.e.SetBase(base)
        Log(self.name, self.label, "切换为模拟盘:", base)
    }

    // 判断数据精度
    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
    }

    // 更新资产
    self.updateAcc = function(callBackFuncGetAcc) {
        var ret = callBackFuncGetAcc(self)
        if (!ret) {
        	return false 
        }
        self.accData = ret 
        return true 
    }

    // 更新持仓
    self.updatePos = function(httpMethod, url, params) {
        var pos = self.e.IO("api", httpMethod, url, params)
        var ret = []
        if (!pos) {
            return false 
        } else {
            // 整理数据
            // {"jsonrpc":"2.0","result":[],"usIn":1616484238870404,"usOut":1616484238870970,"usDiff":566,"testnet":true}
            try {
                _.each(pos.result, function(ele) {
                    ret.push(ele)
                })
            } catch(err) {
                Log("错误：", err)
                return false 
            }
            self.pos = ret
        }
        return true 
    }

    // 更新行情数据
    self.updateTicker = function(url, callBackFuncGetArr, callBackFuncGetTicker) {
    	var tickers = []
    	var subscribeTickers = []
    	var ret = self.httpQuery(url)
    	if (!ret) {
    		return false 
    	}
    	// Log("测试", ret)// 测试
    	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("错误：", 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("错误:", 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
    }
    
    // 返回持仓表格
    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 : []
        }
        /* 接口返回的持仓数据格式
        {
            "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])
                }
                // 遍历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 
    }

    // 初始化
    self.init()
	return self 
}


function main() {
    // 初始化，清空日志
    if(isResetLog) {
    	LogReset(1)
    }

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

    // 切换为模拟盘
    var base = "https://www.deribit.com"
    if (isTestNet) {    
        m1.setBase(testNetBase)    
        m2.setBase(testNetBase)
        base = testNetBase
    }

    while(true) {
        // 期权
        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}}) 
        
        // 永续期货
        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
        }

        // 更新持仓
        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
        }

        // 交互
        var cmd = GetCommand()
        if(cmd) {
            // 处理交互
            Log("交互命令：", cmd)
            var arr = cmd.split(":")
            // cmdClearLog 
            if(arr[0] == "setContractType") {
                // parseFloat(arr[1])
                m1.e.SetContractType(arr[1])
                Log("exchanges[0]交易所对象设置合约：", 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("执行价格：", price, "执行数量：", amount, "执行方向：", 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("执行价格：", price, "执行数量：", amount, "执行方向：", arr[0])
            } else if (arr[0] == "setHedgeDeltaStep") {
                hedgeDeltaStep = parseFloat(arr[1])
                Log("设置参数hedgeDeltaStep：", hedgeDeltaStep)
            } 
        }
        
        // 获取期货合约价格
        var perpetualTicker = m2.getTicker("BTC-PERPETUAL")
        var hedgeMsg = " PERPETUAL:" + JSON.stringify(perpetualTicker)

        // 从账户数据中获取delta总值        
        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 大于0 对冲期货做空                
                var amount = _N(Math.abs(sumDelta) * perpetualTicker.ask1, -1)                
                if (amount > 10) {
                    Log("超过对冲阈值，当前总delta：", sumDelta, "买入期货")
                    m2.e.SetContractType("BTC-PERPETUAL")                    
                    m2.e.SetDirection("buy")
                    m2.e.Buy(-1, amount)
                } else {
                	hedgeMsg += ", 对冲下单量小于10"
                }
            } else {
                // delta 小于0 对冲期货做多
                var amount = _N(Math.abs(sumDelta) * perpetualTicker.bid1, -1)
                if (amount > 10) {
                    Log("超过对冲阈值，当前总delta：", sumDelta, "卖出期货")
                    m2.e.SetContractType("BTC-PERPETUAL")
                    m2.e.SetDirection("sell")
                    m2.e.Sell(-1, amount)
                } else {
                	hedgeMsg += ", 对冲下单量小于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

रणनीति चल रही हैः

यह रणनीति शिक्षण रणनीति है, सीखने के लिए मुख्य है, लेकिन कृपया सावधानी से उपयोग करें।