Анализ стратегии высокочастотных сделок - Penny Jump

Высокочастотная торговля - это сложная и конкурентная область, которая зависит от быстрого выполнения сделок и чувствительного понимания микроструктуры рынка. Одной из наиболее популярных стратегий является 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

Центральная идея стратегии пенни-прыга заключается в том, что как только на рынке появляется слон и поддерживает определенную цену (например, $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): эта строка кода проверяет наличие незавершенных заказов. Если длина матрицы orders равна 0, это означает, что нет незавершенных заказов, цикл будет прерван.
• for (var i = 0; i < orders.length; i++): это цикл for, который проходит через все незавершенные заказы.
• exchange.CancelOrder(orders[i].Id): эта строка кода использует функцию exchange.CancelOrder (), чтобы отменить каждый заказ с помощью ID заказа.
• 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 истинной, и, если да, отключает записи журналов. Это сделано для того, чтобы гарантировать, что политика не записывает ненужные журналы.

• 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): эта строка кода вызывает функцию update Status, которая обновляет информацию о состоянии политики. Она записывает текущее состояние рынка, включая покупку, продажу и количество ранее заблокированных (lock).

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

    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): проверяет, больше ли разница между текущей ценой покупки и AskPrice, чем 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)): вызывает функцию update Status, которая записывает текущее состояние политики, включая местонахождение найденной косы и соответствующую информацию. Это будет отображаться в строке состояния политики.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant)Функция exchange.Buy используется для покупки найденного слона слона. Цена покупки - elephant.Price + PennyTick, количество покупок - Lot, и операция покупки описывается как "Bids[" + 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 для продажи успешно купленных слоновых оленей с целью получения прибыли.

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

• 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)Например, в случае, если вы хотите продать свой актив по минимальной цене на рынке, вы должны:

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

Это пояснение построенной стратегии. Основная идея этой стратегии заключается в том, чтобы найти на рынке слоновую мышь ("большую плату"), купить и продать ее с небольшой прибылью. Она включает в себя несколько важных параметров, таких как количество покупок ("Лот"), интервал ошибок ("Интервал"), уровень слона ("Амоунт") и расстояние слона ("Пространство слона") для регулирования поведения стратегии.

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

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

Когда вы продолжаете выполнять эту политику, она постоянно выполняет следующие действия:

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

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

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

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

• Вызвать функцию update Status, которая записывает местоположение и информацию о месте нахождения слонов.
• Используйте функцию exchange.Buy для покупки слоновой кости с ценой elephant.Price + PennyTick, количество покупок - Lot.
• Начинается новый бесконечный цикл, используемый для ожидания исполнения покупательных заказов.
• Проверяет состояние заказа и выходит из цикла, если заказ выполнен.
• Если время ожидания превышает установленный интервал ожидания ("Wait Interval"), все незавершенные заказы отменяются.
• Вычисляется изменение активов счета после успешной покупки, если изменение меньше 0.001, то покупка провалилась, увеличивается количество провалов и продолжается следующий цикл.
• Зарегистрировать информацию о успешных покупках слоновой ткани, включая количество покупок.

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

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

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

Заключение

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