El trading de alta frecuencia es un campo desafiante y competitivo que depende de la ejecución rápida de operaciones y de conocimientos sensibles de la microestructura del mercado. Una de las estrategias que ha recibido mucha atención es el Penny Jump, que se centra en aprovechar los “elefantes” del mercado para obtener ganancias pequeñas pero frecuentes. En este artículo, explicaremos en detalle cómo funciona la estrategia Penny Jump y profundizaremos en los detalles del código de la estrategia para que los principiantes puedan comprender cómo funciona.

Entendiendo la estrategia del Penny Jump

En el mercado de valores, los “elefantes” suelen ser inversores institucionales que desean comprar o vender grandes cantidades de acciones pero no están dispuestos a negociar a precios de mercado. En lugar de ello, optan por colocar una gran cantidad de órdenes limitadas, también conocidas como órdenes pendientes, en el mercado para indicar sus intenciones. Este comportamiento ha atraído una gran atención en el mercado porque las transacciones grandes pueden tener un impacto significativo en el mercado.

Por ejemplo, supongamos que la profundidad de mercado de una acción originalmente se veía así: 200 | \(1,01 x \)1,03 | 200. Luego, entró un “elefante” y realizó una orden para comprar 3.000 acciones a 1,01 dólares. En este punto, la profundidad del mercado será 3200 | \(1,01 x \)1,03 | 200. Esta acción es como introducir un “elefante” que se convierte en el foco de atención de los demás participantes en el mercado.

• Mercado competitivo Para los traders de alta frecuencia, sus ganancias provienen principalmente del análisis de la microestructura del mercado para inferir las intenciones de otros traders. Una vez que aparece un elefante, los traders de alta frecuencia establecerán rápidamente posiciones para capturar pequeñas fluctuaciones de precios. Su objetivo es realizar transacciones frecuentes durante un corto período de tiempo, acumulando ganancias pequeñas pero acumulativas.

• La difícil situación de los elefantes Si bien los elefantes pueden desear operar a gran escala en el mercado, sus acciones también delatan sus intenciones comerciales, lo que los convierte en objetivos para los traders de alta frecuencia. Los traders de alta frecuencia intentan establecer posiciones con antelación y luego se benefician de las fluctuaciones de precios. La presencia de un elefante en el mercado puede desencadenar una reacción en el mercado competitivo, afectando así su estrategia comercial.

• Engaño en el mercado En realidad, los grandes inversores institucionales no suelen colocar descaradamente un gran número de órdenes de compra o venta en el mercado, porque ese comportamiento puede provocar que otros participantes del mercado tomen contramedidas o incluso manipulen el mercado. Por lo tanto, pueden adoptar estrategias para crear impresiones falsas para atraer a los traders de alta frecuencia para que ingresen al mercado y luego vendan o compren rápidamente para beneficiarse de las fluctuaciones de los precios.

La idea central de la estrategia Penny Jump

La idea central de la estrategia Penny Jump es que una vez que aparece un elefante en el mercado y soporta un precio específico (por ejemplo, \( 1,01), los traders de alta frecuencia aumentarán rápidamente sus ofertas en un centavo, por ejemplo a \) 1,02. Esto se debe a que los traders de alta frecuencia entienden que la aparición de un elefante significa que hay un fuerte soporte de compra en ese nivel de precios, por lo que intentan seguirlo con la esperanza de que el precio suba. Cuando el precio sube a \(1,03 x \)1,05, el trader de alta frecuencia puede vender rápidamente y obtener una ganancia de $0,01.

No sólo eso, los traders de alta frecuencia también pueden obtener ganancias después de comprar incluso si el precio no sube. Como saben que el elefante apoya el precio más bajo, pueden vender rápidamente sus acciones al elefante y obtener una pequeña ganancia por la diferencia.

Analizando el código de la estrategia Penny Jump

Código fuente de la estrategia: https://www.fmz.com/strategy/358

El código de estrategia proporcionado arriba es un ejemplo que implementa la estrategia Penny Jump. Aquí hay una explicación detallada del código para que los principiantes puedan entender cómo funciona:

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

// Variables
var InitAccount = null;

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

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", Counter.f, "\n"+msg+"#0000ff\n"+new Date());
}

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("买单得手: " + opAmount +", 开始出手...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

Revisaré el código de estrategia que proporcionaste línea por línea para ayudarte a entender cómo funciona con más detalle.

var Counter = {
    i: 0,
    w: 0,
    f: 0
};

Este código inicializa un objeto llamado Contador, que se utiliza para rastrear las estadísticas comerciales de la estrategia. En concreto, incluye tres atributos:

• i: indica el número total de transacciones.
• w: indica el número de transacciones exitosas.
• f: indica el número de transacciones fallidas.

Estos atributos se registran y actualizan durante la ejecución de la política.

var InitAccount = null;

Esta línea de código inicializa una variable llamada InitAccount, que almacenará la información de la cuenta cuando la estrategia comience a ejecutarse.

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

Este es unCancelAll()El propósito de esta función es cancelar todas las órdenes abiertas en el mercado. Vamos a explicar su funcionalidad paso a paso:

• while (true):Este es un bucle infinito que se ejecutará hasta que no haya pedidos pendientes.
• var orders = _C(exchange.GetOrders):Esta línea de código utiliza la función exchange.GetOrders para obtener todos los pedidos pendientes de la cuenta actual y los almacena en la variable orders.
• if (orders.length == 0):Esta línea de código verifica si hay pedidos sin cumplir. Si la longitud de la matriz de pedidos es 0, significa que no hay pedidos sin cumplir y el bucle se interrumpirá.
• for (var i = 0; i < orders.length; i++):Este es un bucle for que itera a través de todos los pedidos pendientes.
• exchange.CancelOrder(orders[i].Id):Esta línea de código utiliza la función exchange.CancelOrder() para cancelar cada pedido por su ID de pedido.
• Sleep(Interval):Esta línea de código introduce un ciclo de espera, esperando durante un cierto período de tiempo (en milisegundos) para garantizar que la operación de cancelación de pedido no sea demasiado frecuente.

El propósito de esta función es garantizar que antes de ejecutar la estrategia principal, no existan órdenes pendientes para evitar interferir con la ejecución de la estrategia principal.

function updateStatus(msg) {
    LogStatus("调戏次数:", Counter.i, "成功:", Counter.w, "失败:", Counter.f, "\n" + msg + "#0000ff\n" + new Date());
}

Este es unupdateStatus(msg)Una función que actualiza la información del estado de la transacción y la registra. Acepta un parámetro msg que generalmente contiene información sobre el estado actual del mercado. Las operaciones específicas de la función incluyen:

usarLogStatus()La función registra la información que se muestra en la barra de estado cuando se ejecuta la estrategia. Muestra el texto sobre el número de transacciones, éxitos y fracasos. AdjuntomsgParámetros que contienen información sobre el estado actual del mercado. Se añade la marca de tiempo actual (new Date()) para mostrar información de la hora. El propósito de esta función es registrar y actualizar la información del estado del comercio para el monitoreo y análisis durante la ejecución de la estrategia.

function main() {
    if (DisableLog) {
        EnableLog(false);
    }
    CancelAll();
    InitAccount = _C(exchange.GetAccount);
    Log(InitAccount);
    var i = 0;
    var locks = 0;
    while (true) {
        Sleep(Interval);
        var depth = _C(exchange.GetDepth);
        if (depth.Asks.length === 0 || depth.Bids.length === 0) {
            continue;
        }
        updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);
        var askPrice = 0;
        for (i = 0; i < depth.Asks.length; i++) {
            if (depth.Asks[i].Amount >= Lot) {
                askPrice = depth.Asks[i].Price;
                break;
            }
        }
        if (askPrice === 0) {
            continue;
        }
        var elephant = null;
        // skip Bids[0]
        for (i = 1; i < depth.Bids.length; i++) {
            if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
                break;
            }
            if (depth.Bids[i].Amount >= ElephantAmount) {
                elephant = depth.Bids[i];
                break;
            }
        }

        if (!elephant) {
            locks = 0;
            continue;
        }
        locks++;
        if (locks < LockCount) {
            continue;
        }
        locks = 0;

        updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
        exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
        var ts = new Date().getTime();
        while (true) {
            Sleep(CheckInterval);
            var orders = _C(exchange.GetOrders);
            if (orders.length == 0) {
                break;
            }
            if ((new Date().getTime() - ts) > WaitInterval) {
                for (var i = 0; i < orders.length; i++) {
                    exchange.CancelOrder(orders[i].Id);
                }
            }
        }
        var account = _C(exchange.GetAccount);
        var opAmount = _N(account.Stocks - InitAccount.Stocks);
        if (opAmount < 0.001) {
            Counter.f++;
            Counter.i++;
            continue;
        }
        updateStatus("买单得手: " + opAmount +", 开始出手...");
        exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
        var success = true;
        while (true) {
            var depth = _C(exchange.GetDepth);
            if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price-(STTick*PennyTick))) {
                success = false;
                updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
                CancelAll();
                account = _C(exchange.GetAccount);
                var opAmount = _N(account.Stocks - InitAccount.Stocks);
                if (opAmount < 0.001) {
                    break;
                }
                exchange.Sell(depth.Bids[0].Price, opAmount);
            }
            var orders = _C(exchange.GetOrders);
            if (orders.length === 0) {
                break;
            }
            Sleep(CheckInterval);
        }
        if (success) {
            Counter.w++;
        } else {
            Counter.f++;
        }
        Counter.i++;
        var account = _C(exchange.GetAccount);
        LogProfit(account.Balance - InitAccount.Balance, account);
    }
}

Esta es la principal función de ejecución de la estrategia.main(), que contiene la lógica central de la estrategia. Expliquemos su funcionamiento línea por línea:

• if (DisableLog):Esta línea de código verifica si la variable DisableLog es verdadera y, si es así, deshabilita el registro. Esto es para garantizar que la política no registre información innecesaria.

• CancelAll():Llame a la función CancelAll() explicada anteriormente para asegurarse de que no existan pedidos sin completar.

• InitAccount = _C(exchange.GetAccount):Esta línea de código obtiene la información de la cuenta actual y la almacena en la variable InitAccount. Esto se utilizará para registrar el estado de la cuenta cuando la estrategia comience a ejecutarse.

• var i = 0; y var locks = 0;:Inicializa dos variables i y bloqueos, que se utilizarán en la lógica de estrategia posterior.

• while (true):Este es un bucle infinito, utilizado principalmente para la ejecución continua de estrategias.

A continuación, lo explicaremos línea por línea.while (true)La lógica de la estrategia principal dentro del bucle.

while (true) {
    Sleep(Interval);
    var depth = _C(exchange.GetDepth);
    if (depth.Asks.length === 0 || depth.Bids.length === 0) {
        continue;
    }
    updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ",  卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks);

• Sleep(Interval):Esta línea de código permite que la estrategia permanezca en reposo durante un período de tiempo para controlar la frecuencia de ejecución de la estrategia. El parámetro Intervalo define el intervalo de sueño en milisegundos.

• var depth = _C(exchange.GetDepth):Obtenga la información de profundidad del mercado actual, incluido el precio y la cantidad de órdenes de compra y venta. Esta información se almacenará en la variable de profundidad.

• if (depth.Asks.length === 0 || depth.Bids.length === 0):Esta línea de código verifica la información de profundidad del mercado para garantizar que existan órdenes de compra y venta. Si uno de ellos no existe, significa que el mercado puede no tener suficiente información comercial y la estrategia seguirá esperando.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks):Esta línea de código llama a la función updateStatus para actualizar la información de estado de la estrategia. Registra el estado actual del mercado, incluido el precio de oferta, el precio de venta y el número de bloqueos anteriores.

    var askPrice = 0;
    for (i = 0; i < depth.Asks.length; i++) {
        if (depth.Asks[i].Amount >= Lot) {
            askPrice = depth.Asks[i].Price;
            break;
        }
    }
    if (askPrice === 0) {
        continue;
    }
    var elephant = null;

• var askPrice = 0;:Inicialice la variable askPrice, que se utilizará para almacenar el precio de la orden de venta que cumple las condiciones.

• for (i = 0; i < depth.Asks.length; i++):Este es un bucle for que se utiliza para iterar sobre la información de precio y cantidad de la orden de venta del mercado.

• if (depth.Asks[i].Amount >= Lot):En el bucle, verifique si la cantidad de cada orden de venta es mayor o igual al lote especificado. Si es así, almacene el precio de la orden de venta en askPrice y finalice el bucle.

• if (askPrice === 0):Si no se encuentra una orden de venta satisfactoria (askPrice sigue siendo 0), la estrategia continuará esperando y omitirá las operaciones posteriores.

• var elephant = null;:Inicialice la variable elefante, que se utilizará para almacenar la información de la orden de compra identificada como “elefante”.

    for (i = 1; i < depth.Bids.length; i++) {
        if ((askPrice - depth.Bids[i].Price) > ElephantSpace) {
            break;
        }
        if (depth.Bids[i].Amount >= ElephantAmount) {
            elephant = depth.Bids[i];
            break;
        }
    }

    if (!elephant) {
        locks = 0;
        continue;
    }
    locks++;
    if (locks < LockCount) {
        continue;
    }
    locks = 0;

Continúe iterando a través de la información de precio y cantidad de las órdenes de compra del mercado, omitiendo la primera orden de compra (Ofertas)[0]）。

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace):Verifique si la diferencia entre el precio de compra actual y el precio de venta es mayor que ElephantSpace. Si es así, significa que está lo suficientemente lejos del “elefante” y la estrategia no continuará buscando.

• if (depth.Bids[i].Amount >= ElephantAmount): Comprueba si el importe de la orden de compra actual es mayor o igual que ElephantAmount. Si es así, almacena la información de la orden de compra en la variable Elephant.

• if (!elephant):Si no se encuentra el “elefante”, restablezca el recuento de bloqueo a 0 y continúe esperando.

locks++: Si se encuentra el “elefante”, se incrementará el número de bloqueos. Esto es para garantizar que la estrategia se ejecute después de que la existencia del “elefante” se confirme varias veces durante un período de tiempo.

• if (locks < LockCount):Verifique si el número de bloqueos alcanza el requisito (LockCount). Si no se cumplen los requisitos, continúe esperando.

    updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant));
    exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant);
    var ts = new Date().getTime();
    while (true) {
        Sleep(CheckInterval);
        var orders = _C(exchange.GetOrders);
        if (orders.length == 0) {
            break;
        }
        if ((new Date().getTime() - ts) > WaitInterval) {
            for (var i = 0; i < orders.length; i++) {
                exchange.CancelOrder(orders[i].Id);
            }
        }
    }

• updateStatus("调戏大象中....大象在第" + i + "档, " + JSON.stringify(elephant)):Llame a la función updateStatus para registrar el estado actual de la estrategia, incluida la posición del engranaje del “elefante” encontrado y la información relacionada. Esto se indicará en la columna Estado de la política.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant):Utilice la función Intercambio.Comprar para comprar el “elefante” encontrado. El precio de compra es elephant.Price + PennyTick, la cantidad de compra es Lot y la operación de compra se describe como “Ofertas”.[” + i + “]“。

• var ts = new Date().getTime():Obtener la marca de tiempo de la hora actual para el cálculo posterior de intervalos de tiempo.

• while (true):Introduzca un nuevo bucle infinito para esperar la ejecución de la orden de compra “elefante”.

• Sleep(CheckInterval):La estrategia duerme durante un período de tiempo para controlar la frecuencia con la que se verifica el estado del pedido.

• var orders = _C(exchange.GetOrders):Obtener toda la información del pedido de la cuenta actual.

• if (orders.length == 0):Verifique si hay pedidos sin completar, si no, salga del circuito.

• (new Date().getTime() - ts) > WaitInterval: Calcula el intervalo de tiempo entre la hora actual y la hora en la que se compra el “elefante”. Si supera WaitInterval, significa que se agotó el tiempo de espera.

• for (var i = 0; i < orders.length; i++): Iterar sobre todos los pedidos no completados.

• exchange.CancelOrder(orders[i].Id):Cancele cada orden abierta utilizando la función exchange.CancelOrder.

    var account = _C(exchange.GetAccount);
    var opAmount = _N(account.Stocks - InitAccount.Stocks);
    if (opAmount < 0.001) {
        Counter.f++;
        Counter.i++;
        continue;
    }
    updateStatus("买单得手: " + opAmount + ", 开始出手...");
    exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount);
    var success = true;
    while (true) {
        var depth = _C(exchange.GetDepth);
        if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))) {
            success = false;
            updateStatus("没有得手, 开始止损, 当前买一: " + depth.Bids[0].Price);
            CancelAll();
            account = _C(exchange.GetAccount);
            var opAmount = _N(account.Stocks - InitAccount.Stocks);
            if (opAmount < 0.001) {
                break;
            }
            exchange.Sell(depth.Bids[0].Price, opAmount);
        }
        var orders = _C(exchange.GetOrders);
        if (orders.length === 0) {
            break;
        }
        Sleep(CheckInterval);
    }
    if (success) {
        Counter.w++;
    } else {
        Counter.f++;
    }
    Counter.i++;
    var account = _C(exchange.GetAccount);
    LogProfit(account.Balance - InitAccount.Balance, account);
}

• var account = _C(exchange.GetAccount):Obtener información actual de la cuenta.

• var opAmount = _N(account.Stocks - InitAccount.Stocks):Calcula el cambio en los activos en la cuenta después de comprar “Elefante”. Si el cambio es menor a 0,001, significa que la compra ha fallado, se incrementará el número de fallas y se continuará con el siguiente ciclo.

• updateStatus("买单得手: " + opAmount + ", 开始出手..."):Registra la información de la compra exitosa de “elefante”, incluida la cantidad de compra.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount):Utilice la función exchange.Sell para vender el “elefante” comprado exitosamente y obtener ganancias. El precio de venta es elefante.Precio + (PennyTick * ProfitTick).

Entra en un nuevo bucle infinito esperando la ejecución de la orden de venta.

• var depth = _C(exchange.GetDepth):Obtenga información sobre la profundidad del mercado.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))):Verifique la información de profundidad del mercado. Si el precio del mercado ha caído hasta el precio de stop loss, ejecute la operación de stop loss.

• CancelAll():Llame a la función CancelAll() para cancelar todas las órdenes incompletas para evitar riesgos de posición.

• if (opAmount < 0.001): Verifique nuevamente la cantidad de compra. Si es menor a 0,001, significa que la compra falló y se saldrá del bucle.

• exchange.Sell(depth.Bids[0].Price, opAmount):Ejecutar una operación de stop loss y vender los activos restantes al precio más bajo del mercado actual.

Finalmente, dependiendo de si la transacción es exitosa o no, se actualiza el número de éxitos y fracasos y se registra la ganancia de la transacción.

Ésta es una explicación línea por línea de toda la estrategia. La idea central de esta estrategia es buscar “elefantes” (grandes órdenes de compra) en el mercado, comprarlos y venderlos para obtener pequeñas ganancias. Incluye varios parámetros importantes, como la cantidad de compra (Lote), el intervalo de reintento de error (Intervalo), el nivel del elefante (ElephantAmount), la distancia del elefante (ElephantSpace), etc., para ajustar el comportamiento de la estrategia.

En general, esta estrategia es una estrategia comercial de alta frecuencia que tiene como objetivo explotar la información de profundidad del mercado, identificar grandes órdenes de compra y ejecutar transacciones de compra y venta en un período corto de tiempo. Requiere monitorear constantemente el mercado y ejecutar operaciones de compra y venta para obtener rápidamente pequeñas ganancias. Sin embargo, también es una estrategia de alto riesgo, ya que requiere una respuesta rápida a las fluctuaciones del mercado, considerando también la gestión de riesgos y mecanismos de stop-loss para evitar pérdidas significativas.

Tenga en cuenta que esta estrategia se basa en mercados y plataformas comerciales específicos y es posible que deba ajustarse y optimizarse adecuadamente para diferentes mercados e intercambios. En la aplicación práctica, los inversores necesitan probar y evaluar cuidadosamente el rendimiento de la estrategia para asegurarse de que sea coherente con sus objetivos de inversión y su tolerancia al riesgo.

A medida que continúe ejecutando la estrategia, esta seguirá repitiéndose y hará lo siguiente:

1. En primer lugar, la estrategia verifica la información de profundidad del mercado para comprender las órdenes de compra y venta actuales.

2. A continuación, la estrategia intentará encontrar una orden de venta que cumpla las condiciones, donde la cantidad de la orden de venta sea mayor o igual al Lote. Si se encuentra una orden de venta que cumple las condiciones, el precio de la orden de venta se registrará como askPrice.

3. La estrategia luego continúa buscando “elefantes” (grandes órdenes de compra). Iterará a través de las órdenes de compra en el mercado, omitiendo la primera orden de compra (generalmente la orden de compra con el precio más alto). Si se encuentra un “elefante” que cumpla las condiciones, se registrará la información del “elefante” y se aumentará el número de cerraduras.

4. Si se encuentran suficientes “elefantes” consecutivamente (controlados por el parámetro LockCount), la estrategia realizará además las siguientes operaciones:

• Llame a la función updateStatus para registrar la posición del engranaje del “elefante” y la información relacionada.
• Utilice la función Exchange.Buy para comprar “elephant”, el precio de compra es elephant.Price + PennyTick, y la cantidad de compra es Lot.
• Inicia un nuevo bucle infinito esperando la ejecución de una orden de compra.
• Verifique el estado del pedido y, si se completó, salga del bucle.
• Si el tiempo de espera excede el intervalo de espera establecido (WaitInterval), todos los pedidos no completados serán cancelados.
• Calcular el cambio en los activos de la cuenta después de una compra exitosa. Si el cambio es menor a 0,001, significa que la compra falló; aumente el número de fallas y continúe con el siguiente ciclo.
• Registre la información de la compra exitosa de “elefantes”, incluida la cantidad de compra.

1. A continuación, la estrategia continuará entrando en un nuevo bucle infinito, a la espera de la ejecución de la operación de venta. En este bucle, hace lo siguiente:

• Obtenga información sobre la profundidad del mercado y verifique si el precio del mercado ha alcanzado el nivel de stop loss.
• Si el precio de mercado alcanza o cae por debajo del precio de stop loss, se ejecutará la operación de stop loss, es decir, se venderán los activos restantes.
• Llame a la función CancelAll para cancelar todas las órdenes incompletadas para reducir los riesgos de posición.
• Verifique nuevamente el cambio en los activos de la cuenta después de que la compra se haya realizado correctamente. Si el cambio es menor a 0,001, significa que la compra falló y se sale del bucle.
• Por último, registre si la transacción es exitosa o no y actualice el número de éxitos y fracasos en función de los resultados de la transacción.

Toda la estrategia repite continuamente las operaciones mencionadas anteriormente para capturar tantos “elefantes” como sea posible y obtener pequeñas ganancias. Se trata de una estrategia de trading de alta frecuencia que requiere una respuesta rápida a los cambios del mercado y que al mismo tiempo considera la gestión de riesgos y mecanismos de stop loss para proteger el capital. Los inversores deberían considerar cuidadosamente el uso de esta estrategia, especialmente en mercados altamente volátiles.

Conclusión

La estrategia Penny Jump es un ejemplo clásico de trading de alta frecuencia, que demuestra el juego sutil y la competencia entre los participantes del mercado. Esta estrategia es particularmente prominente en el mercado de criptomonedas, donde la volatilidad es alta y los inversores institucionales y los traders de alta frecuencia buscan ganancias rápidas. Sin embargo, esto también hace que el mercado sea desafiante y requiera una constante adaptación y ajuste de las estrategias para mantener la ventaja competitiva. En este mundo ferozmente competitivo, sólo aquellos traders que sean buenos en observar la microestructura del mercado y responder rápidamente tendrán éxito.