Estratégias de troca de moeda digital quantitativa

Estratégias de troca de moeda digital quantitativa

Quando você começa a projetar estratégias de negociação quantitativa de moeda digital, muitas vezes há uma grande variedade de necessidades estratégicas, independentemente da linguagem e da plataforma. Por exemplo, às vezes são necessárias várias rodadas, às vezes são necessárias várias plataformas de hedge, às vezes são necessárias várias transações em simultâneo, etc. Abaixo, compartilhamos algumas experiências de design quando as necessidades estratégicas são implementadas. A plataforma de aprendizagem ainda usa a plataforma de negociação quantitativa dos inventores.https://www.fmz.comO mercado escolheu o mercado de moedas digitais.

• Planejamento de estratégias para a multiculturalidade

  Essas necessidades são mais necessárias para escrever uma estratégia de tendência multi-variedade, uma estratégia de grelha multi-variedade, etc., que precisa ser executada com a lógica estratégica e a repetição do mercado com diferentes transações. O projeto costuma ser:

  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)
          }
      }
  }
  

  A partir de agora, o nosso objetivo é criar uma rede de computadores que permita que os robôs possam usar os seus próprios recursos.

  

  Como se pode ver, isso permite configurar um objeto de troca no robô, trocar pares de transações, obter mercados de diferentes pares de transações, realizar uma variedade de mercados e executá-los sob uma lógica estratégica. Podemos ver que os três pares de negociação que definimos: BTC_USDT, LTC_USDT, ETH_USDT, são os que se reproduzem no ciclo de aquisição de mercados, que, após a aquisição de mercados, podem ser especificados para a detecção de mercados e desencadear uma lógica de negociação estratégica bem concebida.

  Alguns colegas podem dizer: "Eu não gosto de trocar pares, sinto-me um pouco incomodado, a estratégia não é tão clara". Afinal, há outras maneiras de fazer o design, como a outra que apresentamos abaixo.

• A mesma conta de bolsa configura vários objetos de troca para o robô

  A estratégia iterativa é executada em lógica, obtendo dados de mercado de diferentes pares de transações através de vários objetos de câmbio. Por exemplo, configure o robô assim: configure três objetos de troca para o robô, com pares de negociação definidos como BTC_USDT, LTC_USDT e ETH_USDT, respectivamente.

  O objeto da troca, chamado "OKEX Live V3 Test", está no centro de controle, na página de configuração da troca:O Google Maps é um site de redes sociais.

  Modifique o código, porque desta vez nós adicionamos vários objetos de troca ao robô, respectivamente os objetos de troca para 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)
          }
      }
  }
  

  A partir de agora, o mundo está a ser transformado.

  Os exemplos acima, seja para trocar pares de transações, ou para adicionar uma configuração de conta de vários pares de transações diferentes. Como é que é possível usar várias contas numa mesma estratégia?

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

  Algumas estratégias são, por exemplo, a cobertura de cross-market de várias bolsas, a estratégia de várias contas em uma única bolsa, etc.

  • A plataforma é uma plataforma de intercâmbio que permite a troca de informações entre diferentes empresas.Por exemplo, configurei duas casas de câmbio no Centro de Controle - > Bolsas - > Adicionar Bolsas na página. Na estratégia, eu posso acessar as informações de ativos das contas configuradas nessas duas exchanges.

    

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

    Claro que eu também posso configurar uma segunda ou terceira conta para uma casa de câmbio.

  • A maioria das casas de câmbio são configuras, sendo as mesmas casas de câmbio.

    Por exemplo, adicionamos uma conta de futuros de tokens.

    Como se pode ver, esta é a configuração das contas de duas bolsas de "tokens futuros".

    

    Quando a política é criada, um objeto de troca de futuros de tokens aparece para seleção na opção "Modificar a configuração" do robô.

    

    Por exemplo, isso pode permitir que duas contas tenham uma estratégia de compra-venda-primeira-grelha (para cima) e uma estratégia de compra-venda-primeira-grelha (para baixo).

    A partir dos dois exemplos.

    Aqui está a diferença entre configurar vários objetos de câmbio em um robô e "configurar vários objetos de câmbio para um robô na mesma conta de câmbio":

    O exemplo de "a mesma conta de exchange configurar vários objetos de exchange para robôs" é semelhante, mas há uma diferença. A diferença é que o exemplo acima é uma configuração de exchange, ou seja:

    

    O objeto de troca é sempre usado quando o robô é configurado:A configuração.

    A única coisa que é diferente é a configuração do negócio quando o objeto é adicionado à bolsa. Quando a função GetAccount é chamada, a informação de ativos da mesma conta é sempre acessada.

    No entanto:Os dois objetos de câmbio de futuros de tokens assim configurados, embora sejam tokens futuros, são representados por contas de câmbio diferentes.

• A configuração de câmbio de criptomoedas permite que a estratégia de futuros de moeda digital seja mais simples.

  Às vezes, a estratégia de hedge de um contrato de moeda digital é que muitos cenários exigem a emissão simultânea de ordens para aproveitar oportunidades de negociação instantâneas. Mas, como os contratos são diferentes, é necessário mudar para o contrato correspondente quando se obtém um mercado, quando o pedido é executado. Quando a função exchange.Go é usada para executar uma função simultânea ou obter um mercado, não é rápido devido a problemas de sincronização.

  Claro que há uma maneira! Podemos adicionar dois objetos de troca ao robô, como mencionado acima: "Configurar vários objetos de troca para o robô com a mesma conta de troca".Em seguida, use essa configuração de câmbio para adicionar um objeto de câmbio. A partir daí, uma caixa de sugestões vai aparecer!A configuração de uma conta de câmbio não permite a adição de objetos de câmbio com a mesma moeda ou par de transações.

  Como é que isso funciona? Parece que não é possível fazer com que o robô estratégico use dois objetos de troca e que os objetos de troca estejam ligados a um código de conta de troca? Afinal, há uma solução!

  Em "Control Center" - "Exchange", adicionamos uma configuração de OKEX.

  

  Clique em salvar para configurar.

  

  "Definição de prioridades" significa que temos duas configurações de exchanges, mas usando a mesma informação de configuração API KEY.

  

  O que é que isso tem a ver com isso? E, claro, quando se trata de criar uma estratégia, o design é 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)
      }
  }
  

  A estratégia de design não parece ser muito simples e a ideia é muito mais clara.

  Disco real:

  Como você pode ver, cada transação para obter dois contratos em simultâneo leva apenas cerca de 50 milissegundos.