Explicação detalhada da configuração da estratégia de negociação quantitativa de moeda digital

Quando você está apenas começando a projetar estratégias quantitativas de negociação de moeda digital, você frequentemente tem vários requisitos de estratégia. Não importa qual linguagem ou plataforma você usa, você encontrará requisitos de design de estratégia para várias situações. Por exemplo, às vezes é preciso rotacionar diversas variedades, às vezes é preciso proteger diversas plataformas e, às vezes, é preciso negociar diferentes variedades simultaneamente, etc. Vamos compartilhar algumas experiências de design ao implementar requisitos estratégicos. A plataforma de aprendizagem ainda utiliza a Inventor Quantitative Trading Platform (https://www.fmz.com), e o mercado selecionado é o mercado de moeda digital.

• ### Design de estratégia “multimoeda”

Esse tipo de demanda geralmente exige a escrita de uma estratégia de tendência multivariada, uma estratégia de grade multivariada etc., o que requer execução iterativa da lógica da estratégia usando diferentes pares de negociação. Geralmente projetado assim:

  function Process (symbol) {
      exchange.IO("currency", symbol)
      var ticker = _C(exchange.GetTicker)
      Log("已经切换交易对，按照策略逻辑处理交易对 ：", symbol, "行情：", ticker)
      // ...
      // ..
      // .
  }  

  function main(){
      var symbols = ["BTC_USDT", "LTC_USDT", "ETH_USDT"]
      while (true) {
          for (var i = 0 ; i < symbols.length; i++) {
              Process(symbols[i])
              Sleep(500)
          }
      }
  }

Configuramos o robô:

Como você pode ver, isso torna possível configurar um objeto de troca no robô, alternar pares de negociação, obter condições de mercado de diferentes pares de negociação, conduzir condições de mercado multivariadas e executar sob uma lógica de estratégia. Pode ser visto que os três pares de negociação que definimos: BTC_USDT, LTC_USDT, ETH_USDT, são iterados por sua vez no loop para obter as informações de mercado. Após obter as informações de mercado, podemos detectar especificamente as informações de mercado e acionar a lógica de negociação projetada pela estratégia.

Alguns alunos podem dizer: “Não gosto de alternar pares de negociação. Parece um pouco problemático e o design da estratégia não é claro.” De fato, existem outros métodos de design, que são outro método que apresentamos abaixo.

• ### Configurar vários objetos de troca para o robô com a mesma conta de troca

Obtenha dados de mercado para diferentes pares de negociação por meio de vários objetos de câmbio e execute-os na lógica da estratégia iterativa. Por exemplo, configure o robô assim: configure três objetos de troca para o robô e defina os pares de negociação como BTC_USDT, LTC_USDT e ETH_USDT, respectivamente.

O objeto de troca chamado “OKEX Spot V3 Test” está no centro de controle, página de configuração de troca: Já configurado.

Modifique o código porque desta vez adicionamos vários objetos de troca ao robô, ou seja, os objetos de troca com pares de negociação BTC_USDT, LTC_USDT e ETH_USDT.

  function Process (e) {
      var ticker = _C(e.GetTicker)
      Log("交易所", e.GetName(), "按照策略逻辑处理交易对 ：", e.GetCurrency(), "行情：", ticker)
      // ...
      // ..
      // .
  }  

  function main(){
      while (true) {
          for (var i = 0 ; i < exchanges.length; i++) {
              Process(exchanges[i])
              Sleep(500)
          }
      }
  }

Execute o robô:

Os exemplos descritos acima são sobre alternar pares de negociação ou adicionar um objeto de troca com vários pares de negociação diferentes a uma conta configurada. Todos são configurados usando apenas uma conta de câmbio (usando um câmbio configurado). Então, como você usa várias contas de câmbio em uma estratégia?

• ### Estratégias para usar várias contas de câmbio

Certas estratégias incluem, por exemplo, hedge entre mercados em diversas bolsas, estratégias de múltiplas contas em uma única bolsa, etc.

• Várias trocas são configuradas, mas são trocas diferentes. Por exemplo, configurei 2 exchanges na página Centro de Controle->Exchange->Adicionar Exchange. Posso acessar as informações de ativos das contas configuradas nessas duas exchanges na estratégia.

  

  function main(){
      Log(exchanges[0].GetAccount())    // 打印第一个 交易所对象的账户资产信息，即火币期货 这个交易所的资产信息。
      Log(exchanges[1].GetAccount())    // ... 打印Bit-Z这个交易所的资产信息
  }
  

  Claro, também posso adicionar a configuração de troca da segunda e terceira contas a uma troca.

• Várias configurações de troca são a mesma troca.

  Por exemplo, vamos adicionar outra conta Huobi Futures.

  Como você pode ver, duas contas da bolsa Huobi Futures foram configuradas.

  

  Ao criar uma estratégia, um objeto da Huobi Futures Exchange aparece na opção “Modificar configuração” do robô para seleção.

  

  Por exemplo, você pode ter duas contas, uma usando uma estratégia de grade vender primeiro e comprar depois (para cima) e a outra usando uma estratégia de grade comprar primeiro e vender depois (para baixo).

  Através dos dois exemplos acima

  Aqui está a diferença entre configurar vários objetos de troca no robô e configurar vários objetos de troca para o robô com a mesma conta de troca:

  À primeira vista, isso é um pouco semelhante ao exemplo de “Configuração de vários objetos de troca para o robô com a mesma conta de troca” explicado acima, mas há diferenças. A diferença é que o exemplo acima é uma configuração de troca, ou seja:

  

  Ao configurar o objeto de troca no robô, sempre use: Esta configuração.

  Acontece que as configurações do par de negociação são diferentes ao adicionar um objeto de troca. Se você chamar a função GetAccount, você sempre acessará as informações de ativos da mesma conta.

  No entanto: Os dois objetos da Huobi Futures Exchange configurados dessa maneira, embora ambos sejam Huobi Futures, representam contas de câmbio diferentes.

• Faça bom uso da configuração de câmbio para facilitar o design de estratégias de futuros de moeda digital.

Às vezes, ao implementar uma estratégia de hedge de contrato de moeda digital, para aproveitar oportunidades de negociação passageiras, muitos cenários exigem ordens simultâneas. No entanto, como os contratos são diferentes, você precisa alternar para o contrato correspondente ao obter informações de mercado e fazer ordens. Ao usar a função exchange.Go para executar simultaneamente funções de ordem ou obter informações de mercado, ela não é muito rápida devido a problemas de sincronização. E o design dos contratos de troca faz com que a lógica não pareça tão simples. Então existe uma maneira melhor?

Claro que há um jeito! Podemos adicionar dois objetos de troca ao robô de acordo com a descrição acima de “Configurando vários objetos de troca para o robô com a mesma conta de troca”. Em seguida, ainda usando essa configuração de troca, adicione outro objeto de troca. Uma caixa de prompt aparecerá neste momento! Uma configuração de conta de câmbio não pode adicionar objetos de câmbio com a mesma moeda e par de negociação.

O que devo fazer neste caso? Parece que não é possível deixar o robô de estratégia usar dois objetos de troca e vincular o objeto de troca a um código de conta de troca? Ainda há um jeito!

Vamos para “Centro de Controle” -> “Câmbio” e adicionamos uma configuração de câmbio de futuros OKEX.

Após a configuração, clique em Salvar.

### 「Destaque」Agora temos duas configurações de troca, mas as mesmas informações de configuração da CHAVE DE API são usadas.

Quais são os benefícios disso? Claro que, ao escrever uma estratégia, o design é muito simples!

  function main(){
      exchanges[0].SetContractType("quarter")        // 设置第一个添加的交易所对象 当前的合约为季度合约
      exchanges[1].SetContractType("this_week")      // 设置第二个添加的交易所对象，当前的合约为当周合约

      while (true) {
          var beginTime = new Date().getTime()       // 记录这次获取行情时起始的时间戳。
          var rA = exchanges[0].Go("GetTicker")      // 创建并发 线程去获取 第一个交易所对象，也就是季度合约的行情数据。
          var rB = exchanges[1].Go("GetTicker")      // 创建并发 线程去获取 第二个交易所对象，也就是当周合约的行情数据。

          var tickerA = rA.wait()                    // 并发的两个线程各自执行自己的任务，这里等待获取数据，A 等待时，B任务也在执行。
          var tickerB = rB.wait()                    // 所以这里看似是顺序执行，实际在底层是并发的。只不过获取的时候是顺序先获取A，在获取B。
          var endTime = new Date().getTime()         // 记录并发获取两个合约行情结束时的时间戳。

          if (tickerA && tickerB) {                  // 如果获取的数据没有问题，执行以下逻辑。
              var diff = tickerA.Last - tickerB.Last // 计算差价
              $.PlotLine("diff", diff)               // 使用画线类库把差价画在图表上。
              if (diff > 500) {                      // 如果差价大于500， 对冲套利（当然设置500 的差价是比较大的，很少见。）
                  // 对冲
                  rA = exchanges[0].Go("Sell", tickerA.Buy, 1)     // 并发线程创建 季度合约下卖单
                  rB = exchanges[1].Go("Buy", tickerB.Sell, 1)     // 并发线程创建 当周合约下买单

                  var idA = rA.wait()           // 等待 返回下单结果，返回的是订单ID
                  var idB = rB.wait()           // ...
              }

              // ...
          }

          LogStatus(_D(), "并发获取两个合约行情耗时：", endTime - beginTime, "毫秒。")    // 显示在状态栏上时间，以便知道程序在执行。
          Sleep(500)
      }
  }

Essa estratégia de design parece muito mais simples e as ideias muito mais claras?

Operação de disco real:

Pode-se observar que leva apenas cerca de 50 milissegundos para obter informações de mercado de dois contratos simultaneamente a cada vez.