资源加载中... loading...
  1. 文库
  2. 原创教程
  3. 数字货币现货对冲策略设计（1）

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

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

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

数字货币现货对冲策略设计（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不会触发，所以不会设置汇率转换。

  • 重置所有数据

数字货币现货对冲策略设计（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的参数可以基于某个参数显示或者隐藏，这样我们就可以做一个参数来决定是使用价格差，还是差价比例。

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

策略界面参数上增加了一个参数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函数传入当前计价币到目标计价币的汇率。

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

相关内容
更多内容

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

2019 - FMZ - 发明者量化