Explora el diseño de estrategias de alta frecuencia del cambio mágico de LeeksReaper

En artículos anteriores, hemos analizado la idea y la implementación de código de la estrategia de alta frecuencia de la versión spot original LeeksReaper.

Análisis de la estrategia de LeeksReaperhttps://www.fmz.com/bbs-topic/9725(en inglés) Análisis de la estrategia de LeeksReaperhttps://www.fmz.com/bbs-topic/9733）

Muchos usuarios de la moneda digital prestan más atención a la estrategia del líder de dinero impreso.La estrategia del líder de dinero impreso se negocia en el contrato Binance USDT. Se puede ver a partir de la observación y el análisis de muchos seguidores que esta estrategia de alta frecuencia es similar al principio de LeeksReaper (el líder Xiaocao también dijo que el principio de las estrategias de alta frecuencia es similar).

Por lo tanto, no pude evitar hacer el cambio mágico. Aunque el efecto estratégico del cambio mágico fue mucho peor que las estrategias de los líderes. También es una práctica de aprendizaje para las estrategias de alta frecuencia. Los FMZer que estén interesados discutirán y aprenderán juntos.

LeeksReaper después del cambio mágico.

var TickInterval = 100

function LeeksReaper() {
    var self = {}
    self.numTick = 0
    self.lastTradeId = 0
    self.vol = 0
    self.askPrice = 0
    self.bidPrice = 0
    self.orderBook = {
        Asks: [],
        Bids: []
    }
    self.prices = []
    self.tradeOrderId = 0
    self.account = null
    self.buyPrice = 0
    self.sellPrice = 0
    self.state = 0
    self.depth = null

    self.updateTrades = function() {
        var trades = _C(exchange.GetTrades)
        if (self.prices.length == 0) {
            while (trades.length == 0) {
                trades = trades.concat(_C(exchange.GetTrades))
            }
            for (var i = 0; i < 15; i++) {
                self.prices[i] = trades[trades.length - 1].Price
            }
        }
        self.vol = 0.7 * self.vol + 0.3 * _.reduce(trades, function(mem, trade) {
            // Huobi not support trade.Id
            if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
                self.lastTradeId = Math.max(trade.Id == 0 ? trade.Time : trade.Id, self.lastTradeId)
                mem += trade.Amount
            }
            return mem
        }, 0)

    }
    self.updateOrderBook = function() {
        var orderBook = _C(exchange.GetDepth)
        self.depth = orderBook
        self.buyPrice = orderBook.Bids[pendingLevel].Price
        self.sellPrice = orderBook.Asks[pendingLevel].Price
        self.orderBook = orderBook
        if (orderBook.Bids.length < 3 || orderBook.Asks.length < 3) {
            return
        }
        self.bidPrice = orderBook.Bids[0].Price * 0.618 + orderBook.Asks[0].Price * 0.382 + 0.01
        self.askPrice = orderBook.Bids[0].Price * 0.382 + orderBook.Asks[0].Price * 0.618 - 0.01
        self.prices.shift()
        self.prices.push(_N((orderBook.Bids[0].Price + orderBook.Asks[0].Price) * 0.15 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.1 +
            (orderBook.Bids[3].Price + orderBook.Asks[3].Price) * 0.075 +
            (orderBook.Bids[4].Price + orderBook.Asks[4].Price) * 0.05 +
            (orderBook.Bids[5].Price + orderBook.Asks[5].Price) * 0.025))
    }

    self.updateAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        LogProfit(parseFloat(account.Info.totalWalletBalance), account)
    }

    self.CancelAll = function() {
        while (1) {
            var orders = _C(exchange.GetOrders)
            if (orders.length == 0) {
                break
            }
            for (var i = 0; i < orders.length; i++) {
                exchange.CancelOrder(orders[i].Id)
            }
            Sleep(100)
        }
    }

    self.poll = function() {
        self.numTick++
        self.updateTrades()
        self.updateOrderBook()
        var pos = _C(exchange.GetPosition)

        var burstPrice = self.prices[self.prices.length - 1] * burstThresholdPct
        var bull = false
        var bear = false
        LogStatus(_D(), "\n", 'Tick:', self.numTick, 'self.vol:', self.vol, ', lastPrice:', self.prices[self.prices.length - 1], ', burstPrice: ', burstPrice)

        if (self.numTick > 2 && (
                self.prices[self.prices.length - 1] - _.max(self.prices.slice(-6, -1)) > burstPrice ||
                self.prices[self.prices.length - 1] - _.max(self.prices.slice(-6, -2)) > burstPrice && self.prices[self.prices.length - 1] > self.prices[self.prices.length - 2]
            )) {
            bull = true
        } else if (self.numTick > 2 && (
                self.prices[self.prices.length - 1] - _.min(self.prices.slice(-6, -1)) < -burstPrice ||
                self.prices[self.prices.length - 1] - _.min(self.prices.slice(-6, -2)) < -burstPrice && self.prices[self.prices.length - 1] < self.prices[self.prices.length - 2]
            )) {
            bear = true            
        }

        if (pos.length != 0) {
            if (pos[0].Type == PD_LONG) {
                self.state = 1
            } else {
                self.state = 2
            }
        } else {
            self.state = 0
        }


        if ((!bull && !bear)) {
            return
        }

        if (bull) {
            var price = (self.state == 0 || self.state == 1) ? self.buyPrice : self.depth.Bids[coverPendingLevel].Price
            var amount = (self.state == 0 || self.state == 1) ? pendingAmount : pos[0].Amount
            exchange.SetDirection("buy")
            exchange.Buy(price, amount)
        } else if (bear) {
            var price = (self.state == 0 || self.state == 2) ? self.sellPrice : self.depth.Asks[coverPendingLevel].Price
            var amount = (self.state == 0 || self.state == 2) ? pendingAmount : pos[0].Amount
            exchange.SetDirection("sell")
            exchange.Sell(price, amount)                    
        }
        self.numTick = 0
        Sleep(TickInterval)
        self.CancelAll()
        self.updateAccount()
    }

    while (!self.account) {
        self.updateAccount()
        Sleep(500)
    }
    Log("self.account:", self.account)

    return self
}

function main() {
    LogProfitReset()
    exchange.SetPrecision(pricePrecision, amountPrecision)
    exchange.SetContractType("swap")
    var reaper = LeeksReaper()  
    while (true) {
        reaper.poll()
        Sleep(100)
    }
}

La idea de modificar la estrategia

La estrategia es planear el comercio en el mercado de contratos Binance USDT, que admite posiciones unidireccionales. Por lo tanto, la estrategia se modifica de acuerdo con las características de la posición unidireccional (la posición unidireccional es más conveniente para modificar la estrategia), no consideramos cerrar la posición, solo consideramos la venta y compra. La idea está más cerca de la versión spot del LeeksReaper.

La estrategia mantiene básicamente el criterio original de la ruptura de la tendencia de los precios a corto plazo, que está controlada por el parámetroburstThresholdPCT, de acuerdo con el cual juzgar si el precio a corto plazo esbullo bienbear.

La estrategia elimina algunos de los módulos originales, como el módulo de balance. Se espera que se abra una posición a un costo más bajo en un juego caótico largo/corto, se siga la tendencia a corto plazo y se cierre la posición cuando la tendencia a corto plazo se invierta y se continúe abriendo la posición con una orden pendiente inversa.

La estrategia es corta y simple porque eliminó otro código inútil. Aunque la estrategia es una estrategia que no gana dinero, o incluso pierde dinero, pero como FMZer que están aprendiendo estrategia de alta frecuencia, observar el comportamiento de la estrategia de alta frecuencia, observar las micro-leyes del mercado es un modelo que se puede utilizar.

Optimización de la estrategia

En la actualidad, no se ha encontrado una buena dirección para la optimización. Alguien interesado puede dejar sus comentarios y discutir juntos.

Estrategia de:https://www.fmz.com/strategy/260806

Esta estrategia es sólo para aprender, el bot real puede tener pérdidas cuando el mercado no es muy optimista.