资源加载中... loading...

数字货币现货对冲策略设计（1）

Author: 发明者量化-小小梦, Created: 2021-07-19 17:38:24, Updated: 2023-09-20 10:35:16

数字货币现货对冲策略设计（1）

对于策略设计的初学者来说，对冲策略是非常好的练手策略。本篇实现一个简单但是可以实盘的数字货币现货对冲策略，希望可以让初学者学习到一些设计经验。

根据策略需求设计一些函数、策略界面参数

首先明确这个即将设计的策略是一个数字货币现货对冲策略，我们设计最简单的对冲，只在两个现货交易所之间价格较高的交易所卖出，价格较低的交易所买入从而赚取差价。当价格较高的交易所全部都是计价币的时候（因为价格较高币都卖出了），价格较低的交易所全部都是币的时候（价格较低都买成币了）就无法对冲了。这个时候只能等价格反转对冲。

对冲的时候下单价格、数量，交易所都有精度限制，并且还有最小下单量限制。除了最小限制外策略在对冲时也要考虑一次对冲的最大下单量，下单量过大盘口也不会有足够的订单量。还需要考虑如果两个交易所计价币是不同的如何用汇率转换。对冲时手续费、吃单滑点都是交易成本，并不是只要有差价就可以对冲，所以对冲差价也有个触发值，低于某个差价时对冲是亏钱的。

基于这些考虑，策略需要设计出几个参数：

对冲差价：hedgeDiffPrice，当差价超过这个值时，触发对冲操作。
最小对冲量：minHedgeAmount，可对冲的最小下单量（币数）。
最大对冲量：maxHedgeAmount，一次对冲的最大下单量（币数）。
A价格精度：pricePrecisionA，A交易所下单价格精度（小数位数）。
A下单量精度：amountPrecisionA，A交易所下单量精度（小数位数）。
B价格精度：pricePrecisionB，B交易所下单价格精度（小数位数）。
B下单量精度：amountPrecisionB，B交易所下单量精度（小数位数）。
A交易所汇率：rateA，第一个添加的交易所对象的汇率转换，默认1不转换。
B交易所汇率：rateB，第二个添加的交易所对象的汇率转换，默认1不转换。

对冲策略需要保持两个账户的币数始终不变（即不持有任何方向头寸，保持中性），所以需要策略中有一个平衡逻辑始终检测平衡。检测平衡时就避免不了要获取两个交易所的资产数据。我们就需要写一个函数来使用。

updateAccs

function updateAccs(arrEx) {
    var ret = []
    for (var i = 0 ; i < arrEx.length ; i++) {
        var acc = arrEx[i].GetAccount()
        if (!acc) {
            return null
        }
        ret.push(acc)
    }
    return ret 
}

当下单之后如果没有成交的订单我们需要及时的撤销掉，不能让订单一直挂着。这个操作不论是平衡模块中，还是对冲逻辑中都是需要去处理的，所以还需要设计一个订单全撤函数。

cancelAll

function cancelAll() {
    _.each(exchanges, function(ex) {
        while (true) {
            var orders = _C(ex.GetOrders)
            if (orders.length == 0) {
                break
            }
            for (var i = 0 ; i < orders.length ; i++) {
                ex.CancelOrder(orders[i].Id, orders[i])
                Sleep(500)
            }
        }
    })
}

在平衡币数时，我们需要在某个深度数据中查找累计到一定币数的价格，所以就需要一个这样的函数来处理。

getDepthPrice

function getDepthPrice(depth, side, amount) {
    var arr = depth[side]
    var sum = 0
    var price = null
    for (var i = 0 ; i < arr.length ; i++) {
        var ele = arr[i]
        sum += ele.Amount
        if (sum >= amount) {
            price = ele.Price
            break
        }
    }
    return price
}

然后就是我们需要对具体对冲的下单操作进行设计编写，需要设计成并发下单：

hedge

function hedge(buyEx, sellEx, price, amount) {
    var buyRoutine = buyEx.Go("Buy", price, amount)
    var sellRoutine = sellEx.Go("Sell", price, amount)
    Sleep(500)
    buyRoutine.wait()
    sellRoutine.wait()
}

最后，我们来完成平衡函数的设计，平衡函数略微有点复杂。

keepBalance

function keepBalance(initAccs, nowAccs, depths) {
    var initSumStocks = 0
    var nowSumStocks = 0 
    _.each(initAccs, function(acc) {
        initSumStocks += acc.Stocks + acc.FrozenStocks
    })
    _.each(nowAccs, function(acc) {
        nowSumStocks += acc.Stocks + acc.FrozenStocks
    })
  
    var diff = nowSumStocks - initSumStocks
    // 计算币差
    if (Math.abs(diff) > minHedgeAmount && initAccs.length == nowAccs.length && nowAccs.length == depths.length) {
        var index = -1
        var available = []
        var side = diff > 0 ? "Bids" : "Asks"
        for (var i = 0 ; i < nowAccs.length ; i++) {
            var price = getDepthPrice(depths[i], side, Math.abs(diff))
            if (side == "Bids" && nowAccs[i].Stocks > Math.abs(diff)) {
                available.push(i)
            } else if (price && nowAccs[i].Balance / price > Math.abs(diff)) {
                available.push(i)
            }
        }
        for (var i = 0 ; i < available.length ; i++) {
            if (index == -1) {
                index = available[i]
            } else {
                var priceIndex = getDepthPrice(depths[index], side, Math.abs(diff))
                var priceI = getDepthPrice(depths[available[i]], side, Math.abs(diff))
                if (side == "Bids" && priceIndex && priceI && priceI > priceIndex) {
                    index = available[i]
                } else if (priceIndex && priceI && priceI < priceIndex) {
                    index = available[i]
                }
            }
        }
        if (index == -1) {
            Log("无法平衡")            
        } else {
            // 平衡下单
            var price = getDepthPrice(depths[index], side, Math.abs(diff))
            if (price) {
                var tradeFunc = side == "Bids" ? exchanges[index].Sell : exchanges[index].Buy
                tradeFunc(price, Math.abs(diff))
            } else {
                Log("价格无效", price)
            }
        }        
        return false
    } else if (!(initAccs.length == nowAccs.length && nowAccs.length == depths.length)) {
        Log("错误：", "initAccs.length:", initAccs.length, "nowAccs.length:", nowAccs.length, "depths.length:", depths.length)
        return true 
    } else {
        return true 
    }
}

根据策略需求设计好了这些函数，下面可以开始设计策略的主函数了。

策略主函数设计

在FMZ上策略是从main函数开始执行的。在main函数开始的部分我们要做一些策略的初始化工作。

交易所对象名称因为策略中很多操作要使用到交易所对象，例如获取行情、下单等等。所以每次都使用一个较长的名字会很麻烦，小技巧就是使用一个简单的名字代替，例如：
```
var exA = exchanges[0]
var exB = exchanges[1]
```
这样后面编写代码就很舒服了。

汇率、精度相关设计

  // 精度，汇率设置
  if (rateA != 1) {
      // 设置汇率A
      exA.SetRate(rateA)
      Log("交易所A设置汇率：", rateA, "#FF0000")
  }
  if (rateB != 1) {
      // 设置汇率B
      exB.SetRate(rateB)
      Log("交易所B设置汇率：", rateB, "#FF0000")
  }
  exA.SetPrecision(pricePrecisionA, amountPrecisionA)
  exB.SetPrecision(pricePrecisionB, amountPrecisionB)

如果汇率参数rateA、rateB有设置为1的（默认是1），即rateA != 1或rateB != 1不会触发，所以不会设置汇率转换。

重置所有数据

有时候策略启动时需要删除所有日志、清空记录的数据。就可以设计一个策略界面参数isReset，然后在策略中初始化的部分设计重置代码，例如：
```
  if (isReset) {   // 当isReset为真时重置数据
      _G(null)
      LogReset(1)
      LogProfitReset()
      LogVacuum()
      Log("重置所有数据", "#FF0000")
  }
```
恢复初始账户数据、更新当前账户数据为了判断平衡，策略需要持续记录最初的账户资产情况用于和当前对比，nowAccs这个变量就是用来记录当前账户数据，使用我们刚才设计好的函数updateAccs获取当前交易所的账户数据。initAccs用来记录最初的账户状态（交易所A和交易所B的币数、计价币数等数据）。对于initAccs首先使用_G()函数恢复（_G函数会持久记录数据，并且可以重新返回记录的数据，具体查看API文档：链接），如果查询不到就用当前的账户信息赋值并用_G函数记录。

例如以下代码：
```
  var nowAccs = _C(updateAccs, exchanges)
  var initAccs = _G("initAccs")
  if (!initAccs) {
      initAccs = nowAccs
      _G("initAccs", initAccs)
  }
```

交易逻辑，主函数中的主循环

主循环中的代码就是策略逻辑每轮执行的流程，不停的往复执行就构成了策略主循环。让我们来看下主循环中程序每次执行的流程。

获取行情数据，判断行情数据有效性
```
      var ts = new Date().getTime()
      var depthARoutine = exA.Go("GetDepth")
      var depthBRoutine = exB.Go("GetDepth")
      var depthA = depthARoutine.wait()
      var depthB = depthBRoutine.wait()
      if (!depthA || !depthB || depthA.Asks.length == 0 || depthA.Bids.length == 0 || depthB.Asks.length == 0 || depthB.Bids.length == 0) {
          Sleep(500)
          continue 
      }
```
这里可以看到使用了FMZ平台的并发函数exchange.Go，创建了调用GetDepth()接口的并发对象depthARoutine、depthBRoutine。这两个并发对象创建时，调用GetDepth()接口也随即发生，此时两个获取深度数据的请求都向交易所发送了过去。然后调用depthARoutine、depthBRoutine对象的wait()方法获取深度数据。
获取到深度数据之后，需要对深度数据进行检查判断其有效性。对于数据异常的情况触发执行continue语句重新执行主循环。
使用价差值参数还是差价比例参数？
```
      var targetDiffPrice = hedgeDiffPrice
      if (diffAsPercentage) {
          targetDiffPrice = (depthA.Bids[0].Price + depthB.Asks[0].Price + depthB.Bids[0].Price + depthA.Asks[0].Price) / 4 * hedgeDiffPercentage
      }
```
参数上我们做了这样的设计。FMZ的参数可以基于某个参数显示或者隐藏，这样我们就可以做一个参数来决定是使用价格差，还是差价比例。

策略界面参数上增加了一个参数diffAsPercentage。另外两个基于这个参数显示或者隐藏的参数设置为： hedgeDiffPrice@!diffAsPercentage，当diffAsPercentage为假显示该参数。 hedgeDiffPercentage@diffAsPercentage，当diffAsPercentage为真显示该参数。这样设计之后，我们勾选了diffAsPercentage参数，就是按差价比例作为对冲触发条件。不勾选diffAsPercentage参数就是按价格差作为对冲触发条件。

判断对冲触发条件

      if (depthA.Bids[0].Price - depthB.Asks[0].Price > targetDiffPrice && Math.min(depthA.Bids[0].Amount, depthB.Asks[0].Amount) >= minHedgeAmount) {          // A -> B 盘口条件满足            
          var price = (depthA.Bids[0].Price + depthB.Asks[0].Price) / 2
          var amount = Math.min(depthA.Bids[0].Amount, depthB.Asks[0].Amount)
          if (nowAccs[0].Stocks > minHedgeAmount && nowAccs[1].Balance / price > minHedgeAmount) {
              amount = Math.min(amount, nowAccs[0].Stocks, nowAccs[1].Balance / price, maxHedgeAmount)
              Log("触发A->B:", depthA.Bids[0].Price - depthB.Asks[0].Price, price, amount, nowAccs[1].Balance / price, nowAccs[0].Stocks)  // 提示信息
              hedge(exB, exA, price, amount)
              cancelAll()
              lastKeepBalanceTS = 0
              isTrade = true 
          }            
      } else if (depthB.Bids[0].Price - depthA.Asks[0].Price > targetDiffPrice && Math.min(depthB.Bids[0].Amount, depthA.Asks[0].Amount) >= minHedgeAmount) {   // B -> A 盘口条件满足
          var price = (depthB.Bids[0].Price + depthA.Asks[0].Price) / 2
          var amount = Math.min(depthB.Bids[0].Amount, depthA.Asks[0].Amount)
          if (nowAccs[1].Stocks > minHedgeAmount && nowAccs[0].Balance / price > minHedgeAmount) {
              amount = Math.min(amount, nowAccs[1].Stocks, nowAccs[0].Balance / price, maxHedgeAmount)
              Log("触发B->A:", depthB.Bids[0].Price - depthA.Asks[0].Price, price, amount, nowAccs[0].Balance / price, nowAccs[1].Stocks)  // 提示信息
              hedge(exA, exB, price, amount)
              cancelAll()
              lastKeepBalanceTS = 0
              isTrade = true 
          }            
      }

对冲触发条件有这么几个： 1、首先满足对冲差价，只有当盘口的差价满足设置的差价参数时才可对冲。 2、盘口可对冲量要满足参数上设置的最小对冲量，因为不同交易所可能限制的最小下单量不同，所以要取两者中最小的。 3、卖出操作的交易所中的资产足够卖出，买入操作的交易所中的资产足够买入。这些条件满足时，执行对冲函数进行对冲下单。在主函数之前我们提前声明了一个变量isTrade用来标记是否发生对冲，这里如果对冲触发则设置该变量为true。并且重置全局变量lastKeepBalanceTS为0（lastKeepBalanceTS用于标记最近一次平衡操作的时间戳，设置为0会立即触发平衡操作），然后取消所有挂单。

平衡操作

      if (ts - lastKeepBalanceTS > keepBalanceCyc * 1000) {
          nowAccs = _C(updateAccs, exchanges)
          var isBalance = keepBalance(initAccs, nowAccs, [depthA, depthB])
          cancelAll()
          if (isBalance) {
              lastKeepBalanceTS = ts
              if (isTrade) {
                  var nowBalance = _.reduce(nowAccs, function(sumBalance, acc) {return sumBalance + acc.Balance}, 0)
                  var initBalance = _.reduce(initAccs, function(sumBalance, acc) {return sumBalance + acc.Balance}, 0)
                  LogProfit(nowBalance - initBalance, nowBalance, initBalance, nowAccs)
                  isTrade = false 
              }                
          }            
      }

可以看到平衡函数会定期执行，但是如果对冲操作触发了之后，lastKeepBalanceTS被重置为0则平衡操作会立即触发。平衡成功之后会计算收益。

状态栏信息

      LogStatus(_D(), "A->B:", depthA.Bids[0].Price - depthB.Asks[0].Price, " B->A:", depthB.Bids[0].Price - depthA.Asks[0].Price, " targetDiffPrice:", targetDiffPrice, "\n", 
          "当前A，Stocks:", nowAccs[0].Stocks, "FrozenStocks:", nowAccs[0].FrozenStocks, "Balance:", nowAccs[0].Balance, "FrozenBalance", nowAccs[0].FrozenBalance, "\n", 
          "当前B，Stocks:", nowAccs[1].Stocks, "FrozenStocks:", nowAccs[1].FrozenStocks, "Balance:", nowAccs[1].Balance, "FrozenBalance", nowAccs[1].FrozenBalance, "\n", 
          "初始A，Stocks:", initAccs[0].Stocks, "FrozenStocks:", initAccs[0].FrozenStocks, "Balance:", initAccs[0].Balance, "FrozenBalance", initAccs[0].FrozenBalance, "\n", 
          "初始B，Stocks:", initAccs[1].Stocks, "FrozenStocks:", initAccs[1].FrozenStocks, "Balance:", initAccs[1].Balance, "FrozenBalance", initAccs[1].FrozenBalance)

状态栏没有设计特别复杂，显示当前时间，显示A交易所到B交易所的差价和B交易所到A交易所的差价。显示当前对冲目标差价。显示A交易所账户资产数据，B交易所账户资产数据。

对于不同计价币的交易对的处理

在参数上我们设计了转换汇率值参数，在策略开头main函数初始操作的部分我们也设计了汇率转换。需要注意的是SetRate汇率转换函数需要首先执行。因为这个函数影响两个层面：

所有行情数据、订单数据、持仓数据中的价格换算。
账户资产中计价币的换算。例如当前交易对为BTC_USDT，价格单位都是USDT，账户资产里可用计价币也是USDT。如果我想换算成CNY的数值，在代码中设置exchange.SetRate(6.8)就把exchange这个交易所对象下的所有函数获取的数据进行了换算，换算成了CNY。换算为什么计价币就给SetRate函数传入当前计价币到目标计价币的汇率。

完整的策略：不同计价币的现货对冲策略（教学）

Related

More

松鼠宽客_乌克兰剑圣 厉害

Forums
|
API
|
Github
|
About
|
SiteMap