Cuantificación FMZ: Desarrollo de casos de diseño de necesidades comunes en el mercado de criptomonedas (1)

En el ámbito de la negociación de activos de criptomonedas, la obtención y el análisis de datos de mercado, las tasas de consulta y el monitoreo de los cambios en los activos de las cuentas son operaciones clave. A continuación se presentan algunos casos de código para implementar algunas necesidades comunes.

1 ¿Cómo escribir la moneda que ha aumentado más en 4 horas para obtener dinero en efectivo?

Cuando se escribe un programa de estrategia de comercio cuantitativo en FMZ, primero se necesita analizar las necesidades que se encuentran.

• ¿Qué lenguaje de programación se usa para diseñar? La implementación está planeada para usar JavaScript.
• Necesitamos datos de mercado en tiempo real de todas las monedas Al ver esta necesidad, lo primero que hicimos fue revisar la documentación de la API de Binance para ver si hay datos de mercados agregados (los mercados agregados son los mejores, una variedad por variedad). Encuentra la interfaz de mercado agregado:GET https://api.binance.com/api/v3/ticker/price¿Qué es esto? En FMZ, el acceso a la interfaz de mercado de la bolsa (interfaz pública sin necesidad de firma) se utilizaHttpQueryLa función.
• Necesita estadísticas de los ciclos de ventanas giratorias de 4 horas La idea de cómo diseñar la estructura de este programa de estadísticas.
• Calcula la caída de la cuota, ordena Si se piensa en un algoritmo de descenso de la subida, es:涨跌幅百分比 =（当前价格 - 初始价格）/ 初始价格 * 100La unidad es %.

Después de pensar en el problema y determinar la solución, comenzamos el proceso de diseño manualmente.

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

Descifrar el código

• 1. Estructura de datosvar dictSymbolsPrice = {}: un objeto vacío que se utiliza para almacenar información de precios de cada par de transacciones. La clave es el símbolo del par de transacciones, el valor es un objeto que contiene el nombre del par de transacciones, la matriz de datos de precios y la información de la caída de los precios.
• 2. La función principal es main ((()
  • 2.1. Ciclos infinitos

    while (true) {
        // ...
    }
    

    El programa sigue monitoreando los precios de las transacciones en la API de Binance a través de un ciclo infinito.
  • 2.2. Obtener información sobre los precios

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

    Obtenga información sobre el precio actual de la pareja a través de la API de Binance. Si no es una matriz, espere 5 segundos y vuelva a intentar.
  • 2.3. Actualizar los precios

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

    Recorre la matriz de información de precios obtenida, actualizando los datos en dictSymbolsPrice. Para cada par de transacciones, se agrega el horario actual y el precio a la matriz de datos correspondiente.
  • 2.4. Manejo de las excepciones

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

    Captura las anomalías y registra la información de las anomalías para asegurar que el programa continúe ejecutándose.
  • 2.5. Calcular la caída de la cuota

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

    Se recorre el precio de dictSymbols, se calcula la caída de las cuotas de cada par de transacciones y se elimina el dato más antiguo si la duración de los datos es superior a 4 horas.
  • 2.6. Ordenar y generar tablas

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

    Se ordenan los pares de transacciones de alto a bajo en función de la caída de la cuota y se genera una tabla que contiene información sobre los pares de transacciones.
  • 2.7. Exportación y aplazamiento de los diarios

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

    La tabla y el tiempo actual se exportan en forma de registro y se espera 5 segundos para continuar con el siguiente ciclo.

El programa obtiene información sobre los precios en tiempo real de los pares de transacciones a través de la API de Binance, luego calcula la caída del par y lo exporta a los registros en forma de tabla. El programa tiene la función de monitorear los precios de las transacciones en tiempo real mediante una ejecución continua y recurrente. Tenga en cuenta que el programa incluye un procesamiento de excepciones para garantizar que la ejecución no se interrumpa debido a una excepción al obtener la información sobre los precios.

Pruebas en disco real

Dado que los datos se recopilan poco a poco al comienzo, no se puede calcular la caída de la curva si no se recopilan suficientes datos de 4 horas. Por lo tanto, al comenzar se calcula el precio inicial como referencia, y después de recopilar suficientes datos de 4 horas, se elimina el dato más antiguo para mantener la ventana de 4 horas.

2. Busque las tarifas de todo tipo de fondos en los contratos de Bitcoin U.

Para consultar las tasas de capital y el código anterior es similar, lo primero que se necesita es consultar la documentación de la API de Binance para encontrar las interfaces relacionadas con las tasas de capital.

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

Implementación de código

En la actualidad, los países con más exportaciones de capitales están en el top 10 debido a la gran cantidad de contratos.

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 que se devuelve es la siguiente: si nos fijamos en la documentación de Bitcoin, la última tasa de financiación 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
}

La prueba en disco real:

El precio de compra de la versión de python de OKX

Algunos usuarios han presentado ejemplos que requieren una versión de Python, y son de OKX Exchange.

https://www.okx.com/priapi/v5/public/funding-rate-all?currencyType=1Los datos que devuelve la interfaz:

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

El código específico es:

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)

La prueba en disco real:

Enlace a la sección

Estos ejemplos proporcionan ideas básicas de diseño, métodos de invocación y proyectos reales que pueden necesitar modificaciones y expansiones apropiadas según las necesidades específicas. Esperamos que el código le ayude a satisfacer mejor las necesidades de las transacciones de activos digitales de criptomonedas.