Vorwort

In unserem vorherigen Artikel „Wash-Trading-Strategien für Kryptowährungen“ haben wir ein Strategiekonzept zur Steigerung des Handelsvolumens durch Kauf und Verkauf zum gleichen Preis vorgestellt. Der Hauptzweck dieser Strategie besteht darin, Börsenrabatte oder Stufenvorteile zu erhalten, anstatt von Preisarbitrage zu profitieren. Wash-Trading-Strategien sind zwar hilfreich, um mehr über Handelsstrukturen zu erfahren, ihre tatsächliche Rentabilität ist jedoch begrenzt und sie können Compliance-Risiken bergen.

Dieser Artikel stellt eine weitere, praktischere Market-Making-Strategie vor, die auf dem vorherigen Artikel basiert:Handicap-StrategieIm Gegensatz zur Wash-Trading-Strategie handelt es sich bei der Market-Maker-Strategie um eine echte Arbitrage-Strategie, die Gewinne durch die Festlegung einer Spanne zwischen Kauf- und Verkaufspreisen erzielt, was eher dem Gewinnmodell traditioneller Market-Maker entspricht.

⚠️ Wichtiger Hinweis

Der in diesem Artikel vorgestellte Marktstrategiecode dient lediglich als Lernrahmen und spiegelt keine realen Handelserfahrungen wider. Die hier vorgestellten Strategien dienen ausschließlich technischen Lern- und Forschungszwecken und wurden unter realen Marktbedingungen nicht vollständig validiert. Lesern wird empfohlen, vor der Verwendung dieser Informationen gründliche Backtests und Risikobewertungen durchzuführen und sie nicht direkt im realen Handel einzusetzen.

Grundsätze der Handicap-Strategie

Die Market-Order-Book-Strategie ist eine Market-Making-Strategie, die das Market-Order-Book (d. h. die Markttiefe) für Arbitragezwecke nutzt. Bei dieser Strategie passen Market Maker den Orderpreis dynamisch innerhalb der Lücke zwischen Geld- und Briefkursen basierend auf Marktschwankungen an, indem sie Aufträge platzieren und stornieren. So profitieren sie von der Marktliquidität und kurzfristigen Preisschwankungen, um Gewinne zu erzielen.

Kernfunktionen

1. Passen Sie die Preise ausstehender Bestellungen dynamisch an：Passen Sie die Preise von Kauf- und Verkaufsaufträgen dynamisch an die Markttiefe und Preisschwankungen an, um die Wahrscheinlichkeit einer Transaktion zu erhöhen.
2. Kontrollieren Sie die Anzahl ausstehender Bestellungen: Kontrollieren Sie die Anzahl der ausstehenden Aufträge basierend auf Kontoguthaben und Positionen, um eine übermäßige Aussetzung gegenüber Marktrisiken zu vermeiden.
3. Auftragsstatusverwaltung: Überprüfen Sie regelmäßig den Bestellstatus und bearbeiten Sie nicht abgeschlossene Bestellungen.

Unterschiede zur Knock-on-Strategie

Vorteile der Handicap-Strategie

• Verbesserung der Marktliquidität：Durch die Platzierung von Aufträgen auf dem Markt können wir die Kauf- und Verkaufstiefe des Marktes erhöhen und mehr Händler zur Teilnahme bewegen.
• Verdienen Sie Geld-Brief-Spanne: Durch die Bereitstellung von Liquidität können Market Maker die Geld-Brief-Spanne verdienen und so einen Gewinn erzielen.
• Flexibel auf Marktschwankungen reagieren：Die Marktstrategie kann den Preis ausstehender Aufträge dynamisch an Marktschwankungen anpassen, um Marktrisiken zu reduzieren.

Herausforderungen der Handicap-Strategie

• Marktrisiko: Marktpreisschwankungen können dazu führen, dass die Aufträge des Market Makers nicht ausgeführt werden oder sogar zu Verlusten führen.
• Finanzieller Druck：Market Maker benötigen ausreichende Mittel, um die Kauf- und Verkaufstiefe des Marktes aufrechtzuerhalten. Unzureichende Mittel können zum Scheitern der Strategie führen.
• Komplexes Auftragsmanagement：Die Marktstrategie erfordert eine regelmäßige Überprüfung des Auftragsstatus und die Bearbeitung nicht abgeschlossener Aufträge, was die Komplexität der Strategie erhöht.

Struktur der Handicap-Strategie

Im Einklang mit der Strike-Strategie implementiert der Code in diesem Artikel eine Market-Making-Strategie basierend auf der Marktnotierungsstrategie, die hauptsächlich in zwei Kategorien unterteilt ist:

1. MidClass: Die mittlere Ebene der Börse ist für die Interaktion mit der Börsenschnittstelle verantwortlich, um Marktdaten, Kontoinformationen, Auftragsstatus usw. abzurufen.
2. MarketMaker: Market-Making-Strategieklasse, verantwortlich für die Ausführung der Marktstrategie, die dynamische Generierung von Preisen für ausstehende Aufträge, die Generierung ausstehender Aufträge, die Überprüfung des Auftragsstatus, die Aktualisierung des Strategiestatus usw.

Handicap-Strategieprozess

1. Initialisierung

existierenMarketMakerBei der Klasseninitialisierungsmethode werden zunächst die Genauigkeitsinformationen der Börse abgerufen und die Strategieparameter initialisiert, z. B. Genauigkeit des Transaktionsvolumens, Preisgenauigkeit usw.

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. Erstellen Sie ein Wörterbuch mit ausstehenden Aufträgen

Der Kern der Marktstrategie besteht darin, ein Verzeichnis der ausstehenden Aufträge zu erstellen, das die Kauf- und Verkaufspreise sowie die Mengen enthält. Der Code generiert dieses Verzeichnis durch Berechnung des Mittelpreises und des Preisversatzes.

3. Bewegung der Preise ausstehender Aufträge

Die Preisbewegung der Pending Order wird durch die Berechnung des Preisoffsets erreicht. Das Preisoffset basiert auf der Preisspanne (price_range) und das Mindestpreisintervall (min_price_step) berechnet.

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

• price_range: Preisspanne, die den Abweichungsbereich zwischen dem Preis der ausstehenden Bestellung und dem Mittelpreis angibt.
• min_price_step: Mindestpreisintervall, das den Mindestanpassungsschritt jedes ausstehenden Auftragspreises angibt.
• price_offset: Preisoffset, der die Abweichung zwischen dem aktuellen Auftragspreis und dem Mittelpreis angibt.

Wenn der Preisversatz größer als 0 ist, bedeutet dies, dass die Bestellung weiterhin aufgegeben werden kann. Andernfalls wird die Anzahl der ausstehenden Bestellungen zurückgesetzt.

4. Erstellen Sie ein ausstehendes Auftragswörterbuch

Basierend auf dem Preisversatz werden die Kauf- und Verkaufspreise berechnet und ein Wörterbuch ausstehender Aufträge erstellt.

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: Gebotspreis, berechnet als Mittelpreis abzüglich des Preisversatzes.
• sell_price: Briefkurs, berechnet als Mittelkurs plus Preisversatz.
• trade_dict: Wörterbuch der ausstehenden Aufträge, einschließlich Kauf- und Verkaufspreisen und Mengen.

5. Marktgeschäfte durchführen

Führen Sie die Bestelltransaktion gemäß dem generierten Bestellwörterbuch aus.create_orderMethode: Platzieren Sie Kaufaufträge und Verkaufsaufträge gleichzeitig.

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. Bestellstatus prüfen

Überprüfen Sie regelmäßig den Auftragsstatus und bearbeiten Sie nicht erfüllte Aufträge. Die Logik der Auftragsstatusverarbeitung ähnelt der Cross-Trading-Strategie, aber aufgrund von Preisunterschieden kann eine teilweise Ausführung zu tatsächlichen Gewinnen oder Verlusten führen.

Die Hauptnachteile der Handicap-Strategie

1. Die Preisbewegung ausstehender Aufträge ist nicht flexibel genug

Der Preisanpassungsmechanismus dieser Strategie ist relativ einfach, weist jedoch die folgenden Einschränkungen auf:

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

• Lineare Einstellgrenze：Der Preisausgleich erfolgt linear abnehmend und kann nicht dynamisch an die tatsächliche Marktvolatilität angepasst werden.
• Parameterverfestigung：price_range Und min_price_stepEs handelt sich um einen festen Parameter, der nicht in Echtzeit an die Marktbedingungen angepasst werden kann.
• Ansprechhysterese: Wenn sich die Marktpreise schnell ändern, kann die Preisanpassung der Strategie möglicherweise nicht mit dem Marktrhythmus Schritt halten
• Mangelndes Marktbewusstsein: Es berücksichtigt keine Marktmikrostrukturfaktoren wie Orderbuchtiefe und Handelsvolumen

Verbesserungsrichtung：

• Einführung eines dynamischen Preisanpassungsmechanismus basierend auf der Volatilität
• Passen Sie die Preise ausstehender Aufträge basierend auf der Markttiefe und Liquidität an
• Verbessern Sie Ihr Urteilsvermögen hinsichtlich Markttrends und vermeiden Sie es, Aufträge gegen den Trend zu erteilen

2. Bestandsrisiko

Die Marktstrategie ist mit ernsthaften Bestandsrisikoproblemen konfrontiert:

Risikoperformance：

• Einseitiges Transaktionsrisiko：Wenn nur Kaufaufträge oder Verkaufsaufträge ausgeführt werden, führt dies zu einer unausgeglichenen Position
• Richtungsrisiko: In einem Trendmarkt kann sich eine große Menge an Einwegpositionen ansammeln
• Kapitalbesetzung: Übermäßige Lagerbestände binden viel Geld und beeinträchtigen die Effizienz der Strategie

Risikopunkte im Code：

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']  # 只有买单成交，积累多头持仓

Die Auswirkungen des Bestandsrisikos：

• Sinkende Rentabilität: Einseitige Positionen führen zu Verlusten, wenn ungünstige Preisänderungen auftreten
• Liquiditätsdruck：Zusätzliche Mittel werden zur Absicherung von Bestandsrisiken benötigt
• Strategie funktioniert nicht: Im Extremfall kann die Strategie nicht weiterlaufen

Risikomanagementmaßnahmen：

• Bestandsbeschränkungen: Legen Sie ein maximales Positionslimit fest, um eine übermäßige Anhäufung zu verhindern
• Dynamische Absicherung: Wenn der Bestand den Schwellenwert überschreitet, aktiv schließen oder absichern
• Preisneigung：Passen Sie Kauf- und Verkaufspreise basierend auf dem aktuellen Lagerbestand an, um Rücktransaktionen zu fördern

Zusammenfassung der Strategie

Die Market-Making-Strategie basiert auf der Markttiefe. Sie sorgt für Marktliquidität, indem sie Preis und Menge der Kauf- und Verkaufsaufträge dynamisch anpasst. Im Vergleich zur Wash-Trading-Strategie weist die Market-Making-Strategie folgende Merkmale auf:

✅ Vorteile

• Erzielen Sie echte Arbitragegewinne durch Preisunterschiede
• Im Einklang mit dem Gewinnmodell traditioneller Market Maker
• Bereitstellung echter Marktliquidität

❌ Herausforderung

• Angesichts der Risiken von Marktpreisschwankungen
• Ein ausgefeilteres Risikomanagement ist erforderlich
• Höhere Anforderungen an Mittel und Technologie
• Der Preisanpassungsmechanismus ist nicht flexibel genug：Der lineare Preisbewegungsmechanismus lässt sich nur schwer an das komplexe Marktumfeld anpassen
• Wichtige Bestandsrisiken: Einseitige Transaktionen können leicht zu unausgeglichenen Positionen führen und das Risiko ist in Trendmärkten besonders groß.

🔮 Zukünftige Optimierungsrichtungen

Angesichts der Mängel der aktuellen Handicap-Strategie können wir diese in Zukunft in folgenden Richtungen optimieren und verbessern:

1. Dynamische Market-Making-Strategie：

   • Adaptive Preisanpassungen basierend auf der Marktvolatilität
   • Passen Sie Pending-Order-Strategien dynamisch an die Tiefe des Orderbuchs an
   • Einführung von maschinellem Lernen zur Vorhersage der Marktrichtung

2. Bestandsverwaltungsstrategie：

   • Bestandsüberwachung und Risikobewertung in Echtzeit
   • Dynamischer Absicherungsmechanismus und Algorithmus zum Bestandsausgleich
   • Preis-Tilt-Strategie basierend auf dem Lagerbestand

3. Mehrstufige Market-Making-Strategie：

   • Bereitstellung von Liquidität auf mehreren Preisniveaus gleichzeitig
   • Streuen Sie Einzelpunktrisiken und verbessern Sie die Gesamtstabilität
   • Näher an der tatsächlichen Tätigkeit professioneller Market Maker

4. Intelligentes Risikomanagement：

   • Echtzeitüberwachung von Risikoindikatoren
   • Automatischer Stop-Loss- und Risikokontrollmechanismus
   • Notfallbehandlung von anormalen Marktsituationen

Strategiekodex (überarbeitet)

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)