1. Cuadrado
  2. Negociación de la red de contratos bidireccionales v1.0.2

Negociación de la red de contratos bidireccionales v1.0.2

El autor:el viento, Fecha: 2021-06-24 15:37:17
Las etiquetas:Cuadrícula

Negociación de la red de contratos bidireccionales v1.0.2

Función

Negociación de la red de contratos Y también para hacer una diferencia de precio con más tiempo libre. La probabilidad de que las operaciones se produzcan es muy baja debido a la estrategia bidireccional.

  • Comprar con más tiempo de juicio
  • El doble juego
  • Cuenta automática
  • Tendencia abierta (en desarrollo, versión de pago)
  • Velocidad de crecimiento y descenso Dinámica de modificación de la cantidad de pedidos (en desarrollo, versión de pago)
  • La tendencia de la horquilla de oro se suma (en desarrollo, versión de pago)

Los datos de las revisiones

img

img

Se duplicó en el primer semestre de 2000. Las ganancias son evidentes y pueden ser sostenidas en cualquier momento, tanto en la subida como en la baja.

El mantenimiento

Optimización continua


/*backtest
start: 2021-01-01 00:00:00
end: 2021-06-21 23:59:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":2000}]
*/

// 首次买入
let FIRST_BUY = true;
// 已存在买涨订单
let MANY_BUYING = false;
// 已存在做空订单
let SHORT_BUYING = false;
// 买涨订单创建时间
let MANY_BUY_TIME = null;
// 做空订单创建时间
let SHORT_BUY_TIME = null;
// 买涨空仓时间
let MANY_EMPTY_STEP_TIME = null;
// 做空空仓时间
let SHORT_EMPTY_STEP_TIME = null;
// 校验空仓时间
let CHECK_TIME = null;

let QUANTITY = [0.001, 0.002, 0.004, 0.008, 0.016, 0.032, 0.064];
// 下次购买价格(多仓)
let MANY_NEXT_BUY_PRICE = 0;
// 下次购买价格(空仓)
let SHORT_NEXT_BUY_PRICE = 0;
// 当前仓位(多仓)
let MANY_STEP = 0;
// 当前仓位(空仓)
let SHORT_STEP = 0;
// 止盈比率
let PROFIT_RATIO = 1;
// 补仓比率
let DOUBLE_THROW_RATIO = 1.5;
// 卖出后下次购买金额下浮比率
let BUY_PRICE_RATIO = 1;
// 交易订单列表(多仓)
let MANY_ORDER_LIST = [];
// 交易订单列表(空仓)
let SHORT_ORDER_LIST = [];

function getManyQuantity() {
    if (MANY_STEP < QUANTITY.length) {
        return QUANTITY[MANY_STEP]
    }
    return QUANTITY[0]
}

function getShortQuantity() {
    if (SHORT_STEP < QUANTITY.length) {
        return QUANTITY[SHORT_STEP]
    }
    return QUANTITY[0]
}

function firstManyBuy(ticker) {
    if (MANY_BUYING) {
        return
    }
    exchange.SetDirection("buy")
    let orderId = exchange.Buy(ticker.Last, getManyQuantity())
    if (!orderId) {
        return
    }
    MANY_BUYING = true
    while (true) {
        exchange.SetDirection("buy") 
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        if (1 === order.Status || 2 === order.Status) {
            MANY_NEXT_BUY_PRICE = order.Price * ((100 - DOUBLE_THROW_RATIO) / 100)
            MANY_STEP = MANY_STEP + 1
            MANY_BUYING = false
            MANY_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 + PROFIT_RATIO) / 100)
            MANY_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
    }
}

function firstShortBuy(ticker) {
    if (SHORT_BUYING) {
        return
    }
    exchange.SetDirection("sell")
    let orderId = exchange.Sell(ticker.Last, getShortQuantity())
    if (!orderId) {
        return
    }
    SHORT_BUYING = true
    while (true) {
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        if (1 === order.Status || 2 === order.Status) {
            SHORT_NEXT_BUY_PRICE = order.Price * ((100 + DOUBLE_THROW_RATIO) / 100)
            SHORT_STEP = SHORT_STEP + 1
            SHORT_BUYING = false
            SHORT_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 - PROFIT_RATIO) / 100)
            SHORT_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
    }
}

function manyBuy(ticker) {
    if (MANY_BUYING) {
        return
    }
    Log('ticker: ' + ticker.Last + ' MANY_NEXT_BUY_PRICE: ' + MANY_NEXT_BUY_PRICE)
    if (ticker.Last > MANY_NEXT_BUY_PRICE) {
        return
    }
    exchange.SetDirection("buy")
    let orderId = exchange.Buy(ticker.Last, getManyQuantity())
    if (!orderId) {
        return
    }
    MANY_BUYING = true
    MANY_BUY_TIME = Unix()
    while (true) {
        let now = Unix()
        let order = exchange.GetOrder(orderId)
        let expire = MANY_BUY_TIME + (60 * 30)
        if (null === order) {
            continue
        }
        // 买入成功处理
        if (1 === order.Status || 2 === order.Status) {
            MANY_NEXT_BUY_PRICE = order.Price * ((100 - DOUBLE_THROW_RATIO) / 100)
            MANY_STEP = MANY_STEP + 1
            MANY_BUYING = false
            MANY_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 + PROFIT_RATIO) / 100)
            MANY_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
        // 买入超时处理
        if (now >= expire) {
            exchange.CancelOrder(orderId)
            MANY_BUYING = false
            MANY_BUY_TIME = null
            MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - DOUBLE_THROW_RATIO) / 100)
            return
        }
    }
}

function shortBuy(ticker) {
    if (SHORT_BUYING) {
        return
    }
    Log('ticker: ' + ticker.Last + ' SHORT_NEXT_BUY_PRICE: ' + SHORT_NEXT_BUY_PRICE)
    if (ticker.Last < SHORT_NEXT_BUY_PRICE) {
        return
    }
    exchange.SetDirection("sell")
    let orderId = exchange.Sell(ticker.Last, getShortQuantity())
    if (!orderId) {
        return
    }
    SHORT_BUYING = true
    SHORT_BUY_TIME = Unix()
    while (true) {
        let now = Unix()
        let expire = SHORT_BUY_TIME + (60 * 30)
        let order = exchange.GetOrder(orderId)
        if (null === order) {
            continue
        }
        // 买入成功处理
        if (1 === order.Status || 2 === order.Status) {
            SHORT_NEXT_BUY_PRICE = order.Price * ((100 + DOUBLE_THROW_RATIO) / 100)
            SHORT_STEP = SHORT_STEP + 1
            SHORT_BUYING = false
            SHORT_EMPTY_STEP_TIME = null
            let sellPrice = order.Price * ((100 - PROFIT_RATIO) / 100)
            SHORT_ORDER_LIST.push({
                buyPrice: order.Price,
                sellPrice: sellPrice,
                quantity: order.Amount,
                isSell: false,
            })
            break
        }
        // 买入超时处理
        if (now >= expire) {
            exchange.CancelOrder(orderId)
            SHORT_BUYING = false
            SHORT_BUY_TIME = null
            SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + DOUBLE_THROW_RATIO) / 100)
            return
        }
    }
}


function manySell(ticker) {
    // 遍历卖出订单
    for (let item of MANY_ORDER_LIST) {
        if (item.isSell) {
            continue
        }
        if (ticker.Last >= item.sellPrice) {
            item.isSell = true;
            exchange.SetDirection("closebuy")
            let orderId = exchange.Sell(ticker.Last, item.quantity)
            if (!orderId) {
                return
            }
            while (true) {
                let order = exchange.GetOrder(orderId)
                if (null === order) {
                    continue
                }
                if (1 === order.Status || 2 === order.Status) {
                    MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - BUY_PRICE_RATIO) / 100)
                    MANY_STEP = MANY_STEP - 1
                    if (0 === MANY_STEP) {
                        MANY_EMPTY_STEP_TIME = Unix()
                    }
                    break
                }
            }
        }
    }
}

function shortSell(ticker) {
    // 遍历卖出订单
    for (let item of SHORT_ORDER_LIST) {
        if (item.isSell) {
            continue
        }
        if (ticker.Last <= item.sellPrice) {
            item.isSell = true;
            exchange.SetDirection("closesell")
            let orderId = exchange.Buy(ticker.Last, item.quantity)
            if (!orderId) {
                return
            }
            while (true) {
                let order = exchange.GetOrder(orderId)
                if (null === order) {
                    continue
                }
                if (1 === order.Status || 2 === order.Status) {
                    SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + BUY_PRICE_RATIO) / 100)
                    SHORT_STEP = SHORT_STEP - 1
                    if (0 === SHORT_STEP) {
                        SHORT_EMPTY_STEP_TIME = Unix()
                    }
                    break
                }
            }
        }
    }
}

function check(ticker) {
    let now = Unix()
    if (null !== CHECK_TIME) {
        let expire = CHECK_TIME + (60 * 10)
        if (now < expire) {
            return
        }
    }
    CHECK_TIME = now

    if (null !== MANY_EMPTY_STEP_TIME) {
        let expire = MANY_EMPTY_STEP_TIME + (60 * 30)
        if (now >= expire) {
            MANY_NEXT_BUY_PRICE = ticker.Last * ((100 - DOUBLE_THROW_RATIO) / 100)
            Log('没有买涨持仓, 调整买入价: ' + MANY_NEXT_BUY_PRICE)
        }
    }
    
    if (null !== SHORT_EMPTY_STEP_TIME) {
        let expire = SHORT_EMPTY_STEP_TIME + (60 * 30)
        if (now >= expire) {
            SHORT_NEXT_BUY_PRICE = ticker.Last * ((100 + DOUBLE_THROW_RATIO) / 100)
            Log('没有做空持仓, 调整买入价: ' + SHORT_NEXT_BUY_PRICE)
        }
    }
}

function onTick() {
    // 在这里写策略逻辑，将会不断调用，例如打印行情信息
    let ticker = exchange.GetTicker()
    if (!ticker) {
        return
    }
    if (FIRST_BUY) {
        // 首次做多购买
        firstManyBuy(ticker)
        // 首次做空购买
        firstShortBuy(ticker)
        FIRST_BUY = false
        return
    }
    
    // 做多买入
    manyBuy(ticker)
    // 做空买入
    shortBuy(ticker)
    // 做多卖出
    manySell(ticker)
    // 做空卖出
    shortSell(ticker)
    // 空仓检测
    check(ticker)
}

function main() {
    // 开合约
    exchange.SetContractType("swap")

    while(true){
        onTick()
        // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁
        Sleep(60000)
    }
}
Relacionados
Más.

Hexie8 es muy bueno.¿Puede haber más monedas?

¿ Qué quieres decir?¿Qué significa cheque? ¿Qué significa que regularmente aumenta o disminuye el umbral de compra?

Artrón¿Por qué no tiene la configuración de parámetros estratégicos?

Exodus [traducción de la estrategia]También se encontró un problema: en el retest de 2020-1-1 a junio de 2020, el robot entero se detuvo en el 3-30 y, además, en el test de 2021-1-1 a 201-6-21, el ETH se detuvo en el 1-2, sin saber si era un problema de fmz o un problema de robot.

- ¿ Por qué?No puede ser una cobertura real de múltiples espacios, como una red de contratos.

Exodus [traducción de la estrategia]El autor de WeChat no respondió, sólo podía venir aquí y decir unas palabras, funcionó durante 7 días, 200 cuchillos y 70 cuchillos de oro. 1. ¿Es normal la función de apertura de una sola opción bidireccional? Ver la estrategia dice que se lee una sola opción bidireccional, la probabilidad de explosión es pequeña, pero en siete días, excepto cuando el robot se inicia, se abre una sola opción bidireccional, casi no se abre una sola opción bidireccional, después de mi investigación, se encontró que se actualiza una posición bidireccional en 10 minutos, lo que resulta en cambios lentos, no tiene sentido, ni se abre una sola opción bidireccional, por ejemplo, hoy la caída del 5% de BTC hoy no se abre una sola opción. 2. explotar sobre el capital de la hipoteca por defecto, no quiero que la hipoteca necesita para asegurar que los fondos de 1000 cuchillos a 2000 cuchillos más, tengo doscientos cuchillos hoy si no hay ninguna razón extraña para despertarme ya he explotado, la garantía adicional temporal. Si el dinero no es suficiente, también se puede ajustar manualmente la cantidad de la hipoteca, aquí le recuerdo, no vea el código de la hipoteca explosiva. 3. Por favor, pregúntame, ya que nunca se detienen las pérdidas, por lo que en caso de capital suficiente, ¿nunca se abrirá el mercado, pero por qué se producen pérdidas en la revisión? Esta estrategia me gusta bastante, se puede obtener ganancias independientemente de la dirección, ajustar el aumento de la posición y el riesgo de explosión de capital no es grande, la sensación de ajustar el espacio abierto y el precio de la venta puede ser optimizado, según el capital añadido el aumento de la posición de adaptación, etc.

Sí, también.El hermano de WeChat

Exodus [traducción de la estrategia]Se solucionó, el cambio de Bitcoin es perfecto.

Exodus [traducción de la estrategia]Ver el recuadro se siente bien, pero ¿es como si no pudiera usarse en el disco real? Si abro el token bch se producirá un error, Sell ((490.14, 0.001): map[err_code:1067 err_msg:The volume field is illegal. Please re-enter. status:error ts:1.625132342294e+12].

el uso de la¿No hay un disco real?

Exodus [traducción de la estrategia]La curva de ganancias es terrible, más del 120%.

Envié una lámpara para ver la espada.Me ha hecho reír.

Exodus [traducción de la estrategia]Me siento mal, hoy he perdido mucho dinero, estoy esperando 2.0 por favor, ¿cómo puedo experimentar esta nueva estrategia?

el vientoEstos problemas fueron descubiertos en la versión 2.0 del desarrollo. La razón por la que no se puede hacer un descuento es porque el porcentaje de pago es fijo, es decir, el aumento del uno por ciento, el descuento, el descenso del uno por ciento, el aumento del uno por ciento. Debido a que los descensos son de un porcentaje, el porcentaje de compra de los descensos es uniforme, de 1000 toneladas a 1500, y el porcentaje de 1000 y el porcentaje de 1500 no son diferentes, los vacíos son más difíciles de comprar y los precios cambian con demasiada frecuencia, lo que hace que los vacíos puedan no ser comprados. El problema del stop loss, en la versión 2.0 se hizo un cierto tratamiento, un tratamiento de stop loss muy simple, pero desde el punto de vista de los datos de retrospección, el efecto también puede ser, cuando usted compra una bolsa o hace una posición vacía cuando se alcanza un cierto umbral, 1.0 no se procesa, por lo que puede aparecer que algunos pedidos nunca se pueden realizar, por ejemplo, en el BTC 65000 el número de compradores 0.001, entonces el BTC cayó esta lista nunca se puede salir. /upload/asset/2034c4ec56c423120b9c6.png /upload/asset/203032c94e60a3915cc9f.png /upload/asset/2030b880b030476977f4b.png /upload/asset/2030d89e9fd59f528be4c.png /upload/asset/2030d89e9fd59f528be4c.png /upload/asset/2030b880b030476977f4b.png /upload/asset/2030d89e9fd59f528be4c.png

el vientoHe probado con Binance el disco real que está funcionando y otras plataformas pueden reportar errores.

el vientoEl disco real todavía está funcionando, necesita tiempo

el vientoSi nos fijamos en la curva más reciente, la anterior tiene un error.

2019 FMZ - Todos los derechos reservados