No campo da negociação de ativos de criptomoeda, obter e analisar dados de mercado, consultar taxas e monitorar alterações de ativos de conta são operações essenciais. A seguir estão exemplos de código para implementar alguns requisitos comuns.

1. Como escrevo o código que mostra o maior aumento na negociação à vista da Binance em 4 horas?

Ao escrever um programa de estratégia de negociação quantitativa na FMZ, primeiro você precisa analisar os requisitos. Assim, de acordo com as necessidades, analisamos os seguintes pontos:

• Qual linguagem de programação é usada para escrever o design Implementação planejada usando Javascript.
• Precisa de dados de mercado à vista em tempo real para todas as moedas Quando vimos esse requisito, a primeira coisa que fizemos foi consultar a documentação da API da Binance para ver se havia algum dado de mercado agregado (dados de mercado agregados seriam melhores, pois seria demorado e trabalhoso verificar cada produto um por um). um). Consulte a interface de informações agregadas de mercado:GET https://api.binance.com/api/v3/ticker/price。 No FMZ, acesse a interface de cotação de câmbio (interface pública que não requer assinatura) usandoHttpQueryfunção.
• Precisa contar os dados do período de janela móvel de 4 horas Pense em como estruturar esse programa estatístico.
• Calcular a subida e descida, classificar Pense no algoritmo de ascensão e queda:涨跌幅百分比 =（当前价格 - 初始价格）/ 初始价格 * 100, a unidade é “%”.

Pense no problema e decida uma solução. Começamos a projetar o programa.

Design de código

var dictSymbolsPrice = {}

function main() {
    while (true) {
        // GET https://api.binance.com/api/v3/ticker/price
        try {
            var arr = JSON.parse(HttpQuery("https://api.binance.com/api/v3/ticker/price"))
            if (!Array.isArray(arr)) {
                Sleep(5000)
                continue 
            }
            
            var ts = new Date().getTime()
            for (var i = 0; i < arr.length; i++) {
                var symbolPriceInfo = arr[i]
                var symbol = symbolPriceInfo.symbol
                var price = symbolPriceInfo.price

                if (typeof(dictSymbolsPrice[symbol]) == "undefined") {
                    dictSymbolsPrice[symbol] = {name: symbol, data: []}
                }
                dictSymbolsPrice[symbol].data.push({ts: ts, price: price})
            }
        } catch(e) {
            Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
        }
        
        // 计算涨跌幅
        var tbl = {
            type : "table",
            title : "涨跌幅",
            cols : ["交易对", "当前价格", "4小时前价格", "涨跌幅", "数据长度", "最早数据时间", "最新数据时间"],
            rows : []
        }
        for (var symbol in dictSymbolsPrice) {
            var data = dictSymbolsPrice[symbol].data
            if (data[data.length - 1].ts - data[0].ts > 1000 * 60 * 60 * 4) {
                dictSymbolsPrice[symbol].data.shift()
            }

            data = dictSymbolsPrice[symbol].data
            dictSymbolsPrice[symbol].percentageChange = (data[data.length - 1].price - data[0].price) / data[0].price * 100
        }

        var entries = Object.entries(dictSymbolsPrice)
        entries.sort((a, b) => b[1].percentageChange - a[1].percentageChange)

        for (var i = 0; i < entries.length; i++) {
            if (i > 9) {
                break
            }   
            var name = entries[i][1].name
            var data = entries[i][1].data
            var percentageChange = entries[i][1].percentageChange
            var currPrice = data[data.length - 1].price
            var currTs = _D(data[data.length - 1].ts)
            var prePrice = data[0].price
            var preTs = _D(data[0].ts)
            var dataLen = data.length

            tbl.rows.push([name, currPrice, prePrice, percentageChange + "%", dataLen, preTs, currTs])
        }
        
        LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
        Sleep(5000)
    }
}

Análise de código

• 1. Estrutura de Dados var dictSymbolsPrice = {}: Um objeto vazio usado para armazenar informações de preço para cada par de negociação. A chave é o símbolo do par de negociação, e o valor é um objeto que contém o nome do par de negociação, uma matriz de dados de preço e informações de alteração.

• 1. Função principal main()
  • 2.1. Loop infinito

  while (true) {
      // ...
  }
  

  O programa monitora continuamente os preços dos pares de negociação da API da Binance por meio de um loop infinito.

  • 2.2. Obtenha informações sobre preços

  var arr = JSON.parse(HttpQuery("https://api.binance.com/api/v3/ticker/price"))
  

  Obtenha as informações atuais sobre o preço do par de negociação por meio da API da Binance. Se o valor retornado não for uma matriz, aguarde 5 segundos e tente novamente.

  • 2.3. Atualizar dados de preços

  for (var i = 0; i < arr.length; i++) {
      // ...
  }
  

  Percorra a matriz de informações de preço obtida e atualize os dados em dictSymbolsPrice. Para cada par de negociação, adicione o registro de data e hora atual e o preço à matriz de dados correspondente.

  • 2.4. Tratamento de exceções

  } catch(e) {
      Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
  }
  

  Capture exceções e registre informações sobre elas para garantir que o programa possa continuar a ser executado.

  • 2.5. Calcular o aumento ou diminuição

  for (var symbol in dictSymbolsPrice) {
      // ...
  }
  

  Percorra dictSymbolsPrice, calcule o aumento ou a diminuição de cada par de negociação e exclua os dados mais antigos se o comprimento dos dados exceder 4 horas.

  • 2.6. Classificando e gerando tabelas

  var entries = Object.entries(dictSymbolsPrice)
  entries.sort((a, b) => b[1].percentageChange - a[1].percentageChange)
  
  
  for (var i = 0; i < entries.length; i++) {
      // ...
  }
  

  Classifique os pares de negociação por aumento ou diminuição, do maior para o menor, e gere uma tabela contendo as informações do par de negociação.

  • 2.7. Saída de log e atraso

  LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
  Sleep(5000)
  

  Exiba a tabela e a hora atual em formato de log e aguarde 5 segundos antes de continuar para o próximo ciclo.

O programa obtém informações de preço em tempo real do par de negociação por meio da API da Binance, calcula o aumento ou a diminuição e as exibe no log na forma de uma tabela. O programa é executado em um loop contínuo para atingir a função de monitoramento em tempo real dos preços dos pares de transações. Vale ressaltar que o programa inclui tratamento de exceções para garantir que a execução não seja interrompida devido a exceções na obtenção de informações de preço.

Teste de operação de disco real

Como os dados só podem ser coletados pouco a pouco no início, é impossível calcular a ascensão e a queda de forma contínua se não forem coletados dados suficientes para 4 horas. Portanto, no começo, o preço inicial é usado como referência para cálculo. Após coletar dados suficientes para 4 horas, os dados mais antigos são eliminados um por um para manter um período de janela de 4 horas para calcular a subida e a queda.

2. Verifique as taxas de financiamento de todos os contratos futuros de margem U da Binance

Consultar a taxa de financiamento é similar ao código acima. Primeiro, você precisa verificar a documentação da API da Binance para encontrar a interface relacionada à taxa de financiamento. A Binance tem várias interfaces para consultar taxas de financiamento. Aqui, tomamos a interface de contratos baseados em U como exemplo:

GET https://fapi.binance.com/fapi/v1/premiumIndex

Implementação de código

Como há muitos contratos, exibimos aqui os dez com as maiores taxas de financiamento.

function main() {
    while (true) {
        // GET https://fapi.binance.com/fapi/v1/premiumIndex
        try {
            var arr = JSON.parse(HttpQuery("https://fapi.binance.com/fapi/v1/premiumIndex"))
            if (!Array.isArray(arr)) {
                Sleep(5000)
                continue 
            }
            
            arr.sort((a, b) => parseFloat(b.lastFundingRate) - parseFloat(a.lastFundingRate))
            var tbl = {
                type: "table",
                title: "U本位合约资金费率前十",
                cols: ["合约", "资金费率", "标记价格", "指数价格", "当期费率时间", "下期费率时间"],
                rows: []
            }
            for (var i = 0; i < 9; i++) {
                var obj = arr[i]
                tbl.rows.push([obj.symbol, obj.lastFundingRate, obj.markPrice, obj.indexPrice, _D(obj.time), _D(obj.nextFundingTime)])
            }
            LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
        } catch(e) {
            Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
        }
        Sleep(1000 * 10)
    }
}

A estrutura de dados retornada é a seguinte. Da documentação da Binance, podemos ver que lastFundingRate é a taxa de financiamento que queremos.

{
    "symbol":"STMXUSDT",
    "markPrice":"0.00883606",
    "indexPrice":"0.00883074",
    "estimatedSettlePrice":"0.00876933",
    "lastFundingRate":"0.00026573",
    "interestRate":"0.00005000",
    "nextFundingTime":1702828800000,
    "time":1702816229000
}

Teste de operação de disco real:

Versão Python para obter a taxa de financiamento do contrato de câmbio OKX

Um usuário mencionou que uma versão do Python é necessária, e ela é da bolsa OKX. Aqui também é implementado, a propósito:

https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1Dados retornados pela interface:

{
    "code":"0",
    "data":[
        {
            "fundingTime":1702828800000,
            "fundingList":[
                {
                    "instId":"BTC-USDT-SWAP",
                    "nextFundingRate":"0.0001102188733642",
                    "minFundingRate":"-0.00375",
                    "fundingRate":"0.0000821861465884",
                    "maxFundingRate":"0.00375"
                } ...

Código específico:

import requests
import json
from time import sleep
from datetime import datetime

def main():
    while True:
        # https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1
        try:
            response = requests.get("https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1")
            arr = response.json()["data"][0]["fundingList"]
            Log(arr) 
            if not isinstance(arr, list):
                sleep(5)
                continue

            arr.sort(key=lambda x: float(x["fundingRate"]), reverse=True)

            tbl = {
                "type": "table",
                "title": "U本位合约资金费率前十",
                "cols": ["合约", "下期费率", "最小", "当期", "最大"],
                "rows": []
            }

            for i in range(min(9, len(arr))):
                obj = arr[i]
                row = [
                    obj["instId"],
                    obj["nextFundingRate"],
                    obj["minFundingRate"],
                    obj["fundingRate"],
                    obj["maxFundingRate"]
                ]
                tbl["rows"].append(row)
            
            LogStatus(_D(), "\n", '`' + json.dumps(tbl) + '`')

        except Exception as e:
            Log(f"Error: {str(e)}")

        sleep(10)

Teste de operação de disco real:

END

Esses exemplos fornecem ideias básicas de design e métodos de chamada. Em projetos reais, modificações e extensões apropriadas podem ser necessárias com base em necessidades específicas. Espero que esses códigos possam ajudar você a atender melhor às suas diversas necessidades na negociação de ativos digitais de criptomoeda.