O mercado de criptomoedas oferece um ambiente de negociação único, criando um cenário de aplicação ideal para estratégias de negociação em grade. Comparado aos mercados financeiros tradicionais, o setor de criptomoedas opera 24 horas por dia, 7 dias por semana, com flutuações de preços contínuas e frequentes, criando abundantes oportunidades de arbitragem para estratégias de grade. Além disso, os principais instrumentos de negociação, como contratos à vista e perpétuos, não têm restrições de vencimento, permitindo que os traders mantenham posições a longo prazo sem se preocupar com o risco de vencimento do contrato. Ademais, a alta volatilidade e a liquidez relativamente alta do mercado de criptomoedas proporcionam condições favoráveis para a implementação de estratégias de grade.

É justamente por essas características que as estratégias de grid trading demonstram forte aplicabilidade e potencial de lucro no mercado de criptomoedas. A grid trading é uma estratégia amplamente utilizada no mercado de criptomoedas que permite aos traders lucrar com a volatilidade do mercado sem precisar prever sua direção. Ao emitir ordens de compra e venda em diferentes faixas de preço, a grid trading ajuda os traders a obter lucros tanto durante a alta quanto na queda dos preços.

As estratégias de negociação em grade têm muitas variações. Este artigo discutirá apenas brevemente alguns formatos para ajudar iniciantes a começar com este método clássico de negociação quantitativa. A ideia central de uma estratégia de negociação em grade é colocar uma série de ordens de compra e venda em diferentes níveis de preço. As ordens de compra são colocadas quando o preço atinge os nós inferiores da grade, e as ordens de venda são colocadas quando o preço atinge os nós superiores, obtendo assim pequenos lucros com as flutuações do mercado. A vantagem dessa estratégia é que os traders não precisam prever a direção do mercado; eles dependem das flutuações dos preços de mercado dentro da grade.

Princípios da Estratégia de Grade

Principais elementos da negociação de rede tradicional

• Nós da grade:Pontos de preço predefinidos nos quais ordens de compra ou venda são colocadas.
• Espaçamento da grade:A distância do preço entre os nós da grade adjacentes determina o quanto o preço precisa flutuar para acionar uma transação.
• Tamanho da grade:O número total de nós da grade controla a faixa de preço coberta pela estratégia.

Como funcionam as estratégias de negociação em grade

• Quando o preço sobe de um nível baixo e ultrapassa o nó de grade definido, uma ordem de venda é acionada.
• Quando o preço cai de um nível alto e rompe o nó de grade definido, uma ordem de compra é acionada.
• Ao constantemente “comprar na baixa e vender na alta” em diferentes faixas, mesmo que o preço flutue para frente e para trás dentro da faixa, você ainda pode lucrar com cada flutuação.

Exemplo

Suponha que uma estratégia de grade seja definida com um intervalo de grade de US\( 8.000 a US\) 9.000, com um intervalo de grade de US\( 500. Quando o preço sobe de US\) 8.000 para US\( 8.500, a estratégia comprará a US\) 8.000 e venderá a US\( 8.500. Se o preço subir ainda mais para US\) 9.000, a estratégia venderá novamente parte de seus ativos. Quando o preço cair de US\( 9.000 para US\) 8.500, a estratégia comprará novamente. Ao repetir esse processo, a estratégia pode acumular lucros continuamente em meio às flutuações do mercado.

Comparação entre a estratégia de negociação em grade e a estratégia de negociação balanceada

O cerne de uma estratégia equilibrada é manter uma proporção fixa de ativos, como 50% de moeda digital e 50% de moeda fiduciária. Quando o preço de uma criptomoeda sobe e a proporção de criptomoedas mantidas excede 50%, ela é vendida; quando o preço cai, ela é comprada. Isso garante que o valor dos ativos mantidos permaneça próximo à proporção fixa. Independentemente das flutuações do mercado, uma estratégia equilibrada mantém uma certa quantidade de criptomoedas.

Semelhanças e diferenças entre estratégia de grade e estratégia de equilíbrio

• Semelhanças:Ambos lucram com a volatilidade comprando na baixa e vendendo na alta, e a estratégia pode gerar valor quando o mercado retorna ao seu preço original.
• Diferenças:Estratégias de grade operam apenas dentro de uma faixa de preço predefinida, enquanto estratégias balanceadas são independentes de faixas de preço específicas. Uma estratégia de grade pode não conseguir continuar negociando se o preço cair fora da faixa, enquanto uma estratégia balanceada permite compras e vendas constantes, mantendo a liquidez.

Contrato: Estratégia de Grade Aritmética

A estratégia de grade aritmética é uma estratégia quantitativa clássica de negociação, frequentemente utilizada em mercados voláteis. Essa estratégia captura os lucros das flutuações de preços, colocando ordens de compra e venda em intervalos de preço fixos (intervalos aritméticos). É adequada para mercados com alta volatilidade, mas com direção imprevisível, como criptomoedas e certos contratos futuros.

Lógica Central

Conceitos principais:

1. intervalo equidistante
   Na estratégia de grade aritmética, há uma lacuna entre os preços de compra e venda.Intervalos de preços fixos, que está no códigogridPor exemplo, quando o preço oscila em 300 unidades (como no códigogrid=300), uma ordem de compra ou venda é acionada.

2. Inicialização da grade
   A estratégia gera os preços iniciais de compra e venda com base no preço atual, que sãobuyp e sellpOs dois intervalos de preços são baseados no intervalo da gradegridPara definir, respectivamente acima e abaixo do preço atualgridunidades.

3. Obter lucro e reverter
   Quando o preço sobe para uma determinada faixa, a estratégia compra na área de posição comprada e define uma ordem de venda para obter lucro. Se o preço continuar subindo para a área de posição reversa (upper), a posição longa terá lucro e ficará vendida, e vice-versa.

4. Gestão de posições dentro da grade
   Cada ação de compra ou venda dentro da grade será acionada quando o preço atingir o valor predefinidobuyp ou sellpApós cada transação, o sistema ajusta automaticamente o próximo grupo de preços de compra e venda para manter um intervalo de grade fixo.

5. Adicionar e reduzir posições
   A estratégia ajusta continuamente sua posição com base no preço da grade. Quando o preço atinge o ponto de compra, aumenta sua posição (aumenta sua posição); quando atinge o ponto de venda, reduz gradualmente sua posição (diminui sua posição). Comprando e vendendo repetidamente, captura cada pequena flutuação do mercado.

Código de estratégia

'''backtest
start: 2024-08-26 00:00:00
end: 2024-09-25 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":2500}]
args: [["H",30],["n1",0.001],["grid",300],["bottom",50000]]
'''

# 交易参数配置（设为策略参数）
M = 20          # 杠杆大小
H = 50          # 初始底仓份数
n1 = 1          # 单个网格交易数量
grid = 200      # 单个网格交易间距
bottom = 35000  # 开多点位
upper = 60000   # 开空点位

def CancelPendingOrders():
    orders = _C(exchanges[0].GetOrders)
    if len(orders)>0:
        for j in range(len(orders)):
            exchanges[0].CancelOrder(orders[j].Id, orders[j])
            j=j+1

def main():
    exchange.SetContractType('swap')
    exchange.SetMarginLevel(M)
    currency=exchange.GetCurrency()
    if _G('buyp') and _G('sellp'):
        buyp=_G('buyp')
        sellp=_G('sellp')
        Log('读取网格价格')
    else:
        ticker=exchange.GetTicker()
        buyp=ticker["Last"]-grid
        sellp=ticker["Last"]+grid
        _G('buyp',buyp)
        _G('sellp',sellp)
        Log('网格数据初始化')
    while True:
        account=exchange.GetAccount()
        ticker=exchange.GetTicker()
        position=exchange.GetPosition()
        orders=exchange.GetOrders()
        if len(position)==0:
            if ticker["Last"]>upper:
                exchange.SetDirection('sell')
                exchange.Sell(-1,n1*H)
                Log(currency,'到达开空区域,买入空头底仓')
                
            else:
                exchange.SetDirection('buy')
                exchange.Buy(-1,n1*H)
                Log(currency,'到达开多区域,买入多头底仓')
        if len(position)==1:
            if position[0]["Type"]==1: #持有空头仓位
                if ticker["Last"]<bottom:
                    Log(currency,'空单全部止盈反手')
                    exchange.SetDirection('closesell')
                    exchange.Buy(-1,position[0].Amount)
                else: 
                    orders=exchange.GetOrders()
                    if len(orders)==0: 
                        exchange.SetDirection('sell')
                        exchange.Sell(sellp,n1)
                        exchange.SetDirection('closesell')
                        exchange.Buy(buyp,n1)
                    if len(orders)==1:
                        if orders[0]["Type"]==1: #止盈成交
                            Log(currency,'网格减仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp-grid
                            sellp=sellp-grid
                            LogProfit(account["Balance"])
                        if orders[0]["Type"]==0:
                            Log(currency,'网格加仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp+grid
                            sellp=sellp+grid
                            LogProfit(account["Balance"])
        
            if position[0]["Type"]==0:
                if ticker["Last"]>float(upper):
                    Log(currency,'多单全部止盈反手')
                    exchange.SetDirection('closebuy')
                    exchange.Sell(-1,position[0].Amount)
                else:
                    orders=exchange.GetOrders()
                    if len(orders)==0:
                        exchange.SetDirection('buy')
                        exchange.Buy(buyp,n1)
                        exchange.SetDirection('closebuy')
                        exchange.Sell(sellp,n1)
                    if len(orders)==1:
                        if orders[0]["Type"]==0: #止盈成交
                            Log(currency,'网格减仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp+grid
                            sellp=sellp+grid
                            LogProfit(account["Balance"])
                        if orders[0]["Type"]==1:
                            Log(currency,'网格加仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp-grid
                            sellp=sellp-grid
                            LogProfit(account["Balance"])

A estratégia de grade aritmética tem considerável aplicabilidade no mercado de criptomoedas, particularmente em mercados voláteis, porém imprevisíveis. Ao emitir ordens de compra e venda em intervalos de preço fixos, essa estratégia captura efetivamente as flutuações do mercado, mantendo operações automatizadas e lógica simples. A alta volatilidade do mercado de criptomoedas oferece uma boa oportunidade para essa estratégia prosperar.

Vale ressaltar que os custos de transação de uma estratégia de grade aritmética advêm principalmente da frequência de ordens de compra e venda, e não da emissão ou cancelamento delas. Essa característica requer atenção especial em corretoras de criptomoedas com altas taxas de transação. Para otimizar os retornos, recomenda-se escolher corretoras com taxas mais baixas e ajustar o intervalo da grade e a taxa de alocação de fundos com base nas condições específicas do mercado.

No geral, a estratégia de grade aritmética é adequada para o mercado volátil de criptomoedas, mas pode estar sujeita a riscos significativos em mercados unilaterais. Ao definir parâmetros adequadamente e otimizar a gestão de fundos, a robustez e a lucratividade da estratégia podem ser efetivamente aprimoradas.

Spot: Estratégia de Grade Dinâmica

Estratégia de grade dinâmicaDiferente da estratégia tradicional de rede fixa, elaGeração DinâmicaeAjustando nós de malhaEsta estratégia permite maior flexibilidade nas flutuações do mercado. Gera novos nós de grade com base nas flutuações do mercado em tempo real, aprimorando a adaptabilidade e a capacidade de controle de risco da estratégia. O conceito central é gerar novos nós somente quando as flutuações de preço excedem um determinado limite e gerenciar as posições adequadamente.

Principais recursos

1. Geração de nós de malha dinâmica：

   • O preço de mercado rompe o nó da grade anterior e a faixa de flutuação excede a faixa predefinida (por_GridPointDiscontrole), a estratégia gera novos nós de grade.
   • Cada nó da grade registra o preço atual e as informações de posição e define as condições de fechamento (por_GridCovDisSpread de fechamento controlado).

2. Operações de compra e venda：

   • Direção longa（direction = 1): Quando o preço subir e ultrapassar o nó da grade, venda os ativos que você tinha; quando ele cair novamente, compre novamente.
   • Direção curta（direction = -1): Quando o preço cair e ultrapassar o nó da grade, compre o ativo; quando ele se recuperar, venda o ativo mantido.

3. Operação de fechamento：

   • Quando o preço atinge o preço de fechamento definido (_GridCovDisDefinir), executar operações de recompra (em posições compradas) ou de venda (em posições vendidas) de acordo com a direção atual para concluir o fechamento da posição.

4. Controle de quantidade de malha：

   • Se o número de nós da grade exceder o valor máximo de configuração (_GridNum), a estratégia excluirá automaticamente o primeiro nó da grade, evitando assim posições excessivas e reduzindo riscos.

Lógica Central

1. Parâmetros de inicialização：

   • _GridNum: Número máximo de nós de grade, o número máximo de nós de grade que a estratégia de controle permite manter ao mesmo tempo.
   • _GridPointAmount: A quantidade do pedido de cada nó da grade.
   • _GridPointDis: O espaçamento de preços entre os nós da grade.
   • _GridCovDis: A diferença de preço para o fechamento de uma posição. Quando a flutuação entre o preço de mercado e o preço da grade exceder essa diferença de preço, a posição será fechada.

2. Função UpdateGrid：

   • Com base no preço atual (current_price), preço de compra (bids_price) e o preço de venda (asks_price) atualiza os nós da grade. Sempre que o preço de mercado ultrapassa um nó da grade, a estratégia gera um novo nó da grade e executa a negociação correspondente.
   • Verifique se as condições de fechamento são acionadas e execute a operação de fechamento quando acionada.
   • Controla o número máximo de nós da grade. Se o número máximo for excedido, os nós mais antigos da grade serão excluídos.

3. Circuito principal：

   • mainA função obtém continuamente dados de preços de mercado em tempo real e chamaUpdateGridAs funções atualizam os nós da grade e realizam operações de negociação.
   • passarLogStatusRegistre o status atual da rede, informações da conta, etc. para facilitar o monitoramento em tempo real da operação da estratégia.

Código de estratégia (requer referências de modelo de desenho e spot em Python)

'''backtest
start: 2024-04-01 00:00:00
end: 2024-09-23 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"ETH_USDT"}]
'''

direction = 1  # 网格方向：1表示向上，-1表示向下
_GridNum = 10  # 网格节点数量
_GridPointAmount = 0.1  # 每个网格节点的下单量
_GridPointDis = 100  # 网格节点之间的价格间距
_GridCovDis = 150  # 平仓价与网格节点的差距
_Grid = []  # 网格数据列表

def UpdateGrid(nowBidsPrice, nowAsksPrice, direction):  # up 1, down -1
    global _Grid

    # 检查是否需要创建新的网格节点
    if len(_Grid) == 0 or (direction == 1 and nowBidsPrice - _Grid[-1]['price'] > _GridPointDis) or \
            (direction == -1 and _Grid[-1]['price'] - nowAsksPrice > _GridPointDis):
        
        if len(_Grid) == 0:
            Log('策略起始')
        if len(_Grid) != 0 and direction == 1 and nowBidsPrice - _Grid[-1]['price'] > _GridPointDis:
            Log('向上突破，突破阈值：', nowBidsPrice - _Grid[-1]['price'])
        if len(_Grid) != 0 and direction == -1 and _Grid[-1]['price'] - nowAsksPrice > _GridPointDis:
            Log('向下突破，突破阈值：', _Grid[-1]['price'] - nowAsksPrice)

        # 根据方向决定当前网格节点的价格
        nowPrice = nowBidsPrice if direction == 1 else nowAsksPrice
        _Grid.append({
            'price': nowPrice if len(_Grid) == 0 else _Grid[-1]['price'] + _GridPointDis * direction,
            'hold': {'price': 0, 'amount': 0},
            'coverPrice': (nowPrice - direction * _GridCovDis) if len(_Grid) == 0 else _Grid[-1]['price'] + _GridPointDis * direction - direction * _GridCovDis
        })

        Log('网格更新数量：', len(_Grid), '网格最新增添：', _Grid[-1])

        # 下单操作，向上突破时卖出，向下突破时买入
        tradeInfo = ext.Sell(_GridPointAmount) if direction == 1 else ext.Buy(_GridPointAmount)
        _Grid[-1]['hold']['price'] = tradeInfo['price']
        _Grid[-1]['hold']['amount'] = tradeInfo['amount']

        Log('网格操作：', '向上卖出' if direction == 1 else '向下买入')

    # 检查是否需要平仓
    if len(_Grid) > 0 and (
            (direction == 1 and nowAsksPrice < _Grid[-1]['coverPrice']) or 
            (direction == -1 and nowBidsPrice > _Grid[-1]['coverPrice'])):

        coverInfo = ext.Buy(_Grid[-1]['hold']['amount']) if direction == 1 else ext.Sell(_Grid[-1]['hold']['amount'])
        Log('价格跌破平仓价格，买入，去除最后添加网格' if direction == 1 else '价格突破平仓价格，卖出，去除最后添加网格')

        _Grid.pop()  # 移除已平仓的网格节点
    
    # 如果网格数量超出设定值，则平掉最早的网格节点
    elif len(_Grid) > _GridNum:
        coverFirstInfo = ext.Buy(_Grid[0]['hold']['amount']) if direction == 1 else ext.Sell(_Grid[0]['hold']['amount'])
        Log('网格数量过多，买入操作，去除初始网格' if direction == 1 else '网格数量过多，卖出操作，去除初始网格')
        _Grid.pop(0)

def main():
    global _Grid
    while True:
        ticker = _C(exchange.GetTicker)
        records = _C(exchange.GetRecords)
        ext.PlotRecords(records, "kline")
        UpdateGrid(ticker['Buy'], ticker['Sell'], direction)

        # 记录当前网格状态
        msg = ""
        for grid in _Grid:
            msg += str(grid) + "\n"
        
        LogStatus(_D(), _C(exchange.GetAccount), "\n", "_Grid.length:", len(_Grid), "_GridNum:", _GridNum, "\n", msg)
        Sleep(500)

Nota:

1. Para ajudar todos a entender o processo de geração da grade, muitos comentários são adicionados ao código, os quais podem ser excluídos na aplicação real.
2. Para facilitar a negociação, a estratégia à vista utiliza a biblioteca de modelos de negociação à vista. Você pode observar o código-fonte para aprender mais sobre ele.
3. Quando aplicado à negociação real, ele precisa ser aprimorado de acordo com as características das diferentes bolsas.

Futuros: Estratégia de Rede Bidirecional Long-Short

A estratégia de Grade Bidirecional Long-Short é uma variante de grade mais complexa, porém poderosa, que permite negociações simultâneas em direções longas e curtas, maximizando as oportunidades de lucro em mercados voláteis. Em sua essência, essa estratégia ajusta posições dinamicamente com base nos desvios de preço em relação ao preço inicial, alcançando uma estratégia verdadeiramente neutra em relação ao mercado.

Principais recursos

1. Modos longo e curto: Independentemente de o preço subir ou descer, a estratégia pode obter lucros operando na direção correspondente
2. Ajustes de posição dinâmicos：Calcule a posição alvo com base no desvio do preço em relação ao preço inicial
3. Ordem de grade bidirecional: Defina ordens de compra e venda ao mesmo tempo para capturar flutuações de preços em ambas as direções
4. Controle de Risco：Reduzir riscos unilaterais por meio de gerenciamento de posição razoável e controle de ordens

Estratégia Lógica

A lógica central da estratégia é determinar a posição alvo com base no grau de desvio entre o preço e o preço inicial:

• Quando o preço sobe, a posição alvo é negativa (curta) e, quanto mais o preço sobe, maior é a posição curta.
• Quando o preço cai, a posição-alvo é positiva (longa). Quanto mais o preço cai, maior a posição longa.
• Ajuste gradualmente a posição real para a posição alvo por meio da execução de ordens de grade

Código de estratégia

import time
import math

# 全局变量初始化
InitPrice = 800
Funding = 50000

# 策略参数（需要在策略页面设置）
pct = 5.0        # 网格间距百分比
value = 5000      # 每个网格的投入金额
Interval = 3     # 策略执行间隔（秒）

# 账户资产信息
assets = {
    'USDT': {
        'total_balance': 0,
        'margin_balance': 0,
        'margin': 0,
        'unrealised_profit': 0
    }
}

def init():
    """初始化策略"""
    global symbol, Funding, base_currency
    
    Log('交易模式：多空都做')
    
    # 设置合约类型
    exchange.SetContractType('swap')
    
    # 获取交易币种
    currency = exchange.GetCurrency()
    symbol = currency  # 保持原格式，如 "BTC_USDT"
    base_currency = symbol.split('_')[0]  # 获取基础币种，如 "BTC"
    Log('交易币种：', symbol)
    Log('基础币种：', base_currency)

    swapcode = symbol + '.swap'
    ticker = exchange.GetTicker(swapcode)  # 回测系统需要
    exchange_info = exchange.GetMarkets()
    data = exchange_info.get(swapcode)
    
    # 初始化资产信息
    assets[base_currency] = {
        'amount': 0,
        'price': 0,
        'hold_price': 0,
        'price': 0,
        'unrealised_profit': 0,
        'leverage': 20,
        'liquidation_price': 0,
        'AmountPrecision': data['AmountPrecision'],
        'PricePrecision': data['PricePrecision'],
        'MinQty': data['MinQty']
    }
    
    # 撤销所有挂单
    cancel_all_orders()
    
    # 获取初始资金
    account = exchange.GetAccount()
    if account:
        Funding = account.Balance + account.FrozenBalance
        Log('初始资金：', Funding)

def calculate_grid_orders():
    """计算网格订单"""
    if InitPrice == 0 or assets[base_currency]['price'] == 0:
        return None
    
    current_price = assets[base_currency]['price']
    current_amount = assets[base_currency]['amount']
    
    # 多空都做模式：根据价格变化计算目标持仓
    price_change_ratio = (current_price - InitPrice) / InitPrice
    target_amount = -price_change_ratio * (value / pct) / current_price
    
    # 计算买卖价格
    grid_spacing = current_price * (pct / 100)  # 网格间距
    buy_price = current_price - grid_spacing
    sell_price = current_price + grid_spacing
    
    # 计算订单数量
    order_amount = value / current_price
    
    return {
        'buy_price': round(buy_price, assets[base_currency]['PricePrecision']),
        'sell_price': round(sell_price, assets[base_currency]['PricePrecision']),
        'buy_amount': round(order_amount, assets[base_currency]['AmountPrecision']),
        'sell_amount': round(order_amount, assets[base_currency]['AmountPrecision']),
        'target_amount': target_amount
    }

def execute_strategy():
    """执行交易策略"""
    # 计算网格订单
    grid_info = calculate_grid_orders()
    if not grid_info:
        return
    
    current_amount = assets[base_currency]['amount']
    target_amount = grid_info['target_amount']
    amount_diff = target_amount - current_amount
    
    # 如果持仓偏离较大，先调整持仓
    if abs(amount_diff) > assets[base_currency]['MinQty']:
        cancel_all_orders()
        Sleep(500)
        
        # 判断需要的操作
        if amount_diff > 0:
            # 需要增加多头持仓或减少空头持仓
            if current_amount >= 0:
                # 当前是多头或空仓，直接开多
                Log(f'当前持仓：{current_amount}，需要开多：{abs(amount_diff):.6f}')
                open_position('LONG', assets[base_currency]['price'], abs(amount_diff))
            else:
                # 当前是空头，需要先平空再开多
                if abs(amount_diff) <= abs(current_amount):
                    # 只需要平掉部分空仓
                    Log(f'当前空仓：{current_amount}，需要平仓：{abs(amount_diff):.6f}')
                    safe_close_position(abs(amount_diff), assets[base_currency]['price'])
                else:
                    # 需要平掉所有空仓，然后开多
                    Log(f'平掉所有空仓：{abs(current_amount):.6f}')
                    if safe_close_position(abs(current_amount), assets[base_currency]['price']):
                        Sleep(1000)  # 等待平仓完成
                        
                        # 更新持仓信息
                        update_account()
                        remaining_amount = abs(amount_diff) - abs(current_amount)
                        if remaining_amount > assets[base_currency]['MinQty']:
                            Log(f'开多剩余数量：{remaining_amount:.6f}')
                            open_position('LONG', assets[base_currency]['price'], remaining_amount)
        
        elif amount_diff < 0:
            # 需要增加空头持仓或减少多头持仓
            if current_amount <= 0:
                # 当前是空头或空仓，直接开空
                Log(f'当前持仓：{current_amount}，需要开空：{abs(amount_diff):.6f}')
                open_position('SHORT', assets[base_currency]['price'], abs(amount_diff))
            else:
                # 当前是多头，需要先平多再开空
                if abs(amount_diff) <= current_amount:
                    # 只需要平掉部分多仓
                    Log(f'当前多仓：{current_amount}，需要平仓：{abs(amount_diff):.6f}')
                    safe_close_position(abs(amount_diff), assets[base_currency]['price'])
                else:
                    # 需要平掉所有多仓，然后开空
                    Log(f'平掉所有多仓：{current_amount:.6f}')
                    if safe_close_position(current_amount, assets[base_currency]['price']):
                        Sleep(1000)  # 等待平仓完成
                        
                        # 更新持仓信息
                        update_account()
                        remaining_amount = abs(amount_diff) - current_amount
                        if remaining_amount > assets[base_currency]['MinQty']:
                            Log(f'开空剩余数量：{remaining_amount:.6f}')
                            open_position('SHORT', assets[base_currency]['price'], remaining_amount)
    
    # 检查是否需要重新挂网格单
    orders = exchange.GetOrders()
    if not orders or len(orders) < 2:  # 多空都做模式需要2个订单
        cancel_all_orders()
        Sleep(500)
        
        # 重新获取最新持仓信息
        update_account()
        current_amount = assets[base_currency]['amount']
        
        # 挂买单和卖单（网格订单）
        buy_amount = grid_info['buy_amount']
        sell_amount = grid_info['sell_amount']
        
        # 多空都做模式：无论当前持仓如何，都要挂多空双向网格单
        place_grid_orders(current_amount, grid_info, buy_amount, sell_amount)

def place_grid_orders(current_amount, grid_info, buy_amount, sell_amount):
    """放置网格订单 - 多空都做模式"""
    Log(f'放置网格订单 - 当前持仓：{current_amount}')
    
    # 多空都做模式：无论当前持仓如何，都要挂多空双向网格单
    Log(f'多空都做模式 - 挂开多单：数量={buy_amount:.6f}，价格={grid_info["buy_price"]}')
    open_position('LONG', grid_info['buy_price'], buy_amount)
    Sleep(200)
    Log(f'多空都做模式 - 挂开空单：数量={sell_amount:.6f}，价格={grid_info["sell_price"]}')
    open_position('SHORT', grid_info['sell_price'], sell_amount)

def cancel_all_orders():
    """撤销所有未成交订单"""
    try:
        orders = exchange.GetOrders()
        if orders:
            for order in orders:
                exchange.CancelOrder(order['Id'])
                Sleep(100)  # 避免频繁操作
        return True
    except Exception as e:
        Log('撤单异常：', str(e))
        return False

def get_real_position():
    """获取真实持仓信息"""
    try:
        positions = exchange.GetPosition()
        if positions:
            for pos in positions:
                if pos['ContractType'] == 'swap' and pos['Amount'] > 0:
                    position_amount = pos['Amount'] * (1 if pos['Type'] == 0 else -1)
                    return position_amount, pos['Price'], pos['Profit']

        return 0, 0, 0
    except Exception as e:
        Log('获取持仓异常：', str(e))
        return 0, 0, 0

def update_account():
    """更新账户信息"""
    try:
        account = exchange.GetAccount()
        if not account:
            Log('获取账户信息失败')
            return False
        
        # 更新USDT资产信息
        assets['USDT']['total_balance'] = account.Balance + account.FrozenBalance
        assets['USDT']['margin_balance'] = account.Balance
        
        # 获取真实持仓信息
        position_amount, hold_price, profit = get_real_position()
        assets[base_currency]['amount'] = position_amount
        assets[base_currency]['hold_price'] = hold_price
        assets[base_currency]['unrealised_profit'] = profit
        
        return True
    except Exception as e:
        Log('更新账户异常：', str(e))
        return False

def update_price():
    """更新行情价格"""
    global InitPrice
    
    ticker = exchange.GetTicker()
    if not ticker:
        Log('获取行情失败')
        return False
    
    # 设置初始价格
    if InitPrice == 0:
        InitPrice = ticker.Last
        Log('设置初始价格：', InitPrice)
    
    assets[base_currency]['price'] = ticker.Last
    return True

def create_order(side, price, amount, order_type="开仓"):
    """使用CreateOrder下单函数"""
    try:
        if amount <= 0:
            Log(f'订单数量无效：{amount}')
            return False
        
        # 构造期货合约symbol
        contract_symbol = f"{symbol}.swap"
        
        # 下单
        order_id = exchange.CreateOrder(contract_symbol, side, price, amount)
        
        if order_id:
            Log(f'{order_type} {side} 下单成功：价格={price}, 数量={amount}, 订单ID={order_id}')
            return order_id
        else:
            Log(f'{order_type} {side} 下单失败：价格={price}, 数量={amount}')
            return False
            
    except Exception as e:
        Log('下单异常：', str(e))
        return False

def safe_close_position(close_amount, price=-1):
    """安全平仓函数"""
    try:
        if close_amount <= 0:
            Log(f'平仓数量无效：{close_amount}')
            return False
        
        # 实时获取持仓信息
        current_position, _, _ = get_real_position()
        
        # 检查是否真的有持仓
        if current_position == 0:
            Log('当前无持仓，跳过平仓操作')
            return False
        
        # 检查平仓数量是否超过持仓
        if abs(close_amount) > abs(current_position):
            Log(f'平仓数量超过持仓：持仓{current_position}，平仓{close_amount}，调整为持仓数量')
            close_amount = abs(current_position)
        
        # 根据当前持仓方向确定平仓操作
        if current_position > 0:  # 当前是多仓
            side = "closebuy"  # 平多仓
            Log(f'平多仓：数量={close_amount}，价格={price}')
        else:  # 当前是空仓
            side = "closesell"  # 平空仓
            Log(f'平空仓：数量={close_amount}，价格={price}')
        
        return create_order(side, price, close_amount, "平仓")
        
    except Exception as e:
        Log('平仓异常：', str(e))
        return False

def open_position(direction, price, amount):
    """开仓函数"""
    try:
        if amount <= 0:
            Log(f'开仓数量无效：{amount}')
            return False
        
        # 确定开仓方向
        if direction == 'LONG':
            side = "buy"  # 开多仓
            Log(f'开多仓：数量={amount}，价格={price}')
        else:  # SHORT
            side = "sell"  # 开空仓
            Log(f'开空仓：数量={amount}，价格={price}')
        
        return create_order(side, price, amount, "开仓")
        
    except Exception as e:
        Log('开仓异常：', str(e))
        return False

def update_status():
    """更新状态显示"""
    try:
        if Funding > 0:
            current_balance = assets['USDT']['total_balance']
            profit = current_balance - Funding
            profit_rate = (profit / Funding) * 100
            
            status_info = f"""
策略状态 - {symbol}
交易模式: 多空都做
当前价格: {assets[base_currency]['price']}
初始价格: {InitPrice}
持仓数量: {assets[base_currency]['amount']}
持仓价格: {assets[base_currency]['hold_price']}
账户余额: {current_balance:.4f} USDT
总收益: {profit:.4f} USDT ({profit_rate:.2f}%)
未实现盈亏: {assets[base_currency]['unrealised_profit']:.4f} USDT
"""
            LogStatus(status_info)
    
    except Exception as e:
        Log('状态更新异常：', str(e))

def main():
    """主函数"""
    # 设置错误过滤
    SetErrorFilter("502:|503:|tcp|character|unexpected|network|timeout|WSARecv|Connect|GetAddr|no such|reset|http|received|EOF|reused|Unknown")
    
    # 初始化
    init()
    
    Log('策略启动成功')
    
    while True:
        try:
            # 更新账户信息
            if not update_account():
                Log('更新账户信息失败，等待重试')
                Sleep(5000)
                continue
            
            # 更新价格信息
            if not update_price():
                Log('更新价格信息失败，等待重试')
                Sleep(5000)
                continue
            
            # 执行策略
            execute_strategy()
            
            # 更新状态
            update_status()
            
            # 休眠
            Sleep(Interval * 1000)
            
        except Exception as e:
            Log('主循环异常：', str(e))
            Sleep(5000)  # 发生异常时等待5秒再继续

A vantagem de uma estratégia de grade bidirecional longa-curta é sua adaptabilidade a diversas condições de mercado, permitindo retornos lucrativos por meio de operações apropriadas, sejam elas em alta, em queda ou voláteis. No entanto, também exige uma gestão de risco cuidadosa, especialmente em condições extremas de mercado.

Resumir

A flexibilidade e a automação das estratégias de grade as tornam uma ferramenta comum em negociações quantitativas. Diferentes variantes de grade podem se adaptar a diversos ambientes de mercado. Cada estratégia tem seus próprios cenários de aplicação e vantagens específicas. Os investidores podem escolher a estratégia de grade apropriada com base nas flutuações específicas do mercado e em seu apetite ao risco pessoal, e combiná-la com ferramentas como gestão dinâmica de posições e estratégias de stop-loss e take-profit para otimizar ainda mais a eficácia da estratégia.

precisarilustrarAs três estratégias discutidas neste artigo são todas do Strategy Plaza na plataforma Inventor, fornecendo um resumo. Como um tipo clássico de estratégia quantitativa, as estratégias de grade ainda oferecem muito a explorar, como evitar chamadas de margem e mitigar riscos, e como otimizar a utilização de fundos para aumentar os retornos. Os interessados podem visitar o Strategy Plaza, onde estratégias de grade em tempo real estão disponíveis para referência e estudo.