Stratégie d'arbitrage adaptative de crypto-monnaie basée sur le trading en grille
ChaoZhang
Aperçu
Cette stratégie est une stratégie d’arbitrage de crypto-monnaie adaptative basée sur la notion de négociation de grille. Elle est capable d’ajuster automatiquement la fourchette de prix de la négociation de grille en fonction des fluctuations du marché et de négocier de manière efficace dans cette fourchette de prix.
Principe de stratégie
La stratégie est basée sur l’idée suivante:
La dynamique calcule la gamme de prix d’une grille de transactions en fonction des hauts et des bas historiques des prix.
Dans cette fourchette de prix, il y a N lignes de grille de négociation à intervalles réguliers.
Lorsque le prix franchit chaque ligne de grille, il ouvre une position en plus ou en moins en fonction d’un nombre fixe.
L’arbitrage est effectué entre les lignes de grille adjacentes, la liquidation est effectuée après la réalisation des bénéfices.
Lorsque le prix revient dans la grille, continuez à ouvrir des positions au coût marginal de la grille.
Le cycle est donc continu, avec des arbitrages à haute fréquence dans la fourchette des prix.
Plus précisément, la stratégie commence par calculer en temps réel les limites supérieures et inférieures du prix de la grille en fonction des paramètres de la fenêtre de retour i_boundLookback et de la zone de fluctuation i_boundDev.
Ensuite, N lignes de grille sont séparées entre les limites supérieures et inférieures ((i_gridQty). Les prix de ces lignes de grille sont stockés dans l’arbre GridLineArr.
Lorsqu’un prix franchit une ligne de grille, il ouvre ou ferme une position en fonction d’un nombre fixe (le capital stratégique divisé par le nombre de grilles). Les ordres sont enregistrés dans l’arbre orderArr.
Lorsque le prix franchit à nouveau la ligne de grille adjacente, il est possible d’appliquer le profit de l’ordre précédent pour obtenir une position de marge.
Il y a donc un cycle de reprise et de retournement et un arbitrage très fréquent dans la fourchette des fluctuations des prix.
Analyse des avantages
Le plus grand avantage de cette stratégie par rapport à la stratégie de grille traditionnelle est que la portée de la grille s’ajuste automatiquement et peut s’adapter aux fluctuations du marché. Elle présente les caractéristiques suivantes:
Le système est automatique et ne nécessite aucune intervention.
Il est capable de capturer les tendances des prix et de négocier en fonction de celles-ci.
Les risques sont maîtrisés, il n’y a pas de risque de poursuite unilatérale.
La fréquence des transactions est élevée et le taux de profit élevé.
Le logiciel est facile à comprendre et à configurer.
Le taux d’utilisation des fonds est élevé et il n’est pas facile de s’enliser.
Le robot est adapté aux échanges en temps réel.
Analyse des risques
Bien que cette stratégie présente de nombreux avantages, elle comporte également des risques, principalement liés à:
Le risque de perte est plus élevé en cas de forte fluctuation des prix.
Il faut un temps de détention et une paire de transactions appropriés pour réaliser des bénéfices.
La taille des fonds doit être soigneusement évaluée pour correspondre à la marge de fluctuation.
Les paramètres peuvent nécessiter une surveillance et une optimisation régulières pour assurer le bon fonctionnement.
Les mesures de réponse comprennent:
Augmenter la distance entre les grilles et élargir la portée des grilles
Choisissez une paire de transactions avec une volatilité plus stable.
Adapter la taille des fonds pour assurer une liquidité suffisante
Créer un mécanisme de surveillance et d’alerte automatique.
Direction d’optimisation
Cette stratégie peut être optimisée dans les domaines suivants:
Réseau dynamique: les paramètres de la grille peuvent être ajustés automatiquement en fonction de la volatilité de la paire de transactions.
Les mécanismes d’arrêtLe but de la stratégie est de mettre en place une position de stop-loss raisonnable afin d’éviter les risques d’extrême.
Réseau composite: une combinaison de grilles avec différents paramètres dans différentes périodes de temps, permettant la réplication du temps.
Apprentissage automatique: utilisation de règles alternatives telles que les réseaux de neurones pour optimiser automatiquement les paramètres.
Arbitrage inter-marchésLes échanges de crypto-monnaies peuvent être effectués à travers des bourses ou des paires de devises.
Résumer
La stratégie est une stratégie d’arbitrage de grille de crypto-monnaie très pratique et adaptable. La principale caractéristique de la stratégie de grille est qu’elle est automatiquement ajustée par rapport à la stratégie de grille traditionnelle.
/*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)