A negociação de alta frequência é um campo desafiador e competitivo que depende da execução rápida de negociações e de insights sensíveis sobre a microestrutura do mercado. Uma das estratégias que tem recebido muita atenção é o Penny Jump, que se concentra em aproveitar os “elefantes” do mercado para obter lucros pequenos, mas frequentes. Neste artigo, explicaremos em detalhes como a estratégia Penny Jump funciona, ao mesmo tempo em que nos aprofundamos nos detalhes do código da estratégia para que os iniciantes possam entender como ela funciona.

Compreendendo a estratégia do Penny Jump

No mercado de ações, os “elefantes” geralmente são investidores institucionais que querem comprar ou vender grandes quantidades de ações, mas não estão dispostos a negociar a preços de mercado. Em vez disso, eles optam por colocar um grande número de ordens limitadas, também conhecidas como ordens pendentes, no mercado para indicar suas intenções. Esse comportamento atraiu grande atenção no mercado porque grandes transações podem ter um impacto significativo no mercado.

Por exemplo, suponha que a profundidade de mercado de uma ação originalmente fosse assim: 200 | US\( 1,01 x US\) 1,03 | 200. Então, um “elefante” entrou e fez uma ordem de compra de 3.000 ações a US\( 1,01. Neste ponto, a profundidade do mercado se tornará 3.200 | US\) 1,01 x US$ 1,03 | 200. Essa ação é como introduzir um “elefante” que se torna o foco dos demais participantes do mercado.

• Mercado Competitivo Para traders de alta frequência, seus lucros vêm principalmente da análise da microestrutura do mercado para inferir as intenções de outros traders. Quando um elefante aparece, os traders de alta frequência rapidamente estabelecem posições para capturar pequenas flutuações de preços. O objetivo deles é fazer negociações frequentes em um curto período de tempo, acumulando lucros pequenos, mas cumulativos.

• A situação dos elefantes Embora os elefantes possam querer operar em grande escala no mercado, suas ações também revelam suas intenções de negociação, tornando-os alvos de traders de alta frequência. Os traders de alta frequência tentam estabelecer posições com antecedência e então lucrar com as flutuações de preços. A presença de um elefante no mercado pode desencadear uma reação no mercado competitivo, afetando assim sua estratégia de negociação.

• Engano no mercado Na realidade, grandes investidores institucionais geralmente não colocam descaradamente um grande número de ordens de compra ou venda no mercado, porque tal comportamento pode fazer com que outros participantes do mercado tomem contramedidas ou até mesmo manipulem o mercado. Portanto, eles podem adotar estratégias para criar falsas impressões e atrair traders de alta frequência para entrar no mercado e, então, vender ou comprar rapidamente para lucrar com as flutuações de preços.

A ideia central da estratégia Penny Jump

A ideia central da estratégia Penny Jump é que, assim que um elefante aparece no mercado e suporta um preço específico (por exemplo, US\( 1,01), os traders de alta frequência aumentam rapidamente seus lances em um centavo, por exemplo, para US\) 1,02. Isso ocorre porque os traders de alta frequência entendem que o aparecimento de um elefante significa que há um forte suporte de compra naquele nível de preço, então eles tentam segui-lo na esperança de que o preço suba. Quando o preço sobe para US\( 1,03 x US\) 1,05, o trader de alta frequência pode vender rapidamente, obtendo um lucro de US$ 0,01.

Além disso, os traders de alta frequência também podem lucrar depois de comprar, mesmo que o preço não suba. Como sabem que o elefante sustenta o preço mais baixo, eles podem vender rapidamente suas ações para o elefante e obter um pequeno lucro com a diferença.

Analisando o código da estratégia Penny Jump

Código fonte da estratégia: https://www.fmz.com/strategy/358

O código de estratégia fornecido acima é um exemplo que implementa a estratégia Penny Jump. Aqui está uma explicação detalhada do código para que iniciantes possam entender como ele 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);
    }
}

Analisarei o código de estratégia que você forneceu linha por linha para ajudar você a entender como ele funciona com mais detalhes.

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

Este código inicializa um objeto chamado Counter, que é usado para rastrear as estatísticas de negociação da estratégia. Especificamente, inclui três atributos:

• i: indica o número total de transações.
• w: indica o número de transações bem-sucedidas.
• f: indica o número de transações com falha.

Esses atributos são registrados e atualizados durante a execução da política.

var InitAccount = null;

Esta linha de código inicializa uma variável chamada InitAccount, que armazenará as informações da conta quando a estratégia começar a ser executada.

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 é umCancelAll()O objetivo desta função é cancelar todas as ordens abertas no mercado. Vamos explicar sua funcionalidade passo a passo:

• while (true): Este é um loop infinito que será executado até que não haja mais pedidos pendentes.
• var orders = _C(exchange.GetOrders): Esta linha de código usa a função exchange.GetOrders para obter todos os pedidos pendentes para a conta atual e armazená-los na variável orders.
• if (orders.length == 0):Esta linha de código verifica se há algum pedido não atendido. Se o comprimento da matriz de pedidos for 0, significa que não há pedidos não atendidos e o loop será interrompido.
• for (var i = 0; i < orders.length; i++): Este é um loop for que itera por todos os pedidos pendentes.
• exchange.CancelOrder(orders[i].Id): Esta linha de código usa a função exchange.CancelOrder() para cancelar cada pedido pelo seu ID de pedido.
• Sleep(Interval):Esta linha de código introduz um ciclo de espera, aguardando um certo período de tempo (em milissegundos) para garantir que a operação de cancelamento do pedido não seja muito frequente.

O objetivo desta função é garantir que, antes de executar a estratégia principal, não existam ordens pendentes para evitar interferir na execução da estratégia principal.

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

Este é umupdateStatus(msg)Uma função que atualiza informações de status de transação e as registra. Ele aceita um parâmetro msg que geralmente contém informações sobre o status atual do mercado. As operações específicas da função incluem:

usarLogStatus()A função registra as informações exibidas na barra de status quando a estratégia está em execução. Ele mostra o texto sobre o número de transações, sucessos e falhas. ApegadomsgParâmetros que contêm informações sobre o status atual do mercado. O registro de data e hora atual é anexado (new Date()) para exibir informações de tempo. O objetivo desta função é registrar e atualizar informações de status de negociação para monitoramento e análise durante a execução da estratégia.

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 é a principal função de execução da estratégiamain(), que contém a lógica central da estratégia. Vamos explicar seu funcionamento linha por linha:

• if (DisableLog): Esta linha de código verifica se a variável DisableLog é verdadeira e, se for, desabilita o registro. Isso é para garantir que a política não registre informações desnecessárias.

• CancelAll(): Chame a função CancelAll() explicada anteriormente para garantir que não haja pedidos não concluídos.

• InitAccount = _C(exchange.GetAccount): Esta linha de código obtém as informações da conta atual e as armazena na variável InitAccount. Isso será usado para registrar o estado da conta quando a estratégia começar a ser executada.

• var i = 0; e var locks = 0;: Inicialize duas variáveis ​​i e locks, que serão usadas na lógica de estratégia subsequente.

• while (true): Este é um loop infinito, usado principalmente para execução contínua de estratégias.

A seguir, explicaremos linha por linhawhile (true)A principal lógica da estratégia dentro do loop.

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 linha de código permite que a estratégia fique em espera por um período de tempo para controlar a frequência de execução da estratégia. O parâmetro Intervalo define o intervalo de sono em milissegundos.

• var depth = _C(exchange.GetDepth): Obtenha informações atuais sobre o mercado, incluindo o preço e a quantidade de ordens de venda e compra. Essas informações serão armazenadas na variável de profundidade.

• if (depth.Asks.length === 0 || depth.Bids.length === 0):Esta linha de código verifica as informações de profundidade do mercado para garantir que existam ordens de venda e compra. Se um deles não existir, significa que o mercado pode não ter informações de negociação suficientes, e a estratégia continuará esperando.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks): Esta linha de código chama a função updateStatus para atualizar as informações de status da estratégia. Ele registra o status atual do mercado, incluindo o preço de compra, o preço de venda e o número de bloqueios 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;: Inicialize a variável askPrice, que será usada para armazenar o preço da ordem de venda que atende às condições.

• for (i = 0; i < depth.Asks.length; i++): Este é um loop for usado para iterar sobre as informações de preço e quantidade da ordem de venda de mercado.

• if (depth.Asks[i].Amount >= Lot): No loop, verifique se a quantidade de cada ordem de venda é maior ou igual ao lote especificado. Se for o caso, armazene o preço da ordem de venda em askPrice e encerre o loop.

• if (askPrice === 0): Se nenhuma ordem de venda satisfatória for encontrada (askPrice ainda é 0), a estratégia continuará esperando e pulará as operações subsequentes.

• var elephant = null;: Inicialize a variável elephant, que será usada para armazenar as informações da ordem de compra identificadas como “elephant”.

    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;

Continue a iterar através das informações de preço e quantidade das ordens de compra do mercado, ignorando a primeira ordem de compra (Bids[0]）。

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): Verifique se a diferença entre o preço de compra atual e o preço de venda é maior que o ElephantSpace. Se for assim, significa que ele está longe o suficiente do “elefante” e a estratégia não continuará a busca.

• if (depth.Bids[i].Amount >= ElephantAmount): Verifique se o valor atual da ordem de compra é maior ou igual a ElephantAmount. Se for, armazene as informações da ordem de compra na variável elephant.

• if (!elephant): Se o “elefante” não for encontrado, redefina a contagem de bloqueios para 0 e continue esperando.

locks++: Se o “elefante” for encontrado, o número de bloqueios será incrementado. Isso é para garantir que a estratégia seja executada depois que a existência do “elefante” for confirmada diversas vezes ao longo de um período de tempo.

• if (locks < LockCount): Verifique se o número de bloqueios atinge o requisito (LockCount). Se os requisitos não forem atendidos, continue aguardando.

    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)): Chame a função updateStatus para registrar o status atual da estratégia, incluindo a posição da engrenagem do “elefante” encontrado e informações relacionadas. Isso será indicado na coluna Status da política.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): Use a função exchange.Buy para comprar o “elefante” encontrado. O preço de compra é elefante.Preço + PennyTick, a quantidade de compra é Lote e a operação de compra é descrita como “Lances[” + i + “]“。

• var ts = new Date().getTime(): Obtenha o registro de data e hora do horário atual para cálculos subsequentes de intervalos de tempo.

• while (true): Entre em um novo loop infinito para aguardar a execução da ordem de compra “elefante”.

• Sleep(CheckInterval): A estratégia fica inativa por um período de tempo para controlar a frequência com que o status do pedido é verificado.

• var orders = _C(exchange.GetOrders): Obtenha todas as informações do pedido da conta corrente.

• if (orders.length == 0): Verifique se há algum pedido não concluído, caso contrário, saia do loop.

• (new Date().getTime() - ts) > WaitInterval: Calcula o intervalo de tempo entre o momento atual e o momento em que o “elefante” é comprado. Se exceder WaitInterval, significa que a espera expirou.

• for (var i = 0; i < orders.length; i++): Iterar sobre todos os pedidos não concluídos.

• exchange.CancelOrder(orders[i].Id): Cancele cada ordem aberta usando a função 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): Obtenha informações da conta corrente.

• var opAmount = _N(account.Stocks - InitAccount.Stocks): Calcule a variação de ativos na conta após a compra de “Elefante”. Se a alteração for menor que 0,001, significa que a compra falhou, o número de falhas será aumentado e o próximo ciclo continuará.

• updateStatus("买单得手: " + opAmount + ", 开始出手..."): Registra as informações da compra bem-sucedida do “elefante”, incluindo a quantidade comprada.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): Use a função exchange.Sell para vender o “elefante” adquirido com sucesso e obter lucro. O preço de venda é elefante.Preço + (PennyTick * ProfitTick).

Entra em um novo loop infinito aguardando a execução da ordem de venda.

• var depth = _C(exchange.GetDepth): Obtenha informações detalhadas sobre o mercado.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): Verifique as informações de profundidade do mercado. Se o preço de mercado caiu para o preço de stop loss, execute a operação de stop loss.

• CancelAll(): Chame a função CancelAll() para cancelar todos os pedidos não concluídos para evitar riscos de posição.

• if (opAmount < 0.001): Verifique a quantidade de compra novamente. Se for menor que 0,001, significa que a compra falhou e o loop será encerrado.

• exchange.Sell(depth.Bids[0].Price, opAmount): Execute uma operação de stop loss e venda os ativos restantes ao menor preço de mercado atual.

Por fim, dependendo se a transação é bem-sucedida ou não, o número de sucessos e falhas é atualizado, e o lucro da transação é registrado.

Essa é uma explicação linha por linha de toda a estratégia. A ideia central dessa estratégia é procurar “elefantes” (grandes ordens de compra) no mercado, comprá-los e vendê-los com pequenos lucros. Inclui vários parâmetros importantes, como quantidade de compra (Lot), intervalo de repetição de erro (Interval), nível do elefante (ElephantAmount), distância do elefante (ElephantSpace), etc., para ajustar o comportamento da estratégia.

Em geral, essa estratégia é uma estratégia de negociação de alta frequência que visa explorar informações de profundidade de mercado, identificar grandes ordens de compra e executar transações de compra e venda em um curto período de tempo. É preciso monitorar constantemente o mercado e executar operações de compra e venda para obter pequenos lucros rapidamente. No entanto, também é uma estratégia de alto risco, pois exige uma resposta rápida às flutuações do mercado, além de considerar mecanismos de gerenciamento de risco e stop-loss para evitar perdas significativas.

Observe que esta estratégia é baseada em mercados e plataformas de negociação específicos e pode precisar ser adequadamente ajustada e otimizada para diferentes mercados e bolsas. Na aplicação real, os investidores precisam testar e avaliar cuidadosamente o desempenho da estratégia para garantir que ela seja consistente com seus objetivos de investimento e tolerância ao risco.

À medida que você continua a executar a estratégia, ela continuará em loop e fará o seguinte:

1. Primeiro, a estratégia verifica as informações de profundidade do mercado para entender as ordens atuais de venda e compra.

2. Em seguida, a estratégia tentará encontrar uma ordem de venda que atenda às condições, onde a quantidade da ordem de venda seja maior ou igual ao Lote. Se uma ordem de venda que atenda às condições for encontrada, o preço da ordem de venda será registrado como askPrice.

3. A estratégia então continua a procurar por “elefantes” (grandes ordens de compra). Ele iterará pelas ordens de compra no mercado, pulando a primeira ordem de compra (geralmente a ordem de compra com o preço mais alto). Se um “elefante” que atenda às condições for encontrado, as informações do “elefante” serão registradas e o número de eclusas será aumentado.

4. Se forem encontrados “elefantes” suficientes consecutivamente (controlados pelo parâmetro LockCount), a estratégia executará as seguintes operações:

• Chame a função updateStatus para registrar a posição da engrenagem do “elefante” e informações relacionadas.
• Use a função exchange.Buy para comprar “elefante”, o preço de compra é elephant.Price + PennyTick, e a quantidade de compra é Lot.
• Inicia um novo loop infinito aguardando a execução de uma ordem de compra.
• Verifique o status do pedido e, se ele for concluído, saia do ciclo.
• Se o tempo de espera exceder o intervalo de espera definido (WaitInterval), todos os pedidos não concluídos serão cancelados.
• Calcule a mudança nos ativos da conta após uma compra bem-sucedida. Se a mudança for menor que 0,001, significa que a compra falhou, aumente o número de falhas e continue para o próximo ciclo.
• Registre as informações da compra bem-sucedida de “elefantes”, incluindo a quantidade comprada.

1. Em seguida, a estratégia continuará entrando em um novo loop infinito, aguardando a execução da operação de venda. Neste loop, ele faz o seguinte:

• Obtenha informações de profundidade de mercado e verifique se o preço de mercado atingiu o nível de stop loss.
• Caso o preço de mercado atinja ou caia abaixo do preço de stop loss, a operação de stop loss será executada, ou seja, os ativos restantes serão vendidos.
• Chame a função CancelAll para cancelar todos os pedidos não concluídos para reduzir os riscos de posição.
• Verifique novamente a alteração nos ativos da conta após a compra ser bem-sucedida. Se a alteração for menor que 0,001, significa que a compra falhou e o loop foi encerrado.
• Por fim, registre se a transação foi bem-sucedida ou não e atualize o número de sucessos e falhas com base nos resultados da transação.

Toda a estratégia passa continuamente pelas operações acima para capturar o máximo de “elefantes” possível e obter pequenos lucros. Esta é uma estratégia de negociação de alta frequência que exige resposta rápida às mudanças do mercado, ao mesmo tempo em que considera mecanismos de gerenciamento de risco e stop-loss para proteger o capital. Os investidores devem considerar cuidadosamente o uso dessa estratégia, especialmente em mercados altamente voláteis.

Conclusão

A estratégia Penny Jump é um exemplo clássico de negociação de alta frequência, que demonstra o jogo sutil e a competição entre os participantes do mercado. Essa estratégia é particularmente proeminente no mercado de criptomoedas, onde a volatilidade é alta e os investidores institucionais e traders de alta frequência buscam lucros rápidos. No entanto, isso também torna o mercado desafiador, exigindo constante adaptação e ajuste de estratégias para manter a vantagem competitiva. Neste mundo extremamente competitivo, somente os traders que são bons em observar a microestrutura do mercado e responder rapidamente terão sucesso.