重构错误码：统一使用 ErrorCode 枚举

- 创建 ErrorCode 枚举类，按业务模块划分错误码范围 - 1001-1999: 参数错误 - 2001-2999: 认证/权限错误 - 3001-3999: 资源不存在 - 4001-4999: 业务逻辑错误（按模块细分） - 5001-5999: 服务器内部错误（按服务细分） - 重构 ApiResponse 支持 ErrorCode 枚举 - 重构所有 Controller 使用 ErrorCode 枚举替代硬编码错误码 - 保留旧方法（标记为 @Deprecated）以保持兼容性 - 修复未使用变量警告
2025-12-02 22:58:51 +08:00
parent 792ddb8635
commit f1c9b34488
8 changed files with 392 additions and 139 deletions
@@ -1,6 +1,7 @@
 package com.wrbug.polymarketbot.controller

 import com.wrbug.polymarketbot.dto.*
+import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.AccountService
 import kotlinx.coroutines.runBlocking
 import org.slf4j.LoggerFactory
@@ -26,10 +27,10 @@ class AccountController(
        return try {
            // 参数验证
            if (request.privateKey.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("私钥不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_PRIVATE_KEY_EMPTY))
            }
            if (request.walletAddress.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("钱包地址不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_WALLET_ADDRESS_EMPTY))
            }
            
            val result = accountService.importAccount(request)
@@ -40,14 +41,14 @@ class AccountController(
                onFailure = { e ->
                    logger.error("导入账户失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("导入账户失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_IMPORT_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("导入账户异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("导入账户失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_IMPORT_FAILED, e.message))
        }
    }
    
@@ -65,14 +66,14 @@ class AccountController(
                onFailure = { e ->
                    logger.error("更新账户失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("更新账户失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_UPDATE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("更新账户异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("更新账户失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_UPDATE_FAILED, e.message))
        }
    }
    
@@ -90,15 +91,15 @@ class AccountController(
                onFailure = { e ->
                    logger.error("删除账户失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.businessError(e.message ?: "业务逻辑错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("删除账户失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.BUSINESS_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_DELETE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("删除账户异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("删除账户失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_DELETE_FAILED, e.message))
        }
    }
    
@@ -115,12 +116,12 @@ class AccountController(
                },
                onFailure = { e ->
                    logger.error("查询账户列表失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.serverError("查询账户列表失败: ${e.message}"))
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_LIST_FETCH_FAILED, e.message))
                }
            )
        } catch (e: Exception) {
            logger.error("查询账户列表异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询账户列表失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_LIST_FETCH_FAILED, e.message))
        }
    }
    
@@ -138,14 +139,14 @@ class AccountController(
                onFailure = { e ->
                    logger.error("查询账户详情失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("查询账户详情失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_DETAIL_FETCH_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("查询账户详情异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询账户详情失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_DETAIL_FETCH_FAILED, e.message))
        }
    }
    
@@ -163,14 +164,14 @@ class AccountController(
                onFailure = { e ->
                    logger.error("查询账户余额失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("查询账户余额失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_BALANCE_FETCH_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("查询账户余额异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询账户余额失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_BALANCE_FETCH_FAILED, e.message))
        }
    }
    
@@ -188,14 +189,14 @@ class AccountController(
                onFailure = { e ->
                    logger.error("设置默认账户失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("设置默认账户失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_DEFAULT_SET_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("设置默认账户异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("设置默认账户失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_DEFAULT_SET_FAILED, e.message))
        }
    }
    
@@ -208,17 +209,16 @@ class AccountController(
            val result = runBlocking { accountService.getAllPositions() }
            result.fold(
                onSuccess = { positionListResponse ->
-                    val total = positionListResponse.currentPositions.size + positionListResponse.historyPositions.size
                    ResponseEntity.ok(ApiResponse.success(positionListResponse))
                },
                onFailure = { e ->
                    logger.error("查询仓位列表失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.serverError("查询仓位列表失败: ${e.message}"))
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_POSITIONS_FETCH_FAILED, e.message))
                }
            )
        } catch (e: Exception) {
            logger.error("查询仓位列表异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询仓位列表失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_POSITIONS_FETCH_FAILED, e.message))
        }
    }
    
@@ -230,23 +230,23 @@ class AccountController(
        return try {
            // 参数验证
            if (request.accountId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("账户ID无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ACCOUNT_ID_INVALID))
            }
            if (request.marketId.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("市场ID不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_MARKET_ID_EMPTY))
            }
            // side 可以是任意结果名称（如 "YES", "NO", "Pakistan" 等），不再限制为 YES/NO
            if (request.side.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("方向不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_SIDE_EMPTY))
            }
            if (request.orderType !in listOf("MARKET", "LIMIT")) {
-                return ResponseEntity.ok(ApiResponse.paramError("订单类型必须是MARKET或LIMIT"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ORDER_TYPE_MUST_BE_MARKET_OR_LIMIT))
            }
            if (request.quantity.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("卖出数量不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_QUANTITY_EMPTY))
            }
            if (request.orderType == "LIMIT" && (request.price == null || request.price.isBlank())) {
-                return ResponseEntity.ok(ApiResponse.paramError("限价订单必须提供价格"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_PRICE_EMPTY))
            }
            
            val result = runBlocking { accountService.sellPosition(request) }
@@ -257,15 +257,15 @@ class AccountController(
                onFailure = { e ->
                    logger.error("创建卖出订单失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.businessError(e.message ?: "业务逻辑错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("创建卖出订单失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.BUSINESS_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_ORDER_CREATE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("创建卖出订单异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("创建卖出订单失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_ORDER_CREATE_FAILED, e.message))
        }
    }
    
@@ -283,14 +283,14 @@ class AccountController(
                onFailure = { e ->
                    logger.error("获取可赎回仓位统计失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("获取可赎回仓位统计失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, "获取可赎回仓位统计失败: ${e.message}"))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("获取可赎回仓位统计异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("获取可赎回仓位统计失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, "获取可赎回仓位统计失败: ${e.message}"))
        }
    }
    
@@ -302,19 +302,19 @@ class AccountController(
        return try {
            // 参数验证
            if (request.positions.isEmpty()) {
-                return ResponseEntity.ok(ApiResponse.paramError("赎回仓位列表不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_REDEEM_POSITIONS_EMPTY))
            }
            
            // 验证每个仓位项
            for (item in request.positions) {
                if (item.accountId <= 0) {
-                    return ResponseEntity.ok(ApiResponse.paramError("账户ID无效"))
+                    return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ACCOUNT_ID_INVALID))
                }
                if (item.marketId.isBlank()) {
-                    return ResponseEntity.ok(ApiResponse.paramError("市场ID不能为空"))
+                    return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_MARKET_ID_EMPTY))
                }
                if (item.outcomeIndex < 0) {
-                    return ResponseEntity.ok(ApiResponse.paramError("结果索引无效"))
+                    return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_INDEX_SETS_INVALID))
                }
            }
            
@@ -326,15 +326,15 @@ class AccountController(
                onFailure = { e ->
                    logger.error("赎回仓位失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.businessError(e.message ?: "业务逻辑错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("赎回仓位失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.BUSINESS_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_REDEEM_POSITIONS_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("赎回仓位异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("赎回仓位失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ACCOUNT_REDEEM_POSITIONS_FAILED, e.message))
        }
    }
    
@@ -1,6 +1,7 @@
 package com.wrbug.polymarketbot.controller

 import com.wrbug.polymarketbot.dto.*
+import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.CopyTradingService
 import org.slf4j.LoggerFactory
 import org.springframework.http.ResponseEntity
@@ -24,13 +25,13 @@ class CopyTradingController(
    fun createCopyTrading(@RequestBody request: CopyTradingCreateRequest): ResponseEntity<ApiResponse<CopyTradingDto>> {
        return try {
            if (request.accountId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("账户 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ACCOUNT_ID_INVALID))
            }
            if (request.templateId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_TEMPLATE_ID_INVALID))
            }
            if (request.leaderId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("Leader ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_LEADER_ID_INVALID))
            }
            
            val result = copyTradingService.createCopyTrading(request)
@@ -41,14 +42,14 @@ class CopyTradingController(
                onFailure = { e ->
                    logger.error("创建跟单失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("创建跟单失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_CREATE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("创建跟单异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("创建跟单失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_CREATE_FAILED, e.message))
        }
    }
    
@@ -65,12 +66,12 @@ class CopyTradingController(
                },
                onFailure = { e ->
                    logger.error("查询跟单列表失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.serverError("查询跟单列表失败: ${e.message}"))
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_LIST_FETCH_FAILED, e.message))
                }
            )
        } catch (e: Exception) {
            logger.error("查询跟单列表异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询跟单列表失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_LIST_FETCH_FAILED, e.message))
        }
    }
    
@@ -81,7 +82,7 @@ class CopyTradingController(
    fun updateCopyTradingStatus(@RequestBody request: CopyTradingUpdateStatusRequest): ResponseEntity<ApiResponse<CopyTradingDto>> {
        return try {
            if (request.copyTradingId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("跟单 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_COPY_TRADING_ID_INVALID))
            }
            
            val result = copyTradingService.updateCopyTradingStatus(request)
@@ -92,15 +93,15 @@ class CopyTradingController(
                onFailure = { e ->
                    logger.error("更新跟单状态失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.businessError(e.message ?: "业务逻辑错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("更新跟单状态失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.BUSINESS_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_UPDATE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("更新跟单状态异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("更新跟单状态失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_UPDATE_FAILED, e.message))
        }
    }
    
@@ -111,7 +112,7 @@ class CopyTradingController(
    fun deleteCopyTrading(@RequestBody request: CopyTradingDeleteRequest): ResponseEntity<ApiResponse<Unit>> {
        return try {
            if (request.copyTradingId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("跟单 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_COPY_TRADING_ID_INVALID))
            }
            
            val result = copyTradingService.deleteCopyTrading(request.copyTradingId)
@@ -122,14 +123,14 @@ class CopyTradingController(
                onFailure = { e ->
                    logger.error("删除跟单失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("删除跟单失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_DELETE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("删除跟单异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("删除跟单失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_DELETE_FAILED, e.message))
        }
    }
    
@@ -140,7 +141,7 @@ class CopyTradingController(
    fun getAccountTemplates(@RequestBody request: AccountTemplatesRequest): ResponseEntity<ApiResponse<AccountTemplatesResponse>> {
        return try {
            if (request.accountId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("账户 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ACCOUNT_ID_INVALID))
            }
            
            val result = copyTradingService.getAccountTemplates(request.accountId)
@@ -151,14 +152,14 @@ class CopyTradingController(
                onFailure = { e ->
                    logger.error("查询钱包绑定的模板失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("查询钱包绑定的模板失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_TEMPLATES_FETCH_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("查询钱包绑定的模板异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询钱包绑定的模板失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_COPY_TRADING_TEMPLATES_FETCH_FAILED, e.message))
        }
    }
 }
@@ -1,6 +1,7 @@
 package com.wrbug.polymarketbot.controller

 import com.wrbug.polymarketbot.dto.*
+import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.CopyTradingStatisticsService
 import kotlinx.coroutines.runBlocking
 import org.slf4j.LoggerFactory
@@ -27,7 +28,7 @@ class CopyTradingStatisticsController(
    fun getStatisticsDetail(@RequestBody request: StatisticsDetailRequest): ResponseEntity<ApiResponse<CopyTradingStatisticsResponse>> {
        return try {
            if (request.copyTradingId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("跟单关系ID无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_COPY_TRADING_ID_INVALID))
            }
            
            val result = runBlocking { statisticsService.getStatistics(request.copyTradingId) }
@@ -38,14 +39,14 @@ class CopyTradingStatisticsController(
                onFailure = { e ->
                    logger.error("获取统计信息失败: copyTradingId=${request.copyTradingId}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("获取统计信息失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_STATISTICS_FETCH_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("获取统计信息异常: copyTradingId=${request.copyTradingId}", e)
-            ResponseEntity.ok(ApiResponse.serverError("获取统计信息失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_STATISTICS_FETCH_FAILED, e.message))
        }
    }
 }
@@ -70,16 +71,16 @@ class CopyOrderTrackingController(
    fun getOrderList(@RequestBody request: OrderTrackingRequest): ResponseEntity<ApiResponse<OrderListResponse>> {
        return try {
            if (request.copyTradingId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("跟单关系ID无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_COPY_TRADING_ID_INVALID))
            }
            
            if (request.type.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("订单类型不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_EMPTY, "订单类型不能为空"))
            }
            
            val validTypes = listOf("buy", "sell", "matched")
            if (!validTypes.contains(request.type.lowercase())) {
-                return ResponseEntity.ok(ApiResponse.paramError("订单类型无效，必须是: buy, sell, matched"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ORDER_TYPE_INVALID_FOR_TRACKING))
            }
            
            val result = statisticsService.getOrderList(request)
@@ -90,14 +91,14 @@ class CopyOrderTrackingController(
                onFailure = { e ->
                    logger.error("查询订单列表失败: copyTradingId=${request.copyTradingId}, type=${request.type}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("查询订单列表失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ORDER_TRACKING_LIST_FETCH_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("查询订单列表异常: copyTradingId=${request.copyTradingId}, type=${request.type}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询订单列表失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ORDER_TRACKING_LIST_FETCH_FAILED, e.message))
        }
    }
 }
@@ -1,6 +1,7 @@
 package com.wrbug.polymarketbot.controller

 import com.wrbug.polymarketbot.dto.*
+import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.CopyTradingTemplateService
 import org.slf4j.LoggerFactory
 import org.springframework.http.ResponseEntity
@@ -24,7 +25,7 @@ class CopyTradingTemplateController(
    fun createTemplate(@RequestBody request: TemplateCreateRequest): ResponseEntity<ApiResponse<TemplateDto>> {
        return try {
            if (request.templateName.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板名称不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_TEMPLATE_NAME_EMPTY))
            }
            
            val result = templateService.createTemplate(request)
@@ -35,14 +36,14 @@ class CopyTradingTemplateController(
                onFailure = { e ->
                    logger.error("创建模板失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("创建模板失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_CREATE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("创建模板异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("创建模板失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_CREATE_FAILED, e.message))
        }
    }
    
@@ -53,7 +54,7 @@ class CopyTradingTemplateController(
    fun updateTemplate(@RequestBody request: TemplateUpdateRequest): ResponseEntity<ApiResponse<TemplateDto>> {
        return try {
            if (request.templateId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_TEMPLATE_ID_INVALID))
            }
            
            val result = templateService.updateTemplate(request)
@@ -64,14 +65,14 @@ class CopyTradingTemplateController(
                onFailure = { e ->
                    logger.error("更新模板失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("更新模板失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_UPDATE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("更新模板异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("更新模板失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_UPDATE_FAILED, e.message))
        }
    }
    
@@ -82,7 +83,7 @@ class CopyTradingTemplateController(
    fun deleteTemplate(@RequestBody request: TemplateDeleteRequest): ResponseEntity<ApiResponse<Unit>> {
        return try {
            if (request.templateId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_TEMPLATE_ID_INVALID))
            }
            
            val result = templateService.deleteTemplate(request.templateId)
@@ -93,15 +94,15 @@ class CopyTradingTemplateController(
                onFailure = { e ->
                    logger.error("删除模板失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.businessError(e.message ?: "业务逻辑错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("删除模板失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.BUSINESS_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_DELETE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("删除模板异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("删除模板失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_DELETE_FAILED, e.message))
        }
    }
    
@@ -112,10 +113,10 @@ class CopyTradingTemplateController(
    fun copyTemplate(@RequestBody request: TemplateCopyRequest): ResponseEntity<ApiResponse<TemplateDto>> {
        return try {
            if (request.templateId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_TEMPLATE_ID_INVALID))
            }
            if (request.templateName.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("新模板名称不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_TEMPLATE_NAME_EMPTY))
            }
            
            val result = templateService.copyTemplate(request)
@@ -126,14 +127,14 @@ class CopyTradingTemplateController(
                onFailure = { e ->
                    logger.error("复制模板失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("复制模板失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_COPY_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("复制模板异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("复制模板失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_COPY_FAILED, e.message))
        }
    }
    
@@ -150,12 +151,12 @@ class CopyTradingTemplateController(
                },
                onFailure = { e ->
                    logger.error("查询模板列表失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.serverError("查询模板列表失败: ${e.message}"))
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_LIST_FETCH_FAILED, e.message))
                }
            )
        } catch (e: Exception) {
            logger.error("查询模板列表异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询模板列表失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_LIST_FETCH_FAILED, e.message))
        }
    }
    
@@ -166,7 +167,7 @@ class CopyTradingTemplateController(
    fun getTemplateDetail(@RequestBody request: TemplateDetailRequest): ResponseEntity<ApiResponse<TemplateDto>> {
        return try {
            if (request.templateId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("模板 ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_TEMPLATE_ID_INVALID))
            }
            
            val result = templateService.getTemplateDetail(request.templateId)
@@ -177,14 +178,14 @@ class CopyTradingTemplateController(
                onFailure = { e ->
                    logger.error("查询模板详情失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("查询模板详情失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_DETAIL_FETCH_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("查询模板详情异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询模板详情失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_TEMPLATE_DETAIL_FETCH_FAILED, e.message))
        }
    }
 }
@@ -1,6 +1,7 @@
 package com.wrbug.polymarketbot.controller

 import com.wrbug.polymarketbot.dto.*
+import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.LeaderService
 import org.slf4j.LoggerFactory
 import org.springframework.http.ResponseEntity
@@ -24,7 +25,7 @@ class LeaderController(
    fun addLeader(@RequestBody request: LeaderAddRequest): ResponseEntity<ApiResponse<LeaderDto>> {
        return try {
            if (request.leaderAddress.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("Leader 地址不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_LEADER_ADDRESS_EMPTY))
            }
            
            val result = leaderService.addLeader(request)
@@ -35,15 +36,15 @@ class LeaderController(
                onFailure = { e ->
                    logger.error("添加 Leader 失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.businessError(e.message ?: "业务逻辑错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("添加 Leader 失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.BUSINESS_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_ADD_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("添加 Leader 异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("添加 Leader 失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_ADD_FAILED, e.message))
        }
    }
    
@@ -54,7 +55,7 @@ class LeaderController(
    fun updateLeader(@RequestBody request: LeaderUpdateRequest): ResponseEntity<ApiResponse<LeaderDto>> {
        return try {
            if (request.leaderId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("Leader ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_LEADER_ID_INVALID))
            }
            
            val result = leaderService.updateLeader(request)
@@ -65,14 +66,14 @@ class LeaderController(
                onFailure = { e ->
                    logger.error("更新 Leader 失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("更新 Leader 失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_UPDATE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("更新 Leader 异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("更新 Leader 失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_UPDATE_FAILED, e.message))
        }
    }
    
@@ -83,7 +84,7 @@ class LeaderController(
    fun deleteLeader(@RequestBody request: LeaderDeleteRequest): ResponseEntity<ApiResponse<Unit>> {
        return try {
            if (request.leaderId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("Leader ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_LEADER_ID_INVALID))
            }
            
            val result = leaderService.deleteLeader(request.leaderId)
@@ -94,15 +95,15 @@ class LeaderController(
                onFailure = { e ->
                    logger.error("删除 Leader 失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.businessError(e.message ?: "业务逻辑错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("删除 Leader 失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        is IllegalStateException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.BUSINESS_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_DELETE_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("删除 Leader 异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("删除 Leader 失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_DELETE_FAILED, e.message))
        }
    }
    
@@ -119,12 +120,12 @@ class LeaderController(
                },
                onFailure = { e ->
                    logger.error("查询 Leader 列表失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.serverError("查询 Leader 列表失败: ${e.message}"))
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_LIST_FETCH_FAILED, e.message))
                }
            )
        } catch (e: Exception) {
            logger.error("查询 Leader 列表异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询 Leader 列表失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_LIST_FETCH_FAILED, e.message))
        }
    }
    
@@ -135,7 +136,7 @@ class LeaderController(
    fun getLeaderDetail(@RequestBody request: LeaderDetailRequest): ResponseEntity<ApiResponse<LeaderDto>> {
        return try {
            if (request.leaderId <= 0) {
-                return ResponseEntity.ok(ApiResponse.paramError("Leader ID 无效"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_LEADER_ID_INVALID))
            }
            
            val result = leaderService.getLeaderDetail(request.leaderId)
@@ -146,14 +147,14 @@ class LeaderController(
                onFailure = { e ->
                    logger.error("查询 Leader 详情失败: ${e.message}", e)
                    when (e) {
-                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.paramError(e.message ?: "参数错误"))
-                        else -> ResponseEntity.ok(ApiResponse.serverError("查询 Leader 详情失败: ${e.message}"))
+                        is IllegalArgumentException -> ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ERROR, e.message))
+                        else -> ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_DETAIL_FETCH_FAILED, e.message))
                    }
                }
            )
        } catch (e: Exception) {
            logger.error("查询 Leader 详情异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("查询 Leader 详情失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_LEADER_DETAIL_FETCH_FAILED, e.message))
        }
    }
 }
@@ -2,6 +2,7 @@ package com.wrbug.polymarketbot.controller

 import com.wrbug.polymarketbot.api.LatestPriceResponse
 import com.wrbug.polymarketbot.dto.*
+import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.AccountService
 import com.wrbug.polymarketbot.service.PolymarketClobService
 import kotlinx.coroutines.runBlocking
@@ -30,7 +31,7 @@ class MarketController(
    fun getMarketPrice(@RequestBody request: MarketPriceRequest): ResponseEntity<ApiResponse<MarketPriceResponse>> {
        return try {
            if (request.marketId.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("市场ID不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_MARKET_ID_EMPTY))
            }
            
            val result = runBlocking { accountService.getMarketPrice(request.marketId) }
@@ -40,12 +41,12 @@ class MarketController(
                },
                onFailure = { e ->
                    logger.error("获取市场价格失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.serverError("获取市场价格失败: ${e.message}"))
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_MARKET_PRICE_FETCH_FAILED, e.message))
                }
            )
        } catch (e: Exception) {
            logger.error("获取市场价格异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("获取市场价格失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_MARKET_PRICE_FETCH_FAILED, e.message))
        }
    }
    
@@ -58,7 +59,7 @@ class MarketController(
    fun getLatestPrice(@RequestBody request: LatestPriceRequest): ResponseEntity<ApiResponse<LatestPriceResponse>> {
        return try {
            if (request.tokenId.isBlank()) {
-                return ResponseEntity.ok(ApiResponse.paramError("tokenId 不能为空"))
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_TOKEN_ID_EMPTY))
            }
            
            val result = runBlocking { clobService.getLatestPrice(request.tokenId) }
@@ -68,12 +69,12 @@ class MarketController(
                },
                onFailure = { e ->
                    logger.error("获取最新价失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.serverError("获取最新价失败: ${e.message}"))
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_MARKET_LATEST_PRICE_FETCH_FAILED, e.message))
                }
            )
        } catch (e: Exception) {
            logger.error("获取最新价异常: ${e.message}", e)
-            ResponseEntity.ok(ApiResponse.serverError("获取最新价失败: ${e.message}"))
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_MARKET_LATEST_PRICE_FETCH_FAILED, e.message))
        }
    }
 }
@@ -1,5 +1,7 @@
 package com.wrbug.polymarketbot.dto

+import com.wrbug.polymarketbot.enums.ErrorCode
+
 /**
 * 统一API响应格式
 * @param code 响应码，0表示成功，非0表示失败
@@ -20,45 +22,61 @@ data class ApiResponse<T>(
        }
        
        /**
-         * 创建失败响应
+         * 创建失败响应（使用 ErrorCode 枚举）
+         */
+        fun <T> error(errorCode: ErrorCode, customMsg: String? = null): ApiResponse<T> {
+            return ApiResponse(
+                code = errorCode.code,
+                data = null,
+                msg = customMsg ?: errorCode.message
+            )
+        }
+        
+        /**
+         * 创建失败响应（使用错误码和自定义消息）
         */
        fun <T> error(code: Int, msg: String): ApiResponse<T> {
            return ApiResponse(code = code, data = null, msg = msg)
        }
        
        /**
-         * 创建参数错误响应
+         * 创建参数错误响应（兼容旧代码，建议使用 error(ErrorCode)）
         */
+        @Deprecated("使用 error(ErrorCode.PARAM_ERROR, msg) 替代", ReplaceWith("error(ErrorCode.PARAM_ERROR, msg)"))
        fun <T> paramError(msg: String): ApiResponse<T> {
-            return ApiResponse(code = 1001, data = null, msg = msg)
+            return error(ErrorCode.PARAM_ERROR, msg)
        }
        
        /**
-         * 创建认证错误响应
+         * 创建认证错误响应（兼容旧代码，建议使用 error(ErrorCode)）
         */
+        @Deprecated("使用 error(ErrorCode.AUTH_ERROR, msg) 替代", ReplaceWith("error(ErrorCode.AUTH_ERROR, msg)"))
        fun <T> authError(msg: String): ApiResponse<T> {
-            return ApiResponse(code = 2001, data = null, msg = msg)
+            return error(ErrorCode.AUTH_ERROR, msg)
        }
        
        /**
-         * 创建资源不存在响应
+         * 创建资源不存在响应（兼容旧代码，建议使用 error(ErrorCode)）
         */
+        @Deprecated("使用 error(ErrorCode.NOT_FOUND, msg) 替代", ReplaceWith("error(ErrorCode.NOT_FOUND, msg)"))
        fun <T> notFound(msg: String): ApiResponse<T> {
-            return ApiResponse(code = 3001, data = null, msg = msg)
+            return error(ErrorCode.NOT_FOUND, msg)
        }
        
        /**
-         * 创建业务逻辑错误响应
+         * 创建业务逻辑错误响应（兼容旧代码，建议使用 error(ErrorCode)）
         */
+        @Deprecated("使用 error(ErrorCode.BUSINESS_ERROR, msg) 替代", ReplaceWith("error(ErrorCode.BUSINESS_ERROR, msg)"))
        fun <T> businessError(msg: String): ApiResponse<T> {
-            return ApiResponse(code = 4001, data = null, msg = msg)
+            return error(ErrorCode.BUSINESS_ERROR, msg)
        }
        
        /**
-         * 创建服务器内部错误响应
+         * 创建服务器内部错误响应（兼容旧代码，建议使用 error(ErrorCode)）
         */
+        @Deprecated("使用 error(ErrorCode.SERVER_ERROR, msg) 替代", ReplaceWith("error(ErrorCode.SERVER_ERROR, msg)"))
        fun <T> serverError(msg: String): ApiResponse<T> {
-            return ApiResponse(code = 5001, data = null, msg = msg)
+            return error(ErrorCode.SERVER_ERROR, msg)
        }
    }
 }
@@ -0,0 +1,230 @@
+package com.wrbug.polymarketbot.enums
+
+/**
+ * 错误码枚举
+ * 按业务模块划分错误码范围
+ * 
+ * 错误码范围划分：
+ * - 1001-1999: 参数错误 (Param Error)
+ * - 2001-2999: 认证/权限错误 (Auth Error)
+ * - 3001-3999: 资源不存在 (Not Found)
+ * - 4001-4999: 业务逻辑错误 (Business Error)
+ *   - 4001-4099: Leader 管理
+ *   - 4101-4199: 模板管理
+ *   - 4201-4299: 跟单管理
+ *   - 4301-4399: 订单相关
+ *   - 4401-4499: 市场相关
+ *   - 4501-4599: 仓位相关
+ * - 5001-5999: 服务器内部错误 (Server Error)
+ */
+enum class ErrorCode(
+    val code: Int,
+    val message: String
+) {
+    // ==================== 参数错误 (1001-1999) ====================
+    PARAM_ERROR(1001, "参数错误"),
+    PARAM_EMPTY(1002, "参数不能为空"),
+    PARAM_INVALID(1003, "参数无效"),
+    
+    // 账户相关参数错误
+    PARAM_PRIVATE_KEY_EMPTY(1101, "私钥不能为空"),
+    PARAM_WALLET_ADDRESS_EMPTY(1102, "钱包地址不能为空"),
+    PARAM_WALLET_ADDRESS_INVALID(1103, "钱包地址格式无效"),
+    PARAM_ACCOUNT_ID_INVALID(1104, "账户ID无效"),
+    PARAM_ACCOUNT_NAME_EMPTY(1105, "账户名称不能为空"),
+    
+    // Leader 相关参数错误
+    PARAM_LEADER_ADDRESS_EMPTY(1201, "Leader 地址不能为空"),
+    PARAM_LEADER_ADDRESS_INVALID(1202, "Leader 地址格式无效"),
+    PARAM_LEADER_ID_INVALID(1203, "Leader ID 无效"),
+    PARAM_LEADER_NAME_EMPTY(1204, "Leader 名称不能为空"),
+    PARAM_CATEGORY_INVALID(1205, "分类无效，只支持 sports 或 crypto"),
+    
+    // 模板相关参数错误
+    PARAM_TEMPLATE_NAME_EMPTY(1301, "模板名称不能为空"),
+    PARAM_TEMPLATE_ID_INVALID(1302, "模板 ID 无效"),
+    PARAM_COPY_MODE_INVALID(1303, "copyMode 必须是 RATIO 或 FIXED"),
+    PARAM_COPY_RATIO_INVALID(1304, "跟单比例无效"),
+    PARAM_FIXED_AMOUNT_INVALID(1305, "固定金额无效"),
+    
+    // 跟单相关参数错误
+    PARAM_COPY_TRADING_ID_INVALID(1401, "跟单关系ID无效"),
+    PARAM_ORDER_TYPE_INVALID(1402, "订单类型无效"),
+    PARAM_ORDER_TYPE_MUST_BE_MARKET_OR_LIMIT(1403, "订单类型必须是MARKET或LIMIT"),
+    PARAM_QUANTITY_EMPTY(1404, "数量不能为空"),
+    PARAM_PRICE_EMPTY(1405, "限价订单必须提供价格"),
+    PARAM_SIDE_EMPTY(1406, "方向不能为空"),
+    PARAM_MARKET_ID_EMPTY(1407, "市场ID不能为空"),
+    PARAM_ORDER_TYPE_EMPTY(1408, "订单类型不能为空"),
+    
+    // 市场相关参数错误
+    PARAM_TOKEN_ID_EMPTY(1501, "tokenId 不能为空"),
+    PARAM_CONDITION_ID_EMPTY(1502, "conditionId 不能为空"),
+    PARAM_REDEEM_POSITIONS_EMPTY(1503, "赎回仓位列表不能为空"),
+    PARAM_INDEX_SETS_INVALID(1504, "结果索引无效"),
+    
+    // 统计相关参数错误
+    PARAM_ORDER_TYPE_INVALID_FOR_TRACKING(1601, "订单类型无效，必须是: buy, sell, matched"),
+    
+    // ==================== 认证/权限错误 (2001-2999) ====================
+    AUTH_ERROR(2001, "认证失败"),
+    AUTH_TOKEN_INVALID(2002, "认证令牌无效"),
+    AUTH_TOKEN_EXPIRED(2003, "认证令牌已过期"),
+    AUTH_PERMISSION_DENIED(2004, "权限不足"),
+    AUTH_API_KEY_INVALID(2005, "API Key 无效"),
+    AUTH_API_SECRET_INVALID(2006, "API Secret 无效"),
+    AUTH_API_PASSPHRASE_INVALID(2007, "API Passphrase 无效"),
+    AUTH_API_CREDENTIALS_MISSING(2008, "API 凭证未配置"),
+    
+    // ==================== 资源不存在 (3001-3999) ====================
+    NOT_FOUND(3001, "资源不存在"),
+    ACCOUNT_NOT_FOUND(3002, "账户不存在"),
+    LEADER_NOT_FOUND(3003, "Leader 不存在"),
+    TEMPLATE_NOT_FOUND(3004, "模板不存在"),
+    COPY_TRADING_NOT_FOUND(3005, "跟单关系不存在"),
+    MARKET_NOT_FOUND(3006, "市场不存在"),
+    ORDER_NOT_FOUND(3007, "订单不存在"),
+    POSITION_NOT_FOUND(3008, "仓位不存在"),
+    
+    // ==================== 业务逻辑错误 (4001-4999) ====================
+    BUSINESS_ERROR(4001, "业务逻辑错误"),
+    
+    // Leader 管理 (4001-4099)
+    LEADER_ALREADY_EXISTS(4001, "该 Leader 地址已存在"),
+    LEADER_ADDRESS_SAME_AS_ACCOUNT(4002, "Leader 地址不能与自己的账户地址相同"),
+    LEADER_HAS_COPY_TRADINGS(4003, "该 Leader 还有跟单关系，请先删除跟单关系"),
+    
+    // 模板管理 (4101-4199)
+    TEMPLATE_NAME_ALREADY_EXISTS(4101, "模板名称已存在"),
+    TEMPLATE_HAS_COPY_TRADINGS(4102, "该模板还有跟单关系在使用，请先删除跟单关系"),
+    
+    // 跟单管理 (4201-4299)
+    COPY_TRADING_ALREADY_EXISTS(4201, "该跟单关系已存在"),
+    COPY_TRADING_DISABLED(4202, "跟单关系已禁用"),
+    COPY_TRADING_ENABLED(4203, "跟单关系已启用"),
+    NO_ENABLED_COPY_TRADINGS(4204, "没有启用的跟单关系"),
+    
+    // 订单相关 (4301-4399)
+    ORDER_CREATE_FAILED(4301, "创建订单失败"),
+    ORDER_CANCEL_FAILED(4302, "取消订单失败"),
+    ORDER_NOT_MATCHED(4303, "订单未匹配"),
+    ORDER_ALREADY_FILLED(4304, "订单已成交"),
+    ORDER_INSUFFICIENT_BALANCE(4305, "余额不足"),
+    ORDER_AMOUNT_TOO_SMALL(4306, "订单金额低于最小限制"),
+    ORDER_AMOUNT_TOO_LARGE(4307, "订单金额超过最大限制"),
+    ORDER_PRICE_INVALID(4308, "订单价格无效"),
+    ORDER_QUANTITY_INVALID(4309, "订单数量无效"),
+    
+    // 市场相关 (4401-4499)
+    MARKET_PRICE_FETCH_FAILED(4401, "获取市场价格失败"),
+    MARKET_ORDERBOOK_EMPTY(4402, "订单簿为空"),
+    MARKET_TOKEN_ID_INVALID(4403, "Token ID 无效"),
+    
+    // 仓位相关 (4501-4599)
+    POSITION_REDEEM_FAILED(4501, "赎回仓位失败"),
+    POSITION_NOT_REDEEMABLE(4502, "仓位不可赎回"),
+    POSITION_INSUFFICIENT(4503, "仓位不足"),
+    POSITION_ALREADY_REDEEMED(4504, "仓位已赎回"),
+    
+    // 账户相关业务错误 (4601-4699)
+    ACCOUNT_ALREADY_EXISTS(4601, "账户已存在"),
+    ACCOUNT_IS_DEFAULT(4602, "账户已是默认账户"),
+    ACCOUNT_HAS_ACTIVE_ORDERS(4603, "账户有活跃订单"),
+    ACCOUNT_IS_LAST_ONE(4604, "不能删除最后一个账户"),
+    ACCOUNT_API_KEY_CREATE_FAILED(4605, "自动获取 API Key 失败"),
+    ACCOUNT_PROXY_ADDRESS_FETCH_FAILED(4606, "获取代理地址失败"),
+    ACCOUNT_BALANCE_FETCH_FAILED(4607, "查询账户余额失败"),
+    ACCOUNT_POSITIONS_FETCH_FAILED(4608, "查询仓位列表失败"),
+    
+    // 统计相关 (4701-4799)
+    STATISTICS_FETCH_FAILED(4701, "获取统计信息失败"),
+    ORDER_LIST_FETCH_FAILED(4702, "查询订单列表失败"),
+    
+    // ==================== 服务器内部错误 (5001-5999) ====================
+    SERVER_ERROR(5001, "服务器内部错误"),
+    SERVER_DATABASE_ERROR(5002, "数据库错误"),
+    SERVER_NETWORK_ERROR(5003, "网络错误"),
+    SERVER_TIMEOUT(5004, "请求超时"),
+    SERVER_EXTERNAL_API_ERROR(5005, "外部API调用失败"),
+    SERVER_RPC_ERROR(5006, "RPC调用失败"),
+    SERVER_WEBSOCKET_ERROR(5007, "WebSocket连接错误"),
+    SERVER_ENCRYPTION_ERROR(5008, "加密/解密错误"),
+    SERVER_SIGNATURE_ERROR(5009, "签名错误"),
+    
+    // 账户服务错误 (5101-5199)
+    SERVER_ACCOUNT_IMPORT_FAILED(5101, "导入账户失败"),
+    SERVER_ACCOUNT_UPDATE_FAILED(5102, "更新账户失败"),
+    SERVER_ACCOUNT_DELETE_FAILED(5103, "删除账户失败"),
+    SERVER_ACCOUNT_LIST_FETCH_FAILED(5104, "查询账户列表失败"),
+    SERVER_ACCOUNT_DETAIL_FETCH_FAILED(5105, "查询账户详情失败"),
+    SERVER_ACCOUNT_BALANCE_FETCH_FAILED(5106, "查询账户余额失败"),
+    SERVER_ACCOUNT_DEFAULT_SET_FAILED(5107, "设置默认账户失败"),
+    SERVER_ACCOUNT_POSITIONS_FETCH_FAILED(5108, "查询仓位列表失败"),
+    SERVER_ACCOUNT_ORDER_CREATE_FAILED(5109, "创建卖出订单失败"),
+    SERVER_ACCOUNT_REDEEM_POSITIONS_FAILED(5110, "赎回仓位失败"),
+    
+    // Leader 服务错误 (5201-5299)
+    SERVER_LEADER_ADD_FAILED(5201, "添加 Leader 失败"),
+    SERVER_LEADER_UPDATE_FAILED(5202, "更新 Leader 失败"),
+    SERVER_LEADER_DELETE_FAILED(5203, "删除 Leader 失败"),
+    SERVER_LEADER_LIST_FETCH_FAILED(5204, "查询 Leader 列表失败"),
+    SERVER_LEADER_DETAIL_FETCH_FAILED(5205, "查询 Leader 详情失败"),
+    
+    // 模板服务错误 (5301-5399)
+    SERVER_TEMPLATE_CREATE_FAILED(5301, "创建模板失败"),
+    SERVER_TEMPLATE_UPDATE_FAILED(5302, "更新模板失败"),
+    SERVER_TEMPLATE_DELETE_FAILED(5303, "删除模板失败"),
+    SERVER_TEMPLATE_COPY_FAILED(5304, "复制模板失败"),
+    SERVER_TEMPLATE_LIST_FETCH_FAILED(5305, "查询模板列表失败"),
+    SERVER_TEMPLATE_DETAIL_FETCH_FAILED(5306, "查询模板详情失败"),
+    
+    // 跟单服务错误 (5401-5499)
+    SERVER_COPY_TRADING_CREATE_FAILED(5401, "创建跟单失败"),
+    SERVER_COPY_TRADING_UPDATE_FAILED(5402, "更新跟单失败"),
+    SERVER_COPY_TRADING_DELETE_FAILED(5403, "删除跟单失败"),
+    SERVER_COPY_TRADING_LIST_FETCH_FAILED(5404, "查询跟单列表失败"),
+    SERVER_COPY_TRADING_TEMPLATES_FETCH_FAILED(5405, "查询钱包绑定的模板失败"),
+    
+    // 市场服务错误 (5501-5599)
+    SERVER_MARKET_PRICE_FETCH_FAILED(5501, "获取市场价格失败"),
+    SERVER_MARKET_LATEST_PRICE_FETCH_FAILED(5502, "获取最新价失败"),
+    
+    // 统计服务错误 (5601-5699)
+    SERVER_STATISTICS_FETCH_FAILED(5601, "获取统计信息失败"),
+    SERVER_ORDER_TRACKING_LIST_FETCH_FAILED(5602, "查询订单列表失败"),
+    
+    // 区块链服务错误 (5701-5799)
+    SERVER_BLOCKCHAIN_RPC_ERROR(5701, "区块链RPC调用失败"),
+    SERVER_BLOCKCHAIN_PROXY_ADDRESS_FETCH_FAILED(5702, "获取代理地址失败"),
+    SERVER_BLOCKCHAIN_BALANCE_FETCH_FAILED(5703, "查询余额失败"),
+    SERVER_BLOCKCHAIN_POSITIONS_FETCH_FAILED(5704, "查询仓位失败"),
+    SERVER_BLOCKCHAIN_REDEEM_FAILED(5705, "赎回仓位交易失败"),
+    
+    // WebSocket 服务错误 (5801-5899)
+    SERVER_WEBSOCKET_CONNECTION_FAILED(5801, "WebSocket连接失败"),
+    SERVER_WEBSOCKET_MESSAGE_SEND_FAILED(5802, "WebSocket消息发送失败"),
+    SERVER_WEBSOCKET_SUBSCRIBE_FAILED(5803, "WebSocket订阅失败"),
+    
+    // 订单跟踪服务错误 (5901-5999)
+    SERVER_ORDER_TRACKING_PROCESS_FAILED(5901, "处理订单跟踪失败"),
+    SERVER_ORDER_TRACKING_BUY_FAILED(5902, "处理买入订单失败"),
+    SERVER_ORDER_TRACKING_SELL_FAILED(5903, "处理卖出订单失败"),
+    SERVER_ORDER_TRACKING_MATCH_FAILED(5904, "订单匹配失败");
+    
+    companion object {
+        /**
+         * 根据错误码查找枚举
+         */
+        fun fromCode(code: Int): ErrorCode? {
+            return values().find { it.code == code }
+        }
+        
+        /**
+         * 根据错误码获取错误消息
+         */
+        fun getMessage(code: Int): String {
+            return fromCode(code)?.message ?: "未知错误"
+        }
+    }
+}
+