Prefácio

Em nosso artigo anterior, “Estratégias de Wash Trading em Criptomoedas”, detalhamos uma estrutura estratégica para acumular volume de negociação comprando e vendendo ao mesmo preço. O objetivo principal dessa estratégia é obter descontos em exchanges ou benefícios de nível, em vez de lucrar com a arbitragem de preços. Embora as estratégias de wash trading sejam valiosas para aprender sobre estruturas de negociação, sua rentabilidade real é limitada e podem apresentar riscos de conformidade.

Este artigo apresentará outra estratégia de criação de mercado mais prática, baseada no artigo anterior:Estratégia de HandicapDiferentemente da estratégia de wash trading, a estratégia de market maker é uma verdadeira estratégia de arbitragem que gera lucros ao definir um spread entre os preços de compra e venda, o que está mais alinhado com o modelo de lucro dos market maker tradicionais.

⚠️ Aviso importante

O código de estratégia de mercado apresentado neste artigo destina-se apenas a servir como estrutura de aprendizado e não reflete nenhuma experiência real de negociação. As estratégias aqui apresentadas destinam-se apenas a fins de aprendizado técnico e pesquisa e não foram totalmente validadas em condições reais de mercado. Recomenda-se aos leitores que realizem testes de backtesting e avaliação de risco completos antes de utilizar estas informações, e não as utilizem diretamente em negociações reais.

Princípios da Estratégia de Handicap

A estratégia do livro de ordens de mercado é uma estratégia de formação de mercado que explora o livro de ordens de mercado (ou seja, a profundidade do mercado) para arbitragem. Nessa estratégia, os formadores de mercado ajustam dinamicamente o preço da ordem dentro da lacuna entre os preços de compra e venda com base nas flutuações do mercado, colocando e cancelando ordens, capitalizando assim a liquidez do mercado e as flutuações de preço de curto prazo para gerar lucros.

Principais recursos

1. Ajuste dinamicamente os preços dos pedidos pendentes：Ajuste dinamicamente os preços das ordens de compra e venda com base na profundidade do mercado e nas flutuações de preços para aumentar a probabilidade de transação.
2. Controle o número de pedidos pendentes: Controle o número de ordens pendentes com base nos fundos e posições da conta para evitar exposição excessiva aos riscos de mercado.
3. Gerenciamento de status do pedido: Verifique o status dos pedidos regularmente e processe pedidos não concluídos.

Diferenças da estratégia knock-on

Vantagens da Estratégia de Handicap

• Melhorar a liquidez do mercado：Ao colocar ordens no mercado, podemos aumentar a profundidade de compra e venda do mercado e atrair mais traders para participar.
• Ganhe o spread bid-ask:Ao fornecer liquidez, os formadores de mercado podem ganhar o spread entre compra e venda e, assim, obter lucro.
• Responda com flexibilidade às flutuações do mercado：A estratégia de mercado pode ajustar dinamicamente o preço da ordem pendente de acordo com as flutuações do mercado para reduzir os riscos de mercado.

Desafios da Estratégia de Handicap

• Risco de Mercado: Flutuações nos preços de mercado podem fazer com que as ordens do formador de mercado não sejam executadas ou até mesmo resultar em perdas.
• Pressão financeira：Os formadores de mercado precisam de fundos suficientes para manter a profundidade de compra e venda do mercado. Fundos insuficientes podem levar ao fracasso da estratégia.
• Gestão de pedidos complexos：A estratégia de mercado exige verificação regular do status dos pedidos e processamento de pedidos não concluídos, o que aumenta a complexidade da estratégia.

Estrutura da estratégia de handicap

Consistente com a estratégia de ataque, o código neste artigo implementa uma estratégia de criação de mercado baseada na estratégia de cotação de mercado, que é dividida principalmente em duas categorias:

1. MidClass:A camada intermediária da bolsa é responsável por interagir com a interface da bolsa para obter dados de mercado, informações da conta, status do pedido, etc.
2. MarketMaker: Classe de estratégia de criação de mercado, responsável por executar estratégias de mercado, gerar dinamicamente preços de ordens pendentes, gerar ordens pendentes, verificar status de ordens, atualizar status de estratégia, etc.

Processo de Estratégia de Handicap

1. Inicialização

existirMarketMakerNo método de inicialização de classe, primeiro obtenha as informações de precisão da bolsa e inicialize os parâmetros da estratégia, como precisão do volume de transações, precisão do preço, etc.

self.precision_info = self.exchange_mid.get_precision()  # 获取精度信息
self.price_precision = self.precision_info['price_precision']  # 价格精度
self.amount_precision = self.precision_info['amount_precision']  # 交易量精度

2. Gerar um dicionário de pedidos pendentes

O cerne da estratégia de mercado é gerar um dicionário de ordens pendentes, que contém os preços de compra e venda e as quantidades. O código gera esse dicionário calculando o preço médio e o offset de preço.

3. Movimento de preços de ordens pendentes

O movimento do preço da ordem pendente é obtido através do cálculo do offset de preço. O offset de preço é baseado na faixa de preço (price_range) e o intervalo de preço mínimo (min_price_step) calculado.

price_offset = price_range - self.pending_order_count * min_price_step  # 计算价格偏移量
do_trade = price_offset > 0

• price_range: Faixa de preço, indicando o intervalo de desvio entre o preço da ordem pendente e o preço médio.
• min_price_step: Intervalo de preço mínimo, indicando o passo mínimo de ajuste de cada preço de ordem pendente.
• price_offset: Deslocamento de preço, que indica o desvio entre o preço do pedido atual e o preço médio.

Se o deslocamento do preço for maior que 0, significa que a ordem pode continuar a ser colocada; caso contrário, o número de ordens pendentes será zerado.

4. Gerar dicionário de ordens pendentes

Com base no deslocamento de preço, os preços de compra e venda são calculados e um dicionário de ordens pendentes é gerado.

if do_trade:
    buy_price = mid_price - price_offset  # 计算买价
    buy_price = round(buy_price, self.price_precision)  # 四舍五入买价
    
    sell_price = mid_price + price_offset  # 计算卖价
    sell_price = round(sell_price, self.price_precision)  # 四舍五入卖价

    trade_dict = {
        'do_trade': do_trade,
        'buy_price': buy_price,
        'sell_price': sell_price,
        'amount': trade_amount
    }

    Log('返回盘口挂单字典：', trade_dict)
    return trade_dict
else:
    self.pending_order_count = 0  # 重置挂单次数

• buy_price: Preço de oferta, calculado como o preço médio menos o preço de compensação.
• sell_price: Preço pedido, calculado como o preço médio mais o preço de compensação.
• trade_dict: Dicionário de ordens pendentes, incluindo preços de compra e venda e quantidades.

5. Executar negociações de mercado

De acordo com o dicionário de ordens gerado, execute a transação da ordem.create_orderMétodo, coloque ordens de compra e ordens de venda ao mesmo tempo.

def make_trade_by_dict(self, trade_dict):
    if trade_dict['do_trade']:
        buy_id = self.exchange_mid.create_order('buy', trade_dict['buy_price'], trade_dict['amount'])  # 挂买单
        sell_id = self.exchange_mid.create_order('sell', trade_dict['sell_price'], trade_dict['amount'])  # 挂卖单
        
        self.traded_pairs['pan_kou'].append({
            'buy_id': buy_id, 'sell_id': sell_id, 'init_time': time.time(), 'amount': trade_dict['amount']
        })

6. Verifique o status do pedido

Verifique regularmente o status dos pedidos e processe os pedidos não atendidos. A lógica de processamento do status dos pedidos é semelhante à estratégia de negociação cruzada, mas, devido às diferenças de preço, a execução parcial pode resultar em lucro ou prejuízo.

As principais desvantagens da estratégia de handicap

1. O movimento de preços das ordens pendentes não é flexível o suficiente

O mecanismo de ajuste de preços nesta estratégia é relativamente simples, com as seguintes limitações:

price_offset = price_range - self.pending_order_count * min_price_step  # 计算价格偏移量

• Limite de ajuste linear：O deslocamento de preço adota um método decrescente linear e não pode ser ajustado dinamicamente de acordo com a volatilidade real do mercado
• Solidificação de parâmetros：price_range e min_price_stepÉ um parâmetro fixo e não pode ser ajustado em tempo real de acordo com as condições de mercado
• Histerese de resposta:Quando os preços de mercado mudam rapidamente, o ajuste de preço da estratégia pode não acompanhar o ritmo do mercado
• Falta de conhecimento do mercado: Não leva em consideração fatores de microestrutura de mercado, como profundidade do livro de ordens e volume de negociação

Direção de melhoria：

• Introdução de um mecanismo dinâmico de ajuste de preços baseado na volatilidade
• Ajuste os preços dos pedidos pendentes com base na profundidade e liquidez do mercado
• Melhore seu julgamento sobre as tendências do mercado e evite colocar ordens contra a tendência

2. Risco de estoque

A estratégia de mercado enfrenta sérios problemas de risco de estoque:

Desempenho de Risco：

• Risco de transação unilateral：Quando apenas ordens de compra ou venda são executadas, isso levará a uma posição desequilibrada
• Risco direcional:Em um mercado em tendência, uma grande quantidade de posições unidirecionais pode se acumular
• Ocupação de capital: O excesso de estoque ocupará muitos fundos e afetará a eficiência da estratégia

Pontos de risco no código：

if buy_order_status['Status'] == ORDER_STATE_PENDING:
    self.sell_amount += traded_pair['amount']  # 只有卖单成交，积累空头持仓
elif sell_order_status['Status'] == ORDER_STATE_PENDING:
    self.buy_amount += traded_pair['amount']  # 只有买单成交，积累多头持仓

O impacto do risco de estoque：

• Lucratividade em declínio: Posições unilaterais resultarão em perdas quando ocorrerem mudanças desfavoráveis de preços
• Pressão de liquidez：São necessários fundos adicionais para proteger os riscos de estoque
• Falha de estratégia:Em casos extremos, a estratégia pode não continuar a funcionar

Medidas de Gestão de Riscos：

• Restrições de estoque: Defina um limite máximo de posição para evitar acúmulo excessivo
• Cobertura dinâmica:Quando o estoque exceder o limite, feche ou proteja ativamente
• Inclinação de preço：Ajuste os preços de compra e venda com base no estoque atual para incentivar transações reversas

Resumo da estratégia

A estratégia de formação de mercado é uma estratégia de formação de mercado baseada na profundidade do mercado. Ela mantém a liquidez do mercado ajustando dinamicamente o preço e a quantidade de ordens de compra e venda. Comparada à estratégia de wash trading, a estratégia de formação de mercado apresenta as seguintes características:

✅ Vantagens

• Obtenha lucros reais de arbitragem por meio de diferenças de preços
• Em linha com o modelo de lucro dos formadores de mercado tradicionais
• Fornecendo liquidez real de mercado

❌ Desafio

• Diante dos riscos de flutuação dos preços de mercado
• É necessária uma gestão de risco mais sofisticada
• Maiores requisitos para fundos e tecnologia
• O mecanismo de ajuste de preços não é suficientemente flexível：O mecanismo de movimento linear de preços é difícil de adaptar ao ambiente complexo do mercado
• Riscos proeminentes de estoque:Transações unilaterais podem facilmente levar a posições desequilibradas, e o risco é particularmente significativo em mercados em tendência.

🔮 Direções de otimização futuras

Tendo em vista as deficiências da atual estratégia de handicap, podemos otimizá-la e melhorá-la nas seguintes direções no futuro:

1. Estratégia de criação de mercado dinâmica：

   • Ajustes de preços adaptativos com base na volatilidade do mercado
   • Ajuste dinamicamente as estratégias de ordens pendentes com base na profundidade do livro de ordens
   • Apresentando o aprendizado de máquina para prever a direção do mercado

2. Estratégia de gestão de estoque：

   • Monitoramento de estoque e avaliação de risco em tempo real
   • Mecanismo de hedge dinâmico e algoritmo de balanceamento de estoque
   • Estratégia de inclinação de preço com base no status do estoque

3. Estratégia de criação de mercado multinível：

   • Fornecendo liquidez em vários níveis de preços simultaneamente
   • Dispersar riscos pontuais e melhorar a estabilidade geral
   • Mais próximo da operação real dos formadores de mercado profissionais

4. Gestão inteligente de riscos：

   • Monitoramento de indicadores de risco em tempo real
   • Mecanismo automático de stop-loss e controle de risco
   • Tratamento emergencial de situações anormais de mercado

Código de Estratégia (Revisado)

import time, json

class MidClass:
    def __init__(self, exchange_instance):
        '''
        初始化交易所中间层
        
        Args:
            exchange_instance: FMZ的交易所结构
        '''
        self.init_timestamp = time.time()  # 记录初始化时间
        self.exchange = exchange_instance  # 保存交易所对象
        self.exchange_name = self.exchange.GetName()  # 获取交易所名称
        self.trading_pair = self.exchange.GetCurrency()  # 获取交易对名称（如 BTC_USDT）

    def get_precision(self):
        '''
        获取交易对的精度信息
        
        Returns:
            返回包含精度信息的字典，失败时返回 None
        '''
        symbol_code = self.exchange.GetCurrency()
        ticker = self.exchange.GetTicker(symbol_code)  # 回测系统需要
        exchange_info = self.exchange.GetMarkets()
        data = exchange_info.get(symbol_code)

        if not data:
            Log("获取市场信息失败", GetLastError())
            return None

        # 获取该交易对的精度信息
        self.precision_info = {
            'tick_size': data['TickSize'],                  # 价格精度
            'amount_size': data['AmountSize'],              # 数量精度
            'price_precision': data['PricePrecision'],      # 价格小数位精度
            'amount_precision': data['AmountPrecision'],    # 数量小数位精度
            'min_qty': data['MinQty'],                      # 最小下单数量
            'max_qty': data['MaxQty']                       # 最大下单数量
        }

        return self.precision_info

    def get_account(self):
        '''
        获取账户信息
        
        Returns:
            获取信息成功返回 True，获取信息失败返回 False
        '''

        self.balance = '---'  # 账户余额
        self.amount = '---'  # 账户持仓量
        self.frozen_balance = '---'  # 冻结余额
        self.frozen_stocks = '---'  # 冻结持仓量
        self.init_balance = None
        self.init_stocks = None
        self.init_equity = None

        try:
            account_info = self.exchange.GetAccount()  # 获取账户信息
            self.balance = account_info['Balance']  # 更新账户余额
            self.amount = account_info['Stocks']  # 更新持仓量
            self.frozen_balance = account_info['FrozenBalance']  # 更新冻结余额
            self.frozen_stocks = account_info['FrozenStocks']  # 更新冻结持仓量
            self.equity = self.balance + self.frozen_balance + (self.amount + self.frozen_stocks) * self.last_price
            
            if not self.init_balance or not self.init_stocks or not self.init_equity:
                if _G("init_balance") and _G("init_balance") > 0 and _G("init_stocks") and _G("init_stocks") > 0:
                    self.init_balance = round(_G("init_balance"), 2)
                    self.init_stocks = round(_G("init_stocks"), 2)
                    self.init_equity = round(_G("init_equity"), 2)
                else:
                    self.init_balance = round(self.balance + self.frozen_balance, 2)
                    self.init_stocks = self.amount + self.frozen_stocks
                    self.init_equity = round(self.init_balance + (self.init_stocks * self.last_price), 2)
                    _G("init_balance", self.init_balance)
                    _G("init_stocks", self.init_stocks)
                    _G("init_equity", self.init_equity)

                    Log('获取初始eqity', self.init_equity)

            self.profit = self.equity - self.init_equity
            self.profitratio = round((self.equity - self.init_equity)/self.init_equity, 4) * 100

            return True
        except:
            return False  # 获取账户信息失败

    def get_ticker(self):
        '''
        获取市价信息（如买一价、卖一价、最高价、最低价等）
        
        Returns:
            获取信息成功返回 True，获取信息失败返回 False
        '''
        self.high_price = '---'  # 最高价
        self.low_price = '---'  # 最低价
        self.sell_price = '---'  # 卖一价
        self.buy_price = '---'  # 买一价
        self.last_price = '---'  # 最新成交价
        self.volume = '---'  # 成交量
        
        try:
            ticker_info = self.exchange.GetTicker()  # 获取市价信息
        
            self.high_price = ticker_info['High']  # 更新最高价
            self.low_price = ticker_info['Low']  # 更新最低价
            self.sell_price = ticker_info['Sell']  # 更新卖一价
            self.buy_price = ticker_info['Buy']  # 更新买一价
            self.last_price = ticker_info['Last']  # 更新最新成交价
            self.volume = ticker_info['Volume']  # 更新成交量
            return True
        except:
            return False  # 获取市价信息失败
        
    def get_depth(self):
        '''
        获取深度信息（买卖盘的挂单列表）
        
        Returns:
            获取信息成功返回 True，获取信息失败返回 False
        '''
        self.ask_orders = '---'  # 卖盘挂单列表
        self.bid_orders = '---'  # 买盘挂单列表
        
        try:
            depth_info = self.exchange.GetDepth()  # 获取深度信息
            self.ask_orders = depth_info['Asks']  # 更新卖盘挂单列表
            self.bid_orders = depth_info['Bids']  # 更新买盘挂单列表
            return True
        except:
            return False  # 获取深度信息失败
        
    def get_ohlc_data(self, period=PERIOD_M5):
        '''
        获取K线信息
        
        Args:
            period: K线周期，PERIOD_M1 指1分钟, PERIOD_M5 指5分钟, PERIOD_M15 指15分钟,
            PERIOD_M30 指30分钟, PERIOD_H1 指1小时, PERIOD_D1 指一天。
        '''
        self.ohlc_data = self.exchange.GetRecords(period)  # 获取K线数据
        
    def create_order(self, order_type, price, amount):
        '''
        提交一个挂单信息
        
        Args:
            order_type：挂单类型，'buy'指挂买单，'sell'指挂卖单
            price：挂单价格
            amount:挂单数量
            
        Returns:
            挂单Id号，可用以取消挂单
        '''
        if order_type == 'buy':
            try:
                order_id = self.exchange.Buy(price, amount)  # 提交买单
            except:
                return False  # 买单提交失败
            
        elif order_type == 'sell':
            try:
                order_id = self.exchange.Sell(price, amount)  # 提交卖单
            except:
                return False  # 卖单提交失败
        
        return order_id  # 返回订单ID
    
    def get_orders(self):
        '''
        获取未完成的订单列表
        
        Returns:
            未完成的订单列表
        '''
        self.open_orders = self.exchange.GetOrders()  # 获取未完成订单
        return self.open_orders
    
    def cancel_order(self, order_id):
        '''
        取消一个挂单信息
        
        Args:
            order_id：希望取消的挂单ID号
            
        Returns:
            取消挂单成功返回 True，取消挂单失败返回 False
        '''
        return self.exchange.CancelOrder(order_id)  # 取消订单
        
    def refresh_data(self):
        '''
        刷新信息（账户、市价、深度、K线）
        
        Returns:
            刷新信息成功返回 'refresh_data_finish!' 否则返回相应刷新失败的信息提示
        '''

        if not self.get_ticker():  # 刷新市价信息
            return 'false_get_ticker'

        if not self.get_account():  # 刷新账户信息
            return 'false_get_account'
        
        if not self.get_depth():  # 刷新深度信息
            return 'false_get_depth'
        
        try:
            self.get_ohlc_data()  # 刷新K线信息
        except:
            return 'false_get_K_line_info'
        
        return 'refresh_data_finish!'  # 刷新成功


class MarketMaker:
    def __init__(self, mid_class):
        '''
        初始化做市策略
        
        Args:
            mid_class: 交易所中间层对象
        '''
        self.exchange_mid = mid_class  # 交易所中间层对象
        self.precision_info = self.exchange_mid.get_precision()  # 获取精度信息

        self.done_amount = {'pan_kou': 0}  # 已完成交易量
        # 修正：正确分配精度信息
        self.price_precision = self.precision_info['price_precision']  # 价格精度
        self.amount_precision = self.precision_info['amount_precision']  # 交易量精度
        
        self.traded_pairs = {'pan_kou': []}  # 已挂单的交易对
        self.pending_orders = []  # 未完成的订单状态
        self.pending_order_count = 0  # 挂单次数

        self.buy_amount = 0
        self.sell_amount = 0

        self.fee = 0
        self.fee_rate = 0.08 / 100

        self.chart = {
            "__isStock": True,
            "tooltip": {"xDateFormat": "%Y-%m-%d %H:%M:%S, %A"},
            "title": {"text": "挂单数量"},
            "xAxis": {"type": "datetime"},
            "yAxis": {
                "title": {"text": "挂单数量"},
                "opposite": False
            },
            "series": [
                {"name": "挂单买量", "id": "挂单买量", "data": []},
                {"name": "挂单卖量", "id": "挂单卖量", "dashStyle": "shortdash", "data": []}
            ]
        }

    def refresh_data(self):
        '''
        刷新数据（账户、市价、深度、K线）
        '''
        self.exchange_mid.refresh_data()  # 刷新交易所数据
        self.position_amount = 0 if isinstance(self.exchange_mid.amount, str) else self.exchange_mid.amount  # 持仓量
        self.available_balance = 0 if isinstance(self.exchange_mid.balance, str) else self.exchange_mid.balance  # 账户余额

        self.can_buy_amount = self.available_balance / float(self.exchange_mid.buy_price)  # 可买的数量
        self.mid_price = (self.exchange_mid.sell_price + self.exchange_mid.buy_price) / 2  # 中间价

    def make_trade_by_dict(self, trade_dict):
        '''
        根据交易字典执行交易
        
        Args:
            trade_dict: 交易字典
        '''
        Log('4按照字典开始交易')
        self.refresh_data()  # 刷新数据
        
        if trade_dict['do_trade']:
            Log('当前账户资金： 币数余额： ', self.position_amount, '资金余额： ', self.can_buy_amount)
            Log('检查开仓： 币数限制： ', self.position_amount > trade_dict['amount'], '资金限制： ', self.can_buy_amount > trade_dict['amount'])
            if self.position_amount > trade_dict['amount'] and self.can_buy_amount > trade_dict['amount']:
                buy_id = self.exchange_mid.create_order('buy', trade_dict['buy_price'], trade_dict['amount'])  # 挂买单
                sell_id = self.exchange_mid.create_order('sell', trade_dict['sell_price'], trade_dict['amount'])  # 挂卖单
                
                self.traded_pairs['pan_kou'].append({
                    'buy_id': buy_id, 'sell_id': sell_id, 'init_time': time.time(), 'amount': trade_dict['amount']
                })
                    
                self.last_time = time.time()  # 更新上次交易时间
        
    def handle_pending_orders(self):
        '''
        处理未完成的订单
        '''
        pending_orders = self.exchange_mid.get_orders()  # 获取未完成订单
        if len(pending_orders) > 0:
            for order in pending_orders:
                self.exchange_mid.cancel_order(order['Id'])  # 取消未完成订单
                
    def make_pankou_dict(self, price_range, min_price_step, trade_amount):
        
        '''
        生成盘口挂单字典
        
        Args:
            price_range: 价格范围
            min_price_step: 最小价格间隔
            trade_amount: 每次交易量
        
        Returns:
            盘口挂单字典列表
        '''
        Log('3制作盘口挂单字典', '移动盘口次数', self.pending_order_count)
        mid_price = self.mid_price  # 中间价
        
        price_offset = price_range - self.pending_order_count * min_price_step  # 计算价格偏移量
        do_trade = price_offset > 0

        if do_trade:
            buy_price = mid_price - price_offset  # 计算买价
            buy_price = round(buy_price, self.price_precision)  # 四舍五入买价
            
            sell_price = mid_price + price_offset  # 计算卖价
            sell_price = round(sell_price, self.price_precision)  # 四舍五入卖价

            trade_dict = {
                'do_trade': do_trade,
                'buy_price': buy_price,
                'sell_price': sell_price,
                'amount': trade_amount
            }

            Log('返回盘口挂单字典：', trade_dict)
            return trade_dict
        else:
            Log('重置移动盘口次数：', self.pending_order_count)
            self.pending_order_count = 0  # 重置移动盘口次数
            # 修正：当不能交易时返回None或空字典
            return None
            
    
    def check_order_status(self, current_time):
        '''
        检查订单状态
        
        Args:
            current_time: 当前时间戳
        '''
        Log('1开始订单信息检查')
        Log(self.traded_pairs['pan_kou'])
        self.buy_pending = 0
        self.sell_pending = 0
        for traded_pair in self.traded_pairs['pan_kou'].copy():
            Log('检查订单：', traded_pair['buy_id'], traded_pair['sell_id'])

            try:
                buy_order_status = self.exchange_mid.exchange.GetOrder(traded_pair['buy_id'])  # 获取买单状态
                sell_order_status = self.exchange_mid.exchange.GetOrder(traded_pair['sell_id'])  # 获取卖单状态
            except:
                Log(traded_pair, '取消')
                self.exchange_mid.cancel_order(traded_pair['buy_id'])  # 取消买单
                self.exchange_mid.cancel_order(traded_pair['sell_id'])  # 取消卖单
                self.traded_pairs['pan_kou'].remove(traded_pair)  # 移除订单
                return

            Log('检查订单：', traded_pair['buy_id'], buy_order_status, traded_pair['sell_id'], sell_order_status, [sell_order_status['Status'], buy_order_status['Status']])
            if [sell_order_status['Status'], buy_order_status['Status']] == [0, 0]:
                self.buy_pending += 1
                self.sell_pending += 1
                if current_time % 5 == 0:
                    Log('检查挂单，取消挂单（两未完）', buy_order_status['Status'], sell_order_status['Status'], current_time % 5)
                    self.exchange_mid.cancel_order(traded_pair['buy_id'])  # 取消买单
                    self.exchange_mid.cancel_order(traded_pair['sell_id'])  # 取消卖单
                    self.pending_order_count += 1  # 移动盘口次数次数加1
                    self.traded_pairs['pan_kou'].remove(traded_pair)  # 移除订单

            elif {sell_order_status['Status'], buy_order_status['Status']} == {1, 0}:
                if buy_order_status['Status'] == ORDER_STATE_PENDING:
                    self.buy_pending += 1
                if sell_order_status['Status'] == ORDER_STATE_PENDING:
                    self.sell_pending += 1
                if current_time % 5 == 0:
                    Log('检查挂单，取消挂单（一未完）', buy_order_status['Status'], sell_order_status['Status'])
                    self.done_amount['pan_kou'] += traded_pair['amount']  # 更新交易量
                    if buy_order_status['Status'] == ORDER_STATE_PENDING:
                        self.sell_amount += traded_pair['amount']
                        self.fee += sell_order_status['Amount'] * self.fee_rate * sell_order_status['Price']
                        Log('取消该买订单，增加未完成买列表', traded_pair['buy_id'])
                        self.exchange_mid.cancel_order(traded_pair['buy_id'])  # 取消买单
                        self.pending_orders.append(['buy', buy_order_status['Status']])  # 记录未完成订单
                        Log('清除前：', self.traded_pairs['pan_kou'])
                        Log('清除id：', traded_pair)
                        self.traded_pairs['pan_kou'].remove(traded_pair)  # 移除订单
                        Log('清除后：', self.traded_pairs['pan_kou'])
                    elif sell_order_status['Status'] == ORDER_STATE_PENDING:
                        self.buy_amount += traded_pair['amount']
                        self.fee += buy_order_status['Amount'] * self.fee_rate * buy_order_status['Price']
                        Log('取消该卖订单，增加未完成卖列表', traded_pair['sell_id'])
                        self.exchange_mid.cancel_order(traded_pair['sell_id'])  # 取消卖单
                        self.pending_orders.append(['sell', sell_order_status['Status']])  # 记录未完成订单
                        Log('清除前：', self.traded_pairs['pan_kou'])
                        Log('清除id：', traded_pair)
                        self.traded_pairs['pan_kou'].remove(traded_pair)  # 移除订单
                        Log('清除后：', self.traded_pairs['pan_kou'])
                
            elif [sell_order_status['Status'], buy_order_status['Status']] == [1, 1]:
                Log('两订单都已完成')
                Log('完成状态：', buy_order_status['Status'], sell_order_status['Status'], traded_pair['amount'])
                self.done_amount['pan_kou'] += 2 * traded_pair['amount']  # 更新交易量
                self.buy_amount += traded_pair['amount']
                self.sell_amount += traded_pair['amount']
                self.fee += buy_order_status['Amount'] * self.fee_rate * buy_order_status['Price']
                self.fee += sell_order_status['Amount'] * self.fee_rate * sell_order_status['Price']
                self.traded_pairs['pan_kou'].remove(traded_pair)  # 移除订单
            else:
                Log('两订单处于未知状态：', buy_order_status, sell_order_status)
                Log('未知订单状态：', buy_order_status['Status'], sell_order_status['Status'])
                Log('未知订单信息：', traded_pair)

    def update_status(self):

        self.exchange_mid.refresh_data()

        table1 = {
            "type": "table",
            "title": "账户信息",
            "cols": [
                "初始资金", "现存资金", "盘口买入数量", "盘口卖出数量", "费率", "总收益", "收益率"
            ],
            "rows": [
                [   
                    self.exchange_mid.init_equity,
                    self.exchange_mid.equity,
                    round(self.buy_amount, 4),
                    round(self.sell_amount, 4),
                    round(self.fee, 2),
                    self.exchange_mid.profit,
                    str(self.exchange_mid.profitratio) + "%"
                ],
            ],
        }

        LogStatus(
            f"初始化时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(self.exchange_mid.init_timestamp))}\n",
            f"`{json.dumps(table1)}`\n",
            f"最后执行时间: {_D()}\n"
        )

        LogProfit(round(self.exchange_mid.profit, 3), '&')

    def plot_pending(self):
        
        Log('盘口挂单数量：', self.buy_pending, self.sell_pending)
        self.obj_chart = Chart(self.chart)
        now_time = int(time.time() * 1000)
        # 更新挂单买量数据
        self.obj_chart.add(0, [now_time, self.buy_pending])
        # 更新挂单卖量数据
        self.obj_chart.add(1, [now_time, self.sell_pending])

def main():
    '''
    主函数，运行做市策略
    '''
    exchange.IO('simulate', True) #OKX现货模拟账户
    exchange.IO("trade_super_margin")

    current_time = 0
    target_amount = 1  # 目标交易量
    
    price_range = 5  # 价格范围
    min_price_step = 1  # 最小价格间隔
    trade_amount = 0.01  # 每次交易量
    
    exchange_mid = MidClass(exchange)  # 初始化交易所中间层
    Log(exchange_mid.refresh_data())  # 刷新数据
    market_maker = MarketMaker(exchange_mid)  # 初始化做市策略
    
    # 修正：初始化trade_dict
    trade_dict = None
    
    while market_maker.done_amount['pan_kou'] < target_amount:  # 循环直到完成目标交易量
        Log(market_maker.traded_pairs['pan_kou'])
        market_maker.check_order_status(current_time)  # 检查订单状态
        Sleep(1000)  # 等待1秒
        market_maker.refresh_data()  # 刷新数据
        
        if len(market_maker.traded_pairs['pan_kou']) < 1: # 价格移动，盘口挂单撤销，等待至所有挂单完毕，制定新的挂单字典
            
            Log('2盘口交易对数量小于1')
            trade_dict = market_maker.make_pankou_dict(price_range, min_price_step, trade_amount)  # 生成盘口挂单字典
            Log('新交易字典', trade_dict)
        
        # 修正：确保trade_dict存在且不为None
        if trade_dict and trade_dict.get('do_trade', False):
            market_maker.make_trade_by_dict(trade_dict)  # 执行交易

        Log('盘口做市数量：', market_maker.done_amount['pan_kou'])  # 记录交易量

        market_maker.plot_pending()
        market_maker.update_status()
        current_time += 1
        
    Log(market_maker.position_amount, market_maker.can_buy_amount)  # 记录持仓量和可买数量
    Log('现存订单：', exchange.GetOrders())  # 记录现存订单

def onexit():
    Log("执行扫尾函数")

    _G("init_balance", None)
    _G("init_stocks", None)
    _G("init_equity", None)