Anpassungsfähige Kryptowährungs-Grid-Handelsstrategie auf der Grundlage von Arbitrage

Schriftsteller:ChaoZhang, Datum: 2024-01-19 14:17:50
Tags:

Übersicht

Dies ist eine anpassungsfähige Kryptowährungs-Grid-Handelsstrategie, die auf der Grid-Handelsmethode für die Arbitrage basiert. Sie kann automatisch die Preisspanne des Grid-Handels basierend auf Marktschwankungen anpassen und einen effizienten Arbitrage-Handel innerhalb dieser Preisspanne durchführen.

Strategieprinzip

Die Kernidee dieser Strategie lautet:

Dynamisch berechnen Sie einen Preisbereich des Handelsnetzes auf der Grundlage historischer Höchst- und Tiefpreise.
N-Gitterlinien in gleichen Abständen innerhalb dieser Preisspanne setzen.
Wenn der Preis jede Gitterlinie durchbricht, öffnen Sie Long- oder Short-Positionen mit einer festen Menge.
Arbitrage zwischen angrenzenden Netzlinien und Schließung von Positionen für Gewinn.
Wenn der Preis wieder in den Netzbereich eintritt, eröffnen Sie weiterhin Positionen zu den Grenzkosten der Netzlinien.
Dieser Zyklus wird für den Hochfrequenz-Arbitrage-Handel innerhalb des Netzpreisbereichs wiederholt.

Insbesondere berechnet die Strategie zunächst die oberen und unteren Grenzen des Gitter in Echtzeit gemäß den konfigurierten Lookback-Fenstern (i_boundLookback) und dem Volatilitätsbereich (i_boundDev).

Dann werden N Gitterlinien (i_gridQty) gleichmäßig zwischen den oberen und unteren Grenzen aufgeteilt. Die Preise dieser Gitterlinien werden im gridLineArr-Array gespeichert.

Wenn der Preis eine Gitterlinie durchbricht, wird eine feste Menge (Strategiekapital geteilt durch die Anzahl der Gitter) verwendet, um Long- oder Short-Positionen zu eröffnen.

Wenn der Preis die angrenzende Gitterlinie wieder durchbricht, kann er mit früheren Aufträgen für Arbitrage und geschlossenen Positionen für Gewinn abgestimmt werden.

Dieser Zyklus wird bei Hochfrequenz-Arbitrage innerhalb des Preisschwankungenbereichs wiederholt.

Analyse der Vorteile

Der größte Vorteil dieser Strategie im Vergleich zu herkömmlichen Netzstrategien besteht darin, dass der Netzbereich automatisch an die Marktschwankungen angepasst wird und folgende Merkmale aufweist:

Voll automatisiert, kein manueller Eingriff erforderlich.
In der Lage, Preisentwicklungen zu erfassen und in Trendrichtung zu handeln.
Kontrollierbare Risiken, die einseitige Verfolgungsrisiken vermeiden.
Hohe Handelsfrequenz und Gewinnspanne.
Einfach zu verstehen, einfache Konfiguration.
Hohe Kapitalnutzung, nicht leicht zu fangen.
Die Marktänderungen in Echtzeit reflektieren, geeignet für den algorithmischen Handel.

Risikoanalyse

Obwohl die Strategie viele Vorteile bietet, gibt es auch einige Risiken, die sich hauptsächlich auf folgende Bereiche konzentrieren:

Potenzial für größere Verluste bei extremen Preisschwankungen.
Erfordert eine angemessene Haltedauer und ein Handelspaar, um Gewinn zu erzielen.
Die Kapitalgröße muss dem Volatilitätsbereich entsprechen.
Kann eine häufige Überwachung und Optimierung der Parameter erfordern.

Zu den Gegenmaßnahmen gehören:

Vergrößern Sie den Abstand zum Netz, um die Reichweite zu erweitern.
Wählen Sie stabilere Handelspare.
Anpassung der Kapitalstruktur für ausreichende Liquidität.
Einrichtung automatischer Überwachungs- und Warnmechanismen.

Optimierungsrichtlinien

Die Strategie kann in folgenden Aspekten optimiert werden:

Dynamisches Gitter: die Netzparameter automatisch anhand der Volatilität anpassen.
Stop-Loss-Mechanismus: angemessene Stop-Loss-Plätze festlegen, um extreme Risiken zu begrenzen.
Zusammengesetztes Gitter: Kombination von Rastern unter Verwendung verschiedener Parameter für verschiedene Zeiträume, um den Zeitverbrauch zu maximieren.
Maschinelles Lernen: Nutzen Sie neuronale Netzwerke, um automatisch Parameter statt Regeln zu optimieren.
Marktübergreifende Arbitrage: Arbitrage zwischen Börsen oder Währungspaaren.

Zusammenfassung

Zusammenfassend ist dies eine sehr praktische anpassungsfähige Krypto-Grid-Handelsstrategie für die Arbitrage. Im Vergleich zu traditionellen Grid-Strategien ist ihr größtes Merkmal die automatische Anpassung des Grid-Bereichs basierend auf Marktveränderungen, so dass Händler ihren eigenen Handelsbereich konfigurieren können. Die Strategielogik ist klar und leicht zu verstehen und zu konfigurieren, geeignet für einzelne Anleger mit einer gewissen Grundlage und auch als Vorlage für Handelsalgorithmen.

/*backtest
start: 2024-01-11 00:00:00
end: 2024-01-18 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("(IK) Grid Script", overlay=true, pyramiding=14, close_entries_rule="ANY", default_qty_type=strategy.cash, initial_capital=100.0, currency="USD", commission_type=strategy.commission.percent, commission_value=0.1)
i_autoBounds    = input(group="Grid Bounds", title="Use Auto Bounds?", defval=true, type=input.bool)                             // calculate upper and lower bound of the grid automatically? This will theorhetically be less profitable, but will certainly require less attention
i_boundSrc      = input(group="Grid Bounds", title="(Auto) Bound Source", defval="Hi & Low", options=["Hi & Low", "Average"])     // should bounds of the auto grid be calculated from recent High & Low, or from a Simple Moving Average
i_boundLookback = input(group="Grid Bounds", title="(Auto) Bound Lookback", defval=250, type=input.integer, maxval=500, minval=0) // when calculating auto grid bounds, how far back should we look for a High & Low, or what should the length be of our sma
i_boundDev      = input(group="Grid Bounds", title="(Auto) Bound Deviation", defval=0.10, type=input.float, maxval=1, minval=-1)  // if sourcing auto bounds from High & Low, this percentage will (positive) widen or (negative) narrow the bound limits. If sourcing from Average, this is the deviation (up and down) from the sma, and CANNOT be negative.
i_upperBound    = input(group="Grid Bounds", title="(Manual) Upper Boundry", defval=0.285, type=input.float)                      // for manual grid bounds only. The upperbound price of your grid
i_lowerBound    = input(group="Grid Bounds", title="(Manual) Lower Boundry", defval=0.225, type=input.float)                      // for manual grid bounds only. The lowerbound price of your grid.
i_gridQty       = input(group="Grid Lines",  title="Grid Line Quantity", defval=8, maxval=15, minval=3, type=input.integer)       // how many grid lines are in your grid

f_getGridBounds(_bs, _bl, _bd, _up) =>
    if _bs == "Hi & Low"
        _up ? highest(close, _bl) * (1 + _bd) : lowest(close, _bl)  * (1 - _bd)
    else
        avg = sma(close, _bl)
        _up ? avg * (1 + _bd) : avg * (1 - _bd)

f_buildGrid(_lb, _gw, _gq) =>
    gridArr = array.new_float(0)
    for i=0 to _gq-1
        array.push(gridArr, _lb+(_gw*i))
    gridArr

f_getNearGridLines(_gridArr, _price) =>
    arr = array.new_int(3)
    for i = 0 to array.size(_gridArr)-1
        if array.get(_gridArr, i) > _price
            array.set(arr, 0, i == array.size(_gridArr)-1 ? i : i+1)
            array.set(arr, 1, i == 0 ? i : i-1)
            break
    arr

var upperBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true) : i_upperBound  // upperbound of our grid
var lowerBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false) : i_lowerBound // lowerbound of our grid
var gridWidth       = (upperBound - lowerBound)/(i_gridQty-1)                                                       // space between lines in our grid
var gridLineArr     = f_buildGrid(lowerBound, gridWidth, i_gridQty)                                                 // an array of prices that correspond to our grid lines
var orderArr        = array.new_bool(i_gridQty, false)                                                              // a boolean array that indicates if there is an open order corresponding to each grid line

var closeLineArr    = f_getNearGridLines(gridLineArr, close)                                                        // for plotting purposes - an array of 2 indices that correspond to grid lines near price
var nearTopGridLine = array.get(closeLineArr, 0)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line above current price
var nearBotGridLine = array.get(closeLineArr, 1)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line below current price
strategy.initial_capital = 50000
for i = 0 to (array.size(gridLineArr) - 1)
    if close < array.get(gridLineArr, i) and not array.get(orderArr, i) and i < (array.size(gridLineArr) - 1)
        buyId = i
        array.set(orderArr, buyId, true)
        strategy.entry(id=tostring(buyId), long=true, qty=(strategy.initial_capital/(i_gridQty-1))/close, comment="#"+tostring(buyId))
    if close > array.get(gridLineArr, i) and i != 0
        if array.get(orderArr, i-1)
            sellId = i-1
            array.set(orderArr, sellId, false)
            strategy.close(id=tostring(sellId), comment="#"+tostring(sellId))

if i_autoBounds
    upperBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true)
    lowerBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false)
    gridWidth   := (upperBound - lowerBound)/(i_gridQty-1)
    gridLineArr := f_buildGrid(lowerBound, gridWidth, i_gridQty)

closeLineArr    := f_getNearGridLines(gridLineArr, close)
nearTopGridLine := array.get(closeLineArr, 0)
nearBotGridLine := array.get(closeLineArr, 1)

Mehr