Estratégia de arbitragem adaptativa de criptomoedas baseada em negociação em grade
ChaoZhang
Visão geral
A estratégia é uma estratégia de arbitragem de criptomoedas adaptável baseada na ideia de negociação de grades. Ela é capaz de ajustar automaticamente a faixa de preços das negociações de grades de acordo com a flutuação do mercado e realizar negociações de arbitragem eficientes dentro dessa faixa de preços.
Princípio da estratégia
A ideia central da estratégia é:
A dinâmica calcula o intervalo de preços de uma grelha de negociação com base nos altos e baixos históricos.
Neste intervalo de preço, N linhas de grelha de transação são definidas.
Quando o preço ultrapassa cada linha da grelha, a posição é fechada ou fechada de acordo com a quantidade fixa.
Arbitragem entre linhas de grelha adjacentes, liquidação após lucro.
Quando o preço entra novamente na área da grelha, continue a abrir posições no preço de custo marginal da linha da grelha.
O ciclo de arbitragem de alta frequência é executado dentro do preço da grelha.
Concretamente, a estratégia primeiro calcula os limites superiores e inferiores do preço da grade em tempo real, com base nos parâmetros da janela de retrospectiva ((i_boundLookback) e do intervalo de flutuação ((i_boundDev)).
N linhas de grade são então separadas entre os limites superiores e inferiores ((i_gridQty) 。 Os preços dessas linhas de grade são armazenados na matriz gridLineArr。
Quando o preço quebra uma linha da grelha, o posicionamento é aberto ou fechado por uma quantidade fixa (o capital da estratégia dividido pela quantidade da grelha). A ordem é registrada na matriz de ordens Arr.
Quando o preço atravessa novamente a linha de grelha adjacente, pode-se obter uma posição de equilíbrio de lucro para igualar o lucro dos pedidos anteriores.
Assim, o ciclo de arbitragem de alta frequência ocorre dentro da escala de flutuação dos preços.
Análise de vantagens
Comparado com a estratégia de grade tradicional, a maior vantagem da estratégia é que o alcance da grade é automaticamente ajustado e pode se adaptar às flutuações do mercado. Tem as seguintes características:
Ajustamento automático, sem intervenção humana.
A capacidade de capturar a tendência dos preços e de negociar em função da tendência.
O risco é controlado, evitando o risco de um ataque unilateral.
A frequência de transações é alta, a margem de lucro é alta.
É fácil de entender e de usar.
A taxa de aproveitamento dos fundos é alta e não é fácil de ser presa.
A mudança de mercado em tempo real, para a negociação de robôs.
Análise de Riscos
Apesar de ter muitos benefícios, a estratégia também apresenta alguns riscos, que se concentram em:
Os preços podem variar muito, o que aumenta o risco de perdas.
É necessário um tempo de posse e um par de negociações adequados para obter lucro.
É necessário avaliar cuidadosamente a compatibilidade entre o tamanho do capital e a amplitude de flutuação.
Pode ser necessário monitorar e otimizar os parâmetros regularmente para garantir o bom funcionamento.
As medidas de resposta incluem:
Aumentar a distância entre as grades, ampliar o alcance das grades.
Escolha um par de transações com flutuações mais estáveis.
Ajustar o tamanho dos fundos para garantir a liquidez necessária.
Estabelecer mecanismos automáticos de vigilância e alarme.
Direção de otimização
A estratégia pode ser melhorada em vários aspectos:
Grade dinâmico: pode ajustar automaticamente os parâmetros da grade de acordo com a volatilidade do par negociado.
Mecanismo de suspensãoA partir de agora, o que você pode fazer é colocar um ponto de parada razoável para evitar o risco de uma situação extrema.
Grade composta: combinação de grades com diferentes parâmetros em diferentes períodos de tempo, para realizar a repetição do tempo.
Aprendizagem automática: Utilização de regras alternativas, como redes neurais, para otimização automática de parâmetros.
Arbitragem entre mercadosO Bitcoin é uma moeda de criptomoedas, uma moeda de criptomoedas, uma moeda de criptomoedas, uma moeda de criptomoedas.
Resumir
A estratégia é uma estratégia de arbitragem de grelha criptográfica muito prática. Em comparação com a estratégia de grelha tradicional, sua maior característica é que o alcance da grelha é automaticamente ajustado e você pode configurar seu próprio alcance de negociação de acordo com as mudanças no mercado. O conceito da estratégia é claro, fácil de entender e configurar, adequado para o uso de investidores individuais com uma certa base, e também é adequado para ser usado como um modelo de estratégia de robô de negociação.
/*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)