Estrategia de arbitraje de criptomonedas adaptativa basada en el comercio en red
ChaoZhang
Descripción general
La estrategia es una estrategia de arbitraje de criptomonedas adaptable basada en la idea de comercio de la red. Puede ajustar automáticamente el rango de precios de la operación de la red en función de las fluctuaciones del mercado y realizar operaciones de arbitraje eficientes dentro de ese rango de precios.
Principio de estrategia
La idea central de la estrategia es:
La dinámica calcula el rango de precios de una grilla de transacciones en función de los máximos y mínimos históricos de los precios.
En este rango de precios, el intervalo de N líneas de la red de transacciones es igual.
Cuando el precio se rompe en cada línea de la red, se abre una posición de más o menos en una cantidad fija.
Arbitraje entre líneas de la red adyacentes, liquidación después de obtener ganancias.
Cuando el precio vuelva a entrar en el rango de la grilla, continúe abriendo posiciones al costo marginal de la línea de la grilla.
Así, el ciclo de arbitraje de alta frecuencia en el rango de precios de la red.
Concretamente, la estrategia primero calcula los límites superiores y inferiores de los precios de la cuadrícula en tiempo real en función de los parámetros de la ventana de retrospección ((i_boundLookback) y el intervalo de fluctuación ((i_boundDev)) configurados.
Luego se separan N líneas de la cuadrícula ((i_gridQty) entre los límites superiores e inferiores. Los precios de estas líneas de la cuadrícula se almacenan en la matriz GridLineArr.
Cuando el precio se rompe una línea de la red, se hace una posición de ventaja o de baja en una cantidad fija (el capital de la estrategia dividido por la cantidad de la red). Las órdenes se registran en la matriz orderArr.
Cuando el precio vuelve a romper la línea de la rejilla adyacente, se puede igualar el beneficio con el pedido anterior y obtener una posición de estabilización de ganancias.
El arbitraje de alta frecuencia se lleva a cabo dentro de los límites de las fluctuaciones de los precios.
Análisis de las ventajas
La mayor ventaja de esta estrategia frente a las estrategias tradicionales es que el rango de la red se ajusta automáticamente y se adapta a las fluctuaciones del mercado. Tiene las siguientes características:
La adaptación es automática y no requiere intervención humana.
El precio de las acciones es el precio de las acciones, y el precio de las acciones es el precio de las acciones.
El riesgo es controlado, evitando el riesgo de un ataque unilateral.
La frecuencia de las transacciones es alta, y la tasa de ganancias es alta.
Es fácil de entender y de configurar.
La tasa de utilización de los fondos es alta y no es fácil de atrapar.
El sistema de monitoreo de la bolsa de valores es un sistema de monitoreo de la bolsa de valores que refleja los cambios en el mercado en tiempo real y es adecuado para el comercio de robots.
Análisis de riesgos
A pesar de las muchas ventajas de esta estrategia, también hay ciertos riesgos, que se centran principalmente en:
El riesgo de pérdidas es mayor cuando los precios fluctúan mucho.
Se requiere un tiempo de posesión y un par de operaciones adecuados para obtener ganancias.
Se debe evaluar cuidadosamente la compatibilidad entre el tamaño de los fondos y el rango de fluctuación.
Es posible que sea necesario monitorear y optimizar los parámetros regularmente para garantizar el funcionamiento normal.
Las medidas de respuesta incluyen:
Aumentar el espacio entre las rejillas, ampliar el alcance de las rejillas.
Elige un par de operaciones con una fluctuación más estable.
Ajustar el tamaño de los fondos para garantizar la suficiente liquidez.
Establecer mecanismos automáticos de vigilancia y alerta.
Dirección de optimización
La estrategia puede ser optimizada en los siguientes aspectos:
Cuadrícula dinámica: Se puede ajustar automáticamente el parámetro de la cuadrícula en función de la volatilidad del par de operaciones.
Mecanismo de detención de dañosLa estrategia de la compañía es: establecer una posición de parada razonable para evitar el riesgo de situaciones extremas.
Grilla de composición: combinación de rejilla con diferentes parámetros en diferentes períodos de tiempo, para lograr la repetición del tiempo.
Aprendizaje automáticoUtilizando reglas alternativas como redes neuronales para la optimización automática de los parámetros.
Arbitraje entre mercadosEn la actualidad, el mercado de criptomonedas es más amplio que el mercado de divisas.
Resumir
La estrategia en su conjunto es una estrategia de arbitraje de criptomonedas de la red que se adapta a sí misma. En comparación con la estrategia de la red tradicional, su mayor característica es que el alcance de la red se ajusta automáticamente y se puede configurar su propio alcance de operaciones según los cambios en el mercado. La estrategia es clara, fácil de entender y configurar, adecuada para el uso de inversores individuales con una cierta base, y también es una plantilla de estrategia para usar como robot de negociación.
/*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)