Le trading haute fréquence est un domaine difficile et concurrentiel qui repose sur une exécution rapide des transactions et des informations sensibles sur la microstructure du marché. L’une des stratégies qui a reçu beaucoup d’attention est le Penny Jump, qui vise à tirer parti des « éléphants » du marché pour réaliser des bénéfices modestes mais fréquents. Dans cet article, nous expliquerons en détail comment fonctionne la stratégie Penny Jump tout en plongeant dans les détails du code de la stratégie afin que les débutants puissent comprendre son fonctionnement.

Comprendre la stratégie du Penny Jump

Sur le marché boursier, les « éléphants » sont généralement des investisseurs institutionnels qui souhaitent acheter ou vendre de grandes quantités d’actions, mais ne sont pas disposés à négocier aux prix du marché. Au lieu de cela, ils choisissent de placer un grand nombre d’ordres à cours limité, également appelés ordres en attente, sur le marché pour indiquer leurs intentions. Ce comportement a attiré une attention généralisée sur le marché car les transactions importantes peuvent avoir un impact significatif sur le marché.

Par exemple, supposons que la profondeur du marché d’une action ressemblait initialement à ceci : 200 | 1,01 \( x 1,03 \) | 200. Puis, un « éléphant » est arrivé et a passé un ordre d’achat de 3 000 actions à 1,01 \(. À ce stade, la profondeur du marché deviendra 3 200 | 1,01 \) x 1,03 $ | 200. Cette action revient à introduire un « éléphant » qui devient le centre d’attention des autres participants sur le marché.

• Marché concurrentiel Pour les traders à haute fréquence, leurs profits proviennent principalement de l’analyse de la microstructure du marché pour déduire les intentions des autres traders. Une fois qu’un éléphant apparaît, les traders à haute fréquence établiront rapidement des positions pour capturer de minuscules fluctuations de prix. Leur objectif est d’effectuer des transactions fréquentes sur une courte période de temps, accumulant des bénéfices modestes mais cumulatifs.

• Le sort des éléphants Même si les éléphants souhaitent opérer à grande échelle sur le marché, leurs actions trahissent également leurs intentions commerciales, ce qui en fait des cibles pour les traders à haute fréquence. Les traders à haute fréquence tentent d’établir des positions à l’avance et de profiter ensuite des fluctuations de prix. La présence d’un éléphant sur le marché peut déclencher une réaction sur le marché concurrentiel, affectant ainsi sa stratégie commerciale.

• Tromperie sur le marché En réalité, les grands investisseurs institutionnels ne placent généralement pas ouvertement un grand nombre d’ordres d’achat ou de vente sur le marché, car un tel comportement peut amener d’autres acteurs du marché à prendre des contre-mesures ou même à manipuler le marché. Par conséquent, ils peuvent adopter des stratégies pour créer de fausses impressions afin d’attirer les traders à haute fréquence pour entrer sur le marché, puis vendre ou acheter rapidement pour profiter des fluctuations de prix.

L’idée centrale de la stratégie Penny Jump

L’idée principale de la stratégie Penny Jump est qu’une fois qu’un éléphant apparaît sur le marché et soutient un prix spécifique (par exemple, 1,01 \(), les traders à haute fréquence augmenteront rapidement leurs offres d'un centime, par exemple à 1,02 \). C’est parce que les traders à haute fréquence comprennent que l’apparition d’un éléphant signifie qu’il existe un fort support d’achat à ce niveau de prix, ils essaient donc de le suivre dans l’espoir que le prix augmentera. Lorsque le prix monte à 1,03 \( x 1,05 \), le trader haute fréquence peut vendre rapidement, réalisant un bénéfice de 0,01 $.

De plus, les traders à haute fréquence peuvent également réaliser des bénéfices après l’achat même si le prix n’augmente pas. Parce qu’ils savent que l’éléphant soutient le prix le plus bas, ils peuvent rapidement vendre leurs actions à l’éléphant et réaliser un petit bénéfice sur la différence.

Analyse du code de la stratégie Penny Jump

Code source de la stratégie : https://www.fmz.com/strategy/358

Le code de stratégie fourni ci-dessus est un exemple qui implémente la stratégie Penny Jump. Voici une explication détaillée du code afin que les débutants puissent comprendre son fonctionnement :

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

Je vais parcourir le code de stratégie que vous avez fourni ligne par ligne pour vous aider à comprendre son fonctionnement plus en détail.

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

Ce code initialise un objet appelé Counter, qui est utilisé pour suivre les statistiques de trading de la stratégie. Il comprend notamment trois attributs :

• i : indique le nombre total de transactions.
• w : indique le nombre de transactions réussies.
• f : indique le nombre de transactions ayant échoué.

Ces attributs sont enregistrés et mis à jour lors de l’exécution de la politique.

var InitAccount = null;

Cette ligne de code initialise une variable appelée InitAccount, qui stockera les informations du compte lorsque la stratégie commencera à s’exécuter.

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

C’est unCancelAll()Le but de cette fonction est d’annuler tous les ordres ouverts sur le marché. Expliquons son fonctionnement étape par étape :

• while (true):Il s’agit d’une boucle infinie qui s’exécutera jusqu’à ce qu’il n’y ait plus de commandes en attente.
• var orders = _C(exchange.GetOrders):Cette ligne de code utilise la fonction exchange.GetOrders pour obtenir toutes les commandes en attente pour le compte actuel et les stocke dans la variable orders.
• if (orders.length == 0):Cette ligne de code vérifie s’il existe des commandes non exécutées. Si la longueur du tableau des commandes est de 0, cela signifie qu’il n’y a aucune commande non exécutée et que la boucle sera interrompue.
• for (var i = 0; i < orders.length; i++):Il s’agit d’une boucle for qui parcourt toutes les commandes en attente.
• exchange.CancelOrder(orders[i].Id):Cette ligne de code utilise la fonction exchange.CancelOrder() pour annuler chaque commande par son ID de commande.
• Sleep(Interval):Cette ligne de code introduit un cycle d’attente, attendant une certaine période de temps (en millisecondes) pour garantir que l’opération d’annulation de commande ne soit pas trop fréquente.

Le but de cette fonction est de garantir qu’avant d’exécuter la stratégie principale, aucun ordre en attente n’existe pour éviter d’interférer avec l’exécution de la stratégie principale.

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

C’est unupdateStatus(msg)Une fonction qui met à jour les informations sur l’état des transactions et les enregistre. Il accepte un paramètre msg qui contient généralement des informations sur l’état actuel du marché. Les opérations spécifiques de la fonction incluent :

utiliserLogStatus()La fonction enregistre les informations affichées dans la barre d’état lorsque la stratégie est en cours d’exécution. Il montre le texte sur le nombre de transactions, de réussites et d’échecs. Ci-jointmsgParamètres contenant des informations sur l’état actuel du marché. L’horodatage actuel est ajouté (new Date()) pour afficher les informations temporelles. Le but de cette fonction est d’enregistrer et de mettre à jour les informations sur l’état des transactions à des fins de surveillance et d’analyse pendant l’exécution de la stratégie.

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

Il s’agit de la principale fonction d’exécution de la stratégiemain(), qui contient la logique fondamentale de la stratégie. Expliquons son fonctionnement ligne par ligne :

• if (DisableLog):Cette ligne de code vérifie si la variable DisableLog est vraie et, si c’est le cas, elle désactive la journalisation. Cela permet de garantir que la politique n’enregistre pas d’informations inutiles.

• CancelAll(): Appelez la fonction CancelAll() expliquée précédemment pour vous assurer qu’aucune commande non terminée n’existe.

• InitAccount = _C(exchange.GetAccount):Cette ligne de code récupère les informations du compte actuel et les stocke dans la variable InitAccount. Cela sera utilisé pour enregistrer l’état du compte lorsque la stratégie commence à s’exécuter.

• var i = 0; et var locks = 0;: Initialiser deux variables i et locks, qui seront utilisées dans la logique de stratégie ultérieure.

• while (true):Il s’agit d’une boucle infinie, principalement utilisée pour l’exécution continue de stratégies.

Ensuite, nous expliquerons ligne par lignewhile (true)La logique stratégique principale à l’intérieur de la boucle.

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):Cette ligne de code permet à la stratégie de rester en veille pendant un certain temps pour contrôler la fréquence d’exécution de la stratégie. Le paramètre Intervalle définit l’intervalle de veille en millisecondes.

• var depth = _C(exchange.GetDepth):Obtenez les informations actuelles sur la profondeur du marché, y compris le prix et la quantité des ordres de vente et d’achat. Ces informations seront stockées dans la variable de profondeur.

• if (depth.Asks.length === 0 || depth.Bids.length === 0):Cette ligne de code vérifie les informations de profondeur du marché pour garantir que les ordres de vente et d’achat existent. Si l’un d’entre eux n’existe pas, cela signifie que le marché ne dispose peut-être pas de suffisamment d’informations de trading et que la stratégie continuera d’attendre.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks):Cette ligne de code appelle la fonction updateStatus pour mettre à jour les informations d’état de la stratégie. Il enregistre l’état actuel du marché, y compris le prix acheteur, le prix vendeur et le nombre de verrous précédents.

    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;: Initialisez la variable askPrice, qui sera utilisée pour stocker le prix de l’ordre de vente qui répond aux conditions.

• for (i = 0; i < depth.Asks.length; i++):Il s’agit d’une boucle for utilisée pour parcourir les informations de prix et de quantité de l’ordre de vente du marché.

• if (depth.Asks[i].Amount >= Lot):Dans la boucle, vérifiez si la quantité de chaque ordre de vente est supérieure ou égale au lot spécifié. Si tel est le cas, stockez le prix de l’ordre de vente dans askPrice et terminez la boucle.

• if (askPrice === 0):Si aucun ordre de vente satisfaisant n’est trouvé (askPrice est toujours 0), la stratégie continuera d’attendre et ignorera les opérations suivantes.

• var elephant = null;: Initialisez la variable éléphant, qui sera utilisée pour stocker les informations de commande d’achat identifiées comme « éléphant ».

    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;

Continuez à parcourir les informations sur les prix et la quantité des ordres d’achat du marché, en sautant le premier ordre d’achat (offres).[0]）。

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace):Vérifiez si la différence entre le prix d’achat actuel et le prix demandé est supérieure à ElephantSpace. Si c’est le cas, cela signifie qu’il est suffisamment loin de « l’éléphant » et que la stratégie ne continuera pas la recherche.

• if (depth.Bids[i].Amount >= ElephantAmount): Vérifiez si le montant actuel de l’ordre d’achat est supérieur ou égal à ElephantAmount. Si tel est le cas, stockez les informations de l’ordre d’achat dans la variable elephant.

• if (!elephant):Si l’« éléphant » n’est pas trouvé, réinitialisez le nombre de verrous à 0 et continuez d’attendre.

locks++ : Si l’« éléphant » est trouvé, le nombre de verrous sera incrémenté. Cela permet de garantir que la stratégie est exécutée après que l’existence de « l’éléphant » a été confirmée plusieurs fois sur une période donnée.

• if (locks < LockCount):Vérifiez si le nombre de verrous atteint l’exigence (LockCount). Si les conditions ne sont pas remplies, continuez d’attendre.

    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)): Appelez la fonction updateStatus pour enregistrer l’état actuel de la stratégie, y compris la position de l’engrenage de « l’éléphant » trouvé et les informations associées. Cela sera indiqué dans la colonne Statut de la politique.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant):Utilisez la fonction exchange.Buy pour acheter l’“éléphant” trouvé. Le prix d’achat est elephant.Price + PennyTick, la quantité d’achat est Lot et l’opération d’achat est décrite comme « Enchères »[” + i + “]“。

• var ts = new Date().getTime():Obtenez l’horodatage de l’heure actuelle pour le calcul ultérieur des intervalles de temps.

• while (true):Entrez une nouvelle boucle infinie pour attendre l’exécution de l’ordre d’achat « éléphant ».

• Sleep(CheckInterval):La stratégie reste en veille pendant un certain temps pour contrôler la fréquence à laquelle le statut de la commande est vérifié.

• var orders = _C(exchange.GetOrders):Obtenez toutes les informations de commande du compte courant.

• if (orders.length == 0):Vérifiez s’il y a des commandes non terminées, sinon, sortez de la boucle.

• (new Date().getTime() - ts) > WaitInterval: Calculer l’intervalle de temps entre l’heure actuelle et le moment où l’“éléphant” est acheté. S’il dépasse WaitInterval, cela signifie que le délai d’attente a expiré.

• for (var i = 0; i < orders.length; i++): Itérer sur toutes les commandes non terminées.

• exchange.CancelOrder(orders[i].Id):Annulez chaque commande ouverte en utilisant la fonction 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):Obtenez des informations sur votre compte courant.

• var opAmount = _N(account.Stocks - InitAccount.Stocks):Calculez la variation des actifs du compte après l’achat de « Elephant ». Si le changement est inférieur à 0,001, cela signifie que l’achat a échoué, le nombre d’échecs augmentera et le cycle suivant se poursuivra.

• updateStatus("买单得手: " + opAmount + ", 开始出手..."):Enregistre les informations relatives à l’achat réussi d’« éléphant », y compris la quantité achetée.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount):Utilisez la fonction exchange.Sell pour vendre l’« éléphant » acheté avec succès afin de réaliser un profit. Le prix de vente est éléphant.Prix + (PennyTick * ProfitTick).

Entre dans une nouvelle boucle infinie en attendant l’exécution de l’ordre de vente.

• var depth = _C(exchange.GetDepth):Obtenez des informations sur la profondeur du marché.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): Vérifiez les informations sur la profondeur du marché. Si le prix du marché est tombé au prix stop loss, exécutez l’opération stop loss.

• CancelAll(): Appelez la fonction CancelAll() pour annuler toutes les commandes non terminées afin d’éviter les risques de position.

• if (opAmount < 0.001): Vérifiez à nouveau la quantité achetée. Si elle est inférieure à 0,001, cela signifie que l’achat a échoué et que la boucle sera interrompue.

• exchange.Sell(depth.Bids[0].Price, opAmount):Exécutez une opération de stop loss et vendez les actifs restants au prix le plus bas actuel du marché.

Enfin, selon que la transaction est réussie ou non, le nombre de réussites et d’échecs est mis à jour et le bénéfice de la transaction est enregistré.

Voilà une explication ligne par ligne de toute la stratégie. L’idée principale de cette stratégie est de rechercher des « éléphants » (gros ordres d’achat) sur le marché, de les acheter et de les vendre pour de minuscules bénéfices. Il comprend plusieurs paramètres importants, tels que la quantité d’achat (Lot), l’intervalle de nouvelle tentative d’erreur (Interval), le niveau de l’éléphant (ElephantAmount), la distance de l’éléphant (ElephantSpace), etc., pour ajuster le comportement de la stratégie.

En général, cette stratégie est une stratégie de trading à haute fréquence qui vise à exploiter les informations sur la profondeur du marché, à identifier les ordres d’achat importants et à exécuter des transactions d’achat et de vente dans un court laps de temps. Il faut surveiller constamment le marché et exécuter des opérations d’achat et de vente pour réaliser rapidement de petits bénéfices. Cependant, il s’agit également d’une stratégie à haut risque car elle nécessite une réponse rapide aux fluctuations du marché, tout en tenant compte de la gestion des risques et des mécanismes de stop-loss pour éviter des pertes importantes.

Veuillez noter que cette stratégie est basée sur des marchés et des plateformes de trading spécifiques et peut nécessiter d’être ajustée et optimisée de manière appropriée pour différents marchés et bourses. Dans la pratique, les investisseurs doivent tester et évaluer soigneusement les performances de la stratégie pour s’assurer qu’elle est cohérente avec leurs objectifs d’investissement et leur tolérance au risque.

Au fur et à mesure que vous continuez à exécuter la stratégie, elle continuera à tourner en boucle et à effectuer les opérations suivantes :

1. Tout d’abord, la stratégie vérifie les informations sur la profondeur du marché pour comprendre les ordres de vente et d’achat actuels.

2. Ensuite, la stratégie tentera de trouver un ordre de vente qui répond aux conditions, où la quantité de l’ordre de vente est supérieure ou égale au lot. Si un ordre de vente répondant aux conditions est trouvé, le prix de l’ordre de vente sera enregistré comme askPrice.

3. La stratégie continue ensuite de rechercher des « éléphants » (ordres d’achat importants). Il parcourra les ordres d’achat sur le marché, en sautant le premier ordre d’achat (généralement l’ordre d’achat au prix le plus élevé). Si un « éléphant » répondant aux conditions est trouvé, les informations de « l’éléphant » seront enregistrées et le nombre de verrous sera augmenté.

4. Si suffisamment d’« éléphants » sont trouvés consécutivement (contrôlé par le paramètre LockCount), la stratégie effectuera en outre les opérations suivantes :

• Appelez la fonction updateStatus pour enregistrer la position de l’engrenage de « l’éléphant » et les informations associées.
• Utilisez la fonction exchange.Buy pour acheter « éléphant », le prix d’achat est elephant.Price + PennyTick et la quantité d’achat est Lot.
• Démarre une nouvelle boucle infinie en attendant l’exécution d’un ordre d’achat.
• Vérifiez l’état de la commande et si la commande est terminée, sortez de la boucle.
• Si le temps d’attente dépasse l’intervalle d’attente défini (WaitInterval), toutes les commandes non terminées seront annulées.
• Calculez la variation des actifs du compte après un achat réussi. Si la variation est inférieure à 0,001, cela signifie que l’achat a échoué, augmentez le nombre d’échecs et passez au cycle suivant.
• Enregistrez les informations relatives à l’achat réussi d’« éléphants », y compris la quantité achetée.

1. Ensuite, la stratégie continuera à entrer dans une nouvelle boucle infinie, en attendant l’exécution de l’opération de vente. Dans cette boucle, il effectue les opérations suivantes :

• Obtenez des informations sur la profondeur du marché et vérifiez si le prix du marché a atteint le niveau de stop loss.
• Si le prix du marché atteint ou descend en dessous du prix stop loss, l’opération stop loss sera exécutée, c’est-à-dire que les actifs restants seront vendus.
• Appelez la fonction CancelAll pour annuler toutes les commandes non terminées afin de réduire les risques de position.
• Vérifiez à nouveau l’évolution des actifs du compte une fois l’achat réussi. Si la variation est inférieure à 0,001, cela signifie que l’achat a échoué et que la boucle est terminée.
• Enfin, enregistrez si la transaction est réussie ou non et mettez à jour le nombre de réussites et d’échecs en fonction des résultats de la transaction.

L’ensemble de la stratégie consiste à répéter en permanence les opérations ci-dessus pour capturer autant d’« éléphants » que possible et obtenir de minuscules profits. Il s’agit d’une stratégie de trading à haute fréquence qui nécessite une réponse rapide aux changements du marché tout en tenant compte de la gestion des risques et des mécanismes de stop-loss pour protéger le capital. Les investisseurs devraient soigneusement réfléchir à l’utilisation de cette stratégie, en particulier sur des marchés très volatils.

Conclusion

La stratégie Penny Jump est un exemple classique de trading haute fréquence, qui démontre le jeu subtil et la concurrence entre les acteurs du marché. Cette stratégie est particulièrement importante sur le marché des crypto-monnaies, où la volatilité est élevée et où les investisseurs institutionnels et les traders à haute fréquence recherchent des profits rapides. Cependant, cela rend également le marché difficile, nécessitant une adaptation et un ajustement constants des stratégies pour maintenir un avantage concurrentiel. Dans ce monde extrêmement compétitif, seuls les traders qui savent observer la microstructure du marché et réagir rapidement réussiront.