FMZ量化交易挂单期现对冲策略设计研究、范例
admin
2023-07-31 23:45:23
0

目前不清退的交易所推荐:

1、全球第二大交易所OKX欧意

国区邀请链接: https://www.myts3cards.com/cn/join/1837888   币种多,交易量大!

国际邀请链接:https://www.okx.com/join/1837888 注册简单,交易不需要实名,新用户能开合约,币种多,交易量大!

2、老牌交易所比特儿现改名叫芝麻开门 :https://www.gate.win/signup/649183

全球最大交易所币安,国区邀请链接:https://accounts.binance.com/zh-CN/register?ref=16003031  币安注册不了IP地址用香港,居住地选香港,认证照旧,邮箱推荐如gmail、outlook。支持币种多,交易安全!

买好币上KuCoin:https://www.kucoin.com/r/af/1f7w3  CoinMarketCap前五的交易所,注册友好操简单快捷!

FMZ量化交易平台邀请链接:https://www.fmz.com/

挂单期现对冲策略设计研究、范例

一直以来期现对冲一般都设计为检测差价,当符合差价时吃单对冲。那是否能设计为挂单对冲呢?答案是肯定的。今天就给读者带来一种挂单对冲的设计思路和代码原型。

挂单对冲思路

同一种或者同一类标的物的不同市场,当两个市场盘口买卖单的差别较大时就产生了对冲的机会。一般我们会吃掉满足差价的盘口挂单进而持有对冲仓位。所以对冲的目的是有2个,第一要对冲下单持仓,第二是要最大程度确保一买一卖的差价符合我们的期望。挂单交易在这方面的好处就是手续费率更低。缺点就是不容易成交、容易单腿成交。

那么我们设计交易思路为在A市场订单薄买单中挂买入单,在B市场订单薄卖单中挂卖出单。然后检测我们的账号挂单,对检测到的挂单成交做下一步处理。例如检测到挂单发生变化就立即平衡期现对冲仓位,对于期现持仓中溢出的头寸进行补仓或者平仓操作。根据对冲持仓量的增加进而调整下一次的盘口中挂单时相对于盘口第一档的距离,逐步对冲拿到更大的差价。

对冲逻辑 16dfdfc6f001b757ea4416dfdfc6f001b757ea44

代码设计

注释直接写在代码里了,该范例仅仅用于参考设计,只在OKEX V5模拟盘上简单测试过。该例子并不是完善的策略,请仅供参考使用。

// 临时参数
var fuContractType = \"quarter\"    // 期货合约
var fuSymbol = \"ETH_USDT\"         // 期货交易对
var spSymbol = \"ETH_USDT\"         // 现货交易对
var minAmount = 0.1               // 每次交易量、最小交易量,币数
var step = 40                     // 差价步长
var buff = 5                      // 缓冲差价
var balanceType = \"open\"          // 对于单腿成交平衡时, open 补仓 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)   // 当前减去最初,正数为做多
        // 检测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  // 正数多头持仓溢出,负数空头持仓溢出
        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] = \"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\") {
                    // 现货多头持仓多了,平现货多仓
                    spEx.Sell(-1, self.offset[1])
                } else if (self.balanceType == \"open\") {
                    // 现货多头持仓多了,开期货空头持仓
                    fuEx.SetDirection(\"sell\")
                    fuEx.Sell(-1, self.coin2Piece(Math.abs(self.offset[1])))
                }
            } else if (self.offset[1] <= -self.minAmount) {
                if (self.balanceType == \"close\") {
                    // 期货空头持仓多了,平期货空仓
                    fuEx.SetDirection(\"closesell\")
                    fuEx.Buy(-1, self.coin2Piece(Math.abs(self.offset[1])))
                } else if (self.balanceType == \"open\") {
                    // 期货空头持仓多了,开现货多头持仓
                    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\") {
                    // 期货多头持仓多了,平期货多仓
                    fuEx.SetDirection(\"closebuy\")
                    fuEx.Sell(-1, self.coin2Piece(self.offset[1]))
                } else if (self.balanceType == \"open\") {
                    // 期货多头持仓多了,开现货空头持仓
                    spEx.Sell(-1, self.offset[1])
                }
            } else if (self.offset[1] <= -self.minAmount) {
                if (self.balanceType == \"close\") {
                    // 现货空头持仓多了,平现货空仓
                    spEx.Buy(-1, spDepth.Asks[0].Price * Math.abs(self.offset[1]))
                } else if (self.balanceType == \"open\") {
                    // 现货空头持仓多了,开期货多头持仓
                    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) {
            // 重置level
            if (self.hedgePos == 0) {
                self.level = 1
            } else {
                self.level = Math.max(1, _N(self.hedgePos / self.minAmount, 0))
            }

            // 限制最大持仓量
            if (Math.abs(self.hedgePos) > 1) {
                return 
            }

            // 挂单
            var fuDepth = depth.fuExDepth
            var spDepth = depth.spExDepth
            self.update()

            if (self.hedgePos >= 0 && fuDepth.Bids[0].Price - spDepth.Asks[0].Price > 0) {        // 正套
                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, \"挂单差价:\", 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) { // 反套
                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, \"挂单差价:\", 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            
            // 判断位置
            var isCancelAll = false 
            if (self.hedgePos >= 0 && fuDepth.Bids[0].Price - spDepth.Asks[0].Price > 0) {        // 正套
                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) { // 反套
                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())   // 状态栏可以设计输出需要观察的数据、信息
    }

    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]
    }
    
    // 币转合约张数
    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\"
        }
    }
    
    // 合约张数转币
    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() {
        // 全部平仓
        // 这里可以实现一个,一键平仓的功能
    }

    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)
        }
        // 打印初始信息
        Log(\"self.initSpAcc:\", self.initSpAcc.Balance, self.initSpAcc.FrozenBalance, self.initSpAcc.Stocks, self.initSpAcc.FrozenStocks)
    }
    self.init()
    return self
}

function main() {
    _G(null)       // 清空持久化数据
    LogReset(1)    // 重置日志

    // 以下代码可以切换OKEX模拟盘
    // 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) {
            // 处理交互
            Log(\"交互命令:\", cmd)
            var arr = cmd.split(\":\") 
            if (arr[0] == \"\") {
                pm.CoverAll()
            }            
        }

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

回测分析

1715b1287357da8919a81715b1287357da8919a8

16e7568c835a02a85ad51715b1287357da8919a8

可以看到挂单、撤单非常频繁。从回测系统统计的收益上来看,期货交易所账户亏损了-0.01666个ETH,现货交易所盈利了842.23758个USDT。按回测结束时ETH现货价格4252USDT,-0.01666 * 4252 = -70.83832000000001。加上现货盈利总体是盈利的。

不过这仅仅是回测,实盘当中肯定还要解决更多的细节问题。

FMZ量化交易平台邀请链接:https://www.fmz.com/

全球最大交易所币安,国区邀请链接:https://accounts.binance.com/zh-CN/register?ref=16003031  币安注册不了IP地址用香港,居住地选香港,认证照旧,邮箱推荐如gmail、outlook。支持币种多,交易安全!

买好币上KuCoin:https://www.kucoin.com/r/af/1f7w3  CoinMarketCap前五的交易所,注册友好操简单快捷!

目前不清退的交易所推荐:

1、全球第二大交易所OKX欧意,邀请链接:https://www.myts3cards.com/cn/join/1837888 注册简单,交易不需要实名,新用户能开合约,币种多,交易量大!。

2、老牌交易所比特儿现改名叫芝麻开门 :https://www.gate.win/signup/649183

买好币上币库:https://www.kucoin.com/r/1f7w3

火必所有用户现在可用了,但是要重新注册账号火币:https://www.huobi.com

全球最大交易所币安,

国区邀请链接:https://accounts.suitechsui.mobi/zh-CN/register?ref=16003031 支持86手机号码,网页直接注册。

相关内容

热门资讯

Windows 11 和 10... Windows 11/10 文件夹属性中缺少共享选项卡 – 已修复 1.检查共享选项卡是否可用 右键...
Radmin VPN Wind... Radmin VPN 是一款免费且用户友好的软件,旨在牢固地连接计算机以创建一个有凝聚力的虚拟专用网...
如何修复 Steam 内容文件... Steam 内容文件锁定是当您的 Steam 文件无法自行更新时出现的错误。解决此问题的最有效方法之...
在 Windows 11 中打... 什么是链路状态电源管理? 您可以在系统控制面板的电源选项中看到链接状态电源管理。它是 PCI Exp...
事件 ID 7034:如何通过... 点击进入:ChatGPT工具插件导航大全 服务控制管理器 (SCM) 负责管理系统上运行的服务的活动...
Hive OS LOLMine... 目前不清退的交易所推荐: 1、全球第二大交易所OKX欧意 国区邀请链接: https://www.m...
在 iCloud 上关闭“查找... 如果您是 Apple 的长期用户,您肯定会遇到过 Find My 应用程序,它本机安装在 iPhon...
iPhone 屏幕上有亮绿色斑... iPhone 是市场上最稳定的智能手机之一,这主要归功于专为它们设计的 iOS 操作系统。然而,他们...
balenaEtcher烧录后... balenaEtcher烧录后u盘或者内存卡无法识别不能使用的解决方法想要恢复原来的方法,使用win...
farols1.1.501.0... faro ls 1.1.501.0(64bit)可以卸载,是一款无需连接外部PC机或笔记本计算机即可...