En el campo del comercio de activos de criptomonedas, obtener y analizar datos del mercado, verificar las tasas y monitorear los cambios en los activos de la cuenta son operaciones clave. Los siguientes son ejemplos de código para implementar algunos requisitos comunes.

1. ¿Cómo escribo el código que muestra el mayor aumento en el comercio spot de Binance en 4 horas?

Al escribir un programa de estrategia comercial cuantitativa en FMZ, primero debe analizar los requisitos. Así que según las necesidades analizamos los siguientes puntos:

• ¿Qué lenguaje de programación se utiliza para escribir el diseño? Implementación planificada utilizando Javascript.
• Necesita datos del mercado spot en tiempo real para todas las monedas Cuando vimos este requisito, lo primero que hicimos fue revisar la documentación de la API de Binance para ver si había datos de mercado agregados (lo mejor sería tener datos de mercado agregados, ya que sería lento y laborioso verificar cada producto uno por uno). uno). Consulta la interfaz de información agregada del mercado:GET https://api.binance.com/api/v3/ticker/price。 En FMZ, acceda a la interfaz de cotización de bolsa (interfaz pública que no requiere firma) utilizandoHttpQueryfunción.
• Es necesario contar los datos del período de ventana móvil de 4 horas. Piense en cómo estructurar este programa estadístico.
• Calcular la subida y la bajada, ordenar Piense en el algoritmo de ascenso y caída:涨跌幅百分比 =（当前价格 - 初始价格）/ 初始价格 * 100, la unidad es “%”.

Piense en el problema y decida una solución. Comenzamos a diseñar el programa.

Diseño 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álisis de código

• 1. Estructura de datos var dictSymbolsPrice = {}:Un objeto vacío utilizado para almacenar información de precios para cada par comercial. La clave es el símbolo del par comercial y el valor es un objeto que contiene el nombre del par comercial, una matriz de datos de precios e información de cambio.

• 1. Función principal main()
  • 2.1. Bucle infinito

  while (true) {
      // ...
  }
  

  El programa monitorea continuamente los precios de los pares comerciales de la API de Binance a través de un bucle infinito.

  • 2.2. Obtener información sobre precios

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

  Obtenga la información de precios actual del par comercial a través de la API de Binance. Si el valor devuelto no es una matriz, espere 5 segundos y vuelva a intentarlo.

  • 2.3. Actualizar datos de precios

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

  Recorra la matriz de información de precios obtenida y actualice los datos en dictSymbolsPrice. Para cada par comercial, agregue la marca de tiempo y el precio actuales a la matriz de datos correspondiente.

  • 2.4. Manejo de excepciones

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

  Detecte excepciones y registre información sobre ellas para garantizar que el programa pueda seguir ejecutándose.

  • 2.5. Calcular el aumento o disminución

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

  Recorra dictSymbolsPrice, calcule el aumento o la disminución de cada par comercial y elimine los datos más antiguos si la longitud de los datos excede las 4 horas.

  • 2.6 Ordenación y generación de tablas

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

  Ordene los pares comerciales por su aumento o disminución de mayor a menor y genere una tabla que contenga la información del par comercial.

  • 2.7. Salida de registro y demora

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

  Imprima la tabla y la hora actual en formato de registro y espere 5 segundos antes de continuar con el siguiente ciclo.

El programa obtiene la información de precios en tiempo real del par comercial a través de la API de Binance, luego calcula el aumento o la disminución y lo envía al registro en forma de tabla. El programa se ejecuta en un bucle continuo para lograr la función de monitoreo en tiempo real de los precios de los pares de transacciones. Cabe señalar que el programa incluye manejo de excepciones para garantizar que la ejecución no se interrumpa debido a excepciones al obtener información de precios.

Prueba de funcionamiento del disco real

Dado que al principio los datos solo se pueden recopilar bit a bit, es imposible calcular el ascenso y la caída de forma continua si no se han recopilado datos suficientes para 4 horas. Por lo tanto, al principio, se utiliza el precio inicial como referencia para el cálculo. Después de recopilar datos suficientes durante 4 horas, los datos más antiguos se eliminan uno por uno para mantener un período de ventana de 4 horas para calcular el aumento y la caída.

2. Consulta las tasas de financiación de todos los contratos de futuros de margen U de Binance

La consulta de la tasa de financiación es similar al código anterior. Primero, debe consultar la documentación de la API de Binance para encontrar la interfaz relacionada con la tasa de financiación. Binance tiene varias interfaces para consultar las tasas de financiación. Aquí tomamos como ejemplo la interfaz de los contratos basados ​​en U:

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

Implementación de código

Como hay demasiados contratos, aquí mostramos los diez con las tasas de financiación más altas.

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

La estructura de datos devuelta es la siguiente. En la documentación de Binance, podemos ver que lastFundingRate es la tasa de financiación que queremos.

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

Prueba de funcionamiento del disco real:

Versión en Python para obtener la tasa de financiación del contrato de intercambio de OKX

Un usuario mencionó que se necesita una versión de Python, y es del intercambio OKX. Aquí también se implementa por cierto:

https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1Datos devueltos por la interfaz:

{
    "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)

Prueba de funcionamiento del disco real:

END

Estos ejemplos proporcionan ideas de diseño básicas y métodos de llamada. En proyectos reales, es posible que se requieran modificaciones y extensiones adecuadas según las necesidades específicas. Espero que estos códigos puedan ayudarlo a satisfacer mejor sus diversas necesidades en el comercio de activos digitales de criptomonedas.