Der Hochfrequenzhandel ist ein anspruchsvolles und wettbewerbsintensives Feld, das auf eine schnelle Handelsabwicklung und sensible Einblicke in die Mikrostruktur des Marktes angewiesen ist. Eine der Strategien, die viel Aufmerksamkeit erhalten hat, ist der Penny Jump, bei dem es darum geht, „Elefanten“ auf dem Markt auszunutzen, um kleine, aber häufige Gewinne zu erzielen. In diesem Artikel erklären wir ausführlich, wie die Penny Jump-Strategie funktioniert, und gehen dabei auf die Details des Strategiecodes ein, damit Anfänger die Funktionsweise verstehen.

Die Penny-Jump-Strategie verstehen

An der Börse handelt es sich bei „Elefanten“ in der Regel um institutionelle Anleger, die große Mengen an Aktien kaufen oder verkaufen möchten, jedoch nicht bereit sind, zu Marktpreisen zu handeln. Stattdessen platzieren sie eine große Anzahl von Limit-Orders (auch Pending Orders genannt) auf dem Markt, um ihre Absichten kundzutun. Dieses Verhalten hat auf dem Markt große Aufmerksamkeit erregt, da große Transaktionen erhebliche Auswirkungen auf den Markt haben können.

Angenommen, die Markttiefe einer Aktie sah ursprünglich folgendermaßen aus: 200 | 1,01 USD x 1,03 USD | 200. Dann kam ein „Elefant“ und platzierte eine Bestellung zum Kauf von 3.000 Aktien zu 1,01 \(. An diesem Punkt beträgt die Markttiefe 3.200 | 1,01 \) x 1,03 $ | 200. Diese Aktion ist wie die Einführung eines „Elefanten“, der in den Fokus anderer Marktteilnehmer gerät.

• Wettbewerbsfähiger Markt Hochfrequenzhändler erzielen ihre Gewinne hauptsächlich durch die Analyse der Marktmikrostruktur, um auf die Absichten anderer Händler zu schließen. Sobald ein Elefant auftaucht, werden Hochfrequenzhändler schnell Positionen aufbauen, um winzige Preisschwankungen auszunutzen. Ihr Ziel besteht darin, in einem kurzen Zeitraum häufig zu handeln und so kleine, aber kumulierte Gewinne anzuhäufen.

• Die Notlage der Elefanten Zwar möchten Elefanten im großen Stil auf dem Markt agieren, doch ihre Aktionen verraten auch ihre Handelsabsichten, was sie zu Zielen für Hochfrequenzhändler macht. Hochfrequenzhändler versuchen, im Voraus Positionen aufzubauen und dann von Preisschwankungen zu profitieren. Die Anwesenheit eines Elefanten auf dem Markt kann eine Reaktion auf dem Wettbewerbsmarkt auslösen und so seine Handelsstrategie beeinflussen.

• Täuschung auf dem Markt In der Realität platzieren große institutionelle Anleger in der Regel nicht unverhohlen eine große Zahl an Kauf- oder Verkaufsaufträgen auf dem Markt, da ein solches Verhalten andere Marktteilnehmer zu Gegenmaßnahmen oder sogar zu Marktmanipulationen veranlassen könnte. Sie wenden daher möglicherweise Strategien an, um falsche Eindrücke zu erwecken und Hochfrequenzhändler zum Markteintritt zu bewegen, und verkaufen oder kaufen dann schnell, um von Preisschwankungen zu profitieren.

Die Kernidee der Penny Jump Strategie

Die Kernidee der Penny-Jump-Strategie besteht darin, dass Hochfrequenzhändler ihre Gebote schnell um einen Cent, beispielsweise auf 1,02 Dollar, erhöhen, sobald ein Elefant auf dem Markt erscheint und einen bestimmten Preis unterstützt (zum Beispiel 1,01 Dollar). Dies liegt daran, dass Hochfrequenzhändler verstehen, dass das Erscheinen eines Elefanten bedeutet, dass auf diesem Preisniveau eine starke Kaufunterstützung besteht. Daher versuchen sie, diesem zu folgen, in der Hoffnung, dass der Preis steigen wird. Wenn der Preis auf 1,03 x 1,05 \( steigt, kann der Hochfrequenzhändler schnell verkaufen und einen Gewinn von 0,01 \) erzielen.

Darüber hinaus können Hochfrequenzhändler nach dem Kauf auch dann Gewinne erzielen, wenn der Preis nicht steigt. Da sie wissen, dass der Elefant den niedrigsten Preis stützt, können sie ihre Anteile schnell an den Elefanten verkaufen und mit der Differenz einen kleinen Gewinn erzielen.

Den Penny Jump-Strategiecode analysieren

Strategie-Quellcode: https://www.fmz.com/strategy/358

Der oben angegebene Strategiecode ist ein Beispiel, das die Penny Jump-Strategie implementiert. Hier ist eine detaillierte Erklärung des Codes, damit auch Anfänger verstehen, wie er funktioniert:

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

Ich werde den von Ihnen bereitgestellten Strategiecode Zeile für Zeile durchgehen, damit Sie die Funktionsweise genauer verstehen.

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

Dieser Code initialisiert ein Objekt namens Counter, das zum Verfolgen der Handelsstatistiken der Strategie verwendet wird. Konkret umfasst es drei Attribute:

• i: gibt die Gesamtzahl der Transaktionen an.
• w: gibt die Anzahl der erfolgreichen Transaktionen an.
• f: gibt die Anzahl der fehlgeschlagenen Transaktionen an.

Diese Attribute werden während der Richtlinienausführung aufgezeichnet und aktualisiert.

var InitAccount = null;

Diese Codezeile initialisiert eine Variable namens InitAccount, die die Kontoinformationen speichert, wenn mit der Ausführung der Strategie begonnen wird.

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

Dies ist einCancelAll()Der Zweck dieser Funktion besteht darin, alle offenen Aufträge auf dem Markt zu stornieren. Lassen Sie uns die Funktionsweise Schritt für Schritt erklären:

• while (true): Dies ist eine Endlosschleife, die ausgeführt wird, bis keine ausstehenden Bestellungen mehr vorhanden sind.
• var orders = _C(exchange.GetOrders): Diese Codezeile verwendet die Funktion „exchange.GetOrders“, um alle ausstehenden Aufträge für das aktuelle Konto abzurufen und speichert sie in der Variable „Orders“.
• if (orders.length == 0): Diese Codezeile prüft, ob nicht erfüllte Bestellungen vorliegen. Wenn die Länge des Auftrags-Arrays 0 ist, bedeutet dies, dass keine nicht erfüllten Aufträge vorhanden sind und die Schleife wird unterbrochen.
• for (var i = 0; i < orders.length; i++): Dies ist eine For-Schleife, die alle ausstehenden Bestellungen durchläuft.
• exchange.CancelOrder(orders[i].Id): Diese Codezeile verwendet die Funktion exchange.CancelOrder(), um jede Bestellung anhand ihrer Bestell-ID zu stornieren.
• Sleep(Interval): Diese Codezeile führt einen Wartezyklus ein, bei dem eine bestimmte Zeit (in Millisekunden) gewartet wird, um sicherzustellen, dass die Auftragsstornierung nicht zu häufig erfolgt.

Der Zweck dieser Funktion besteht darin, sicherzustellen, dass vor der Ausführung der Hauptstrategie keine ausstehenden Aufträge vorhanden sind, um Störungen bei der Ausführung der Hauptstrategie zu vermeiden.

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

Dies ist einupdateStatus(msg)Eine Funktion, die Transaktionsstatusinformationen aktualisiert und aufzeichnet. Es akzeptiert einen MSG-Parameter, der normalerweise Informationen zum aktuellen Marktstatus enthält. Zu den spezifischen Operationen der Funktion gehören:

verwendenLogStatus()Die Funktion zeichnet die Informationen auf, die während der Ausführung der Strategie in der Statusleiste angezeigt werden. Es zeigt den Text über die Anzahl der Transaktionen, Erfolge und Misserfolge an. BeigefügtmsgParameter, die Informationen über den aktuellen Marktstatus enthalten. Der aktuelle Zeitstempel wird angehängt (new Date()), um Zeitinformationen anzuzeigen. Der Zweck dieser Funktion besteht darin, Handelsstatusinformationen zur Überwachung und Analyse während der Strategieausführung aufzuzeichnen und zu aktualisieren.

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

Dies ist die Hauptausführungsfunktion der Strategiemain(), das die Kernlogik der Strategie enthält. Lassen Sie uns die Funktionsweise Zeile für Zeile erklären:

• if (DisableLog): Diese Codezeile überprüft, ob die Variable „DisableLog“ wahr ist, und deaktiviert ggf. die Protokollierung. Dadurch soll sichergestellt werden, dass die Richtlinie keine unnötigen Informationen protokolliert.

• CancelAll(): Rufen Sie die zuvor erläuterte Funktion CancelAll() auf, um sicherzustellen, dass keine nicht abgeschlossenen Bestellungen vorhanden sind.

• InitAccount = _C(exchange.GetAccount): Diese Codezeile ruft die aktuellen Kontoinformationen ab und speichert sie in der Variable InitAccount. Dies wird verwendet, um den Status des Kontos aufzuzeichnen, wenn mit der Ausführung der Strategie begonnen wird.

• var i = 0; Und var locks = 0;: Initialisieren Sie zwei Variablen i und Sperren, die in der nachfolgenden Strategielogik verwendet werden.

• while (true): Dies ist eine Endlosschleife, die hauptsächlich zur kontinuierlichen Ausführung von Strategien verwendet wird.

Als nächstes erklären wir Zeile für Zeilewhile (true)Die Hauptstrategielogik innerhalb der Schleife.

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): Diese Codezeile ermöglicht es der Strategie, für einen bestimmten Zeitraum zu ruhen, um die Ausführungshäufigkeit der Strategie zu steuern. Der Intervallparameter definiert das Schlafintervall in Millisekunden.

• var depth = _C(exchange.GetDepth): Erhalten Sie aktuelle Informationen zur Markttiefe, einschließlich Preis und Menge der Verkaufs- und Kaufaufträge. Diese Informationen werden in der Tiefenvariable gespeichert.

• if (depth.Asks.length === 0 || depth.Bids.length === 0): Diese Codezeile überprüft die Markttiefeninformationen, um sicherzustellen, dass sowohl Verkaufs- als auch Kaufaufträge vorliegen. Wenn einer von ihnen nicht vorhanden ist, bedeutet dies, dass dem Markt möglicherweise nicht genügend Handelsinformationen zur Verfügung stehen und die Strategie weiterhin auf sich warten lässt.

• updateStatus("搜索大象中.... 买一: " + depth.Bids[0].Price + ", 卖一:" + depth.Asks[0].Price + ", 锁定次数: " + locks): Diese Codezeile ruft die Funktion updateStatus auf, um die Statusinformationen der Strategie zu aktualisieren. Es zeichnet den aktuellen Marktstatus auf, einschließlich des Gebotskurses, des Briefkurses und der Anzahl der vorherigen Sperren.

    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;: Initialisieren Sie die Variable askPrice, die zum Speichern des Verkaufsauftragspreises verwendet wird, der die Bedingungen erfüllt.

• for (i = 0; i < depth.Asks.length; i++): Dies ist eine For-Schleife, die zum Durchlaufen der Preis- und Mengeninformationen der Marktverkaufsorder verwendet wird.

• if (depth.Asks[i].Amount >= Lot): Überprüfen Sie in der Schleife, ob die Menge jeder Verkaufsorder größer oder gleich dem angegebenen Lot ist. Wenn ja, speichern Sie den Preis der Verkaufsorder in askPrice und beenden Sie die Schleife.

• if (askPrice === 0): Wenn keine zufriedenstellende Verkaufsorder gefunden wird (AskPrice ist immer noch 0), wartet die Strategie weiter und überspringt nachfolgende Vorgänge.

• var elephant = null;: Initialisieren Sie die Elefantenvariable, die zum Speichern der als „Elefant“ gekennzeichneten Kaufauftragsinformationen verwendet wird.

    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;

Fahren Sie mit der Iteration durch die Preis- und Mengeninformationen der Marktkaufaufträge fort und überspringen Sie dabei den ersten Kaufauftrag (Gebote[0]）。

• if ((askPrice - depth.Bids[i].Price) > ElephantSpace): Überprüfen Sie, ob die Differenz zwischen dem aktuellen Kaufpreis und dem Angebotspreis größer als ElephantSpace ist. Wenn ja, bedeutet dies, dass er weit genug vom „Elefanten“ entfernt ist und die Strategie die Suche nicht fortsetzt.

• if (depth.Bids[i].Amount >= ElephantAmount): Überprüfen Sie, ob der aktuelle Kaufauftragsbetrag größer oder gleich ElephantAmount ist. Wenn ja, speichern Sie die Kaufauftragsinformationen in der Elephant-Variable.

• if (!elephant): Wenn der „Elefant“ nicht gefunden wird, setzen Sie den Sperrzähler auf 0 zurück und warten Sie weiter.

locks++: Wenn der „Elefant“ gefunden wird, wird die Anzahl der Sperren erhöht. Dadurch soll sichergestellt werden, dass die Strategie ausgeführt wird, nachdem die Existenz des „Elefanten“ über einen bestimmten Zeitraum hinweg mehrfach bestätigt wurde.

• if (locks < LockCount): Überprüfen Sie, ob die Anzahl der Sperren die Anforderung (LockCount) erreicht. Wenn die Voraussetzungen nicht erfüllt sind, warten Sie weiter.

    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)): Rufen Sie die Funktion updateStatus auf, um den aktuellen Status der Strategie aufzuzeichnen, einschließlich der Gangposition des gefundenen „Elefanten“ und zugehöriger Informationen. Dies wird in der Statusspalte der Richtlinie angezeigt.

• exchange.Buy(elephant.Price + PennyTick, Lot, "Bids[" + i + "]", elephant): Verwenden Sie die Funktion „Austausch.Kaufen“, um den gefundenen „Elefanten“ zu kaufen. Der Kaufpreis ist elephant.Price + PennyTick, die Kaufmenge ist Lot und der Kaufvorgang wird als „Gebote“ beschrieben.[” + i + “]“。

• var ts = new Date().getTime(): Holen Sie sich den Zeitstempel der aktuellen Zeit für die nachfolgende Berechnung von Zeitintervallen.

• while (true): Geben Sie eine neue Endlosschleife ein, um auf die Ausführung der „Elefanten“-Kauforder zu warten.

• Sleep(CheckInterval): Die Strategie schläft für einen bestimmten Zeitraum, um zu steuern, wie oft der Bestellstatus überprüft wird.

• var orders = _C(exchange.GetOrders): Alle Bestellinformationen des Girokontos abrufen.

• if (orders.length == 0): Prüfen Sie, ob noch nicht abgeschlossene Bestellungen vorliegen. Wenn nicht, verlassen Sie die Schleife.

• (new Date().getTime() - ts) > WaitInterval: Berechnen Sie das Zeitintervall zwischen der aktuellen Zeit und dem Zeitpunkt, an dem der „Elefant“ gekauft wird. Wenn es WaitInterval überschreitet, bedeutet dies, dass die Wartezeit abgelaufen ist.

• for (var i = 0; i < orders.length; i++): Alle nicht abgeschlossenen Bestellungen durchlaufen.

• exchange.CancelOrder(orders[i].Id): Stornieren Sie jede offene Bestellung mit der Funktion „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): Aktuelle Kontoinformationen abrufen.

• var opAmount = _N(account.Stocks - InitAccount.Stocks): Berechnen Sie die Vermögensänderung auf dem Konto nach dem Kauf von „Elephant“. Wenn die Änderung weniger als 0,001 beträgt, bedeutet dies, dass der Kauf fehlgeschlagen ist, die Anzahl der Fehler erhöht wird und der nächste Zyklus fortgesetzt wird.

• updateStatus("买单得手: " + opAmount + ", 开始出手..."): Protokolliert die Informationen zum erfolgreichen Kauf von „Elefant“, einschließlich der Kaufmenge.

• exchange.Sell(elephant.Price + (PennyTick * ProfitTick), opAmount): Nutzen Sie die Funktion „exchange.Sell“, um den erfolgreich gekauften „Elefanten“ gewinnbringend zu verkaufen. Der Verkaufspreis beträgt elephant.Price + (PennyTick * ProfitTick).

Beginnt mit einer neuen Endlosschleife und wartet auf die Ausführung der Verkaufsorder.

• var depth = _C(exchange.GetDepth): Erhalten Sie Informationen zur Markttiefe.

• if (depth.Bids.length > 0 && depth.Bids[0].Price <= (elephant.Price - (STTick * PennyTick))): Überprüfen Sie die Markttiefeinformationen. Wenn der Marktpreis auf den Stop-Loss-Preis gefallen ist, führen Sie den Stop-Loss-Vorgang aus.

• CancelAll(): Rufen Sie die Funktion CancelAll() auf, um alle nicht abgeschlossenen Aufträge zu stornieren und so Positionsrisiken zu vermeiden.

• if (opAmount < 0.001): Überprüfen Sie die Kaufmenge erneut. Wenn sie kleiner als 0,001 ist, bedeutet dies, dass der Kauf fehlgeschlagen ist und die Schleife verlassen wird.

• exchange.Sell(depth.Bids[0].Price, opAmount): Führen Sie eine Stop-Loss-Operation durch und verkaufen Sie die verbleibenden Vermögenswerte zum aktuell niedrigsten Marktpreis.

Abschließend wird, abhängig davon, ob die Transaktion erfolgreich war oder nicht, die Anzahl der Erfolge und Misserfolge aktualisiert und der Transaktionsgewinn erfasst.

Dies ist eine Zeile-für-Zeile-Erklärung der gesamten Strategie. Die Kernidee dieser Strategie besteht darin, auf dem Markt nach „Elefanten“ (großen Kaufaufträgen) zu suchen, diese zu kaufen und mit winzigen Gewinnen zu verkaufen. Es enthält mehrere wichtige Parameter, wie Kaufmenge (Lot), Fehlerwiederholungsintervall (Interval), Elefantenlevel (ElephantAmount), Elefantendistanz (ElephantSpace) usw., um das Verhalten der Strategie anzupassen.

Im Allgemeinen handelt es sich bei dieser Strategie um eine Hochfrequenzhandelsstrategie, die darauf abzielt, Informationen zur Markttiefe auszunutzen, große Kaufaufträge zu identifizieren und Kauf- und Verkaufstransaktionen in kurzer Zeit auszuführen. Es erfordert eine ständige Überwachung des Marktes und die Durchführung von Kauf- und Verkaufstransaktionen, um schnell kleine Gewinne zu erzielen. Allerdings handelt es sich dabei auch um eine risikoreiche Strategie, da sie eine schnelle Reaktion auf Marktschwankungen erfordert und gleichzeitig Risikomanagement- und Stop-Loss-Mechanismen berücksichtigt werden müssen, um erhebliche Verluste zu vermeiden.

Bitte beachten Sie, dass diese Strategie auf bestimmten Märkten und Handelsplattformen basiert und möglicherweise für verschiedene Märkte und Börsen entsprechend angepasst und optimiert werden muss. In der tatsächlichen Anwendung müssen Anleger die Leistung der Strategie sorgfältig testen und bewerten, um sicherzustellen, dass sie mit ihren Anlagezielen und ihrer Risikotoleranz übereinstimmt.

Während Sie die Strategie weiter ausführen, wird sie in einer Schleife ausgeführt und führt Folgendes aus:

1. Zunächst überprüft die Strategie die Markttiefeninformationen, um die aktuellen Verkaufs- und Kaufaufträge zu verstehen.

2. Als Nächstes versucht die Strategie, einen Verkaufsauftrag zu finden, der die Bedingungen erfüllt, wobei die Menge des Verkaufsauftrags größer oder gleich dem Lot ist. Wenn ein Verkaufsauftrag gefunden wird, der die Bedingungen erfüllt, wird der Verkaufspreis als Briefkurs erfasst.

3. Die Strategie sucht dann weiter nach „Elefanten“ (großen Kaufaufträgen). Dabei werden alle Kaufaufträge auf dem Markt durchlaufen, wobei der erste Kaufauftrag (normalerweise der Kaufauftrag mit dem höchsten Preis) übersprungen wird. Wenn ein „Elefant“ gefunden wird, der die Bedingungen erfüllt, werden die Informationen des „Elefanten“ aufgezeichnet und die Anzahl der Schlösser erhöht.

4. Wenn genügend „Elefanten“ nacheinander gefunden werden (gesteuert durch den Parameter LockCount), führt die Strategie anschließend die folgenden Operationen aus:

• Rufen Sie die Funktion updateStatus auf, um die Gangposition des „Elefanten“ und zugehörige Informationen aufzuzeichnen.
• Verwenden Sie die Funktion „Exchange.Buy“, um „Elefant“ zu kaufen. Der Kaufpreis beträgt „Elephant.Price + PennyTick“ und die Kaufmenge beträgt „Lot“.
• Startet eine neue Endlosschleife und wartet auf die Ausführung einer Kauforder.
• Prüfen Sie den Bestellstatus und brechen Sie die Schleife ab, wenn die Bestellung abgeschlossen ist.
• Überschreitet die Wartezeit das eingestellte Warteintervall (WaitInterval), werden alle noch nicht abgeschlossenen Aufträge storniert.
• Berechnen Sie die Änderung des Kontovermögens nach einem erfolgreichen Kauf. Wenn die Änderung weniger als 0,001 beträgt, bedeutet dies, dass der Kauf fehlgeschlagen ist. Erhöhen Sie die Anzahl der Fehlschläge und fahren Sie mit dem nächsten Zyklus fort.
• Erfassen Sie die Informationen über den erfolgreichen Kauf von „Elefanten“, einschließlich der Kaufmenge.

1. Anschließend wird die Strategie in eine neue Endlosschleife eintreten und auf die Ausführung des Verkaufsvorgangs warten. In dieser Schleife geschieht Folgendes:

• Erhalten Sie Informationen zur Markttiefe und prüfen Sie, ob der Marktpreis das Stop-Loss-Niveau erreicht hat.
• Erreicht oder unterschreitet der Marktpreis den Stop-Loss-Preis, wird die Stop-Loss-Operation ausgeführt, das heißt, die verbleibenden Vermögenswerte werden verkauft.
• Rufen Sie die Funktion „CancelAll“ auf, um alle nicht abgeschlossenen Aufträge zu stornieren und so Positionsrisiken zu reduzieren.
• Überprüfen Sie nach dem erfolgreichen Kauf noch einmal die Änderung des Kontoguthabens. Wenn die Änderung weniger als 0,001 beträgt, bedeutet dies, dass der Kauf fehlgeschlagen ist und die Schleife verlassen wird.
• Zeichnen Sie abschließend auf, ob die Transaktion erfolgreich war oder nicht, und aktualisieren Sie die Anzahl der Erfolge und Fehlschläge basierend auf den Transaktionsergebnissen.

Die gesamte Strategie durchläuft kontinuierlich die oben genannten Vorgänge, um möglichst viele „Elefanten“ zu fangen und kleine Gewinne zu erzielen. Hierbei handelt es sich um eine Hochfrequenz-Handelsstrategie, die eine schnelle Reaktion auf Marktveränderungen erfordert und gleichzeitig das Risikomanagement und Stop-Loss-Mechanismen zum Schutz des Kapitals berücksichtigt. Anleger sollten den Einsatz dieser Strategie sorgfältig abwägen, insbesondere in sehr volatilen Märkten.

Abschluss

Die Penny Jump Strategie ist ein klassisches Beispiel im Hochfrequenzhandel, das das subtile Spiel und den Wettbewerb der Marktteilnehmer verdeutlicht. Diese Strategie ist besonders auf dem Kryptowährungsmarkt beliebt, wo die Volatilität hoch ist und institutionelle Anleger und Hochfrequenzhändler auf der Suche nach schnellen Gewinnen sind. Dies stellt jedoch auch eine Herausforderung auf dem Markt dar, da zur Aufrechterhaltung des Wettbewerbsvorteils eine ständige Anpassung und Neuausrichtung der Strategien erforderlich ist. In dieser Welt mit ihrem erbitterten Wettbewerb werden nur die Händler erfolgreich sein, die die Mikrostruktur des Marktes gut beobachten und schnell reagieren können.