Análise de estratégias de negociação de alta frequência - Penny Jump

O comércio de alta frequência é um campo desafiador e competitivo, que depende da execução rápida de transações e de uma visão sensível da estrutura microscópica do mercado. Uma estratégia muito popular é o Penny Jump, que se concentra em usar o "elefante" do mercado para obter lucros pequenos, mas frequentes. Neste artigo, explicaremos em detalhes como a estratégia Penny Jump funciona, além de aprofundar os detalhes do código da estratégia para que os iniciantes possam entender como ela funciona.

Compreender a estratégia do Penny Jump

No mercado de ações, o "elefante" geralmente se refere a investidores institucionais que desejam comprar ou vender uma grande quantidade de ações, mas não querem negociar pelo preço de mercado. Em vez disso, eles optam por colocar uma grande quantidade de listras limitadas no mercado, ou listras penduradas, para mostrar sua intenção. Esse comportamento tem causado grande preocupação no mercado, pois grandes transações podem ter um impacto significativo no mercado.

Por exemplo, suponhamos que a profundidade de mercado de uma ação fosse assim: 200 dólares 1,01 vezes 1,03 dólares 200; então, um "elefante" entra e pendura uma nota de 3.000 ações por 1,01 dólares; então, a profundidade de mercado é 3,200; $1,01 vezes 1,03 dólares 200; o que é como introduzir um "elefante" que se torna o foco de todos os outros participantes no mercado.

• Mercado de competição Para os traders de alta frequência, seus lucros vêm principalmente da análise da estrutura microscópica do mercado para especular as intenções de outros traders. Uma vez que um elefante aparece, os traders de alta frequência rapidamente estabelecem posições para obter pequenas flutuações de preços.

• A situação dos elefantes Embora os elefantes possam querer operar em grande escala no mercado, seu comportamento também expõe 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 depois lucram com as flutuações de preços. A presença de elefantes no mercado pode desencadear uma reação competitiva do mercado, influenciando assim sua estratégia de negociação.

• Fraudes no mercado Na realidade, os grandes investidores institucionais geralmente não colocam em exibição grandes quantidades de pedidos de compra ou venda no mercado, pois tal comportamento pode levar outros participantes do mercado a tomar medidas de contra-ataque e até mesmo a manipular o mercado. Portanto, eles podem adotar estratégias para fabricar uma ilusão, atrair traders de alta frequência e, em seguida, vender ou comprar rapidamente para obter lucros com as flutuações de preços.

A ideia central da estratégia Penny Jump

A idéia central da estratégia do Penny Jump é que, uma vez que um elefante aparece no mercado e apoia um determinado preço (por exemplo, $1.01), os traders de alta frequência rapidamente aumentam suas ofertas por um centavo, por exemplo, para $1.02.

Além disso, os comerciantes de alta frequência podem obter lucros após a compra, mesmo que o preço não suba. Como eles sabem que o elefante está apoiando o preço inferior, eles podem vender rapidamente as ações para o elefante e obter lucros mínimos.

Resolver o código da política Penny Jump

O código da estratégia:https://www.fmz.com/strategy/358

O código da estratégia fornecido acima é um exemplo para a implementação da estratégia Penny Jump. A seguir está uma explicação detalhada do código para que os iniciantes entendam 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);
    }
}

Vou analisar o código de estratégia que você forneceu passo a passo para ajudá-lo a entender mais detalhadamente como ele funciona.

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

Este código inicializa um objeto chamado Counter, que é usado para rastrear as estatísticas de transações da política; especificamente, ele inclui três propriedades:

• 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 falhadas.

Esses atributos serã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 irá armazenar informações da conta quando a política 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);
    }
}

É uma coisa chamadaCancelAll()A função de limpeza de pedidos é a função de limpar todas as encomendas pendentes no mercado.

• while (true)É um ciclo infinito, que vai continuar a ser executado até que não haja pedidos por concluir.
• var orders = _C(exchange.GetOrders)：这一行代码使用exchange.GetOrders函数获取当前账户所有挂出的订单，并将它们存储在orders变量中。
• if (orders.length == 0): Esta linha de código verifica se há pedidos incompletos. Se o comprimento da matriz de ordens for 0, significa que não há pedidos incompletos, o ciclo será interrompido.
• for (var i = 0; i < orders.length; i++)É um ciclo for, que percorre todos os pedidos não concluídos.
• exchange.CancelOrder(orders[i].Id)Esta linha de código usa a função exchange.CancelOrder (), para cancelar cada ordem através do ID da ordem.
• Sleep(Interval): Esta linha de código introduz um ciclo de espera, que é esperado por um período de tempo (em milissegundos) para garantir que a operação de cancelamento de um pedido não seja muito frequente.

O objetivo desta função é garantir que não haja pedidos incompletos antes da execução da política principal, para evitar interferir na execução da política principal.

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

É uma coisa chamadaupdateStatus(msg)A função é usada para atualizar informações sobre o estado das transações e registrá-las. Ela aceita um parâmetro msg, que geralmente contém informações sobre o estado atual do mercado.

UtilizaçãoLogStatus()A função registra as informações exibidas no bar de estado quando a política é executada. Ela mostra o texto sobre o número de transações, o número de sucessos e o número de falhas. AdicionadomsgParâmetros que contêm informações sobre o estado atual do mercado. Adicionado o botão de tempo atual.new Date()O Google Maps é um aplicativo gratuito para mostrar informações sobre o tempo. O objetivo desta função é registrar e atualizar informações sobre o estado das transações para monitorar e analisar 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égia.main()A partir daí, a estratégia foi desenvolvida, com o intuito de criar uma estratégia de marketing e marketing que incluísse a lógica central da estratégia.

• if (DisableLog): Esta linha de código verifica se a variável DisableLog é verdadeira e, se for, desativa o registro.

• CancelAll()A função CancelAll () é chamada para garantir que não existam pedidos incompletos.

• InitAccount = _C(exchange.GetAccount): Esta linha de código obtém informações sobre a conta atual e as armazena na variável InitAccount.

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

• while (true)O que é um ciclo infinito, usado principalmente para a execução contínua da estratégia.

A seguir, vamos explicá-lo linha a linha.while (true)A principal lógica estratégica dentro do ciclo.

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 deixa a política em repouso por um período de tempo para controlar a frequência de execução da política. O parâmetro Interval define o intervalo de tempo em repouso (em milissegundos).

• var depth = _C(exchange.GetDepth)Obter informações de profundidade do mercado atual, incluindo preços e quantidades de compras e vendas.

• if (depth.Asks.length === 0 || depth.Bids.length === 0): Esta linha de código verifica a informação de profundidade do mercado para garantir que ambas as ofertas de venda e compra estão presentes. Se uma delas não estiver presente, significa que o mercado pode não ter informações suficientes de negociação, então a estratégia continua esperando.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks)Esta linha de código chama a função update Status, informação de estado para atualizar a política. Ele registra o estado atual do mercado, incluindo um preço de compra, um 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;: Inicializa a variável askPrice, que será usada para armazenar o preço de venda de um pedido que atenda às condições.

• for (i = 0; i < depth.Asks.length; i++): é um for loop, usado para percorrer informações de preço e quantidade de pedidos de venda no mercado.

• if (depth.Asks[i].Amount >= Lot): no ciclo, verifique se o número de cada ordem de venda é maior ou igual ao Lot (número de mãos) indicado. Se for, armazene o preço da ordem de venda no AskPrice e termine o ciclo.

• if (askPrice === 0): Se não encontrar um pedido que satisfaça a condição (askPrice ainda é 0), a política continua a esperar, ignorando a operação subsequente.

• var elephant = null;: inicializa a variável elephant, que será usada para armazenar informações de pagamentos identificadas como "elefante de casca de 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;

Continuando a navegar pelo mercado com informações sobre preços e quantidades de ofertas, pule a primeira ofertas (Bids[0]) [4].

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): verifique se o diferencial entre o preço de compra atual e o preço de compra é maior do que o ElephantSpace. Se sim, indique que você está longe o suficiente do ElephantSpace para que a estratégia não continue procurando.

• if (depth.Bids[i].Amount >= ElephantAmount): verifica se o número de pagamentos atuais é maior ou igual ao ElephantAmount, e se for, armazena a informação do pagamento na variável elephant.

• if (!elephant): Se não for encontrado o alfinete, os bloqueios numéricos serão reiniciados em 0 e continuaremos esperando.

locks++: o número de bloqueios será incrementado se o alfinete for encontrado. Isso é para garantir que a política seja executada depois de várias confirmações de que o alfinete existe em um determinado período de tempo.

• if (locks < LockCount): verifique se o número de bloqueios é atingido. Se não for atingido, continue 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))Aplicação: a função update Status é chamada para registrar o estado atual da política, incluindo a localização da casca de elefante-do-mar encontrada e informações relacionadas.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): usar a função exchange.Buy para comprar um elefante encontrado. O preço de compra é elephant.Price + PennyTick, o número de compras é Lot, e descreve a operação de compra como "Bids[" + i + ] elephant".

• var ts = new Date().getTime(): obtém o cronômetro do tempo atual para o intervalo de tempo de cálculo subsequente.

• while (true)O que é o que você está fazendo agora: entrar em um novo ciclo ilimitado para executar pedidos pendentes de aquisição de elefantes.

• Sleep(CheckInterval)A estratégia está em repouso por um tempo para controlar a frequência de verificação do estado dos pedidos.

• var orders = _C(exchange.GetOrders)O site também oferece informações sobre o que você está fazendo:

• if (orders.length == 0): verifique se há pedidos incompletos, se não, saia do ciclo.

• (new Date().getTime() - ts) > WaitInterval: Calcula o intervalo de tempo entre o tempo atual e o momento em que você compra um alho-poró. Se exceder o intervalo de espera, significa que o tempo de espera ultrapassou o intervalo de espera.

• for (var i = 0; i < orders.length; i++)O site da empresa também divulgou uma lista de pedidos pendentes.

• exchange.CancelOrder(orders[i].Id)：使用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)O site também oferece informações sobre a sua conta atual.

• var opAmount = _N(account.Stocks - InitAccount.Stocks): Calcule a mudança de ativos na conta após a compra de um elefante-do-mar. Se a mudança for menor que 0,001, a compra falhou, aumentando o número de falhas e continuando para o próximo ciclo.

• updateStatus("买单得手: " + opAmount + ", 开始出手...")A informação sobre as compras bem-sucedidas, incluindo a quantidade comprada, é registrada.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): usar a função exchange.Sell para vender o elefante elefante com a compra de um elefante elefante para obter um lucro. O preço de venda é elephant.Price + (PennyTick * ProfitTick).

Entrando em um novo ciclo infinito, usado para a execução de pedidos pendentes de venda.

• var depth = _C(exchange.GetDepth)O que você precisa saber é:

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick)))Examine a profundidade do mercado e execute uma operação de stop loss se o preço do mercado já tiver caído para o preço do stop loss.

• CancelAll()A função CancelAll () é chamada para cancelar todos os pedidos incompletos, evitando o risco de armazenamento.

• if (opAmount < 0.001): verifique novamente o número de compras, se for inferior a 0.001, indica que a compra falhou e saiu do ciclo.

• exchange.Sell(depth.Bids[0].Price, opAmount)A operação foi executada com o objetivo de vender os ativos restantes pelo preço mais baixo do mercado atual.

Por fim, os números de sucessos e fracassos são atualizados, dependendo do sucesso ou não da transação, e os lucros da transação são registrados.

Esta é uma explicação de linha por linha da estratégia. A ideia central da estratégia é encontrar o elefante-de-cavalo no mercado (pagando muito) e comprá-lo e vendê-lo para obter um pequeno lucro. Inclui vários parâmetros importantes, como o número de compras (Lot), o intervalo de erros (Interval), o nível do elefante (ElephantAmount) e a distância do elefante (ElephantSpace) para ajustar o comportamento da estratégia.

Em geral, esta estratégia é uma estratégia de negociação de alta frequência, que visa usar informações de profundidade do mercado, identificar grandes quantidades de pagamentos e realizar transações de compra e venda em um curto período de tempo. Requer monitorar continuamente o mercado e executar operações de compra e venda para obter rapidamente pequenos lucros. No entanto, também é uma estratégia de alto risco, pois requer uma reação rápida às flutuações do mercado, além de considerar o gerenciamento de riscos e mecanismos de stop loss para evitar perdas significativas.

Observe que esta estratégia é baseada em mercados e plataformas de negociação específicos, e que pode ser necessário fazer ajustes e otimizações apropriadas para diferentes mercados e exchanges. Em aplicações práticas, os investidores precisam testar e avaliar cuidadosamente o desempenho da estratégia para garantir que ela esteja de acordo com os objetivos de investimento e a capacidade de aceitação de risco.

Quando você continua a executar a política, ela executa continuamente o seguinte:

Primeiro, a estratégia examina informações profundas sobre o mercado para entender a situação atual dos pedidos e compras.

2, Em seguida, a estratégia tentará encontrar os pedidos de venda qualificados, especificamente se o número de pedidos for maior ou igual a Lot (número de mãos). Se encontrar os pedidos de venda qualificados, o preço do pedido será registrado como AskPrice.

3, então, a estratégia vai continuar a procurar a casca de elefante (muitas pagamentos); ela vai percorrer o mercado de pagamentos, ignorando o primeiro pagamento (geralmente o pagamento com o preço mais alto); se encontrar a casca de elefante de casca de elefante qualificada, será registrada a informação da casca de elefante de casca de elefante e aumentará o número de bloqueios (bloques).

4, se encontrar uma quantidade suficiente de filhotes de elefante de barriga (controlada pelo parâmetro LockCount), a política executa a seguinte operação:

• A função update Status é chamada para registrar a classificação da casca de elefante e informações relacionadas.
• Use a função exchange.Buy para comprar um elefante com o preço elephant.Price + PennyTick, com o número de compras Lot.
• Começa um novo ciclo ilimitado, usado para executar pedidos de compra pendentes.
• Verifique o estado do pedido e saia do ciclo se o pedido estiver concluído.
• Se o tempo de espera exceder o intervalo de espera definido ("Wait Interval"), todos os pedidos não concluídos serão cancelados.
• Calcule a mudança de ativos da conta após uma compra bem-sucedida, se a mudança for menor que 0,001, indica que a compra falhou, aumenta o número de falhas e continua no próximo ciclo.
• Os registros de informações sobre as aquisições bem-sucedidas, incluindo a quantidade comprada.

5. Em seguida, a política continua para um novo ciclo infinito, para ser usado para esperar a execução da operação de venda. Neste ciclo, ela executa as seguintes operações:

• A pesquisa também mostra que os preços do mercado estão em um nível muito baixo, o que significa que o mercado está em um nível muito baixo.
• Se o preço do mercado for atingido ou abaixo do preço de parada, a operação de parada será executada, ou seja, o restante dos ativos será vendido.
• A função CancelAll é chamada para cancelar todos os pedidos incompletos para reduzir o risco de armazenamento.
• Reveja a mudança nos ativos da conta após a compra bem-sucedida e, se a mudança for menor que 0,001, a compra falhou e saiu do ciclo.
• Finalmente, o registro do sucesso da transação e a atualização do número de sucessos e falhas de acordo com os resultados da transação.

A estratégia continua a executar as operações acima, para capturar o maior número possível de elefantes e obter lucros mínimos. Esta é uma estratégia de negociação de alta frequência que requer uma resposta rápida às mudanças do mercado, ao mesmo tempo em que é necessário considerar o gerenciamento de riscos e mecanismos de stop loss para proteger o capital. Os investidores devem considerar cuidadosamente o uso desta estratégia, especialmente em mercados altamente voláteis.

A conclusão

A estratégia Penny Jump é um exemplo clássico de negociação de alta frequência, que mostra a delicada brincadeira e a competição entre os participantes do mercado. No mercado de criptomoedas, esta estratégia é particularmente proeminente porque o mercado é altamente volátil e tanto os investidores institucionais quanto os traders de alta frequência buscam lucros rápidos. No entanto, isso também torna o mercado cheio de desafios, que exigem uma constante adaptação e ajuste de estratégias para manter uma vantagem competitiva.