先不用超价单，而是连续市价单，直到仓位吃满为止

s_erc20_to_mexc.py

@@ -85,12 +85,10 @@ class ArbitrageProcess:
 
         # 存储当前套利交易的细节信息,例如买入数量、价格等
         self.sell_price = Decimal(0)
+        self.sell_value = Decimal(0)                                            # 实际卖出价值
         self.buy_price = Decimal(0)
         self.chain_tx_hash = None                                               # 链上买入的tx hash
         self.exchange_sell_amount = Decimal(process_item['exchangeOutAmount'])  # 交易所卖出量
-        self.exchange_sell_order_id = None                                      # 交易所卖出id
-        self.exchange_withdrawal_id = None                                      # 交易所提现id
-        self.exchange_withdrawal_amount = None                                  # 交易所提现数量
         self.actual_profit = Decimal(0)                                         # 實際利潤
 
         # 定义可能的状态
@@ -306,95 +304,77 @@ class ArbitrageProcess:
         logger.info(msg)
         add_state_flow_entry(self.process_item, self.current_state, msg, "pending")
         try:
-            # 第一步直接卖出,这个数量用固定数量
-            pseudo_amount_to_sell = self.exchange_sell_amount
-            # 处理精度
-            pseudo_amount_to_sell = pseudo_amount_to_sell.quantize(self.coin_asset_precision, rounding=ROUND_DOWN)
-            
-            order_params = {
-                "symbol": self.symbol.replace('_', ''),
-                "side": "SELL",
-                "type": "MARKET",
-                "quantity": int(pseudo_amount_to_sell),
-            }
-            order_params_formated = pformat(order_params, indent=2)
-            
-            exchange_sell_order = mexc.trade.post_order(order_params)
-            exchange_sell_order_formated = pformat(exchange_sell_order, indent=2)
-
-            msg = f"交易所现货卖出订单已发送 \n params:{order_params_formated} \n rst: {exchange_sell_order_formated}"
-            if 'orderId' not in exchange_sell_order:
-                logger.error(msg)
-                add_state_flow_entry(self.process_item, self.current_state, msg, "fail")
-                self._set_state(self.STATE_FAILED)
-
-                return
-
-            self.exchange_sell_order_id = exchange_sell_order['orderId']
+            order_times = 0
+            self.already_sold_amount = Decimal(0)
+            while self.already_sold_amount < self.exchange_sell_amount and order_times < 5:
+                order_times = order_times + 1
+                # 第一步直接买入,这个数量用固定数量
+                pseudo_amount_to_sell = self.exchange_sell_amount - self.already_sold_amount
+                # 处理精度
+                pseudo_amount_to_sell = pseudo_amount_to_sell.quantize(self.coin_asset_precision, rounding=ROUND_DOWN)
             
-            logger.info(msg)
-            add_state_flow_entry(self.process_item, self.current_state, msg, "success")
-
-            self._set_state(self.STATE_WAITING_SELL_CONFIRM)
-        except Exception as e:
-            exc_traceback = traceback.format_exc()
-            msg = f"交易所现货卖出下单失败\n{exc_traceback}"
-            logger.error(msg)
-
-            add_state_flow_entry(self.process_item, self.current_state, msg, "fail")
-            self._set_state(self.STATE_FAILED)
-
-            # traceback.print_exc()
-
-    def _wait_sell_confirm(self):
-        """
-        等待交易所现货卖出订单确认（完全成交）
-        """
-        exchange_sell_order_id = self.exchange_sell_order_id
-        msg = f"等待交易所现货卖出订单确认：{exchange_sell_order_id}"
-        logger.info(msg)
-        add_state_flow_entry(self.process_item, self.current_state, msg, "pending")
-
-        try:
-            # 查询交易所订单状态
-            waiting_times = 30
-            last_order = None
-            while waiting_times > 0:
-                params = {
+                order_params = {
                     "symbol": self.symbol.replace('_', ''),
-                    "orderId": exchange_sell_order_id
+                    "side": "SELL",
+                    "type": "MARKET",
+                    "quantity": float(pseudo_amount_to_sell),
                 }
-                order = mexc.trade.get_order(params)
-                last_order = order
-
-                if order['status'] in ["FILLED", "PARTIALLY_CANCELED"]:
-                    money = Decimal(order['cummulativeQuoteQty'])
-                    amount = Decimal(order['executedQty'])
+                order_params_formated = pformat(order_params, indent=2)
+                
+                exchange_sell_order = mexc.trade.post_order(order_params)
+                exchange_sell_order_formated = pformat(exchange_sell_order, indent=2)
 
-                    self.sell_price = money / amount
-                    self.sell_price = self.sell_price.quantize(self.price_precision, rounding=ROUND_DOWN)
+                msg = f"交易所现货卖出订单已发送 \n params:{order_params_formated} \n rst: {exchange_sell_order_formated}"
+                if 'orderId' not in exchange_sell_order:
+                    logger.error(msg)
+                    add_state_flow_entry(self.process_item, self.current_state, msg, "fail")
 
-                    order_formated = pformat(order, indent=2)
-                    msg = f"交易所现货卖出订单已完成, 价格：{self.sell_price}, money: {money}\n order: {order_formated}"
-                    logger.info(msg)
-                    add_state_flow_entry(self.process_item, self.current_state, msg, "success")
+                    continue
 
-                    self.exchange_withdrawal_amount = money
+                # 查询交易所订单状态
+                exchange_sell_order_id = exchange_sell_order['orderId']
+                waiting_times = 5
+                while waiting_times > 0:
+                    params = {
+                        "symbol": self.symbol.replace('_', ''),
+                        "orderId": exchange_sell_order_id
+                    }
+                    order = mexc.trade.get_order(params)
+
+                    if order['status'] in ["FILLED", "PARTIALLY_CANCELED"]:
+                        # 以实际成交数量为准
+                        money = Decimal(order['cummulativeQuoteQty'])
+                        self.already_sold_amount = self.already_sold_amount + Decimal(order['executedQty'])
+
+                        self.sell_value = self.sell_value + money
+                        self.sell_price = self.sell_value / self.already_sold_amount
+                        self.sell_price = self.sell_price.quantize(self.price_precision, rounding=ROUND_DOWN)
+
+                        order_formated = pformat(order, indent=2)
+                        msg = f"交易所现货卖出订单已完成, 价格：{self.buy_price}, money: {money}\n order: {order_formated}"
+                        logger.info(msg)
+                        add_state_flow_entry(self.process_item, self.current_state, msg, "success")
+                        
+                        break
+                    else:
+                        time.sleep(1)
+                        waiting_times = waiting_times - 1
+            
+            if order_times <= 5:
+                msg = 'mexc现货卖出流程完成'
+                logger.info(msg)
+                add_state_flow_entry(self.process_item, self.current_state, msg, "success")
 
-                    self._set_state(self.STATE_BUYING_ON_CHAIN)
-                    return
-                else:
-                    time.sleep(1)
-                    waiting_times = waiting_times - 1
+                self._set_state(self.STATE_BUYING_ON_CHAIN)
+            else:
+                msg = 'mexc现货卖出流程失败, 重试次数大于5'
+                logger.info(msg)
+                add_state_flow_entry(self.process_item, self.current_state, msg, "fail")
 
-            last_order_formated = pformat(last_order, indent=2)
-            msg = f"交易所现货卖出订单失敗, 最後狀態：\n{last_order_formated}。"
-            logger.info(msg)
-            add_state_flow_entry(self.process_item, self.current_state, msg, "fail")
-            self._set_state(self.STATE_FAILED)
+                self._set_state(self.STATE_WAITING_EXCHANGE_ROLLBACK)
         except Exception as e:
             exc_traceback = traceback.format_exc()
-            msg = f"查询交易所现货卖出订单状态时发生错误\n{exc_traceback}"
+            msg = f"交易所现货卖出下单失败\n{exc_traceback}"
             logger.error(msg)
 
             add_state_flow_entry(self.process_item, self.current_state, msg, "fail")
@@ -564,8 +544,6 @@ class ArbitrageProcess:
                                 logger.info(msg)
                                 add_state_flow_entry(self.process_item, self.current_state, msg, "success")
 
-                                self.exchange_withdrawal_amount = self.exchange_withdrawal_amount + money
-
                                 break
                             else:
                                 time.sleep(1)
@@ -635,7 +613,7 @@ class ArbitrageProcess:
         add_state_flow_entry(self.process_item, self.current_state, msg, "pending")
         try:
             # 使用预提现数量进行回滚
-            pseudo_amount_to_buy = Decimal(self.exchange_withdrawal_amount)
+            pseudo_amount_to_buy = Decimal(self.sell_value)
             # 处理精度
             pseudo_amount_to_buy = pseudo_amount_to_buy.quantize(self.base_coin_asset_precision, rounding=ROUND_DOWN)
 

s_mexc_to_erc20.py

@@ -344,7 +344,7 @@ class ArbitrageProcess:
                     "symbol": self.symbol.replace('_', ''),
                     "side": "BUY",
                     "type": "MARKET",
-                    "quantity": int(pseudo_amount_to_buy),          # 以【幣】的數量進行買入
+                    "quantity": float(pseudo_amount_to_buy),          # 以【幣】的數量進行買入
                 }
                 order_params_formated = pformat(order_params, indent=2)
                 
@@ -358,18 +358,15 @@ class ArbitrageProcess:
 
                     continue
 
-                exchange_buy_order_id = exchange_buy_order['orderId']
-
                 # 查询交易所订单状态
+                exchange_buy_order_id = exchange_buy_order['orderId']
                 waiting_times = 5
-                last_order = None
                 while waiting_times > 0:
                     params = {
                         "symbol": self.symbol.replace('_', ''),
                         "orderId": exchange_buy_order_id
                     }
                     order = mexc.trade.get_order(params)
-                    last_order = order
 
                     if order['status'] in ["FILLED", "PARTIALLY_CANCELED"]:
                         # 以实际成交数量为准
@@ -391,7 +388,7 @@ class ArbitrageProcess:
                         time.sleep(1)
                         waiting_times = waiting_times - 1
             
-            if order_times < 5:
+            if order_times <= 5:
                 msg = 'mexc现货买入流程完成'
                 logger.info(msg)
                 add_state_flow_entry(self.process_item, self.current_state, msg, "success")
@@ -614,7 +611,7 @@ class ArbitrageProcess:
                 "side": "SELL",
                 "price": self.buy_price,
                 "type": "LIMIT",
-                "quantity": int(pseudo_amount_to_sell),
+                "quantity": float(pseudo_amount_to_sell),
             }
             order_params_formated = pformat(order_params, indent=2)
             exchange_sell_order = mexc.trade.post_order(order_params)
@@ -791,14 +788,15 @@ class ArbitrageProcess:
     
     def _execute_transfer_to_chain(self):
         """
-        将交易后获得的计价资产(例如USDT)转账回链上
+        将交易后获得的币(例如RATO)转账回链上
         """
         msg = "执行：交易所计价资产转账回链上..."
         logger.info(msg)
         add_state_flow_entry(self.process_item, self.current_state, msg, "pending")
 
         try:
-            pseudo_withdrawal_amount = str(int(float(self.exchange_buy_amount)))
+            self.exchange_buy_amount = self.exchange_buy_amount.quantize(self.coin_asset_precision, rounding=ROUND_DOWN)
+            pseudo_withdrawal_amount = str(self.exchange_buy_amount)
 
             withdrawal_params = {
                 'coin': self.coin,

toto.readme

@@ -66,9 +66,13 @@
 [-] 交易所价格、数量精度
 [-] 交易回滚改为限价单，如果回滚的限价单一直不成交，会把订单留在观测列表，方便即时处理
 
+2025-07-21
+[-] 先不用超价单，而是连续市价单，直到仓位吃满为止
+
 其它todo
+[ ] 简易套利，双方向的测试
+[ ] 等待下一次余额平衡失败，然后修复
 [ ] 下单使用超价单而不是市价单（1、防止砸穿盘面控制风险；2、防止抹茶交易所撤销市价单）
-[ ] 余额额平衡失败，记得查一下
 [ ] 所有策略共用web3、web3搞成wss的，可能会稳定很多
 [ ] mexc到dec方向的approve自動
 [ ] 同时进行买卖锁定差价，不要等抹茶成交了