Высокочастотная торговля — сложная и конкурентная сфера, которая требует быстрого исполнения сделок и тонкого понимания микроструктуры рынка. Одной из стратегий, которая привлекла большое внимание, является Penny Jump, которая фокусируется на использовании «слонов» на рынке для получения небольшой, но регулярной прибыли. В этой статье мы подробно объясним, как работает стратегия Penny Jump, а также углубимся в детали кода стратегии, чтобы новички могли понять, как она работает.

Понимание стратегии Penny Jump

На фондовом рынке «слонами» обычно являются институциональные инвесторы, которые хотят купить или продать большие объемы акций, но не желают торговать по рыночным ценам. Вместо этого они предпочитают размещать на рынке большое количество лимитных ордеров, также известных как отложенные ордера, чтобы обозначить свои намерения. Такое поведение привлекло широкое внимание на рынке, поскольку крупные транзакции могут оказывать существенное влияние на рынок.

Например, предположим, что глубина рынка акций изначально выглядела следующим образом: 200 | \(1,01 x \)1,03 | 200. Затем появился «слон» и разместил приказ купить 3000 акций по 1,01 доллара. В этот момент глубина рынка составит 3200 | \(1,01 x \)1,03 | 200. Это действие похоже на выведение на рынок «слона», который становится центром внимания других участников рынка.

• Конкурентный рынок Прибыль высокочастотных трейдеров в основном формируется за счет анализа микроструктуры рынка с целью определения намерений других трейдеров. Как только появляется слон, высокочастотные трейдеры быстро открывают позиции, чтобы поймать малейшие колебания цен. Их цель — совершать частые сделки в течение короткого периода времени, получая небольшую, но кумулятивную прибыль.

• Бедственное положение слонов Хотя слоны, возможно, и стремятся действовать на рынке масштабно, их действия также выдают их торговые намерения, что делает их мишенью для высокочастотных трейдеров. Высокочастотные трейдеры стараются заранее открывать позиции, а затем извлекать прибыль из колебаний цен. Присутствие слона на рынке может вызвать реакцию на конкурентном рынке, тем самым влияя на его торговую стратегию.

• Обман на рынке В действительности крупные институциональные инвесторы обычно открыто не размещают большое количество ордеров на покупку или продажу на рынке, поскольку такое поведение может побудить других участников рынка принять контрмеры или даже манипулировать рынком. Поэтому они могут применять стратегии, создающие ложное впечатление, чтобы привлечь на рынок высокочастотных трейдеров, а затем быстро продать или купить, чтобы получить прибыль от колебаний цен.

Основная идея стратегии Penny Jump

Основная идея стратегии Penny Jump заключается в том, что как только на рынке появляется слон и поддерживает определенную цену (например, 1,01 доллара), высокочастотные трейдеры быстро увеличивают свои ставки на один цент, например, до 1,02 доллара. Это происходит потому, что высокочастотные трейдеры понимают, что появление слона означает наличие сильной поддержки покупок на этом ценовом уровне, поэтому они стараются следовать за ним в надежде, что цена вырастет. Когда цена вырастет до \(1,03 x \)1,05, высокочастотный трейдер может быстро продать, получив прибыль в размере $0,01.

Более того, высокочастотные трейдеры также могут получать прибыль после покупки, даже если цена не растет. Поскольку они знают, что слон поддерживает минимальную цену, они могут быстро продать свои акции слону и получить небольшую прибыль на разнице.

Анализ кода стратегии Penny Jump

Исходный код стратегии: https://www.fmz.com/strategy/358

Приведенный выше код стратегии является примером, реализующим стратегию Penny Jump. Вот подробное объяснение кода, чтобы новички могли понять, как он работает:

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);
    }
}

Я построчно разберу предоставленный вами код стратегии, чтобы помочь вам более подробно понять, как он работает.

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

Этот код инициализирует объект Counter, который используется для отслеживания торговой статистики стратегии. В частности, он включает в себя три атрибута:

• i: указывает общее количество транзакций.
• w: указывает количество успешных транзакций.
• f: указывает количество неудачных транзакций.

Эти атрибуты регистрируются и обновляются во время выполнения политики.

var InitAccount = null;

Эта строка кода инициализирует переменную InitAccount, которая будет хранить информацию об учетной записи, когда начнется выполнение стратегии.

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);
    }
}

ЭтоCancelAll()Целью данной функции является отмена всех открытых ордеров на рынке. Давайте объясним его функциональность шаг за шагом:

• while (true): Это бесконечный цикл, который будет выполняться до тех пор, пока не останется невыполненных заказов.
• var orders = _C(exchange.GetOrders): Эта строка кода использует функцию exchange.GetOrders для получения всех отложенных ордеров для текущего счета и сохраняет их в переменной orders.
• if (orders.length == 0): Эта строка кода проверяет наличие невыполненных заказов. Если длина массива заказов равна 0, это означает, что невыполненных заказов нет и цикл прервется.
• for (var i = 0; i < orders.length; i++): Это цикл for, который перебирает все невыполненные заказы.
• exchange.CancelOrder(orders[i].Id): Эта строка кода использует функцию exchange.CancelOrder() для отмены каждого заказа по его идентификатору.
• Sleep(Interval): Эта строка кода вводит цикл ожидания, ожидая в течение определенного периода времени (в миллисекундах), чтобы гарантировать, что операция отмены заказа не будет слишком частой.

Цель этой функции — убедиться, что перед выполнением основной стратегии не существует невыполненных заказов, чтобы не мешать выполнению основной стратегии.

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

ЭтоupdateStatus(msg)Функция, которая обновляет информацию о статусе транзакции и записывает ее. Он принимает параметр msg, который обычно содержит информацию о текущем состоянии рынка. Конкретные операции функции включают в себя:

использоватьLogStatus()Функция записывает информацию, отображаемую в строке состояния во время работы стратегии. Он показывает текст о количестве транзакций, успехах и неудачах. ПрикрепилmsgПараметры, содержащие информацию о текущем состоянии рынка. Текущая временная метка добавляется (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);
    }
}

Это основная функция исполнения стратегии.main(), который содержит основную логику стратегии. Давайте объясним его работу построчно:

• if (DisableLog): Эта строка кода проверяет, имеет ли переменная DisableLog значение true, и если да, то отключает ведение журнала. Это необходимо для того, чтобы политика не регистрировала ненужную информацию.

• CancelAll(): Вызовите функцию CancelAll(), описанную ранее, чтобы убедиться в отсутствии незавершенных заказов.

• InitAccount = _C(exchange.GetAccount): Эта строка кода получает информацию о текущей учетной записи и сохраняет ее в переменной InitAccount. Это будет использоваться для записи состояния счета, когда стратегия начнет выполняться.

• var i = 0; и var locks = 0;: Инициализируем две переменные i и locks, которые будут использоваться в последующей логике стратегии.

• while (true): Это бесконечный цикл, в основном используемый для непрерывного выполнения стратегий.

Далее мы объясним построчноwhile (true)Основная логика стратегии внутри цикла.

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): Эта строка кода позволяет стратегии «спать» в течение определенного периода времени, чтобы контролировать частоту выполнения стратегии. Параметр Interval определяет интервал сна в миллисекундах.

• var depth = _C(exchange.GetDepth): Получите текущую информацию о глубине рынка, включая цену и количество ордеров на продажу и покупку. Эта информация будет сохранена в переменной глубины.

• if (depth.Asks.length === 0 || depth.Bids.length === 0): Эта строка кода проверяет информацию о глубине рынка, чтобы убедиться в наличии ордеров на продажу и покупку. Если одного из них нет, это означает, что на рынке может быть недостаточно торговой информации, и стратегия будет продолжать ждать.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks): Эта строка кода вызывает функцию updateStatus для обновления информации о состоянии стратегии. Он регистрирует текущее состояние рынка, включая цену спроса, цену предложения и количество предыдущих блокировок.

    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;: Инициализируйте переменную askPrice, которая будет использоваться для хранения цены ордера на продажу, соответствующей условиям.

• for (i = 0; i < depth.Asks.length; i++): Это цикл for, который используется для перебора информации о цене и количестве рыночного ордера на продажу.

• if (depth.Asks[i].Amount >= Lot): В цикле проверьте, больше ли или равно ли количество каждого ордера на продажу указанному лоту. Если это так, сохраните цену ордера на продажу в askPrice и завершите цикл.

• if (askPrice === 0): Если удовлетворяющий ордер на продажу не найден (askPrice по-прежнему равен 0), стратегия продолжит ждать и пропустит последующие операции.

• var elephant = null;: Инициализируйте переменную elephant, которая будет использоваться для хранения информации о заказе на покупку, идентифицированной как «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;

Продолжайте итерацию по информации о цене и количестве рыночных ордеров на покупку, пропуская первый ордер на покупку (Bids[0]）。

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): Проверьте, превышает ли разница между текущей ценой покупки и ценой предложения значение ElephantSpace. Если это так, то это значит, что он достаточно далеко от «слона» и стратегия не будет продолжать поиск.

• if (depth.Bids[i].Amount >= ElephantAmount): Проверьте, больше ли или равна ли текущая сумма заказа на покупку ElephantAmount. Если это так, сохраните информацию о заказе на покупку в переменной elephant.

• if (!elephant): Если «слон» не найден, сбросьте счетчик блокировок на 0 и продолжайте ждать.

locks++: Если «слон» найден, количество блокировок будет увеличено. Это делается для того, чтобы гарантировать реализацию стратегии после того, как существование «слона» будет подтверждено многократно в течение определенного периода времени.

• if (locks < LockCount): Проверьте, достигает ли количество блокировок требуемого значения (LockCount). Если требования не выполнены, продолжайте ждать.

    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)): Вызовите функцию updateStatus, чтобы записать текущий статус стратегии, включая положение передачи найденного «слона» и связанную с этим информацию. Это будет указано в столбце «Статус» политики.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): Используйте функцию exchange.Buy, чтобы купить найденного «слона». Цена покупки равна elephant.Price + PennyTick, количество покупки равно Lot, а операция покупки описывается как «Ставки[” + i + “]“。

• var ts = new Date().getTime(): Получить временную метку текущего времени для последующего расчета временных интервалов.

• while (true): войти в новый бесконечный цикл для ожидания исполнения ордера на покупку «слон».

• Sleep(CheckInterval): Стратегия спит в течение определенного периода времени, чтобы контролировать частоту проверки статуса заказа.

• var orders = _C(exchange.GetOrders): Получить всю информацию о заказе текущего счета.

• if (orders.length == 0): Проверьте, есть ли незавершенные заказы, если нет, выйдите из цикла.

• (new Date().getTime() - ts) > WaitInterval: Рассчитать временной интервал между текущим временем и временем покупки “слона”. Если он превышает WaitInterval, значит время ожидания истекло.

• for (var i = 0; i < orders.length; i++): Перебрать все незавершенные заказы.

• 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): Получите информацию о текущем счете.

• var opAmount = _N(account.Stocks - InitAccount.Stocks): Рассчитайте изменение активов на счете после покупки «Слона». Если изменение меньше 0,001, это означает, что покупка не удалась, количество неудач будет увеличено, и следующий цикл будет продолжен.

• updateStatus("买单得手: " + opAmount + ", 开始出手..."): Записывает информацию об успешной покупке «слона», включая количество покупки.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): Используйте функцию exchange.Sell, чтобы продать успешно купленного «слона» и получить прибыль. Цена продажи — elephant.Price + (PennyTick * ProfitTick).

Входит в новый бесконечный цикл ожидания исполнения ордера на продажу.

• var depth = _C(exchange.GetDepth): Получите информацию о глубине рынка.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): Проверьте информацию о глубине рынка. Если рыночная цена упала до цены стоп-лосса, выполните операцию стоп-лосса.

• CancelAll(): Вызовите функцию CancelAll(), чтобы отменить все незавершенные ордера и избежать позиционных рисков.

• if (opAmount < 0.001): Проверьте количество покупки еще раз. Если оно меньше 0,001, это означает, что покупка не удалась и цикл будет завершен.

• exchange.Sell(depth.Bids[0].Price, opAmount): Выполните операцию стоп-лосса и продайте оставшиеся активы по текущей минимальной рыночной цене.

Наконец, в зависимости от того, была ли транзакция успешной или нет, обновляется количество успехов и неудач, а также фиксируется прибыль от транзакции.

Это построчное объяснение всей стратегии. Основная идея этой стратегии — искать «слонов» (крупные ордера на покупку) на рынке, покупать их и продавать с небольшой прибылью. Он включает в себя несколько важных параметров, таких как объем покупки (Lot), интервал повтора ошибки (Interval), уровень слона (ElephantAmount), расстояние между слонами (ElephantSpace) и т. д., для настройки поведения стратегии.

В целом эта стратегия представляет собой стратегию высокочастотной торговли, направленную на использование информации о глубине рынка, выявление крупных ордеров на покупку и выполнение сделок купли-продажи за короткий промежуток времени. Требуется постоянно следить за рынком и совершать операции купли-продажи, чтобы быстро получать небольшую прибыль. Однако это также высокорискованная стратегия, поскольку она требует быстрого реагирования на колебания рынка, а также учета механизмов управления рисками и стоп-лосса, чтобы избежать значительных потерь.

Обратите внимание, что данная стратегия основана на конкретных рынках и торговых платформах и может потребовать соответствующей корректировки и оптимизации для различных рынков и бирж. На практике инвесторам необходимо тщательно протестировать и оценить эффективность стратегии, чтобы убедиться, что она соответствует их инвестиционным целям и допустимому уровню риска.

По мере того, как вы продолжаете выполнять стратегию, она будет продолжать циклически выполнять следующее:

1. Сначала стратегия проверяет информацию о глубине рынка, чтобы понять текущие ордера на продажу и покупку.

2. Далее стратегия попытается найти ордер на продажу, который соответствует условиям, где объем ордера на продажу больше или равен лоту. Если будет найден ордер на продажу, отвечающий условиям, цена ордера на продажу будет записана как askPrice.

3. Затем стратегия продолжает искать «слонов» (крупные ордера на покупку). Он будет перебирать ордера на покупку на рынке, пропуская первый ордер на покупку (обычно ордер на покупку с самой высокой ценой). Если будет найден «слон», отвечающий условиям, информация о «слоне» будет записана, а количество блокировок будет увеличено.

4. Если последовательно найдено достаточное количество «слонов» (контролируется параметром LockCount), стратегия далее выполнит следующие операции:

• Вызовите функцию updateStatus, чтобы записать положение передач «слона» и связанную с этим информацию.
• Используйте функцию exchange.Buy, чтобы купить «слона», цена покупки равна elephant.Price + PennyTick, а количество покупки равно Lot.
• Запускает новый бесконечный цикл ожидания исполнения ордера на покупку.
• Проверьте статус заказа и, если заказ выполнен, прервите цикл.
• Если время ожидания превысит установленный интервал ожидания (WaitInterval), все невыполненные заказы будут отменены.
• Рассчитайте изменение активов счета после успешной покупки. Если изменение меньше 0,001, это означает, что покупка не удалась, увеличьте количество неудач и перейдите к следующему циклу.
• Запишите информацию об успешной покупке «слонов», включая количество покупки.

1. Далее стратегия продолжит входить в новый бесконечный цикл, ожидая выполнения операции продажи. В этом цикле выполняется следующее:

• Получите информацию о глубине рынка и проверьте, достигла ли рыночная цена уровня стоп-лосса.
• Если рыночная цена достигнет или опустится ниже цены стоп-лосса, будет выполнена операция стоп-лосса, то есть оставшиеся активы будут проданы.
• Вызовите функцию CancelAll, чтобы отменить все незавершенные ордера и снизить позиционные риски.
• Проверьте еще раз изменение активов счета после успешной покупки. Если изменение меньше 0,001, это означает, что покупка не удалась и цикл завершается.
• Наконец, запишите, была ли транзакция успешной или нет, и обновите количество успехов и неудач на основе результатов транзакции.

Вся стратегия непрерывно циклично проходит через вышеуказанные операции, чтобы поймать как можно больше «слонов» и получить небольшую прибыль. Это стратегия высокочастотной торговли, которая требует быстрого реагирования на изменения рынка, а также учитывает управление рисками и механизмы стоп-лосса для защиты капитала. Инвесторам следует внимательно рассмотреть возможность использования этой стратегии, особенно на крайне волатильных рынках.

Заключение

Стратегия Penny Jump — классический пример высокочастотной торговли, демонстрирующий тонкую игру и конкуренцию среди участников рынка. Эта стратегия особенно актуальна на рынке криптовалют, где волатильность высока, а институциональные инвесторы и высокочастотные трейдеры ищут быструю прибыль. Однако это также усложняет ситуацию на рынке, требуя постоянной адаптации и корректировки стратегий для сохранения конкурентного преимущества. В этом жестко конкурентном мире успеха добьются только те трейдеры, которые умеют хорошо видеть микроструктуру рынка и быстро реагировать.