ڈیریبیٹ آپشنز ڈیلٹا متحرک ہیجنگ حکمت عملی

یہ حکمت عملی جو FMZ Quant میز پر لاتا ہے وہ Deribit Options Delta Dynamic Hedging حکمت عملی ہے، یا مختصر طور پر DDH (متحرک ڈیلٹا ہیجنگ) حکمت عملی.

آپشنز ٹریڈنگ کے مطالعہ کے لئے ، ہمیں عام طور پر ان تصورات پر عبور حاصل کرنا پڑتا ہے:

· آپشن کی قیمتوں کا تعین کرنے کا ماڈل، بی ایس ماڈل، آپشن کی قیمتوں کا تعین [موضوع کی قیمت]، [پاور-ویولڈ قیمت]، [ختم ہونے تک باقی وقت]، [انکشاف شدہ] اتار چڑھاؤ] اور [خطرے سے پاک شرح] کی بنیاد پر کیا جاتا ہے۔

· آپشنز کا خطرہ:

-ڈیلٹا ایک آپشن کا سمت کا خطرہ۔ اگر ڈیلٹا +0.50 ہے تو ، پھر اس آپشن کو ، جو اس وقت منافع یا نقصان کرتا ہے جب موضوع کی قیمت اوپر یا نیچے جاتی ہے ، کو 0.50 اسپاٹ سمجھا جاسکتا ہے۔ -گاما سمت کے خطرے میں تیزی۔ مثال کے طور پر ، کال آپشنز کی صورت میں ، گاما کی وجہ سے ، ڈیلٹا آہستہ آہستہ +0.50 سے +1.00 پر منتقل ہوجائے گا کیونکہ اس وقت سے جب موضوع کی قیمت پاور وائلڈ قیمت پر ہے اس وقت سے قیمت میں اضافہ جاری رہے گا۔ - تھیٹا ٹائم ایکسپوزر۔ جب آپ ایک آپشن خریدتے ہیں ، اگر موضوع کی قیمت میں کوئی تبدیلی نہیں ہوتی ہے ، تو ہر گزرتے دن کے لئے ، آپ تھیٹا کی رقم میں دکھائی جانے والی فیس ادا کرتے ہیں (ڈیربٹ امریکی ڈالر میں بیان کیا گیا ہے) ۔ جب آپ ایک آپشن فروخت کرتے ہیں، اگر موضوع کی قیمت میں کوئی تبدیلی نہیں آتی ہے، تو آپ کو ہر روز تھیٹا کی رقم میں دکھایا گیا فیس ملے گا۔ -ویگا اتار چڑھاؤ کی نمائش۔ جب آپ آپشن خریدتے ہیں تو ، ویگا مثبت ہوتا ہے ، یعنی طویل مدتی اتار چڑھاؤ۔ جب ضمنی اتار چڑھاؤ بڑھتا ہے تو ، آپ ویگا کے نمائش پر فائدہ اٹھاتے ہیں۔ اور اس کے برعکس ، جب آپ آپشن بیچتے ہیں تو ، آپ ضمنی اتار چڑھاؤ کم ہونے کے ساتھ ہی فائدہ اٹھاتے ہیں۔ آپ کو یہ بھی معلوم ہونا چاہئے کہ آپشن خریدنے کے بعد ، آپ کے پاس آپشن کی قیمت میں اضافہ ہوتا ہے ، اور جب آپ آپشن بیچتے ہیں تو ، آپ کو یہ معلوم ہوتا ہے کہ آپشن خریدنے کے بعد ، آپ کو آپشن کی قیمت میں اضافہ ہوتا ہے۔

ڈی ڈی ایچ کی حکمت عملی کی وضاحت:

· ڈی ڈی ایچ کے اصول کی وضاحت خطرہ غیر جانبدار تجارتی سمت اختیارات اور فیوچر کے ڈیلٹا کو مماثل کرکے حاصل کی جاتی ہے۔ چونکہ آپشن s ڈیلٹا موضوع کی قیمت کی تبدیلی کے بعد ہوتا ہے ، لہذا مستقبل اور مقامات کا ڈیلٹا تبدیل نہیں ہوتا ہے۔ آپشن کنٹریکٹ میں پوزیشن لینے اور ڈیلٹا کو فیوچر ہیجنگ کے ساتھ متوازن کرنے کے بعد ، مجموعی طور پر ڈیلٹا ایک بار پھر غیر متوازن ہوجائے گا کیونکہ موضوع کی قیمت چلتی ہے۔ آپشنز اور فیوچر پوزیشنوں کے اس طرح کے امتزاج کو ڈیلٹا کو برابر کرنے کے لئے مستقل متحرک ہیجنگ کی ضرورت ہوتی ہے۔

· مثال کے طور پر: جب ہم کال آپشن خریدتے ہیں تو ، ہم اس وقت طویل سمت میں پوزیشن رکھتے ہیں۔ اس وقت ، آپشنز کے ڈیلٹا کو ہیج کرنے کے لئے فیوچر کو مختصر کرنا ضروری ہے ، مجموعی طور پر ڈیلٹا غیر جانبدار (0 یا 0 کے قریب) تک پہنچنا۔ آئیے آپشن معاہدے کی میعاد ختم ہونے تک باقی وقت، اتار چڑھاؤ اور دیگر عوامل کو نظر انداز کریں۔ پہلا منظرنامہ: جب موضوع کی قیمت بڑھتی ہے تو ، اختیارات کا ڈیلٹا بڑھتا ہے ، اور مجموعی طور پر ڈیلٹا مثبت تعداد میں منتقل ہوجاتا ہے ، اور فیوچر کو دوبارہ ہیج کرنے کی ضرورت ہوتی ہے۔ مستقبل کو مختصر کرنے کے لئے کچھ مختصر پوزیشنیں کھولیں ، تاکہ مجموعی طور پر ڈیلٹا دوبارہ متوازن ہو۔ (دوبارہ توازن سے پہلے ، اختیارات کا ڈیلٹا بڑا ہے ، جبکہ فیوچر کا نسبتا small چھوٹا ہے۔ کال آپشنز کا مارجنل منافع معاہدے کی مختصر پوزیشنوں کے مارجنل نقصان سے زیادہ ہے ، اور پورا پورٹ فولیو منافع بخش ہوگا۔)

دوسرا منظرنامہ: جب موضوع کی قیمت میں کمی آتی ہے تو ، ڈیلٹا کا آپشن حصہ کم ہوجاتا ہے اور مجموعی طور پر ڈیلٹا منفی تعداد میں منتقل ہوجاتا ہے ، مختصر فیوچر پوزیشن کا ایک حصہ بند ہوجاتا ہے اور مجموعی طور پر ڈیلٹا کو دوبارہ توازن میں لاتا ہے۔ (اس وقت ، دوبارہ توازن سے پہلے ، اختیارات کا ڈیلٹا چھوٹا ہے ، جبکہ فیوچر کا نسبتا large بڑا ہے۔ کال آپشنز کا مارجنل نقصان معاہدے کی مختصر پوزیشنوں کے مارجنل منافع سے کم ہے ، اور پورا پورٹ فولیو پھر بھی منافع دے گا۔)

لہذا، ایک مثالی حالت میں، موضوع کے اضافے اور کمی کے طور پر طویل عرصے تک مارکیٹ میں اتار چڑھاؤ کے طور پر فوائد لے آئے گا.

تاہم، غور کرنے کے لئے عوامل بھی ہیں: وقت کی قیمت، لین دین کے اخراجات، اور دیگر عوامل.

اس لیے زیہو پر ہاٹ ہاٹ کی وضاحت کا حوالہ دیا گیا ہے:

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

ڈی ڈی ایچ کی حکمت عملی کے ڈیزائن کی وضاحت

· مجموعی مارکیٹ انٹرفیس کی encapsulation، فریم ورک ڈیزائن · حکمت عملی UI ڈیزائن · اسٹریٹجک انٹرایکشن ڈیزائن · خودکار ہیج فنکشن ڈیزائن ماخذ کوڈ:

// 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

حکمت عملی آپریشن:

یہ حکمت عملی ایک ٹیوٹوریل حکمت عملی ہے، سیکھنے پر مبنی ہے، براہ مہربانی اسے حقیقی بوٹ میں احتیاط سے استعمال کریں.