diff --git a/power_leasing/src/api/machine.js b/power_leasing/src/api/machine.js
index 0ca43f8..1222745 100644
--- a/power_leasing/src/api/machine.js
+++ b/power_leasing/src/api/machine.js
@@ -81,4 +81,26 @@ export function addAsicMachine(data) {
   })
 }
 
+///添加出售机器的币种获取ASIC
+export function getSupportCoin() {
+  return request({
+    url: `/lease/v2/product/machine/getSupportCoin`,
+    method: 'get',    
+  })
+}
+
+///添加出售机器的对应币种的算法获取ASIC
+/**
+ * 根据币种获取支持的算法列表
+ * @param {string} coin - 币种名称，例如 'BTC', 'ETH' 等
+ * @returns {Promise} 返回算法列表
+ */
+export function getSupportAlgo(coin) {
+  return request({
+    url: `/lease/v2/product/machine/getSupportAlgo`,
+    method: 'get',
+    params: { coin } // 使用 params，request 拦截器会自动将参数拼接到 URL 查询字符串中
+  })
+}
+
 
diff --git a/power_leasing/src/api/order.js b/power_leasing/src/api/order.js
index 8c64a99..771dae4 100644
--- a/power_leasing/src/api/order.js
+++ b/power_leasing/src/api/order.js
@@ -98,3 +98,15 @@ export function addOrdersV2(data) {
 
 
 
+
+//已购矿机配置
+export function getPurchasedItems(data) {
+  return request({
+    url: `/lease/v2/order/info/getPurchasedItems`,
+    method: 'post',
+    data
+  })
+}
+
+
+
diff --git a/power_leasing/src/components/header.vue b/power_leasing/src/components/header.vue
index a37ec67..d38ee10 100644
--- a/power_leasing/src/components/header.vue
+++ b/power_leasing/src/components/header.vue
@@ -34,7 +34,7 @@
 <script>
 import { readCart } from '../utils/cartManager'
 import { mainNavigation, getBreadcrumb } from '../utils/navigation'
-import { getGoodsList } from '../api/shoppingCart'
+import { getGoodsListV2 } from '../api/shoppingCart'
 
 export default {
   name: 'Header',
@@ -74,47 +74,37 @@ export default {
     loadCart() {
       this.cart = readCart()
     },
+    /**
+     * 加载服务器购物车数量
+     * 根据新接口结构：res.rows[].cartMachineInfoDtoList.length 累加
+     */
     async loadServerCartCount() {
       try {
-        const res = await getGoodsList()
-        // 统一提取 rows/数组
-        const primary = Array.isArray(res && res.rows)
-          ? res.rows
-          : Array.isArray(res && res.data && res.data.rows)
-            ? res.data.rows
-            : Array.isArray(res && res.data)
-              ? res.data
-              : (Array.isArray(res) ? res : [])
-
-        let groups = []
-        if (Array.isArray(primary) && primary.length) {
-          // 情况A：shop -> shoppingCartInfoDtoList -> productMachineDtoList
-          if (Array.isArray(primary[0] && primary[0].shoppingCartInfoDtoList)) {
-            primary.forEach(shop => {
-              if (Array.isArray(shop && shop.shoppingCartInfoDtoList)) {
-                groups.push(...shop.shoppingCartInfoDtoList)
-              }
-            })
-          } else {
-            // 情况B：直接就是商品分组数组
-            groups = primary
-          }
-        } else if (Array.isArray(res && res.shoppingCartInfoDtoList)) {
-          // 情况C：返回对象直接有 shoppingCartInfoDtoList
-          groups = res.shoppingCartInfoDtoList
-        }
-
+        const res = await getGoodsListV2()
         let total = 0
-        if (groups.length) {
-          total = groups.reduce((sum, g) => sum + (Array.isArray(g && g.productMachineDtoList) ? g.productMachineDtoList.length : 0), 0)
-        } else if (Array.isArray(res && res.productMachineDtoList)) {
-          // 情况D：根对象直接是机器列表
-          total = res.productMachineDtoList.length
+        
+        // 新接口结构：res.rows 是店铺数组，每个店铺有 cartMachineInfoDtoList
+        if (Array.isArray(res && res.rows)) {
+          total = res.rows.reduce((sum, shop) => {
+            const machineList = Array.isArray(shop && shop.cartMachineInfoDtoList) 
+              ? shop.cartMachineInfoDtoList 
+              : []
+            return sum + machineList.length
+          }, 0)
+        } else if (Array.isArray(res && res.data && res.data.rows)) {
+          // 兼容：如果数据在 res.data.rows 中
+          total = res.data.rows.reduce((sum, shop) => {
+            const machineList = Array.isArray(shop && shop.cartMachineInfoDtoList) 
+              ? shop.cartMachineInfoDtoList 
+              : []
+            return sum + machineList.length
+          }, 0)
         }
 
         this.cartServerCount = Number.isFinite(total) ? total : 0
       } catch (e) {
         // 忽略错误，保持当前显示
+        console.error('加载购物车数量失败:', e)
       }
     },
     handleStorageChange(event) {
diff --git a/power_leasing/src/router/routes.js b/power_leasing/src/router/routes.js
index 407f418..f2373fe 100644
--- a/power_leasing/src/router/routes.js
+++ b/power_leasing/src/router/routes.js
@@ -179,6 +179,16 @@ export const accountRoutes = [
           allAuthority: ['all']
         }
       },
+      {
+        path: 'purchased-machine-config',
+        name: 'accountPurchasedMachineConfig',
+        component: () => import('../views/account/purchasedMachineConfig.vue'),
+        meta: {
+          title: '已购矿机配置',
+          description: '查看已购买矿机的配置信息',
+          allAuthority: ['all']
+        }
+      },
       {
         path: 'funds-flow',
         name: 'accountFundsFlow',
diff --git a/power_leasing/src/views/account/OrderList.vue b/power_leasing/src/views/account/OrderList.vue
index 0963641..e11ceb0 100644
--- a/power_leasing/src/views/account/OrderList.vue
+++ b/power_leasing/src/views/account/OrderList.vue
@@ -6,11 +6,16 @@
         <template #default="outer">
           <el-table :data="outer.row.orderItemDtoList || []" size="small" border :header-cell-style="{ textAlign: 'left' }" :cell-style="{ textAlign: 'left' }" row-key="productMachineId">
             <el-table-column prop="productMachineId" label="机器ID" min-width="120" />
-            <el-table-column prop="name" label="名称" min-width="160" />
+            <el-table-column label="矿机类型" min-width="100">
+              <template #default="scope">{{ formatMachineType(scope.row && scope.row.type) }}</template>
+            </el-table-column>
             <el-table-column prop="payCoin" label="币种" min-width="100" />         
             <el-table-column prop="address" label="收款地址" min-width="240" />
             <el-table-column prop="leaseTime" label="租赁天数" min-width="100" />
-            <el-table-column prop="price" label="售价(USDT)" min-width="240">
+            <el-table-column label="购买数量" min-width="100">
+              <template #default="scope">{{ scope.row && scope.row.numbers != null ? scope.row.numbers : '—' }}</template>
+            </el-table-column>
+            <el-table-column prop="price" label="单价(USDT)" min-width="240">
               <template #default="scope">
                 <span class="value strong">
                   <el-tooltip
@@ -31,17 +36,20 @@
         </template>
       </el-table-column>
 
+      <el-table-column label="店铺" width="120">
+        <template #default="scope">{{ scope.row && scope.row.shopName || '—' }}</template>
+      </el-table-column>
       <el-table-column label="订单号" min-width="220">
         <template #default="scope"><span class="value mono">{{ scope.row && scope.row.orderNumber || '—' }}</span></template>
       </el-table-column>
 
-      <el-table-column label="创建时间" min-width="180">
+      <el-table-column label="创建时间" width="160">
         <template #default="scope">{{ formatDateTime(scope.row && scope.row.createTime) }}</template>
       </el-table-column>
-      <el-table-column label="商品数" min-width="100">
+      <el-table-column label="商品数" min-width="70">
         <template #default="scope">{{ Array.isArray(scope.row && scope.row.orderItemDtoList) ? scope.row.orderItemDtoList.length : 0 }}</template>
       </el-table-column>
-      <el-table-column label="总金额(USDT)" min-width="140">
+      <el-table-column label="总金额(USDT)" width="120">
         <template #default="scope">
           <span class="value strong">
             <el-tooltip
@@ -58,7 +66,7 @@
           </span>
         </template>
       </el-table-column>
-      <el-table-column min-width="180">
+      <el-table-column width="160">
         <template #header>
           <el-tooltip placement="top" effect="dark">
             <div slot="content">
@@ -88,24 +96,10 @@
           </span>
         </template>
       </el-table-column>
-      <el-table-column label="待支付金额(USDT)" min-width="140">
-        <template #default="scope">
-          <span class="value strong">
-            <el-tooltip
-              v-if="formatAmount(scope.row && scope.row.noPayAmount, 'USDT').truncated"
-              :content="formatAmount(scope.row && scope.row.noPayAmount, 'USDT').full"
-              placement="top"
-            >
-              <span>
-                {{ formatAmount(scope.row && scope.row.noPayAmount, 'USDT').text }}
-                <i class="el-icon-more amount-more"></i>
-              </span>
-            </el-tooltip>
-            <span v-else>{{ formatAmount(scope.row && scope.row.noPayAmount, 'USDT').text }}</span>
-          </span>
-        </template>
+      <el-table-column label="订单完成时间" width="160">
+        <template #default="scope">{{ formatDateTime(scope.row && scope.row.endTime) }}</template>
       </el-table-column>
-      <el-table-column label="操作" min-width="280" fixed="right">
+      <el-table-column label="操作" min-width="60" fixed="right">
         <template #default="scope">
           <el-button size="mini" @click="handleGoDetail(scope.row)" style="margin-right:8px;">详情</el-button>
           <template v-if="shouldShowActions(scope.row)">
@@ -241,6 +235,18 @@ export default {
       if (!value) return '—'
       try { const str = String(value); return str.includes('T') ? str.replace('T', ' ') : str } catch (e) { return String(value) }
     },
+    /**
+     * 格式化矿机类型
+     * @param {number} type - 矿机类型：0=ASIC, 1=GPU
+     * @returns {string} 类型文本
+     */
+    formatMachineType(type) {
+      if (type === null || type === undefined) return '—'
+      const typeNum = Number(type)
+      if (typeNum === 0) return 'ASIC'
+      if (typeNum === 1) return 'GPU'
+      return '—'
+    },
     async handleCheckout(row) {
       if (!row) return
       try {
diff --git a/power_leasing/src/views/account/index.vue b/power_leasing/src/views/account/index.vue
index 2d6b895..272adee 100644
--- a/power_leasing/src/views/account/index.vue
+++ b/power_leasing/src/views/account/index.vue
@@ -64,6 +64,7 @@ export default {
       buyerLinks: [
         { label: '我的钱包', to: '/account/wallet' },
         { label: '已购商品', to: '/account/purchased' },
+        { label: '已购矿机配置', to: '/account/purchased-machine-config' },
         { label: '订单列表', to: '/account/orders' },
         // { label: '充值记录', to: '/account/rechargeRecord' },
         // { label: '提现记录', to: '/account/withdrawalHistory' },
@@ -154,11 +155,12 @@ export default {
         }
         return
       }
-      // 买家前缀优先匹配，确保“已购详情”等页面归属买家侧
+      // 买家前缀优先匹配，确保"已购详情"等页面归属买家侧
       const buyerPrefixes = [
         '/account/wallet',
         '/account/purchased',
         '/account/purchased-detail',
+        '/account/purchased-machine-config',
         '/account/orders',
         '/account/funds-flow'
       ]
@@ -206,13 +208,26 @@ export default {
       const map = {
         '/account/seller-orders': ['/account/seller-orders'],
         '/account/products': ['/account/products', '/account/product-detail'],
-        '/account/purchased': ['/account/purchased', '/account/purchased-detail']
+        '/account/purchased': ['/account/purchased', '/account/purchased-detail'],
+        '/account/purchased-machine-config': ['/account/purchased-machine-config']
       }
       const prefixes = map[pathLike]
       if (Array.isArray(prefixes)) {
-        return prefixes.some(p => current.indexOf(p) === 0)
+        return prefixes.some(p => {
+          // 精确匹配
+          if (current === p) return true
+          // 对于详情页路径，使用前缀匹配（支持 /account/purchased-detail/:id）
+          if (p === '/account/purchased-detail' || p === '/account/product-detail') {
+            return current.indexOf(p) === 0
+          }
+          // 列表页已经在上面精确匹配了，这里不需要额外处理
+          return false
+        })
       }
-      return current.indexOf(pathLike) === 0
+      // 不在 map 中的路径，精确匹配
+      // 特别注意：避免 /account/purchased 匹配到 /account/purchased-machine-config
+      // 使用精确匹配而不是前缀匹配
+      return current === pathLike
     }
   },
   watch: {
@@ -344,6 +359,7 @@ export default {
   border-radius: 8px;
   padding: 16px;
   min-height: 420px;
+  width: 82vw;
 }
 
 @media (max-width: 768px) {
diff --git a/power_leasing/src/views/account/orderDetail.vue b/power_leasing/src/views/account/orderDetail.vue
index e0608c5..3328923 100644
--- a/power_leasing/src/views/account/orderDetail.vue
+++ b/power_leasing/src/views/account/orderDetail.vue
@@ -7,8 +7,10 @@
         <div class="row"><span class="label">订单ID：</span><span class="value mono">{{ order.id || '—' }}</span></div>
         <div class="row"><span class="label">订单号：</span><span class="value mono">{{ order.orderNumber || '—' }}</span></div>
         <div class="row"><span class="label">状态：</span><span class="value">{{ getOrderStatusText(order.status) }}</span></div>
+        <div class="row"><span class="label">店铺：</span><span class="value">{{ order.shopName || '—' }}</span></div>
         <div class="row"><span class="label">金额(USDT)：</span><span class="value strong">{{ order.totalPrice }}</span></div>
         <div class="row"><span class="label">创建时间：</span><span class="value">{{ formatDateTime(order.createTime) }}</span></div>
+        <div class="row"><span class="label">订单完成时间：</span><span class="value">{{ formatDateTime(order.endTime) }}</span></div>
       </el-card>
 
       <el-card class="section" style="margin-top:12px;">
@@ -16,9 +18,14 @@
         <el-table :data="items" border size="small" style="width:100%"
           :header-cell-style="{ textAlign: 'left' }" :cell-style="{ textAlign: 'left' }">
           <el-table-column prop="productMachineId" label="机器ID" min-width="120" />
-          <el-table-column prop="name" label="名称" min-width="160" />
+          <el-table-column label="矿机类型" min-width="100">
+            <template #default="scope">{{ formatMachineType(scope.row && scope.row.type) }}</template>
+          </el-table-column>
           <el-table-column prop="payCoin" label="币种" min-width="100" />
           <el-table-column prop="leaseTime" label="租赁天数" min-width="100" />
+          <el-table-column label="购买数量" min-width="100">
+            <template #default="scope">{{ scope.row && scope.row.numbers != null ? scope.row.numbers : '—' }}</template>
+          </el-table-column>
           <el-table-column prop="price" label="单价(USDT)" min-width="120" />
           <el-table-column prop="address" label="收款地址" min-width="240" />
         </el-table>
@@ -91,6 +98,18 @@ export default {
       } catch (e) {
         return String(value)
       }
+    },
+    /**
+     * 格式化矿机类型
+     * @param {number} type - 矿机类型：0=ASIC, 1=GPU
+     * @returns {string} 类型文本
+     */
+    formatMachineType(type) {
+      if (type === null || type === undefined) return '—'
+      const typeNum = Number(type)
+      if (typeNum === 0) return 'ASIC'
+      if (typeNum === 1) return 'GPU'
+      return '—'
     }
   }
 }
diff --git a/power_leasing/src/views/account/productMachineAdd.vue b/power_leasing/src/views/account/productMachineAdd.vue
index bfc996d..88109a9 100644
--- a/power_leasing/src/views/account/productMachineAdd.vue
+++ b/power_leasing/src/views/account/productMachineAdd.vue
@@ -15,13 +15,56 @@
     /> -->
 
     <el-card shadow="never" class="form-card">
-      <el-form ref="machineForm" :model="form" :rules="rules" label-width="160px" size="small">
+      <el-form
+        ref="machineForm"
+        :model="form"
+        :rules="rules"
+        label-width="160px"
+        size="small"
+      >
         <el-form-item label="矿机种类">
-          <el-radio-group v-model="form.machineCategory" @change="handleMachineCategoryChange">
+          <el-radio-group
+            v-model="form.machineCategory"
+            @change="handleMachineCategoryChange"
+          >
             <el-radio label="ASIC">ASIC</el-radio>
             <el-radio label="GPU">GPU</el-radio>
           </el-radio-group>
         </el-form-item>
+        <!-- GPU 引导内容 -->
+        <div v-if="form.machineCategory === 'GPU'" class="gpu-guide-section">
+          <el-card shadow="never" class="gpu-guide-card">
+            <div class="gpu-guide-content">
+              <div class="gpu-guide-title">注意事项：</div>
+              <ol class="gpu-guide-list">
+                <li>
+                  GPU商品需先点击下方按钮，下载并在GPU所在主机启动客户端，在下载包中会有启动客户端的操作指引文档
+                </li>
+                <li>
+                  成功在GPU主机启动客户端后，GPU信息会自行添加至商品列表中，点击下方前往商品列表按钮可以前往该页面
+                </li>
+                <li>
+                  客户端和您的卖家账号绑定，如果您需要在本卖家账号<span v-if="userEmail"> ({{ userEmail }})</span>添加多个GPU商品，可通过下列两种方法实现：<br />
+                  方法一：点击下方下载客户端按钮，将下载好的完整客户端包复制到不同的GPU主机并且启动，启动后客户端所在主机的GPU数据会自动添加到商品列表中
+                  (推荐) <br />
+                  方法二：在不同的客户端主机登陆您的卖家账号，进入本页面，点击下载对应操作系统客户端，成功启动客户端后也可自动添加GPU数据到商品列表中
+                </li>
+                <li>目前只支持NVIDIA系列GPU</li>
+              </ol>
+              <div class="gpu-guide-buttons">
+                <el-button type="primary" @click="handleDownloadClient('windows')"
+                  >Windows 客户端下载</el-button
+                >
+                <el-button type="primary" @click="handleDownloadClient('linux')"
+                  >Linux 客户端下载</el-button
+                >
+                <el-button type="success" @click="handleGpuClientStarted"
+                  >前往商品列表</el-button
+                >
+              </div>
+            </div>
+          </el-card>
+        </div>
         <!-- ASIC：币种/算法/理论算力/单位 同行，支持多行动态增删 -->
         <el-form-item
           v-if="form.machineCategory === 'ASIC'"
@@ -35,18 +78,38 @@
               v-for="(row, idx) in form.coinAndAlgoList"
               :key="idx"
             >
-              <el-input
+              <el-select
                 v-model="row.coin"
-                placeholder="币种"
+                placeholder="请选择币种"
                 class="coin-input"
-                @input="handleCoinInput(idx)"
-              />
-              <el-input
+                @change="handleCoinChange(idx, $event)"
+                :loading="loadingCoins"
+                filterable
+                clearable
+              >
+                <el-option
+                  v-for="coin in coinOptions"
+                  :key="coin"
+                  :label="coin"
+                  :value="coin"
+                />
+              </el-select>
+              <el-select
                 v-model="row.algorithm"
-                placeholder="算法"
+                placeholder="请选择算法"
                 class="algo-input"
-                @input="handleAlgorithmInput(idx)"
-              />
+                :loading="loadingAlgos[idx]"
+                :disabled="!row.coin"
+                filterable
+                clearable
+              >
+                <el-option
+                  v-for="algo in (algoOptionsMap[row.coin] || [])"
+                  :key="algo"
+                  :label="algo"
+                  :value="algo"
+                />
+              </el-select>
               <el-input
                 v-model="row.theoryPower"
                 placeholder="理论算力"
@@ -86,35 +149,42 @@
           </div>
         </el-form-item>
 
-        <el-form-item label="矿机型号" prop="type" :required="true">
-          <el-input style="width: 50%;" v-model="form.type" placeholder="示例：龍珠" :maxlength="20" @input="handleTypeInput" />
+        <el-form-item v-if="form.machineCategory === 'ASIC'" label="矿机型号" prop="type" :required="true">
+          <el-input
+            style="width: 50%"
+            v-model="form.type"
+            placeholder="示例：龍珠"
+            :maxlength="20"
+            @input="handleTypeInput"
+          />
         </el-form-item>
         <!-- 理论算力与单位已合并到上面的同行多行输入 -->
-        <el-form-item label="最大租赁天数" prop="maxLeaseDays">
+        <el-form-item v-if="form.machineCategory === 'ASIC'" label="最大租赁天数" prop="maxLeaseDays">
           <el-input
             v-model="form.maxLeaseDays"
             placeholder="1-365"
             inputmode="numeric"
             @input="handleNumeric('maxLeaseDays')"
-            style="width: 50%;"
+            style="width: 50%"
           >
             <template slot="append">天</template>
           </el-input>
         </el-form-item>
-        <el-form-item label="功耗" prop="powerDissipation">
+        <el-form-item v-if="form.machineCategory === 'ASIC'" label="功耗" prop="powerDissipation">
           <el-input
-            v-model="form.powerDissipation"         
+            v-model="form.powerDissipation"
             inputmode="decimal"
             @input="handleNumeric('powerDissipation')"
-            style="width: 50%;"
+            style="width: 50%"
           >
             <template slot="append">kw/h</template>
           </el-input>
         </el-form-item>
-      
+
         <el-form-item
+          v-if="form.machineCategory === 'ASIC'"
           label="统一售价"
-          :prop="(payTypeDefs && payTypeDefs.length) ? 'costMap' : 'cost'"
+          :prop="payTypeDefs && payTypeDefs.length ? 'costMap' : 'cost'"
           :required="true"
         >
           <span slot="label">统一售价</span>
@@ -125,8 +195,8 @@
                 v-model="form.costMap[pt.key]"
                 placeholder="请输入价格"
                 inputmode="decimal"
-                @input="val => handleCostMapInput(pt.key, val)"
-                style="width: 50%;"
+                @input="(val) => handleCostMapInput(pt.key, val)"
+                style="width: 50%"
               >
                 <template slot="append">{{ pt.label }}</template>
               </el-input>
@@ -138,20 +208,24 @@
             placeholder="请输入成本（USDT）"
             inputmode="decimal"
             @input="handleNumeric('cost')"
-            style="width: 50%;"
+            style="width: 50%"
           >
             <template slot="append">USDT</template>
           </el-input>
         </el-form-item>
-      
-      
+
         <!-- 出售机器数量（统一使用，GPU 仅作引导不在本页提交） -->
-        <el-form-item label="出售机器数量(台)" prop="sellCount" :required="true">
+        <el-form-item
+          v-if="form.machineCategory === 'ASIC'"
+          label="出售机器数量(台)"
+          prop="sellCount"
+          :required="true"
+        >
           <el-input
             v-model="form.sellCount"
             placeholder="0 - 9999"
             inputmode="numeric"
-            style="width: 50%;"
+            style="width: 50%"
             @input="handleSellCountInput"
             @blur="handleSellCountBlur"
           />
@@ -159,28 +233,38 @@
       </el-form>
     </el-card>
 
-    <div class="actions">
+    <div v-if="form.machineCategory === 'ASIC'" class="actions">
       <el-button @click="handleBack">取消</el-button>
-      <el-button type="primary" :loading="saving" @click="handleSave">确认添加</el-button>
+      <el-button type="primary" :loading="saving" @click="handleSave"
+        >确认添加</el-button
+      >
     </div>
-    
+
     <!-- 上架确认弹窗 -->
     <el-dialog
       title="请确认上架信息"
       :visible.sync="confirmVisible"
       width="560px"
     >
-      <div style="text-align:left;line-height:1.9;">
-        <div>币种：<b>{{ confirmData.coin }}</b></div>
-        <div>算法：<b>{{ confirmData.algorithm }}</b></div>
-        <div>最大租赁天数：<b>{{ confirmData.maxLeaseDays || '-' }}</b></div>
-        <div>出售机器数量：<b>{{ confirmData.saleNumbers || '-' }}</b></div>
-        <div style="margin-top:8px;">售价：</div>
+      <div style="text-align: left; line-height: 1.9">
+        <div>
+          币种：<b>{{ confirmData.coin }}</b>
+        </div>
+        <div>
+          算法：<b>{{ confirmData.algorithm }}</b>
+        </div>
+        <div>
+          最大租赁天数：<b>{{ confirmData.maxLeaseDays || "-" }}</b>
+        </div>
+        <div>
+          出售机器数量：<b>{{ confirmData.saleNumbers || "-" }}</b>
+        </div>
+        <div style="margin-top: 8px">售价：</div>
         <el-table
           :data="confirmData.priceList"
           border
           size="mini"
-          style="width:100%;"
+          style="width: 100%"
         >
           <el-table-column prop="chain" label="链" width="120" />
           <el-table-column prop="coin" label="币种" width="120" />
@@ -190,236 +274,262 @@
             </template>
           </el-table-column>
         </el-table>
-        <p style="color:#666;margin-top:12px;">请仔细确认以上参数无误后提交。</p>
+        <p style="color: #666; margin-top: 12px">
+          请仔细确认以上参数无误后提交。
+        </p>
       </div>
       <span slot="footer" class="dialog-footer">
         <el-button @click="confirmVisible = false">取消</el-button>
-        <el-button type="primary" :loading="saving" @click="doSubmit">确认提交</el-button>
-      </span>
-    </el-dialog>
-    <!-- GPU 引导弹窗 -->
-    <el-dialog title="GPU 客户端指引" :visible.sync="gpuDialogVisible" width="520px" @close="handleGpuDialogClosed">
-      <div style="text-align:left; line-height:1.8;">
-        <div style="display:flex; align-items:center; gap:12px; margin-bottom:12px;">
-          <el-button type="primary" @click="handleDownloadClient">下载客户端</el-button>
-          <el-button type="success" :disabled="!hasDownloadedClient" @click="handleGpuClientStarted">已启动客户端</el-button>
-        </div>
-        <div style="color:#555;">
-          <div style="margin-bottom:6px; font-weight:600;">注意事项：</div>
-          <ol style="padding-left:18px;">
-            <li>请直接下载客户端后并启动，客户端显示 GPU 信息后，启动完成点击“已启动客户端”按钮（若未完全启动点击按钮会创建失败）。</li>
-            <li>涉及多台主机，每个主机都需要配置相同客户端。</li>
-            <li>客户端身份信息和本网站身份信息一致。</li>
-          </ol>
-        </div>
-      </div>
-      <span slot="footer" class="dialog-footer">
-        <el-button @click="gpuDialogVisible=false">关闭</el-button>
+        <el-button type="primary" :loading="saving" @click="doSubmit"
+          >确认提交</el-button
+        >
       </span>
     </el-dialog>
   </div>
 </template>
 
 <script>
-import { addSingleOrBatchMachine ,downloadClient,addAsicMachine} from '../../api/machine'
-import { getPayTypes } from '../../api/products'
-import request from '../../utils/request'
+import {
+  addSingleOrBatchMachine,
+  downloadClient,
+  addAsicMachine,getSupportCoin,getSupportAlgo
+} from "../../api/machine";
+import { getPayTypes } from "../../api/products";
+import request from "../../utils/request";
 export default {
-  name: 'AccountProductMachineAdd',
+  name: "AccountProductMachineAdd",
   data() {
     return {
       form: {
         productId: Number(this.$route.query.productId) || null,
-        coin: this.$route.query.coin || '',
-        productName: this.$route.query.name || '',
+        coin: this.$route.query.coin || "",
+        productName: this.$route.query.name || "",
         /** 矿机种类：ASIC 或 GPU，默认 ASIC */
-        machineCategory: 'ASIC',
+        machineCategory: "ASIC",
         /** 出售机器数量（仅 ASIC 模式使用） */
-        sellCount: '',
+        sellCount: "",
         /** ASIC：币种/算法/理论算力/单位 行编辑（最多10行） */
         coinAndAlgoList: [
-          { coin: '', algorithm: '', theoryPower: '', unit: 'TH/S' }
+          { coin: "", algorithm: "", theoryPower: "", unit: "TH/S" },
         ],
         powerDissipation: null,
-        type: '',
-        cost: '',
+        type: "",
+        cost: "",
         costMap: {}, // { 'CHAIN-COIN': '123.45' }
-        maxLeaseDays: ''
+        maxLeaseDays: "",
       },
       confirmVisible: false,
       confirmData: {
-        coin: '',
-        algorithm: '',
-        maxLeaseDays: '',
-        saleNumbers: '',
-        priceList: []
+        coin: "",
+        algorithm: "",
+        maxLeaseDays: "",
+        saleNumbers: "",
+        priceList: [],
       },
       rules: {
-        productName: [ { required: true, message: '商品名称不能为空', trigger: 'change' } ],
+        productName: [
+          { required: true, message: "商品名称不能为空", trigger: "change" },
+        ],
         type: [
-          { required: true, message: '矿机型号不能为空', trigger: 'blur' },
+          { required: true, message: "矿机型号不能为空", trigger: "blur" },
           {
             validator: (rule, value, callback) => {
-              const s = String(value || '')
+              const s = String(value || "");
               // 不允许全是空格
               if (s && s.trim().length === 0) {
-                callback(new Error('矿机型号不能全是空格'))
-                return
+                callback(new Error("矿机型号不能全是空格"));
+                return;
               }
-              callback()
+              callback();
             },
-            trigger: 'blur'
-          }
+            trigger: "blur",
+          },
         ],
         coinAndAlgoList: [
-          { validator: (rule, value, callback) => this.validateCoinAlgoRows(rule, value, callback), trigger: 'blur' }
+          {
+            validator: (rule, value, callback) =>
+              this.validateCoinAlgoRows(rule, value, callback),
+            trigger: "blur",
+          },
         ],
         sellCount: [
           {
             validator: (rule, value, callback) => {
-              if (this.form.machineCategory !== 'ASIC') { callback(); return }
-              const raw = String(value ?? '')
-              if (raw === '') { callback(new Error('请输入出售机器数量')); return }
-              if (!/^\d{1,4}$/.test(raw)) { callback(new Error('请输入 0-9999 的整数')); return }
-              const n = Number(raw)
-              if (!Number.isInteger(n) || n < 0 || n > 9999) { callback(new Error('范围需在 0-9999')); return }
-              callback()
+              if (this.form.machineCategory !== "ASIC") {
+                callback();
+                return;
+              }
+              const raw = String(value ?? "");
+              if (raw === "") {
+                callback(new Error("请输入出售机器数量"));
+                return;
+              }
+              if (!/^\d{1,4}$/.test(raw)) {
+                callback(new Error("请输入 0-9999 的整数"));
+                return;
+              }
+              const n = Number(raw);
+              if (!Number.isInteger(n) || n < 0 || n > 9999) {
+                callback(new Error("范围需在 0-9999"));
+                return;
+              }
+              callback();
             },
-            trigger: 'blur'
-          }
+            trigger: "blur",
+          },
         ],
         powerDissipation: [
-          { required: true, message: '功耗不能为空', trigger: 'blur' },
+          { required: true, message: "功耗不能为空", trigger: "blur" },
           {
             validator: (rule, value, callback) => {
-              const str = String(value || '')
-              if (!str) { callback(new Error('功耗不能为空')); return }
-              const pattern = /^\d{1,6}(\.\d{1,4})?$/
-              if (!pattern.test(str)) { callback(new Error('功耗整数最多6位，小数最多4位')); return }
-              if (Number(str) <= 0) { callback(new Error('功耗必须大于0')); return }
-              callback()
+              const str = String(value || "");
+              if (!str) {
+                callback(new Error("功耗不能为空"));
+                return;
+              }
+              const pattern = /^\d{1,6}(\.\d{1,4})?$/;
+              if (!pattern.test(str)) {
+                callback(new Error("功耗整数最多6位，小数最多4位"));
+                return;
+              }
+              if (Number(str) <= 0) {
+                callback(new Error("功耗必须大于0"));
+                return;
+              }
+              callback();
             },
-            trigger: 'blur'
-          }
+            trigger: "blur",
+          },
         ],
         cost: [
           {
             validator(rule, value, callback) {
               // 若为多结算币种模式，跳过此校验（统一售价由每种币种的输入框承担）
-              if (Array.isArray(this.payTypeDefs) && this.payTypeDefs.length > 0) {
-                callback()
-                return
+              if (
+                Array.isArray(this.payTypeDefs) &&
+                this.payTypeDefs.length > 0
+              ) {
+                callback();
+                return;
               }
-              const str = String(value || '')
+              const str = String(value || "");
               if (!str) {
-                callback(new Error('请填写机器成本（USDT）'))
-                return
+                callback(new Error("请填写机器成本（USDT）"));
+                return;
               }
-              const pattern = /^\d{1,12}(\.\d{1,2})?$/
+              const pattern = /^\d{1,12}(\.\d{1,2})?$/;
               if (!pattern.test(str)) {
-                callback(new Error('成本整数最多12位，小数最多2位'))
-                return
+                callback(new Error("成本整数最多12位，小数最多2位"));
+                return;
               }
               if (Number(str) <= 0) {
-                callback(new Error('成本必须大于 0'))
-                return
+                callback(new Error("成本必须大于 0"));
+                return;
               }
-              callback()
+              callback();
             },
-            trigger: 'blur'
-          }
-        ]
-        ,
+            trigger: "blur",
+          },
+        ],
         maxLeaseDays: [
-          { required: true, message: '请填写最大租赁天数', trigger: 'blur' },
+          { required: true, message: "请填写最大租赁天数", trigger: "blur" },
           {
             validator: (rule, value, callback) => {
-              const raw = String(value ?? '')
-              if (!raw) { callback(new Error('请填写最大租赁天数')); return }
-              if (!/^\d{1,3}$/.test(raw)) { callback(new Error('仅允许整数，范围 1-365')); return }
-              const n = Number(raw)
-              if (!Number.isInteger(n) || n < 1 || n > 365) { callback(new Error('范围需在 1-365 天')); return }
-              callback()
+              const raw = String(value ?? "");
+              if (!raw) {
+                callback(new Error("请填写最大租赁天数"));
+                return;
+              }
+              if (!/^\d{1,3}$/.test(raw)) {
+                callback(new Error("仅允许整数，范围 1-365"));
+                return;
+              }
+              const n = Number(raw);
+              if (!Number.isInteger(n) || n < 1 || n > 365) {
+                callback(new Error("范围需在 1-365 天"));
+                return;
+              }
+              callback();
             },
-            trigger: 'blur'
-          }
-        ]
+            trigger: "blur",
+          },
+        ],
       },
       miners: [
-      // {
-      //           "user": "lx_888",
-      //           "miner": null,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "lx999",
-      //           "miner": null,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "lx88",
-      //           "miner": null,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "lx6666",
-      //           "miner": null,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "lx_999",
-      //           "miner": null,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "Lx_6966",
-      //           "miner": null,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "LX_666",
-      //           "miner": null,
-      //           "coin": "nexa"
-      //       },
+        // {
+        //           "user": "lx_888",
+        //           "miner": null,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "lx999",
+        //           "miner": null,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "lx88",
+        //           "miner": null,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "lx6666",
+        //           "miner": null,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "lx_999",
+        //           "miner": null,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "Lx_6966",
+        //           "miner": null,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "LX_666",
+        //           "miner": null,
+        //           "coin": "nexa"
+        //       },
       ],
       minersLoading: false,
-      selectedMiner: '', // 格式 user|coin
+      selectedMiner: "", // 格式 user|coin
       machineOptions: [
-      // {
-      //           "user": "lx_888",
-      //           "miner": `iusfhufhu`,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "lx999",
-      //           "miner": `iusfhufhu2`,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "lx88",
-      //           "miner": `iusfhufhu3`,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "lx6666",
-      //           "miner": `iusfhufhu4`,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "lx_999",
-      //           "miner": `iusfhufhu5`,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "Lx_6966",
-      //           "miner": `iusfhufhu6`,
-      //           "coin": "nexa"
-      //       },
-      //       {
-      //           "user": "LX_666",
-      //           "miner": `iusfhufhu7`,
-      //           "coin": "nexa"
-      //       },
+        // {
+        //           "user": "lx_888",
+        //           "miner": `iusfhufhu`,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "lx999",
+        //           "miner": `iusfhufhu2`,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "lx88",
+        //           "miner": `iusfhufhu3`,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "lx6666",
+        //           "miner": `iusfhufhu4`,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "lx_999",
+        //           "miner": `iusfhufhu5`,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "Lx_6966",
+        //           "miner": `iusfhufhu6`,
+        //           "coin": "nexa"
+        //       },
+        //       {
+        //           "user": "LX_666",
+        //           "miner": `iusfhufhu7`,
+        //           "coin": "nexa"
+        //       },
       ],
       machinesLoading: false,
       selectedMachines: [],
@@ -427,234 +537,365 @@ export default {
       saving: false,
       lastCostBaseline: 0,
       lastCostMapBaseline: {}, // { key: number }
-      lastTypeBaseline: '',
+      lastTypeBaseline: "",
       lastMaxLeaseDaysBaseline: 0,
       lastPowerDissipationBaseline: 0,
       lastTheoryPowerBaseline: 0,
-      lastUnitBaseline: 'TH/S',
+      lastUnitBaseline: "TH/S",
       /** GPU 引导弹窗可见性 */
       gpuDialogVisible: false,
       /** GPU 客户端下载地址（可通过环境变量配置：VUE_APP_GPU_CLIENT_URL） */
-      clientDownloadUrl: process.env.VUE_APP_GPU_CLIENT_URL || '',
+      clientDownloadUrl: process.env.VUE_APP_GPU_CLIENT_URL || "",
       /** 是否点击过下载客户端（用于控制“已启动客户端”按钮禁用态） */
       hasDownloadedClient: false,
       /** 支持的支付方式定义（用于动态渲染统一售价输入组） */
       payTypeDefs: [],
-      params:{
-        cost:353400,
-        powerDissipation:0.01,
-        theoryPower:1000,
-        type:"",
-        unit:"TH/S",
-        productId:1,
-        productMachineURDVos:[
-            {
-                "user":"lx_888",             
-                "miner":"iusfhufhu",
-                "price":353400,
-                "type":"",
-                "state":0
-            },
-            {
-                "user":"lx_888",             
-                "miner":"iusfhufhu2",
-                "price":353400,
-                "type":"",
-                "state":0
-            },
-
-        ]
-
-      }
-    }
+      /** 币种选项列表 */
+      coinOptions: [],
+      /** 算法选项映射 { coin: [algo1, algo2, ...] } */
+      algoOptionsMap: {},
+      /** 加载币种状态 */
+      loadingCoins: false,
+      /** 加载算法状态映射 { index: boolean } */
+      loadingAlgos: {},
+      params: {
+        cost: 353400,
+        powerDissipation: 0.01,
+        theoryPower: 1000,
+        type: "",
+        unit: "TH/S",
+        productId: 1,
+        productMachineURDVos: [
+          {
+            user: "lx_888",
+            miner: "iusfhufhu",
+            price: 353400,
+            type: "",
+            state: 0,
+          },
+          {
+            user: "lx_888",
+            miner: "iusfhufhu2",
+            price: 353400,
+            type: "",
+            state: 0,
+          },
+        ],
+      },
+      userEmail:"",
+    };
   },
   created() {
-    this.initPayTypesFromRoute()
-    this.lastTypeBaseline = this.form.type
+    this.initPayTypesFromRoute();
+    this.lastTypeBaseline = this.form.type;
     // 绑定基于组件实例的校验器，避免 this 丢失
     if (this.rules && this.rules.cost) {
-      this.$set(this.rules, 'cost', [{ validator: this.validateCost, trigger: 'blur' }])
+      this.$set(this.rules, "cost", [
+        { validator: this.validateCost, trigger: "blur" },
+      ]);
     }
     // 多币种价格专用校验
-    this.$set(this.rules, 'costMap', [{ validator: this.validateCostMap, trigger: 'blur' }])
+    this.$set(this.rules, "costMap", [
+      { validator: this.validateCostMap, trigger: "blur" },
+    ]);
 
-    this.getPayTypes()
+    this.getPayTypes();
+    this.loadSupportCoins();
+
+    this.userEmail = JSON.parse(localStorage.getItem("leasEmail")) || "";
   },
   methods: {
     /** ASIC 行校验：币种/算法/理论算力/单位 */
     validateCoinAlgoRows(rule, value, callback) {
       try {
-        const rows = Array.isArray(this.form.coinAndAlgoList) ? this.form.coinAndAlgoList : []
-        if (!rows.length) { callback(new Error('请至少添加一行币种/算法/算力/单位')); return }
-        const coinPattern = /^[A-Za-z0-9]{1,10}$/
-        const algoPattern = /^[A-Za-z0-9-]{2,20}$/
-        const powerPattern = /^\d{1,6}(\.\d{1,4})?$/
-        for (let i = 0; i < rows.length; i += 1) {
-          const r = rows[i] || {}
-          const coin = String(r.coin || '').trim()
-          const algo = String(r.algorithm || '').trim()
-          const power = String(r.theoryPower || '').trim()
-          const unit = String(r.unit || '').trim()
-          if (!coin) { callback(new Error(`第 ${i + 1} 行：请输入币种`)); return }
-          if (!coinPattern.test(coin)) { callback(new Error(`第 ${i + 1} 行：币种仅允许字母或数字，1-10 位`)); return }
-          if (!algo) { callback(new Error(`第 ${i + 1} 行：请输入算法`)); return }
-          if (!algoPattern.test(algo)) { callback(new Error(`第 ${i + 1} 行：算法仅允许字母/数字/“-”，2-20 位`)); return }
-          if (!power || !powerPattern.test(power) || Number(power) <= 0) {
-            callback(new Error(`第 ${i + 1} 行：理论算力需大于0，整数最多6位，小数最多4位`)); return
-          }
-          if (!unit) { callback(new Error(`第 ${i + 1} 行：请选择算力单位`)); return }
+        const rows = Array.isArray(this.form.coinAndAlgoList)
+          ? this.form.coinAndAlgoList
+          : [];
+        if (!rows.length) {
+          callback(new Error("请至少添加一行币种/算法/算力/单位"));
+          return;
         }
-        callback()
+        const powerPattern = /^\d{1,6}(\.\d{1,4})?$/;
+        for (let i = 0; i < rows.length; i += 1) {
+          const r = rows[i] || {};
+          const coin = String(r.coin || "").trim();
+          const algo = String(r.algorithm || "").trim();
+          const power = String(r.theoryPower || "").trim();
+          const unit = String(r.unit || "").trim();
+          if (!coin) {
+            callback(new Error(`第 ${i + 1} 行：请选择币种`));
+            return;
+          }
+          if (!algo) {
+            callback(new Error(`第 ${i + 1} 行：请选择算法`));
+            return;
+          }
+          if (!power || !powerPattern.test(power) || Number(power) <= 0) {
+            callback(
+              new Error(
+                `第 ${i + 1} 行：理论算力需大于0，整数最多6位，小数最多4位`
+              )
+            );
+            return;
+          }
+          if (!unit) {
+            callback(new Error(`第 ${i + 1} 行：请选择算力单位`));
+            return;
+          }
+        }
+        callback();
       } catch (e) {
-        callback(new Error('请检查币种/算法/算力/单位填写'))
+        callback(new Error("请检查币种/算法/算力/单位填写"));
       }
     },
-    /** 行：币种输入过滤（去中文，仅字母数字） */
-    handleCoinInput(index) {
-      const r = this.form.coinAlgoRows[index]
-      let v = String(r.coin || '')
-      v = v.replace(/[\u4e00-\u9fa5]/g, '').replace(/[^A-Za-z0-9]/g, '')
-      this.$set(this.form.coinAlgoRows[index], 'coin', v.toUpperCase())
+    /**
+     * 加载支持的币种列表
+     */
+    async loadSupportCoins() {
+      this.loadingCoins = true;
+      try {
+        const res = await getSupportCoin();
+        if (res && (res.code === 0 || res.code === 200)) {
+          const data = res.data || [];
+          // 处理返回的数据，可能是数组或对象
+          if (Array.isArray(data)) {
+            this.coinOptions = data.map(item => {
+              // 如果是对象，取 coin 字段；如果是字符串，直接使用
+              return typeof item === 'string' ? item : (item.coin || item.name || item);
+            }).filter(Boolean);
+          } else if (data && typeof data === 'object') {
+            // 如果是对象，尝试提取币种列表
+            this.coinOptions = Object.keys(data).map(key => {
+              const item = data[key];
+              return typeof item === 'string' ? item : (item.coin || item.name || key);
+            }).filter(Boolean);
+          }
+          // 去重并排序
+          this.coinOptions = [...new Set(this.coinOptions)].sort();
+        }
+      } catch (e) {
+        console.error("加载币种列表失败", e);
+        this.$message.error("加载币种列表失败，请稍后重试");
+      } finally {
+        this.loadingCoins = false;
+      }
     },
-    /** 行：算法输入过滤（去中文，仅字母数字与-） */
-    handleAlgorithmInput(index) {
-      const r = this.form.coinAlgoRows[index]
-      let v = String(r.algorithm || '')
-      v = v.replace(/[\u4e00-\u9fa5]/g, '').replace(/[^A-Za-z0-9-]/g, '')
-      this.$set(this.form.coinAlgoRows[index], 'algorithm', v.toUpperCase())
+    /**
+     * 币种选择变化处理
+     * @param {number} index - 行索引
+     * @param {string} coin - 选择的币种
+     */
+    async handleCoinChange(index, coin) {
+      // 清空当前行的算法选择
+      this.$set(this.form.coinAndAlgoList[index], "algorithm", "");
+      // 如果选择了币种，加载对应的算法列表
+      if (coin) {
+        await this.loadAlgorithmsForCoin(coin, index);
+      }
+    },
+    /**
+     * 加载指定币种支持的算法列表
+     * @param {string} coin - 币种名称
+     * @param {number} index - 行索引（用于显示加载状态）
+     */
+    async loadAlgorithmsForCoin(coin, index) {
+      if (!coin) return;
+      
+      // 如果已经加载过该币种的算法，直接返回
+      if (this.algoOptionsMap[coin] && this.algoOptionsMap[coin].length > 0) {
+        return;
+      }
+
+      // 设置加载状态
+      this.$set(this.loadingAlgos, index, true);
+      
+      try {
+        const res = await getSupportAlgo(coin);
+        if (res && (res.code === 0 || res.code === 200)) {
+          const data = res.data || [];
+          let algorithms = [];
+          
+          // 处理返回的数据，可能是数组或对象
+          if (Array.isArray(data)) {
+            algorithms = data.map(item => {
+              // 如果是对象，取 algorithm 或 algo 字段；如果是字符串，直接使用
+              return typeof item === 'string' ? item : (item.algorithm || item.algo || item.name || item);
+            }).filter(Boolean);
+          } else if (data && typeof data === 'object') {
+            // 如果是对象，尝试提取算法列表
+            algorithms = Object.keys(data).map(key => {
+              const item = data[key];
+              return typeof item === 'string' ? item : (item.algorithm || item.algo || item.name || key);
+            }).filter(Boolean);
+          }
+          
+          // 去重并排序，保存到映射中
+          this.$set(this.algoOptionsMap, coin, [...new Set(algorithms)].sort());
+        }
+      } catch (e) {
+        console.error(`加载币种 ${coin} 的算法列表失败`, e);
+        this.$message.error(`加载算法列表失败，请稍后重试`);
+        // 设置空数组，避免重复请求
+        this.$set(this.algoOptionsMap, coin, []);
+      } finally {
+        this.$set(this.loadingAlgos, index, false);
+      }
     },
     /** 行：理论算力输入限制（6整数4小数） */
     handleCoinRowTheoryInput(index) {
-      let v = String(this.form.coinAndAlgoList[index].theoryPower ?? '')
-      v = v.replace(/[^0-9.]/g, '')
-      const firstDot = v.indexOf('.')
+      let v = String(this.form.coinAndAlgoList[index].theoryPower ?? "");
+      v = v.replace(/[^0-9.]/g, "");
+      const firstDot = v.indexOf(".");
       if (firstDot !== -1) {
-        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, '')
+        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, "");
       }
-      const endsWithDot = v.endsWith('.')
-      const parts = v.split('.')
-      let intPart = parts[0] || ''
-      let decPart = parts[1] || ''
-      if (intPart.length > 6) intPart = intPart.slice(0, 6)
-      if (decPart) decPart = decPart.slice(0, 4)
-      v = decPart.length ? `${intPart}.${decPart}` : (endsWithDot ? `${intPart}.` : intPart)
-      this.$set(this.form.coinAndAlgoList[index], 'theoryPower', v)
+      const endsWithDot = v.endsWith(".");
+      const parts = v.split(".");
+      let intPart = parts[0] || "";
+      let decPart = parts[1] || "";
+      if (intPart.length > 6) intPart = intPart.slice(0, 6);
+      if (decPart) decPart = decPart.slice(0, 4);
+      v = decPart.length
+        ? `${intPart}.${decPart}`
+        : endsWithDot
+        ? `${intPart}.`
+        : intPart;
+      this.$set(this.form.coinAndAlgoList[index], "theoryPower", v);
     },
     /** 行：单位变更 */
     handleCoinRowUnitChange(index, value) {
-      this.$set(this.form.coinAndAlgoList[index], 'unit', value)
+      this.$set(this.form.coinAndAlgoList[index], "unit", value);
     },
     /** 新增一行 */
     handleAddCoinAlgoRow() {
       if (this.form.coinAndAlgoList.length >= 10) {
-        this.$message.warning('最多添加 10 行')
-        return
+        this.$message.warning("最多添加 10 行");
+        return;
       }
-      const last = (this.form.coinAndAlgoList[this.form.coinAndAlgoList.length - 1]) || { unit: 'TH/S' }
-      this.form.coinAndAlgoList.push({ coin: '', algorithm: '', theoryPower: '', unit: last.unit || 'TH/S' })
+      const last = this.form.coinAndAlgoList[
+        this.form.coinAndAlgoList.length - 1
+      ] || { unit: "TH/S" };
+      const newIndex = this.form.coinAndAlgoList.length;
+      this.form.coinAndAlgoList.push({
+        coin: "",
+        algorithm: "",
+        theoryPower: "",
+        unit: last.unit || "TH/S",
+      });
+      // 初始化新行的加载状态
+      this.$set(this.loadingAlgos, newIndex, false);
     },
     /** 删除一行 */
     handleRemoveCoinAlgoRow(index) {
-      if (this.form.coinAndAlgoList.length <= 1) return
-      this.form.coinAndAlgoList.splice(index, 1)
+      if (this.form.coinAndAlgoList.length <= 1) return;
+      this.form.coinAndAlgoList.splice(index, 1);
     },
     /** 从多行聚合 coin CSV */
     buildCoinCsvFromRows() {
-      const set = new Set()
-      const rows = Array.isArray(this.form.coinAndAlgoList) ? this.form.coinAndAlgoList : []
-      rows.forEach(r => {
-        const token = String(r.coin || '')
+      const set = new Set();
+      const rows = Array.isArray(this.form.coinAndAlgoList)
+        ? this.form.coinAndAlgoList
+        : [];
+      rows.forEach((r) => {
+        const token = String(r.coin || "")
           .split(/[,\s，、]+/)
-          .map(s => s.trim().toUpperCase())
-          .filter(Boolean)
-        token.forEach(t => set.add(t))
-      })
-      return Array.from(set).join(',')
+          .map((s) => s.trim().toUpperCase())
+          .filter(Boolean);
+        token.forEach((t) => set.add(t));
+      });
+      return Array.from(set).join(",");
     },
     /** 从多行聚合 algorithm CSV */
     buildAlgoCsvFromRows() {
-      const set = new Set()
-      const rows = Array.isArray(this.form.coinAndAlgoList) ? this.form.coinAndAlgoList : []
-      rows.forEach(r => {
-        const token = String(r.algorithm || '')
+      const set = new Set();
+      const rows = Array.isArray(this.form.coinAndAlgoList)
+        ? this.form.coinAndAlgoList
+        : [];
+      rows.forEach((r) => {
+        const token = String(r.algorithm || "")
           .split(/[,\s，、]+/)
-          .map(s => s.trim().toUpperCase())
-          .filter(Boolean)
-        token.forEach(t => set.add(t))
-      })
-      return Array.from(set).join(',')
+          .map((s) => s.trim().toUpperCase())
+          .filter(Boolean);
+        token.forEach((t) => set.add(t));
+      });
+      return Array.from(set).join(",");
     },
     /** 实时过滤币种输入中的中文字符（仅保留英文/数字/分隔符） */
     handleCoinsInput() {
-      let v = String(this.form.coinsInput || '')
+      let v = String(this.form.coinsInput || "");
       // 去除中文
-      v = v.replace(/[\u4e00-\u9fa5]/g, '')
-      this.form.coinsInput = v
+      v = v.replace(/[\u4e00-\u9fa5]/g, "");
+      this.form.coinsInput = v;
     },
     /** 实时过滤算法输入中的中文字符（仅保留英文/数字/连字符/分隔符） */
     handleAlgorithmsInput() {
-      let v = String(this.form.algorithmsInput || '')
-      v = v.replace(/[\u4e00-\u9fa5]/g, '')
-      this.form.algorithmsInput = v
+      let v = String(this.form.algorithmsInput || "");
+      v = v.replace(/[\u4e00-\u9fa5]/g, "");
+      this.form.algorithmsInput = v;
     },
     /** 将输入按中英文逗号、空格分割，去空，统一英文逗号连接；可选：统一大写 */
     normalizeCsv(input, upper = true) {
-      const arr = String(input || '')
+      const arr = String(input || "")
         .split(/[,\s，、]+/)
-        .map(s => s.trim())
-        .filter(Boolean)
-      const list = upper ? arr.map(s => s.toUpperCase()) : arr
-      return list.join(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+      const list = upper ? arr.map((s) => s.toUpperCase()) : arr;
+      return list.join(",");
     },
     /** 从 payTypeDefs 与 costMap 生成价格列表 */
     buildPriceList() {
-      const list = []
-      const defs = Array.isArray(this.payTypeDefs) ? this.payTypeDefs : []
-      defs.forEach(d => {
-        const key = d.key
-        const priceRaw = this.form.costMap ? this.form.costMap[key] : ''
-        const priceNum = Number(priceRaw)
+      const list = [];
+      const defs = Array.isArray(this.payTypeDefs) ? this.payTypeDefs : [];
+      defs.forEach((d) => {
+        const key = d.key;
+        const priceRaw = this.form.costMap ? this.form.costMap[key] : "";
+        const priceNum = Number(priceRaw);
         // 允许为空/非数字则不加入
-        if (!Number.isFinite(priceNum) || priceNum <= 0) return
+        if (!Number.isFinite(priceNum) || priceNum <= 0) return;
         list.push({
           chain: d.chain,
           coin: d.coin,
-          price: priceNum
-        })
-      })
-      return list
+          price: priceNum,
+        });
+      });
+      return list;
     },
     async getPayTypes() {
       try {
-        const res = await getPayTypes()
+        const res = await getPayTypes();
         // 期望结构：{ code:200, data:[ { payChain, payCoin, payCoinImage } ] }
         if (res && (res.code === 0 || res.code === 200)) {
-          const list = Array.isArray(res.data) ? res.data : []
-          const defs = []
-          const seen = new Set()
-          list.forEach(it => {
-            const chain = String(it && it.payChain ? it.payChain : '').toUpperCase()
-            const coin = String(it && it.payCoin ? it.payCoin : '').toUpperCase()
-            if (!chain && !coin) return
-            const key = [chain, coin].filter(Boolean).join('-')
-            if (seen.has(key)) return
-            seen.add(key)
+          const list = Array.isArray(res.data) ? res.data : [];
+          const defs = [];
+          const seen = new Set();
+          list.forEach((it) => {
+            const chain = String(
+              it && it.payChain ? it.payChain : ""
+            ).toUpperCase();
+            const coin = String(
+              it && it.payCoin ? it.payCoin : ""
+            ).toUpperCase();
+            if (!chain && !coin) return;
+            const key = [chain, coin].filter(Boolean).join("-");
+            if (seen.has(key)) return;
+            seen.add(key);
             defs.push({
               chain,
               coin,
               key,
               label: key,
-              image: it && it.payCoinImage ? String(it.payCoinImage) : ''
-            })
-          })
+              image: it && it.payCoinImage ? String(it.payCoinImage) : "",
+            });
+          });
           // 根据接口结果渲染“统一售价”输入组
-          this.payTypeDefs = defs
-          const nextCostMap = {}
-          this.payTypeDefs.forEach(d => {
+          this.payTypeDefs = defs;
+          const nextCostMap = {};
+          this.payTypeDefs.forEach((d) => {
             // 保留已输入的数值；否则置空
-            nextCostMap[d.key] = (this.form.costMap && this.form.costMap[d.key]) || ''
-          })
-          this.form.costMap = nextCostMap
+            nextCostMap[d.key] =
+              (this.form.costMap && this.form.costMap[d.key]) || "";
+          });
+          this.form.costMap = nextCostMap;
         }
       } catch (e) {
         // 忽略错误，维持当前 payTypeDefs
@@ -664,493 +905,549 @@ export default {
      * ASIC 模式：出售机器数量输入，仅允许 0-9999 的整数
      */
     handleSellCountInput() {
-      let v = String(this.form.sellCount ?? '')
+      let v = String(this.form.sellCount ?? "");
       // 仅数字
-      v = v.replace(/\D/g, '')
+      v = v.replace(/\D/g, "");
       // 限制最多4位
-      if (v.length > 4) v = v.slice(0, 4)
+      if (v.length > 4) v = v.slice(0, 4);
       // 限制最大 9999
       if (v) {
-        const n = Number(v)
-        if (n > 9999) v = '9999'
+        const n = Number(v);
+        if (n > 9999) v = "9999";
       }
-      this.form.sellCount = v
+      this.form.sellCount = v;
     },
     handleSellCountBlur() {
-      const raw = String(this.form.sellCount ?? '')
-      if (raw === '') return
-      const n = Number(raw)
+      const raw = String(this.form.sellCount ?? "");
+      if (raw === "") return;
+      const n = Number(raw);
       if (!Number.isInteger(n) || n < 0 || n > 9999) {
-        this.$message.warning('出售机器数量需为 0-9999 的整数')
-        this.form.sellCount = ''
+        this.$message.warning("出售机器数量需为 0-9999 的整数");
+        this.form.sellCount = "";
       }
     },
     /**
-     * 矿机种类变更：若选择 GPU，弹出引导弹窗；ASIC 则保持当前页面逻辑
+     * 矿机种类变更
      * @param {string} val
      */
     handleMachineCategoryChange(val) {
-      if (String(val).toUpperCase() === 'GPU') {
-        this.gpuDialogVisible = true
-        // 首次打开时禁用“已启动客户端”按钮
-        this.hasDownloadedClient = false
-      } else {
-        this.gpuDialogVisible = false
-      }
+      // GPU 引导内容已直接显示在页面上，无需弹窗
     },
     /**
      * 下载 GPU 客户端
      */
-    handleDownloadClient() {
+    handleDownloadClient(types) {
       // 走后端接口下载客户端程序
 
-
-      let userEmail =JSON.parse(localStorage.getItem('leasEmail'))
+      let userEmail = JSON.parse(localStorage.getItem("leasEmail"));
       if (!userEmail) {
         // 弹出确认框，用户确认后跳转到外部网站
-        this.$confirm('获取用户信息失败，请重新进入网站？', '提示', {
-          confirmButtonText: '确认',
-          cancelButtonText: '取消',
-          type: 'warning'
-        }).then(() => {
-          // 用户点击确认，跳转到外部网站
-          window.open('https://test.m2pool.com/', '_blank')
-        }).catch(() => {
-          // 用户点击取消，不执行任何操作
+        this.$confirm("获取用户信息失败，请重新进入网站？", "提示", {
+          confirmButtonText: "确认",
+          cancelButtonText: "取消",
+          type: "warning",
         })
-        return     
+          .then(() => {
+            // 用户点击确认，跳转到外部网站
+            window.open("https://test.m2pool.com/", "_blank");
+          })
+          .catch(() => {
+            // 用户点击取消，不执行任何操作
+          });
+        return;
       }
-      console.log(userEmail,'userEmail');
-      
-      this.downloadUrl = ` ${request.defaults.baseURL}/lease/user/downloadClient?userEmail=${userEmail}`
-        let a = document.createElement(`a`)
-        a.href = this.downloadUrl
-        a.click()
-
+      console.log(userEmail, "userEmail");
 
+      this.downloadUrl = ` ${request.defaults.baseURL}/lease/user/downloadClient?userEmail=${userEmail}&type=${types}`;
+      let a = document.createElement(`a`);
+      a.href = this.downloadUrl;
+      a.click();
     },
     /**
      * GPU 客户端已启动：跳转至商品列表
      */
     handleGpuClientStarted() {
       // 跳转到“个人中心-商品列表”页面
-      this.$router.push('/account/products')
-    },
-    /**
-     * GPU 弹窗关闭：自动恢复为 ASIC
-     */
-    handleGpuDialogClosed() {
-      this.form.machineCategory = 'ASIC'
-      this.gpuDialogVisible = false
+      this.$router.push("/account/products");
     },
     /** 统一售价校验：多结算币种时跳过，单价时按 USDT 校验 */
     validateCost(rule, value, callback) {
       // 多支付方式：逐个校验 costMap
       if (Array.isArray(this.payTypeDefs) && this.payTypeDefs.length > 0) {
-        return this.validateCostMap(rule, value, callback)
+        return this.validateCostMap(rule, value, callback);
       }
-      const str = String(value || '')
-      if (!str) { callback(new Error('请填写机器成本（USDT）')); return }
-      const pattern = /^\d{1,12}(\.\d{1,2})?$/
-      if (!pattern.test(str)) { callback(new Error('成本整数最多12位，小数最多2位')); return }
-      if (Number(str) <= 0) { callback(new Error('成本必须大于 0')); return }
-      callback()
+      const str = String(value || "");
+      if (!str) {
+        callback(new Error("请填写机器成本（USDT）"));
+        return;
+      }
+      const pattern = /^\d{1,12}(\.\d{1,2})?$/;
+      if (!pattern.test(str)) {
+        callback(new Error("成本整数最多12位，小数最多2位"));
+        return;
+      }
+      if (Number(str) <= 0) {
+        callback(new Error("成本必须大于 0"));
+        return;
+      }
+      callback();
     },
     // 多支付方式下的价格校验：要求每个支付方式都需填写有效价格
     validateCostMap(rule, value, callback) {
       try {
-        const defs = Array.isArray(this.payTypeDefs) ? this.payTypeDefs : []
-        if (!defs.length) { callback(); return }
-        const pattern = /^\d{1,12}(\.\d{1,2})?$/
-        for (let i = 0; i < defs.length; i += 1) {
-          const d = defs[i]
-          const key = d.key
-          const v = this.form && this.form.costMap ? String(this.form.costMap[key] || '') : ''
-          if (!v) { callback(new Error(`请填写 ${d.label} 的价格`)); return }
-          if (!pattern.test(v)) { callback(new Error(`${d.label} 价格整数最多12位，小数最多2位`)); return }
-          if (Number(v) <= 0) { callback(new Error(`${d.label} 价格必须大于0`)); return }
+        const defs = Array.isArray(this.payTypeDefs) ? this.payTypeDefs : [];
+        if (!defs.length) {
+          callback();
+          return;
         }
-        callback()
+        const pattern = /^\d{1,12}(\.\d{1,2})?$/;
+        for (let i = 0; i < defs.length; i += 1) {
+          const d = defs[i];
+          const key = d.key;
+          const v =
+            this.form && this.form.costMap
+              ? String(this.form.costMap[key] || "")
+              : "";
+          if (!v) {
+            callback(new Error(`请填写 ${d.label} 的价格`));
+            return;
+          }
+          if (!pattern.test(v)) {
+            callback(new Error(`${d.label} 价格整数最多12位，小数最多2位`));
+            return;
+          }
+          if (Number(v) <= 0) {
+            callback(new Error(`${d.label} 价格必须大于0`));
+            return;
+          }
+        }
+        callback();
       } catch (e) {
-        callback(new Error('价格填写有误，请检查'))
+        callback(new Error("价格填写有误，请检查"));
       }
     },
     /** 解析路由参数中的支付方式，生成标准定义 */
     initPayTypesFromRoute() {
-      this.payTypeDefs = []
+      this.payTypeDefs = [];
       try {
-        const raw = this.$route.query.payTypes
-        if (!raw) return
-        const arr = JSON.parse(decodeURIComponent(raw))
-        if (!Array.isArray(arr)) return
-        const defs = []
-        arr.forEach(it => {
-          const chain = String(it && it.chain ? it.chain : '').toUpperCase()
-          const coin = String(it && it.coin ? it.coin : '').toUpperCase()
-          if (!chain && !coin) return
-          const key = [chain, coin].filter(Boolean).join('-')
-          const label = key
-          defs.push({ chain, coin, key, label })
-        })
+        const raw = this.$route.query.payTypes;
+        if (!raw) return;
+        const arr = JSON.parse(decodeURIComponent(raw));
+        if (!Array.isArray(arr)) return;
+        const defs = [];
+        arr.forEach((it) => {
+          const chain = String(it && it.chain ? it.chain : "").toUpperCase();
+          const coin = String(it && it.coin ? it.coin : "").toUpperCase();
+          if (!chain && !coin) return;
+          const key = [chain, coin].filter(Boolean).join("-");
+          const label = key;
+          defs.push({ chain, coin, key, label });
+        });
         // 去重
-        const map = new Map()
-        defs.forEach(d => { if (!map.has(d.key)) map.set(d.key, d) })
-        this.payTypeDefs = Array.from(map.values())
+        const map = new Map();
+        defs.forEach((d) => {
+          if (!map.has(d.key)) map.set(d.key, d);
+        });
+        this.payTypeDefs = Array.from(map.values());
         // 初始化统一售价映射
-        const initCostMap = {}
-        this.payTypeDefs.forEach(d => { initCostMap[d.key] = '' })
-        this.form.costMap = initCostMap
-        this.lastCostMapBaseline = { ...initCostMap }
+        const initCostMap = {};
+        this.payTypeDefs.forEach((d) => {
+          initCostMap[d.key] = "";
+        });
+        this.form.costMap = initCostMap;
+        this.lastCostMapBaseline = { ...initCostMap };
       } catch (e) {
-        this.payTypeDefs = []
+        this.payTypeDefs = [];
       }
     },
     handleBack() {
-      this.$router.back()
+      this.$router.back();
     },
     handleNumeric(key) {
       // 仅允许数字和一个小数点
-      let v = String(this.form[key] ?? '')
+      let v = String(this.form[key] ?? "");
       // 清理非法字符
-      v = v.replace(/[^0-9.]/g, '')
+      v = v.replace(/[^0-9.]/g, "");
       // 保留第一个小数点
-      const firstDot = v.indexOf('.')
+      const firstDot = v.indexOf(".");
       if (firstDot !== -1) {
-        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, '')
+        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, "");
       }
-      const endsWithDot = v.endsWith('.')
-      if (key === 'cost') {
+      const endsWithDot = v.endsWith(".");
+      if (key === "cost") {
         // 成本：整数最多12位，小数最多2位
-        const parts = v.split('.')
-        let intPart = parts[0] || ''
-        let decPart = parts[1] || ''
+        const parts = v.split(".");
+        let intPart = parts[0] || "";
+        let decPart = parts[1] || "";
         if (intPart.length > 12) {
-          intPart = intPart.slice(0, 12)
+          intPart = intPart.slice(0, 12);
         }
         if (decPart) {
-          decPart = decPart.slice(0, 2)
+          decPart = decPart.slice(0, 2);
         }
-        v = decPart.length ? `${intPart}.${decPart}` : (endsWithDot ? `${intPart}.` : intPart)
-      } else if (key === 'powerDissipation' || key === 'theoryPower') {
+        v = decPart.length
+          ? `${intPart}.${decPart}`
+          : endsWithDot
+          ? `${intPart}.`
+          : intPart;
+      } else if (key === "powerDissipation" || key === "theoryPower") {
         // 功耗/理论算力：整数最多6位，小数最多4位
-        const parts = v.split('.')
-        let intPart = parts[0] || ''
-        let decPart = parts[1] || ''
+        const parts = v.split(".");
+        let intPart = parts[0] || "";
+        let decPart = parts[1] || "";
         if (intPart.length > 6) {
-          intPart = intPart.slice(0, 6)
+          intPart = intPart.slice(0, 6);
         }
         if (decPart) {
-          decPart = decPart.slice(0, 4)
+          decPart = decPart.slice(0, 4);
         }
-        v = decPart.length ? `${intPart}.${decPart}` : (endsWithDot ? `${intPart}.` : intPart)
-      } else if (key === 'maxLeaseDays') {
+        v = decPart.length
+          ? `${intPart}.${decPart}`
+          : endsWithDot
+          ? `${intPart}.`
+          : intPart;
+      } else if (key === "maxLeaseDays") {
         // 最大租赁天数：仅整数，范围 1-365，输入阶段限制为最多3位数字
-        v = v.replace(/\D/g, '')
-        if (v.length > 3) v = v.slice(0, 3)
-        this.form[key] = v
-        this.syncMaxLeaseDaysToRows()
-        return
+        v = v.replace(/\D/g, "");
+        if (v.length > 3) v = v.slice(0, 3);
+        this.form[key] = v;
+        this.syncMaxLeaseDaysToRows();
+        return;
       } else {
         // 其他：最多6位小数（保持原有逻辑）
         if (firstDot !== -1) {
-          const [intPart, decPart] = v.split('.')
-          v = intPart + '.' + (decPart ? decPart.slice(0, 6) : '')
+          const [intPart, decPart] = v.split(".");
+          v = intPart + "." + (decPart ? decPart.slice(0, 6) : "");
         }
       }
-      this.form[key] = v
+      this.form[key] = v;
     },
     /** 顶部多结算币种统一售价输入 */
     handleCostMapInput(key, val) {
       // 价格输入：整数最多12位，小数最多2位；允许尾随小数点
-      let v = String(val ?? this.form.costMap[key] ?? '')
-      v = v.replace(/[^0-9.]/g, '')
-      const firstDot = v.indexOf('.')
+      let v = String(val ?? this.form.costMap[key] ?? "");
+      v = v.replace(/[^0-9.]/g, "");
+      const firstDot = v.indexOf(".");
       if (firstDot !== -1) {
-        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, '')
+        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, "");
       }
-      const endsWithDot = v.endsWith('.')
-      const parts = v.split('.')
-      let intPart = parts[0] || ''
-      let decPart = parts[1] || ''
-      if (intPart.length > 12) intPart = intPart.slice(0, 12)
-      if (decPart) decPart = decPart.slice(0, 2)
-      v = decPart.length ? `${intPart}.${decPart}` : (endsWithDot ? `${intPart}.` : intPart)
-      this.$set(this.form.costMap, key, v)
+      const endsWithDot = v.endsWith(".");
+      const parts = v.split(".");
+      let intPart = parts[0] || "";
+      let decPart = parts[1] || "";
+      if (intPart.length > 12) intPart = intPart.slice(0, 12);
+      if (decPart) decPart = decPart.slice(0, 2);
+      v = decPart.length
+        ? `${intPart}.${decPart}`
+        : endsWithDot
+        ? `${intPart}.`
+        : intPart;
+      this.$set(this.form.costMap, key, v);
     },
     /**
      * 顶部矿机型号输入：限制20字符
      */
     handleTypeInput() {
-      if (typeof this.form.type === 'string' && this.form.type.length > 20) {
-        this.form.type = this.form.type.slice(0, 20)
+      if (typeof this.form.type === "string" && this.form.type.length > 20) {
+        this.form.type = this.form.type.slice(0, 20);
       }
     },
     syncCostToRows() {
-      const newCost = Number(this.form.cost)
+      const newCost = Number(this.form.cost);
       if (!Number.isFinite(newCost)) {
-        return
+        return;
       }
-      const oldBaseline = this.lastCostBaseline
-      this.selectedMachineRows = this.selectedMachineRows.map(row => {
-        const priceNum = Number(row.price)
+      const oldBaseline = this.lastCostBaseline;
+      this.selectedMachineRows = this.selectedMachineRows.map((row) => {
+        const priceNum = Number(row.price);
         if (!Number.isFinite(priceNum) || priceNum === oldBaseline) {
-          return { ...row, price: newCost }
+          return { ...row, price: newCost };
         }
-        return row
-      })
-      this.lastCostBaseline = newCost
+        return row;
+      });
+      this.lastCostBaseline = newCost;
     },
     updateMachineType() {
       // 仅记录最近一次外层输入，避免无用同步逻辑
-      this.lastTypeBaseline = this.form.type
+      this.lastTypeBaseline = this.form.type;
     },
     /**
      * 行内功耗输入（限制：整数最多6位，小数最多4位）
      */
     handleRowPowerDissipationInput(index) {
-      let v = String(this.selectedMachineRows[index].powerDissipation ?? '')
-      v = v.replace(/[^0-9.]/g, '')
-      const firstDot = v.indexOf('.')
+      let v = String(this.selectedMachineRows[index].powerDissipation ?? "");
+      v = v.replace(/[^0-9.]/g, "");
+      const firstDot = v.indexOf(".");
       if (firstDot !== -1) {
-        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, '')
+        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, "");
       }
-      const endsWithDot = v.endsWith('.')
-      const parts = v.split('.')
-      let intPart = parts[0] || ''
-      let decPart = parts[1] || ''
-      if (intPart.length > 6) intPart = intPart.slice(0, 6)
-      if (decPart) decPart = decPart.slice(0, 4)
-      v = decPart.length ? `${intPart}.${decPart}` : (endsWithDot ? `${intPart}.` : intPart)
-      this.$set(this.selectedMachineRows[index], 'powerDissipation', v)
+      const endsWithDot = v.endsWith(".");
+      const parts = v.split(".");
+      let intPart = parts[0] || "";
+      let decPart = parts[1] || "";
+      if (intPart.length > 6) intPart = intPart.slice(0, 6);
+      if (decPart) decPart = decPart.slice(0, 4);
+      v = decPart.length
+        ? `${intPart}.${decPart}`
+        : endsWithDot
+        ? `${intPart}.`
+        : intPart;
+      this.$set(this.selectedMachineRows[index], "powerDissipation", v);
     },
     /**
      * 行内功耗校验
      */
     handleRowPowerDissipationBlur(index) {
-      const raw = String(this.selectedMachineRows[index].powerDissipation ?? '')
-      const pattern = /^\d{1,6}(\.\d{1,4})?$/
+      const raw = String(
+        this.selectedMachineRows[index].powerDissipation ?? ""
+      );
+      const pattern = /^\d{1,6}(\.\d{1,4})?$/;
       if (!raw || Number(raw) <= 0 || !pattern.test(raw)) {
-        this.$message.warning('功耗需大于0，整数最多6位，小数最多4位')
-        this.$set(this.selectedMachineRows[index], 'powerDissipation', '')
+        this.$message.warning("功耗需大于0，整数最多6位，小数最多4位");
+        this.$set(this.selectedMachineRows[index], "powerDissipation", "");
       }
     },
     /**
      * 行内理论算力输入（限制：整数最多6位，小数最多4位）
      */
     handleRowTheoryPowerInput(index) {
-      let v = String(this.selectedMachineRows[index].theoryPower ?? '')
-      v = v.replace(/[^0-9.]/g, '')
-      const firstDot = v.indexOf('.')
+      let v = String(this.selectedMachineRows[index].theoryPower ?? "");
+      v = v.replace(/[^0-9.]/g, "");
+      const firstDot = v.indexOf(".");
       if (firstDot !== -1) {
-        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, '')
+        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, "");
       }
-      const endsWithDot = v.endsWith('.')
-      const parts = v.split('.')
-      let intPart = parts[0] || ''
-      let decPart = parts[1] || ''
-      if (intPart.length > 6) intPart = intPart.slice(0, 6)
-      if (decPart) decPart = decPart.slice(0, 4)
-      v = decPart.length ? `${intPart}.${decPart}` : (endsWithDot ? `${intPart}.` : intPart)
-      this.$set(this.selectedMachineRows[index], 'theoryPower', v)
+      const endsWithDot = v.endsWith(".");
+      const parts = v.split(".");
+      let intPart = parts[0] || "";
+      let decPart = parts[1] || "";
+      if (intPart.length > 6) intPart = intPart.slice(0, 6);
+      if (decPart) decPart = decPart.slice(0, 4);
+      v = decPart.length
+        ? `${intPart}.${decPart}`
+        : endsWithDot
+        ? `${intPart}.`
+        : intPart;
+      this.$set(this.selectedMachineRows[index], "theoryPower", v);
     },
     /**
      * 行内理论算力校验
      */
     handleRowTheoryPowerBlur(index) {
-      const raw = String(this.selectedMachineRows[index].theoryPower ?? '')
-      const pattern = /^\d{1,6}(\.\d{1,4})?$/
+      const raw = String(this.selectedMachineRows[index].theoryPower ?? "");
+      const pattern = /^\d{1,6}(\.\d{1,4})?$/;
       if (!raw || Number(raw) <= 0 || !pattern.test(raw)) {
-        this.$message.warning('理论算力需大于0，整数最多6位，小数最多4位')
-        this.$set(this.selectedMachineRows[index], 'theoryPower', '')
+        this.$message.warning("理论算力需大于0，整数最多6位，小数最多4位");
+        this.$set(this.selectedMachineRows[index], "theoryPower", "");
       }
     },
     /**
      * 行内单位变更
      */
     handleRowUnitChange(index, value) {
-      this.$set(this.selectedMachineRows[index], 'unit', value)
+      this.$set(this.selectedMachineRows[index], "unit", value);
     },
     syncMaxLeaseDaysToRows() {
-      const raw = this.form.maxLeaseDays
-      const n = Number(raw)
-      if (!Number.isInteger(n)) return
-      const oldBaseline = this.lastMaxLeaseDaysBaseline
-      this.selectedMachineRows = this.selectedMachineRows.map(row => {
-        const rowNum = Number(row.maxLeaseDays)
+      const raw = this.form.maxLeaseDays;
+      const n = Number(raw);
+      if (!Number.isInteger(n)) return;
+      const oldBaseline = this.lastMaxLeaseDaysBaseline;
+      this.selectedMachineRows = this.selectedMachineRows.map((row) => {
+        const rowNum = Number(row.maxLeaseDays);
         if (!Number.isInteger(rowNum) || rowNum === oldBaseline) {
-          return { ...row, maxLeaseDays: n }
+          return { ...row, maxLeaseDays: n };
         }
-        return row
-      })
-      this.lastMaxLeaseDaysBaseline = n
+        return row;
+      });
+      this.lastMaxLeaseDaysBaseline = n;
     },
     handleRowMaxLeaseDaysInput(index) {
-      let v = String(this.selectedMachineRows[index].maxLeaseDays ?? '')
-      v = v.replace(/\D/g, '')
-      if (v.length > 3) v = v.slice(0, 3)
-      this.$set(this.selectedMachineRows[index], 'maxLeaseDays', v)
+      let v = String(this.selectedMachineRows[index].maxLeaseDays ?? "");
+      v = v.replace(/\D/g, "");
+      if (v.length > 3) v = v.slice(0, 3);
+      this.$set(this.selectedMachineRows[index], "maxLeaseDays", v);
     },
     handleRowMaxLeaseDaysBlur(index) {
-      const raw = String(this.selectedMachineRows[index].maxLeaseDays ?? '')
+      const raw = String(this.selectedMachineRows[index].maxLeaseDays ?? "");
       if (!/^\d{1,3}$/.test(raw)) {
-        this.$message.warning('最大租赁天数需为 1-365 的整数')
-        this.$set(this.selectedMachineRows[index], 'maxLeaseDays', '')
-        return
+        this.$message.warning("最大租赁天数需为 1-365 的整数");
+        this.$set(this.selectedMachineRows[index], "maxLeaseDays", "");
+        return;
       }
-      const n = Number(raw)
+      const n = Number(raw);
       if (!Number.isInteger(n) || n < 1 || n > 365) {
-        this.$message.warning('最大租赁天数需为 1-365 的整数')
-        this.$set(this.selectedMachineRows[index], 'maxLeaseDays', '')
+        this.$message.warning("最大租赁天数需为 1-365 的整数");
+        this.$set(this.selectedMachineRows[index], "maxLeaseDays", "");
       }
     },
     handleRowPriceInput(index) {
       // 价格输入：整数最多12位，小数最多2位；允许尾随小数点
-      let v = String(this.selectedMachineRows[index].price ?? '')
-      v = v.replace(/[^0-9.]/g, '')
-      const firstDot = v.indexOf('.')
+      let v = String(this.selectedMachineRows[index].price ?? "");
+      v = v.replace(/[^0-9.]/g, "");
+      const firstDot = v.indexOf(".");
       if (firstDot !== -1) {
-        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, '')
+        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, "");
       }
-      const endsWithDot = v.endsWith('.')
-      const parts = v.split('.')
-      let intPart = parts[0] || ''
-      let decPart = parts[1] || ''
-      if (intPart.length > 12) { intPart = intPart.slice(0, 12) }
-      if (decPart) { decPart = decPart.slice(0, 2) }
-      v = decPart.length ? `${intPart}.${decPart}` : (endsWithDot ? `${intPart}.` : intPart)
-      this.$set(this.selectedMachineRows[index], 'price', v)
+      const endsWithDot = v.endsWith(".");
+      const parts = v.split(".");
+      let intPart = parts[0] || "";
+      let decPart = parts[1] || "";
+      if (intPart.length > 12) {
+        intPart = intPart.slice(0, 12);
+      }
+      if (decPart) {
+        decPart = decPart.slice(0, 2);
+      }
+      v = decPart.length
+        ? `${intPart}.${decPart}`
+        : endsWithDot
+        ? `${intPart}.`
+        : intPart;
+      this.$set(this.selectedMachineRows[index], "price", v);
     },
     /** 行内多结算币种价格输入 */
     handleRowPriceMapInput(index, key) {
       // 价格输入：整数最多12位，小数最多2位；允许尾随小数点
-      const row = this.selectedMachineRows[index]
-      const map = { ...(row.priceMap || {}) }
-      let v = String(map[key] ?? '')
-      v = v.replace(/[^0-9.]/g, '')
-      const firstDot = v.indexOf('.')
+      const row = this.selectedMachineRows[index];
+      const map = { ...(row.priceMap || {}) };
+      let v = String(map[key] ?? "");
+      v = v.replace(/[^0-9.]/g, "");
+      const firstDot = v.indexOf(".");
       if (firstDot !== -1) {
-        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, '')
+        v = v.slice(0, firstDot + 1) + v.slice(firstDot + 1).replace(/\./g, "");
       }
-      const endsWithDot = v.endsWith('.')
-      const parts = v.split('.')
-      let intPart = parts[0] || ''
-      let decPart = parts[1] || ''
-      if (intPart.length > 12) intPart = intPart.slice(0, 12)
-      if (decPart) decPart = decPart.slice(0, 2)
-      v = decPart.length ? `${intPart}.${decPart}` : (endsWithDot ? `${intPart}.` : intPart)
-      map[key] = v
-      this.$set(this.selectedMachineRows[index], 'priceMap', map)
+      const endsWithDot = v.endsWith(".");
+      const parts = v.split(".");
+      let intPart = parts[0] || "";
+      let decPart = parts[1] || "";
+      if (intPart.length > 12) intPart = intPart.slice(0, 12);
+      if (decPart) decPart = decPart.slice(0, 2);
+      v = decPart.length
+        ? `${intPart}.${decPart}`
+        : endsWithDot
+        ? `${intPart}.`
+        : intPart;
+      map[key] = v;
+      this.$set(this.selectedMachineRows[index], "priceMap", map);
     },
     handleRowPriceMapBlur(index, key) {
-      const row = this.selectedMachineRows[index]
-      const raw = String((row.priceMap && row.priceMap[key]) ?? '')
-      const pattern = /^\d{1,12}(\.\d{1,2})?$/
+      const row = this.selectedMachineRows[index];
+      const raw = String((row.priceMap && row.priceMap[key]) ?? "");
+      const pattern = /^\d{1,12}(\.\d{1,2})?$/;
       if (!raw || Number(raw) <= 0 || !pattern.test(raw)) {
-        this.$message.warning('价格必须大于0，整数最多12位，小数最多2位')
-        const map = { ...(row.priceMap || {}) }
-        map[key] = ''
-        this.$set(this.selectedMachineRows[index], 'priceMap', map)
+        this.$message.warning("价格必须大于0，整数最多12位，小数最多2位");
+        const map = { ...(row.priceMap || {}) };
+        map[key] = "";
+        this.$set(this.selectedMachineRows[index], "priceMap", map);
       }
     },
     handleRowPriceBlur(index) {
-      const raw = String(this.selectedMachineRows[index].price ?? '')
-      const pattern = /^\d{1,12}(\.\d{1,2})?$/
+      const raw = String(this.selectedMachineRows[index].price ?? "");
+      const pattern = /^\d{1,12}(\.\d{1,2})?$/;
       if (!raw || Number(raw) <= 0 || !pattern.test(raw)) {
-        this.$message.warning('价格必须大于0，整数最多12位，小数最多2位')
-        this.$set(this.selectedMachineRows[index], 'price', '')
+        this.$message.warning("价格必须大于0，整数最多12位，小数最多2位");
+        this.$set(this.selectedMachineRows[index], "price", "");
       }
     },
     handleRowTypeInput(index) {
       // 处理矿机型号输入
-      const raw = String(this.selectedMachineRows[index].type || '')
-      const v = raw.length > 20 ? raw.slice(0, 20) : raw
-      this.$set(this.selectedMachineRows[index], 'type', v)
+      const raw = String(this.selectedMachineRows[index].type || "");
+      const v = raw.length > 20 ? raw.slice(0, 20) : raw;
+      this.$set(this.selectedMachineRows[index], "type", v);
     },
     handleRowTypeBlur(index) {
-      const raw = this.selectedMachineRows[index].type
-      const isOnlySpaces = (v) => typeof v === 'string' && v.length > 0 && v.trim().length === 0
+      const raw = this.selectedMachineRows[index].type;
+      const isOnlySpaces = (v) =>
+        typeof v === "string" && v.length > 0 && v.trim().length === 0;
       if (isOnlySpaces(raw)) {
-        this.$message.warning('矿机型号不能全是空格')
-        this.$set(this.selectedMachineRows[index], 'type', '')
+        this.$message.warning("矿机型号不能全是空格");
+        this.$set(this.selectedMachineRows[index], "type", "");
       }
     },
     handleToggleState(index) {
       // 切换上下架状态：0上架，1下架
-      const currentState = this.selectedMachineRows[index].state
-      this.$set(this.selectedMachineRows[index], 'state', currentState === 0 ? 1 : 0)
+      const currentState = this.selectedMachineRows[index].state;
+      this.$set(
+        this.selectedMachineRows[index],
+        "state",
+        currentState === 0 ? 1 : 0
+      );
     },
     async fetchMiners() {
-      this.minersLoading = true
+      this.minersLoading = true;
       try {
         // 按商品币种筛选挖矿账户
-        const res = await getUserMinersList({ coin: this.form.coin || "" })
-        const data = res?.data
-        let list = []
+        const res = await getUserMinersList({ coin: this.form.coin || "" });
+        const data = res?.data;
+        let list = [];
         if (Array.isArray(data)) {
-          list = data
-        } else if (data && typeof data === 'object') {
+          list = data;
+        } else if (data && typeof data === "object") {
           // 现在的结构是 { coin: [ { user, coin }, ... ], coin2: [...] }
-          Object.keys(data).forEach(coinKey => {
-            const arr = Array.isArray(data[coinKey]) ? data[coinKey] : []
-            arr.forEach(item => {
+          Object.keys(data).forEach((coinKey) => {
+            const arr = Array.isArray(data[coinKey]) ? data[coinKey] : [];
+            arr.forEach((item) => {
               if (item && item.user && item.coin) {
-                list.push({ user: item.user, coin: item.coin, miner: item.miner || null })
+                list.push({
+                  user: item.user,
+                  coin: item.coin,
+                  miner: item.miner || null,
+                });
               }
-            })
-          })
+            });
+          });
         } else if (data && data.additionalProperties1) {
-          list = [data.additionalProperties1]
+          list = [data.additionalProperties1];
         }
 
         // 如页面带了 product coin，则仅展示该币种的账户
         if (this.form.coin) {
-          list = list.filter(i => i.coin === this.form.coin)
+          list = list.filter((i) => i.coin === this.form.coin);
         }
-        this.miners = list
+        this.miners = list;
       } catch (e) {
-        console.error('获取挖矿账户失败', e)
+        console.error("获取挖矿账户失败", e);
       } finally {
-        this.minersLoading = false
+        this.minersLoading = false;
       }
     },
     async handleMinerChange(val) {
-      this.selectedMachines = []
+      this.selectedMachines = [];
       if (!val) {
-        this.machineOptions = []
-        return
+        this.machineOptions = [];
+        return;
       }
-      const [user, coin] = val.split('|')
-      this.machinesLoading = true
+      const [user, coin] = val.split("|");
+      this.machinesLoading = true;
       try {
         // 按照API文档要求，传递 userMinerVo 对象
         const userMinerVo = {
           coin: coin,
-          user: user
-        }
-        const res = await getUserMachineList(userMinerVo)
-        const data = res?.data || []
-        this.machineOptions = Array.isArray(data) ? data : []
-        
+          user: user,
+        };
+        const res = await getUserMachineList(userMinerVo);
+        const data = res?.data || [];
+        this.machineOptions = Array.isArray(data) ? data : [];
+
         // 调试信息
-        console.log('选择挖矿账户:', { user, coin })
-        console.log('获取机器列表响应:', res)
-        console.log('机器列表数据:', this.machineOptions)
+        console.log("选择挖矿账户:", { user, coin });
+        console.log("获取机器列表响应:", res);
+        console.log("机器列表数据:", this.machineOptions);
       } catch (e) {
-        console.error('获取机器列表失败', e)
-       
+        console.error("获取机器列表失败", e);
       } finally {
-        this.machinesLoading = false
+        this.machinesLoading = false;
       }
     },
     async handleSave() {
       // 表单校验（除矿机型号外其他必填）
       try {
-        const ok = await this.$refs.machineForm.validate()
+        const ok = await this.$refs.machineForm.validate();
         if (!ok) {
-          return
+          return;
         }
       } catch (e) {
-        return
+        return;
       }
       // if (!this.form.productId) {
       //   this.$message.warning('缺少商品ID')
@@ -1159,56 +1456,62 @@ export default {
       // 现在统一按出售数量提交（GPU 模式不在本页提交）
       {
         // ASIC：校验出售机器数量（允许 0-9999；为 0 则提示）
-        const raw = String(this.form.sellCount ?? '')
-        if (raw === '') {
-          this.$message.warning('请输入出售机器数量')
-          return
+        const raw = String(this.form.sellCount ?? "");
+        if (raw === "") {
+          this.$message.warning("请输入出售机器数量");
+          return;
         }
-        const n = Number(raw)
+        const n = Number(raw);
         if (!Number.isInteger(n) || n < 0 || n > 9999) {
-          this.$message.warning('出售机器数量需为 0-9999 的整数')
-          return
+          this.$message.warning("出售机器数量需为 0-9999 的整数");
+          return;
         }
         if (n === 0) {
-          this.$message.warning('出售机器数量为 0，无需提交')
-          return
+          this.$message.warning("出售机器数量为 0，无需提交");
+          return;
         }
       }
       // 校验：矿机型号不可全空格（允许为空或包含空格的正常文本）
-      const isOnlySpaces = (v) => typeof v === 'string' && v.length > 0 && v.trim().length === 0
+      const isOnlySpaces = (v) =>
+        typeof v === "string" && v.length > 0 && v.trim().length === 0;
       if (isOnlySpaces(this.form.type)) {
-        this.$message.warning('矿机型号不能全是空格')
-        return
+        this.$message.warning("矿机型号不能全是空格");
+        return;
       }
-      const invalidTypeRowIndex = this.selectedMachineRows.findIndex(r => isOnlySpaces(r.type))
+      const invalidTypeRowIndex = this.selectedMachineRows.findIndex((r) =>
+        isOnlySpaces(r.type)
+      );
       if (invalidTypeRowIndex !== -1) {
-        this.$message.warning('存在行的矿机型号全是空格，请修正后再试')
-        return
+        this.$message.warning("存在行的矿机型号全是空格，请修正后再试");
+        return;
       }
       // 统一售价与最大租赁天数已在表单级校验中处理，无需逐机校验
       // 组装确认数据并弹框
-      const coinStr = this.buildCoinCsvFromRows()
-      const algoStr = this.buildAlgoCsvFromRows()
+      const coinStr = this.buildCoinCsvFromRows();
+      const algoStr = this.buildAlgoCsvFromRows();
       this.confirmData = {
-        coin: coinStr || '-',
-        algorithm: algoStr || '-',
+        coin: coinStr || "-",
+        algorithm: algoStr || "-",
         maxLeaseDays: this.form.maxLeaseDays,
         saleNumbers: this.form.sellCount,
-        priceList: this.buildPriceList()
-      }
-      this.confirmVisible = true
-    }
-    ,
+        priceList: this.buildPriceList(),
+      };
+      this.confirmVisible = true;
+    },
     async doSubmit() {
-      this.saving = true
+      this.saving = true;
       try {
         // 统一售卖新增接口参数
-        const list = (this.form.coinAndAlgoList || []).map(r => ({
-          coin: String(r.coin || '').toUpperCase().trim(),
-          algorithm: String(r.algorithm || '').toUpperCase().trim(),
+        const list = (this.form.coinAndAlgoList || []).map((r) => ({
+          coin: String(r.coin || "")
+            .toUpperCase()
+            .trim(),
+          algorithm: String(r.algorithm || "")
+            .toUpperCase()
+            .trim(),
           theoryPower: Number(r.theoryPower) || 0,
-          unit: r.unit
-        }))
+          unit: r.unit,
+        }));
         const payload = {
           // 逗号分隔（中英文逗号都兼容），统一为英文逗号并大写
           coinAndAlgoList: list,
@@ -1216,48 +1519,73 @@ export default {
           name: this.form.type,
           powerDissipation: Number(this.form.powerDissipation) || 0,
           saleNumbers: Number(this.form.sellCount) || 0,
-          priceList: this.buildPriceList()
-        }
+          priceList: this.buildPriceList(),
+        };
         // 过滤空价目
-        payload.priceList = (payload.priceList || []).filter(p => Number(p.price) > 0)
+        payload.priceList = (payload.priceList || []).filter(
+          (p) => Number(p.price) > 0
+        );
 
-        console.log(payload,"请求参数")
+        console.log(payload, "请求参数");
 
-        const res = await addAsicMachine(payload)
+        const res = await addAsicMachine(payload);
         if (res && (res.code === 0 || res.code === 200)) {
-        
           this.$message({
-            message: '添加成功',
+            message: "添加成功",
             duration: 3000,
             showClose: true,
-            type: 'success'
-          })
-          this.confirmVisible = false
-          this.$router.push('/account/products')
-        } 
+            type: "success",
+          });
+          this.confirmVisible = false;
+          this.$router.push("/account/products");
+        }
       } catch (e) {
-        console.error('添加出售机器失败', e)
-        console.log('添加失败')
+        console.error("添加出售机器失败", e);
+        console.log("添加失败");
       } finally {
-        this.saving = false
+        this.saving = false;
       }
-    }
-  }
-  
-}
+    },
+  },
+};
 </script>
 
 <style scoped>
-.product-machine-add { padding: 8px; }
-.header { display: flex; align-items: center; gap: 12px; margin-bottom: 8px; }
-.title { margin: 0; font-size: 18px; font-weight: 600; }
-.notice-alert { margin-bottom: 12px; }
-.notice-alert :deep(.el-alert__content) { text-align: left; }
+.product-machine-add {
+  padding: 8px;
+}
+.header {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 8px;
+}
+.title {
+  margin: 0;
+  font-size: 18px;
+  font-weight: 600;
+}
+.notice-alert {
+  margin-bottom: 12px;
+}
+.notice-alert :deep(.el-alert__content) {
+  text-align: left;
+}
 .notice-alert :deep(.el-alert__title),
-.notice-alert :deep(.el-alert__description) { text-align: left; }
-.label-help { margin-left: 4px; color: #909399; cursor: help; }
-.form-card { margin-bottom: 12px; }
-.actions { text-align: left; }
+.notice-alert :deep(.el-alert__description) {
+  text-align: left;
+}
+.label-help {
+  margin-left: 4px;
+  color: #909399;
+  cursor: help;
+}
+.form-card {
+  margin-bottom: 12px;
+}
+.actions {
+  text-align: left;
+}
 
 /* 统一左对齐，控件宽度 50% */
 .product-machine-add :deep(.el-form-item__content) {
@@ -1274,19 +1602,31 @@ export default {
   border-left: 1px solid #dcdfe6;
 }
 
-::v-deep .el-form-item__content{
-    text-align: left;
- padding-left: 18px !important;
+::v-deep .el-form-item__content {
+  text-align: left;
+  padding-left: 18px !important;
 }
 
 /* 多结算币种价格输入的布局优化 */
-.cost-multi { display: grid; gap: 8px; }
-.cost-item { display: flex; align-items: center; }
-.price-multi { display: grid; gap: 8px; }
-.price-items { display: grid; gap: 8px; }
+.cost-multi {
+  display: grid;
+  gap: 8px;
+}
+.cost-item {
+  display: flex;
+  align-items: center;
+}
+.price-multi {
+  display: grid;
+  gap: 8px;
+}
+.price-items {
+  display: grid;
+  gap: 8px;
+}
 /* 让 链-币种 附加区同宽、居中显示，整体对齐 */
 .price-item :deep(.el-input-group__append),
-.cost-item :deep(.el-input-group__append){
+.cost-item :deep(.el-input-group__append) {
   width: 110px;
   min-width: 110px;
   text-align: center;
@@ -1296,27 +1636,95 @@ export default {
 }
 /* 缩小输入高度并保持垂直居中 */
 .price-item :deep(.el-input__inner),
-.cost-item :deep(.el-input__inner){
+.cost-item :deep(.el-input__inner) {
   height: 30px;
   line-height: 30px;
 }
 /* 让组内附加区高度与输入一致 */
 .price-item :deep(.el-input-group__append),
-.cost-item :deep(.el-input-group__append){
+.cost-item :deep(.el-input-group__append) {
   height: 30px;
   line-height: 30px;
 }
 /* 略微收紧间距，让整体更紧凑 */
-.price-multi { gap: 6px; }
-.price-items { gap: 6px; }
-.cost-multi { gap: 6px; }
+.price-multi {
+  gap: 6px;
+}
+.price-items {
+  gap: 6px;
+}
+.cost-multi {
+  gap: 6px;
+}
 /* ASIC 币种/算法/算力/单位 多行 */
-.coin-algo-rows { display: grid; gap: 8px; width: 100%; }
-.coin-algo-line { display: flex; align-items: center; gap: 8px; }
-.coin-algo-line .coin-input { width: 18%; min-width: 140px; }
-.coin-algo-line .algo-input { width: 24%; min-width: 160px; }
-.coin-algo-line .power-input { width: 20%; min-width: 140px; }
-.coin-algo-line .unit-select { width: 16%; min-width: 120px; }
-.coin-algo-line .op-btn { flex: 0 0 auto; }
+.coin-algo-rows {
+  display: grid;
+  gap: 8px;
+  width: 100%;
+}
+.coin-algo-line {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.coin-algo-line .coin-input {
+  width: 18%;
+  min-width: 140px;
+}
+.coin-algo-line .algo-input {
+  width: 24%;
+  min-width: 160px;
+}
+.coin-algo-line .power-input {
+  width: 20%;
+  min-width: 140px;
+}
+.coin-algo-line .unit-select {
+  width: 16%;
+  min-width: 120px;
+}
+.coin-algo-line .op-btn {
+  flex: 0 0 auto;
+}
+/* GPU 引导区域样式 */
+.gpu-guide-section {
+  margin-bottom: 12px;
+  margin-left: 86px;
+}
+.gpu-guide-card {
+  padding: 20px;
+  background: #f9fafb;
+   width: 85%;
+}
+.gpu-guide-content {
+  text-align: left;
+  line-height: 1.7;
+  font-size: 15px;
+  color: #555;
+}
+.gpu-guide-title {
+  margin-bottom: 8px;
+  font-weight: 600;
+  font-size: 16px;
+  color: #333;
+}
+.gpu-guide-list {
+  padding-left: 18px;
+  margin: 0;
+  font-size: 15px;
+  line-height: 1.8;
+}
+.gpu-guide-list li {
+  margin-bottom: 8px;
+}
+.gpu-guide-list li:last-child {
+  margin-bottom: 0;
+}
+.gpu-guide-buttons {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-top: 16px;
+}
 </style>
 
diff --git a/power_leasing/src/views/account/purchasedMachineConfig.vue b/power_leasing/src/views/account/purchasedMachineConfig.vue
new file mode 100644
index 0000000..5ced14c
--- /dev/null
+++ b/power_leasing/src/views/account/purchasedMachineConfig.vue
@@ -0,0 +1,421 @@
+<template>
+  <div class="account-purchased-machine-config">
+    <div class="toolbar">
+      <div class="left-area">
+        <h2 class="page-title">已购矿机配置</h2>
+      </div>
+    </div>
+
+    <el-table
+      :data="tableData"
+      v-loading="loading"
+      border
+      stripe
+      style="width: 100%"
+      :header-cell-style="{ textAlign: 'left' }"
+      :cell-style="{ textAlign: 'left' }"
+    >
+      <el-table-column type="expand" width="46">
+        <template #default="scope">
+          <div class="expand-content">
+            <div class="expand-row" v-if="scope.row.walletAddress">
+              <div class="expand-label">钱包地址：</div>
+              <div class="expand-value">
+                <span class="mono-ellipsis" style="font-family: monospace;">{{ scope.row.walletAddress }}</span>
+                <el-button 
+                  type="text" 
+                  size="mini" 
+                  icon="el-icon-document-copy" 
+                  @click="handleCopy(scope.row.walletAddress, '钱包地址')"
+                  class="copy-btn"
+                >
+                  复制
+                </el-button>
+              </div>
+            </div>
+            <div class="expand-row" v-if="scope.row.poolUrl">
+              <div class="expand-label">矿池地址：</div>
+              <div class="expand-value">
+                <span class="mono-ellipsis">{{ scope.row.poolUrl }}</span>
+                <el-button 
+                  type="text" 
+                  size="mini" 
+                  icon="el-icon-document-copy" 
+                  @click="handleCopy(scope.row.poolUrl, '矿池地址')"
+                  class="copy-btn"
+                >
+                  复制
+                </el-button>
+              </div>
+            </div>
+            <div class="expand-row" v-if="scope.row.watchUrl">
+              <div class="expand-label">挖矿信息页面地址：</div>
+              <div class="expand-value">
+                <span class="mono-ellipsis">{{ scope.row.watchUrl }}</span>
+                <el-button 
+                  type="text" 
+                  size="mini" 
+                  icon="el-icon-document-copy" 
+                  @click="handleCopy(scope.row.watchUrl, '挖矿信息页面地址')"
+                  class="copy-btn"
+                >
+                  复制
+                </el-button>
+              </div>
+            </div>
+            <div v-if="!scope.row.walletAddress && !scope.row.poolUrl && !scope.row.watchUrl" class="expand-empty">
+              暂无地址信息
+            </div>
+          </div>
+        </template>
+      </el-table-column>
+
+      <!-- <el-table-column prop="id" label="ID" width="80" /> -->
+      
+      <el-table-column prop="coin" label="币种" width="100">
+        <template #default="scope">
+          <span>{{ scope.row.coin || '—' }}</span>
+        </template>
+      </el-table-column>
+
+      <el-table-column prop="algorithm" label="算法" min-width="120">
+        <template #default="scope">
+          <span>{{ scope.row.algorithm || '—' }}</span>
+        </template>
+      </el-table-column>
+
+      <el-table-column prop="pool" label="矿池" min-width="140">
+        <template #default="scope">
+          <span>{{ scope.row.pool || '—' }}</span>
+        </template>
+      </el-table-column>
+
+      <el-table-column prop="poolUser" label="矿池用户" min-width="140">
+        <template #default="scope">
+          <span>{{ scope.row.poolUser || '—' }}</span>
+        </template>
+      </el-table-column>
+
+ 
+
+      <el-table-column prop="startTime" label="开始时间" min-width="160">
+        <template #default="scope">
+          <span>{{ formatDateTime(scope.row.startTime) }}</span>
+        </template>
+      </el-table-column>
+
+      <el-table-column prop="endTime" label="结束时间" min-width="160">
+        <template #default="scope">
+          <span>{{ formatDateTime(scope.row.endTime) }}</span>
+        </template>
+      </el-table-column>
+
+      <el-table-column prop="status" label="状态" width="140">
+        <template #default="scope">
+          <el-tag :type="getStatusType(scope.row.status)">
+            {{ getStatusText(scope.row.status) }}
+          </el-tag>
+        </template>
+      </el-table-column>
+    </el-table>
+
+    <div class="pagination">
+      <el-pagination
+        background
+        layout="total, sizes, prev, pager, next, jumper"
+        :total="total"
+        :current-page.sync="pagination.pageNum"
+        :page-sizes="[10, 20, 50, 100]"
+        :page-size.sync="pagination.pageSize"
+        @size-change="handleSizeChange"
+        @current-change="handleCurrentChange"
+      />
+    </div>
+  </div>
+</template>
+
+<script>
+import { getPurchasedItems } from '../../api/order'
+
+/**
+ * 已购矿机配置页面
+ * - 展示已购买矿机的配置信息
+ * - 支持分页查询
+ */
+export default {
+  name: 'AccountPurchasedMachineConfig',
+  data() {
+    return {
+      loading: false,
+      tableData: [],
+      pagination: {
+        pageNum: 1,
+        pageSize: 10
+      },
+      total: 0,
+      totalPage: 0
+    }
+  },
+  created() {
+    this.fetchTableData()
+  },
+  methods: {
+    /**
+     * 获取已购矿机配置列表
+     */
+    async fetchTableData() {
+      this.loading = true
+      try {
+        const params = {
+          pageNum: this.pagination.pageNum,
+          pageSize: this.pagination.pageSize
+        }
+        const res = await getPurchasedItems(params)
+        if (res && (res.code === 0 || res.code === 200)) {
+          this.tableData = Array.isArray(res.rows) ? res.rows : []
+          this.total = Number(res.total || 0)
+          this.totalPage = Number(res.totalPage || 0)
+        } else {
+          this.tableData = []
+          this.total = 0
+          this.totalPage = 0
+        }
+      } catch (e) {
+        console.error('获取已购矿机配置失败', e)
+        this.$message({
+          message: '获取已购矿机配置失败，请重试',
+          type: 'error',
+          showClose: true
+        })
+        this.tableData = []
+        this.total = 0
+        this.totalPage = 0
+      } finally {
+        this.loading = false
+      }
+    },
+    /**
+     * 处理分页大小变化
+     * @param {number} size - 新的分页大小
+     */
+    handleSizeChange(size) {
+      this.pagination.pageSize = size
+      this.pagination.pageNum = 1
+      this.fetchTableData()
+    },
+    /**
+     * 处理当前页变化
+     * @param {number} page - 新的页码
+     */
+    handleCurrentChange(page) {
+      this.pagination.pageNum = page
+      this.fetchTableData()
+    },
+    /**
+     * 格式化日期时间
+     * @param {string|number} value - 日期时间值
+     * @returns {string} 格式化后的日期时间字符串
+     */
+    formatDateTime(value) {
+      if (!value) return '—'
+      try {
+        const str = String(value)
+        return str.includes('T') ? str.replace('T', ' ') : str
+      } catch (e) {
+        return String(value)
+      }
+    },
+    /**
+     * 复制文本到剪贴板
+     * @param {string} text - 需要复制的内容
+     * @param {string} label - 语义标签，用于提示文案
+     */
+    async handleCopy(text, label = '内容') {
+      if (!text) {
+        this.$message({
+          message: `${label}为空，无法复制`,
+          type: 'warning',
+          showClose: true
+        })
+        return
+      }
+      
+      try {
+        const value = String(text).trim()
+        if (navigator && navigator.clipboard && navigator.clipboard.writeText) {
+          await navigator.clipboard.writeText(value)
+          this.$message({
+            message: `${label}已复制到剪贴板`,
+            type: 'success',
+            showClose: true
+          })
+        } else {
+          // 备用复制方法
+          const textArea = document.createElement('textarea')
+          textArea.value = value
+          textArea.style.position = 'fixed'
+          textArea.style.left = '-9999px'
+          document.body.appendChild(textArea)
+          textArea.focus()
+          textArea.select()
+          try {
+            document.execCommand('copy')
+            this.$message({
+              message: `${label}已复制到剪贴板`,
+              type: 'success',
+              showClose: true
+            })
+          } catch (err) {
+            this.$message({
+              message: '复制失败，请手动复制',
+              type: 'error',
+              showClose: true
+            })
+          }
+          document.body.removeChild(textArea)
+        }
+      } catch (e) {
+        console.error('复制失败', e)
+        this.$message({
+          message: '复制失败，请手动复制',
+          type: 'error',
+          showClose: true
+        })
+      }
+    },
+    /**
+     * 获取状态文本
+     * @param {number|boolean} status - 状态值
+     * @returns {string} 状态文本
+     */
+    getStatusText(status) {
+      const statusNum = Number(status)
+      if (statusNum === 0) return '租约已到期'
+      if (statusNum === 1) return '挖矿中'
+      if (statusNum === 2) return '卖家矿机启动中'
+      // 兼容旧数据（boolean类型）
+      if (status === true) return '挖矿中'
+      return '未知状态'
+    },
+    /**
+     * 获取状态标签类型
+     * @param {number|boolean} status - 状态值
+     * @returns {string} el-tag 的类型
+     */
+    getStatusType(status) {
+      const statusNum = Number(status)
+      if (statusNum === 0) return 'info'      // 租约已到期 - 灰色
+      if (statusNum === 1) return 'success'  // 挖矿中 - 绿色
+      if (statusNum === 2) return 'warning'  // 卖家矿机启动中 - 黄色
+      // 兼容旧数据（boolean类型）
+      if (status === true) return 'success'
+      return 'info'
+    }
+  }
+}
+</script>
+
+<style scoped>
+.account-purchased-machine-config {
+  padding: 4px;
+}
+
+.toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 12px;
+}
+
+.left-area {
+  display: flex;
+  align-items: center;
+}
+
+.page-title {
+  margin: 0;
+  font-size: 18px;
+  font-weight: 600;
+  color: #2c3e50;
+}
+
+.pagination {
+  display: flex;
+  justify-content: flex-end;
+  margin-top: 12px;
+}
+
+/* 展开内容样式 */
+.expand-content {
+  padding: 16px;
+  background-color: #fafafa;
+}
+
+.expand-row {
+  display: flex;
+  align-items: flex-start;
+  margin-bottom: 16px;
+  padding: 12px;
+  background-color: #fff;
+  border-radius: 4px;
+  border: 1px solid #e4e7ed;
+}
+
+.expand-row:last-child {
+  margin-bottom: 0;
+}
+
+.expand-label {
+  min-width: 100px;
+  font-weight: 600;
+  color: #606266;
+  margin-right: 12px;
+  flex-shrink: 0;
+}
+
+.expand-value {
+  flex: 1;
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.expand-value .mono-ellipsis {
+  font-family: monospace;
+  color: #303133;
+  line-height: 1.5;
+  word-break: break-all;
+  flex: 0 1 auto;
+  margin-right: 8px;
+}
+
+.copy-btn {
+  flex-shrink: 0;
+  padding: 0 8px;
+  color: #409eff;
+}
+
+.copy-btn:hover {
+  color: #66b1ff;
+}
+
+.expand-empty {
+  padding: 20px;
+  text-align: center;
+  color: #909399;
+  font-size: 14px;
+}
+
+/* 钱包地址和URL格式化显示样式 */
+.mono-ellipsis {
+  font-family: monospace;
+  display: inline-block;
+  max-width: 100%;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  vertical-align: middle;
+}
+</style>
+
diff --git a/power_leasing/src/views/cart/index.vue b/power_leasing/src/views/cart/index.vue
index 9550888..c59d5d0 100644
--- a/power_leasing/src/views/cart/index.vue
+++ b/power_leasing/src/views/cart/index.vue
@@ -51,7 +51,7 @@
                 </template>
               </el-table-column>
               <el-table-column prop="id" label="机器ID" width="80" />
-              <el-table-column prop="algorithm" label="算法"  />
+              <el-table-column prop="algorithm" label="最大收益算法"  />
             
             
               <!-- <el-table-column prop="powerDissipation" label="功耗(kw/h)">
@@ -343,7 +343,7 @@
                 </template>
               </el-table-column>
               <el-table-column prop="id" label="机器ID" min-width="160" />
-              <el-table-column prop="algorithm" label="算法" min-width="140" />
+              <el-table-column prop="algorithm" label="最大收益算法" min-width="140" />
               <el-table-column prop="unitPrice" min-width="140">
                 <template #header>单价（{{ grp.coinSymbol || 'USDT' }}）</template>
                 <template #default="scope">
@@ -408,6 +408,7 @@
           </div>
         </div>
         <template #footer>
+          <el-button @click="handleConfirmDialogPrev">上一步</el-button>
           <el-button @click="confirmDialog.visible=false">取消</el-button>
           <el-button type="primary" @click="confirmPay">确认结算</el-button>
         </template>
@@ -416,7 +417,7 @@
      
 
       <!-- 购物须知（测试版） - 必须勾选并等待5秒后才可关闭 -->
-      <el-dialog :visible.sync="noticeDialog.visible" width="680px" title="下单须知" :show-close="false" :close-on-click-modal="false" :close-on-press-escape="false">
+      <el-dialog :visible.sync="noticeDialog.visible" width="60vw" title="下单须知" :show-close="false" :close-on-click-modal="false" :close-on-press-escape="false">
         <div class="notice-content">
           <p class="notice-title">尊敬的客户，感谢您选择我们的服务。在您下单前，请务必仔细阅读并完全理解以下须知条款。一旦您点击" 同意并下单"或完成支付流程，即视为您已充分阅读、理解并同意接受本须知的全部内容约束。</p>
           <ol class="notice-list">
@@ -445,7 +446,7 @@
                  :close-on-click-modal="false" :close-on-press-escape="false">
         <div>
           <!-- 未配置的机器配置区域 -->
-          <div v-if="unconfiguredMachinesList.length > 0">
+          <div v-if="configDialog.selectedMachines && configDialog.selectedMachines.length > 0">
             <div style="display:flex;align-items:center;gap:12px;margin-bottom:12px;">
               <div style="font-weight:600;color:#2c3e50;">选择币种/算法</div>
               <el-cascader
@@ -468,65 +469,121 @@
                 style="width: 240px;"
                 size="small"
                 @change="handlePoolValueChange"
+                :disabled="!configDialog.coinAlgoValue || configDialog.coinAlgoValue.length !== 2"
               />
             </div>
-            <el-table 
-                      :data="unconfiguredMachinesList" 
-                      max-height="300" 
-                      border 
-                      stripe
-                      ref="configTable"
-                      row-key="id"
-                      reserve-selection
-                      @selection-change="handleConfigSelectionChange"
-                      :header-cell-style="{ textAlign: 'left', fontSize: '14px' }" 
-                      :cell-style="{ textAlign: 'left', fontSize: '14px' }">
-              <el-table-column type="selection" width="46" />
-              <el-table-column label="矿机种类" width="120">
-                <template #default="scope">
-                  <el-tag
-                    disable-transitions
-                    :class="['type-tag', typeClass(scope.row.type)]"
-                    style="font-size: 14px;"
-                  >
-                    {{ formatMachineType(scope.row.type) }}
-                  </el-tag>
+            <!-- 机器列表 -->
+            <div v-if="unconfiguredMachinesList.length > 0">
+              <div style="font-weight:600;color:#2c3e50;margin-bottom:8px;font-size:14px;">
+                <template v-if="!configDialog.coinAlgoValue || configDialog.coinAlgoValue.length !== 2">
+                  待配置机器（共 {{ unconfiguredMachinesList.length }} 台）
                 </template>
-              </el-table-column>
-              <el-table-column prop="id" label="机器ID" width="120" />
-              <el-table-column prop="algorithm" label="算法" min-width="140" />
-            </el-table>
-            <div style="display:flex;align-items:center;gap:12px;margin-top:12px;flex-wrap: nowrap;">
-              <div style="font-weight:600;color:#2c3e50;white-space: nowrap;">钱包地址</div>
-              <el-input
-                v-model="configDialog.walletAddress"
-                placeholder="请输入钱包地址（26-95个字符，仅支持英文、数字）"
-                size="small"
-                style="width: 380px;"
-                clearable
-                maxlength="95"
-                @input="handleWalletAddressInput"
-              />
-              <div style="font-weight:600;color:#2c3e50;margin-left:8px;white-space: nowrap;">挖矿账户</div>
-              <el-input
-                v-model="configDialog.miningAccount"
-                placeholder="挖矿账户（仅支持英文、数字）"
-                size="small"
-                style="width: 220px;"
-                clearable
-                maxlength="50"
-                @input="handleMiningAccountInput"
-              />
-              <div style="font-weight:600;color:#2c3e50;margin-left:8px;white-space: nowrap;">矿工号</div>
-              <el-input
-                v-model="configDialog.workerId"
-                placeholder="矿工号（最多24个英文字符）"
-                size="small"
-                style="width: 220px;"
-                clearable
-                maxlength="24"
-                @input="handleWorkerIdInput"
-              />
+                <template v-else>
+                  支持该币种/算法的机器（共 {{ unconfiguredMachinesList.length }} 台）
+                </template>
+              </div>
+              <el-table 
+                        :data="unconfiguredMachinesList" 
+                        max-height="300" 
+                        border 
+                        stripe
+                        ref="configTable"
+                        row-key="id"
+                        reserve-selection
+                        @selection-change="handleConfigSelectionChange"
+                        :header-cell-style="{ textAlign: 'left', fontSize: '14px' }" 
+                        :cell-style="{ textAlign: 'left', fontSize: '14px' }">
+                <el-table-column type="selection" width="46" />
+                <el-table-column label="矿机种类" width="120">
+                  <template #default="scope">
+                    <el-tag
+                      disable-transitions
+                      :class="['type-tag', typeClass(scope.row.type)]"
+                      style="font-size: 14px;"
+                    >
+                      {{ formatMachineType(scope.row.type) }}
+                    </el-tag>
+                  </template>
+                </el-table-column>
+                <el-table-column prop="id" label="机器ID" width="120" />
+                <el-table-column prop="algorithm" label="最大收益算法" min-width="140" />
+                <!-- 矿工号列始终显示（只要选择了矿池/模型） -->
+                <el-table-column 
+                  v-if="getCurrentWalletMining() !== null" 
+                  label="矿工号" 
+                  min-width="160">
+                  <template #default="scope">
+                    <el-input
+                      v-model="scope.row._workerId"
+                      placeholder="矿工号"
+                      size="mini"
+                      clearable
+                      maxlength="40"
+                      @input="val => handleMachineWorkerIdInput(scope.row, val)"
+                    />
+                  </template>
+                </el-table-column>
+              </el-table>
+            </div>
+            <!-- 统一输入区域：根据 walletMining 显示钱包地址或挖矿账户 -->
+            <div v-if="getCurrentWalletMining() !== null" style="margin-top: 16px;">
+              <!-- 钱包地址输入（当 walletMining 为 true 时显示） -->
+              <div v-if="getCurrentWalletMining() === true" style="display: flex; align-items: center; gap: 12px;">
+                <label style="font-weight: 600; color: #2c3e50; min-width: 100px;">钱包地址：</label>
+                <el-input
+                  v-model="configDialog.walletAddress"
+                  placeholder="请输入钱包地址"
+                  clearable
+                  maxlength="95"
+                  style="flex: 1; max-width: 500px;"
+                  @input="handleWalletAddressInput"
+                />
+              </div>
+              <!-- 挖矿账户输入（当 walletMining 为 false 时显示） -->
+              <div v-if="getCurrentWalletMining() === false" style="display: flex; align-items: center; gap: 12px;">
+                <label style="font-weight: 600; color: #2c3e50; min-width: 100px;">挖矿账户：</label>
+                <el-input
+                  v-model="configDialog.miningAccount"
+                  placeholder="请输入挖矿账户"
+                  clearable
+                  maxlength="40"
+                  style="flex: 1; max-width: 500px;"
+                  @input="handleMiningAccountInput"
+                />
+              </div>
+            </div>
+            <div v-else-if="configDialog.coinAlgoValue && configDialog.coinAlgoValue.length === 2 && getCurrentWalletMining() === null" style="margin-top: 16px; color: #909399; font-size: 14px;">
+              请先选择矿池/模型
+            </div>
+            <div v-else-if="configDialog.coinAlgoValue && configDialog.coinAlgoValue.length === 2 && unconfiguredMachinesList.length === 0" style="margin-bottom:12px;color:#909399;font-size:14px;">
+              当前选择的币种/算法下没有可配置的机器
+            </div>
+            <!-- 不支持的机器列表 -->
+            <div v-if="unsupportedMachinesList.length > 0" style="margin-top: 16px;">
+              <div style="font-weight:600;color:#f56c6c;margin-bottom:8px;font-size:14px;">
+                不支持该币种/算法的机器（共 {{ unsupportedMachinesList.length }} 台）
+              </div>
+              <el-table 
+                :data="unsupportedMachinesList" 
+                max-height="200" 
+                border 
+                stripe
+                :header-cell-style="{ textAlign: 'left', fontSize: '14px' }" 
+                :cell-style="{ textAlign: 'left', fontSize: '14px' }">
+                <el-table-column label="矿机种类" width="120">
+                  <template #default="scope">
+                    <el-tag
+                      disable-transitions
+                      :class="['type-tag', typeClass(scope.row.type)]"
+                      style="font-size: 14px;"
+                    >
+                      {{ formatMachineType(scope.row.type) }}
+                    </el-tag>
+                  </template>
+                </el-table-column>
+                <el-table-column prop="id" label="机器ID" width="120" />
+                <el-table-column prop="algorithm" label="最大收益算法" min-width="140" />
+              </el-table>
             </div>
           </div>
           
@@ -560,12 +617,21 @@
                   <span v-else>-</span>
                 </template>
               </el-table-column>
-              <el-table-column prop="miningAccount" label="挖矿账户" min-width="140" />
-              <el-table-column prop="workerId" label="矿工号" min-width="140" />
+              <el-table-column 
+                v-if="hasConfiguredMiningAccount" 
+                prop="miningAccount" 
+                label="挖矿账户" 
+                min-width="140" />
+              <el-table-column 
+                v-if="hasConfiguredWorkerId" 
+                prop="workerId" 
+                label="矿工号" 
+                min-width="140" />
             </el-table>
           </div>
         </div>
         <template #footer>
+          <el-button @click="handleConfigPrev">上一步</el-button>
           <el-button @click="handleConfigCancel">取消</el-button>
           <el-button 
             type="primary" 
@@ -609,6 +675,7 @@
         </div>
         <template #footer>
           <div class="dialog-footer">
+            <el-button @click="handleGoogleCodePrev">上一步</el-button>
             <el-button @click="handleGoogleCodeCancel">取消</el-button>
             <el-button 
               type="primary" 
@@ -781,11 +848,67 @@ export default {
     payCoinSymbol() {
       return (this.selectedCoin || '').toUpperCase()
     },
-    // 未配置的机器列表（计算属性，避免每次渲染都重新计算导致选择状态丢失）
+    // 未配置的机器列表（计算属性，根据选择的币种/算法和machineIds过滤）
     unconfiguredMachinesList() {
       const allMachines = this.configDialog.selectedMachines || []
       const configuredIds = new Set((this.configDialog.configuredMachines || []).map(m => m.id))
-      return allMachines.filter(m => !configuredIds.has(m.id))
+      const unconfigured = allMachines.filter(m => !configuredIds.has(m.id))
+      
+      // 如果未选择币种/算法，返回所有未配置的机器
+      const coinAlgo = Array.isArray(this.configDialog.coinAlgoValue) ? this.configDialog.coinAlgoValue : []
+      if (coinAlgo.length !== 2) {
+        return unconfigured
+      }
+      
+      const coin = coinAlgo[0]
+      const algorithm = coinAlgo[1]
+      
+      // 从machineSupportData中查找对应的machineIds
+      const coinData = (this.machineSupportData || []).find(it => String(it && it.coin) === String(coin))
+      if (!coinData) {
+        return []
+      }
+      
+      const algoData = (coinData.algorithmList || []).find(a => String(a && a.algorithm) === String(algorithm))
+      if (!algoData) {
+        return []
+      }
+      
+      const supportedMachineIds = new Set((algoData.machineIds || []).map(id => Number(id)))
+      
+      // 只返回在machineIds中的机器
+      return unconfigured.filter(m => supportedMachineIds.has(Number(m.id)))
+    },
+    // 不支持的机器列表（不在当前选择的币种/算法的machineIds中）
+    unsupportedMachinesList() {
+      const allMachines = this.configDialog.selectedMachines || []
+      const configuredIds = new Set((this.configDialog.configuredMachines || []).map(m => m.id))
+      const unconfigured = allMachines.filter(m => !configuredIds.has(m.id))
+      
+      // 如果未选择币种/算法，返回空列表
+      const coinAlgo = Array.isArray(this.configDialog.coinAlgoValue) ? this.configDialog.coinAlgoValue : []
+      if (coinAlgo.length !== 2) {
+        return []
+      }
+      
+      const coin = coinAlgo[0]
+      const algorithm = coinAlgo[1]
+      
+      // 从machineSupportData中查找对应的machineIds
+      const coinData = (this.machineSupportData || []).find(it => String(it && it.coin) === String(coin))
+      if (!coinData) {
+        return []
+      }
+      
+      const algoData = (coinData.algorithmList || []).find(a => String(a && a.algorithm) === String(algorithm))
+      if (!algoData) {
+        return []
+      }
+      
+      const supportedMachineIds = new Set((algoData.machineIds || []).map(id => Number(id)))
+      
+      // 返回不在machineIds中的机器
+      return unconfigured.filter(m => !supportedMachineIds.has(Number(m.id)))
     },
     /**
      * 检查是否可以点击按钮（计算属性，确保响应式更新）
@@ -844,6 +967,16 @@ export default {
       const allConfigured = Array.from(allMachineIds).every(id => configuredIds.has(id))
       
       return allConfigured
+    },
+    // 判断已配置机器中是否有挖矿账户数据
+    hasConfiguredMiningAccount() {
+      const configured = this.configDialog.configuredMachines || []
+      return configured.some(m => m.miningAccount && String(m.miningAccount).trim().length > 0)
+    },
+    // 判断已配置机器中是否有矿工号数据
+    hasConfiguredWorkerId() {
+      const configured = this.configDialog.configuredMachines || []
+      return configured.some(m => m.workerId && String(m.workerId).trim().length > 0)
     }
   },
   mounted() {
@@ -1573,8 +1706,8 @@ export default {
       
       // 构建订单信息列表 orderInfoVoList
       const orderInfoVoList = []
-      // 构建挖矿配置列表 orderMiningInfoDtoList（按 coinConfigId 分组）
-      const miningConfigMap = new Map() // key: coinConfigId, value: { coinConfigId, poolName, poolUser, walletAddress, walletMining, workerId, machineIds: [] }
+      // 构建挖矿配置列表 orderMiningInfoDtoList（每台机器一个配置项，使用 machineId 字符串）
+      const orderMiningInfoDtoList = []
       
       // 处理单店铺或多店铺的机器
       const allMachines = []
@@ -1595,7 +1728,7 @@ export default {
         })
       }
       
-      // 构建订单信息列表和挖矿配置映射
+      // 构建订单信息列表和挖矿配置列表
       allMachines.forEach(({ shop, machine }) => {
         const sel = this.paySelectionMap[shop.id] || ''
         const [chain, coin] = String(sel).split('|')
@@ -1618,32 +1751,29 @@ export default {
           shopId: shop.id
         })
         
-        // 按 coinConfigId 分组构建挖矿配置
+        // 为每台机器单独创建挖矿配置项，使用 machineId（string）而不是 machineIds（array）
         const coinConfigId = config.coinConfigId
         if (!coinConfigId) {
           console.warn(`机器 ${machine.id} 的 coinConfigId 为空`)
           return
         }
         
-        if (!miningConfigMap.has(coinConfigId)) {
-          miningConfigMap.set(coinConfigId, {
-            coinConfigId: coinConfigId,
-            poolName: config.poolName || '',
-            poolUser: config.miningAccount || '',
-            walletAddress: config.walletAddress || '',
-            walletMining: config.walletMining || '',
-            workerId: config.workerId || '',
-            machineIds: []
-          })
-        }
+        const walletAddress = String(config.walletAddress || '').trim()
+        const poolUser = String(config.miningAccount || '').trim()
+        const workerId = String(config.workerId || '').trim()
         
-        const miningConfig = miningConfigMap.get(coinConfigId)
-        miningConfig.machineIds.push(machine.id)
+        // 为每台机器创建独立的配置项
+        orderMiningInfoDtoList.push({
+          coinConfigId: coinConfigId,
+          poolName: config.poolName || '',
+          poolUser: poolUser,
+          walletAddress: walletAddress,
+          walletMining: config.walletMining || false,
+          workerId: workerId,
+          machineId: String(machine.id) // 使用 machineId（string）而不是 machineIds（array）
+        })
       })
       
-      // 转换为数组
-      const orderMiningInfoDtoList = Array.from(miningConfigMap.values())
-      
       this.creatingOrder = true
       try {
         const res = await this.fetchAddOrdersV2(orderInfoVoList, orderMiningInfoDtoList, googleCode)
@@ -1710,7 +1840,7 @@ export default {
         this.$message({ message: '未找到可结算的上架机器', type: 'warning', showClose: true })
         return
       }
-      // 在点击“结算选中机器”时请求币种/算法支持数据
+      // 在点击"结算选中机器"时请求币种/算法支持数据
       try {
         const ids = []
         picked.forEach(({ items }) => {
@@ -1720,8 +1850,24 @@ export default {
         })
         if (ids.length) {
           await this.fetchGetMachineSupportCoinAndAlgorithm(ids)
+          // 检查是否获取到数据
+          if (!this.machineSupportData || this.machineSupportData.length === 0) {
+            this.$message({
+              message: '加载配置信息失败，请重试',
+              type: 'error',
+              showClose: true
+            })
+            return
+          }
         }
-      } catch (e) { /* noop */ }
+      } catch (e) {
+        this.$message({
+          message: '加载配置信息失败，请重试',
+          type: 'error',
+          showClose: true
+        })
+        return
+      }
       this.pendingCheckoutAll = picked
       // 打开须知弹窗
       this.noticeDialog.visible = true
@@ -1774,6 +1920,12 @@ export default {
       this.confirmDialog.visible = false
       this.showGoogleCodeDialog()
     },
+    // 确认结算弹窗的上一步：返回到配置弹窗
+    handleConfirmDialogPrev() {
+      this.confirmDialog.visible = false
+      // 重新打开配置弹窗
+      this.configDialog.visible = true
+    },
     // 关闭成功弹窗：跳转到订单列表的订单进行中状态
     handleCloseSuccessDialog() {
       try { this.settlementSuccessfulVisible = false } catch (e) { /* noop */ }
@@ -1813,6 +1965,15 @@ export default {
     },
     // 打开配置弹窗并初始化选项与机器列表
     openConfigDialog() {
+      // 检查是否获取到配置数据
+      if (!this.machineSupportData || this.machineSupportData.length === 0) {
+        this.$message({
+          message: '加载配置信息失败，请重试',
+          type: 'error',
+          showClose: true
+        })
+        return
+      }
       // 重置已配置列表
       this.configDialog.configuredMachines = []
       // 初始化币种选项
@@ -1831,21 +1992,10 @@ export default {
           value: a && a.algorithm ? String(a.algorithm) : ''
         })) : []
       }))
-      // 默认选中第一个币种
-      if (!this.configDialog.coin && coinOptions.length) {
-        this.configDialog.coin = coinOptions[0].value
-      }
-      // 默认算法为该币种下第一个
-      try {
-        const firstCoin = (coins && coins.length) ? coins[0] : null
-        const firstAlgo = firstCoin && Array.isArray(firstCoin.algorithmList) && firstCoin.algorithmList.length
-          ? (firstCoin.algorithmList[0].algorithm || '')
-          : ''
-        if (!this.configDialog.algorithm) this.configDialog.algorithm = firstAlgo
-        this.configDialog.coinAlgoValue = [this.configDialog.coin, this.configDialog.algorithm].filter(Boolean)
-      } catch (e) { /* noop */ }
-      // 根据币种初始化算法选项
-      this.refreshAlgorithmOptions()
+      // 不默认选择币种和算法，等用户自己选择
+      this.$set(this.configDialog, 'coin', '')
+      this.$set(this.configDialog, 'algorithm', '')
+      this.$set(this.configDialog, 'coinAlgoValue', [])
       // 构建展示用机器列表
       this.configDialog.selectedMachines = this.buildSelectedMachinesForConfig()
       // 重置选择状态
@@ -1855,12 +2005,9 @@ export default {
       this.$set(this.configDialog, 'miningAccount', '')
       this.$set(this.configDialog, 'workerId', '')
       this.$set(this.configDialog, 'poolValue', [])
-      // 同步加载矿池/模型下拉
-      try {
-        if (this.configDialog.coin && this.configDialog.algorithm) {
-          this.fetchGetMachineSupportPool(this.configDialog.coin, this.configDialog.algorithm)
-        }
-      } catch (e) { /* noop */ }
+      // 重置矿池选项
+      this.$set(this.configDialog, 'poolOptions', [])
+      this.$set(this.configDialog, 'poolRawData', [])
       // 打开弹窗
       this.configDialog.visible = true
     },
@@ -1915,10 +2062,20 @@ export default {
       this.$set(this.configDialog, 'coin', coin)
       this.$set(this.configDialog, 'algorithm', algo)
       this.$set(this.configDialog, 'coinAlgoValue', arr)
-      // 强制触发视图更新
+      // 清空表格选择状态
+      this.$set(this.configDialog, 'selectedMachineIds', [])
       this.$nextTick(() => {
+        try {
+          const tb = this.$refs.configTable
+          if (tb && typeof tb.clearSelection === 'function') {
+            tb.clearSelection()
+          }
+        } catch (e) { /* noop */ }
         this.$forceUpdate()
       })
+      // 清空统一输入框和矿池/模型选择
+      this.$set(this.configDialog, 'walletAddress', '')
+      this.$set(this.configDialog, 'miningAccount', '')
       if (coin && algo) {
         this.fetchGetMachineSupportPool(coin, algo)
       } else {
@@ -1930,11 +2087,95 @@ export default {
     // 矿池/模型选择变化
     handlePoolValueChange(val) {
       this.$set(this.configDialog, 'poolValue', val || [])
+      // 获取当前选择的矿池/模型的 walletMining 值
+      const poolValue = Array.isArray(val) ? val : []
+      if (poolValue.length === 2) {
+        const poolId = poolValue[0]
+        const coinConfigId = poolValue[1]
+        const poolOption = (this.configDialog.poolOptions || []).find(p => p.value === poolId)
+        if (poolOption) {
+          const modelOption = (poolOption.children || []).find(m => m.value === coinConfigId)
+          if (modelOption && modelOption.raw) {
+            const walletMining = modelOption.raw.walletMining || false
+            // 清空统一输入框
+            this.$set(this.configDialog, 'walletAddress', '')
+            this.$set(this.configDialog, 'miningAccount', '')
+            // 清空所有未配置机器的矿工号
+            const unconfigured = this.unconfiguredMachinesList
+            unconfigured.forEach(machine => {
+              this.$set(machine, '_walletMining', walletMining)
+              this.$set(machine, '_workerId', '')
+            })
+          }
+        }
+      } else {
+        // 如果未选择矿池/模型，清空统一输入框
+        this.$set(this.configDialog, 'walletAddress', '')
+        this.$set(this.configDialog, 'miningAccount', '')
+      }
       // 强制触发视图更新
       this.$nextTick(() => {
         this.$forceUpdate()
       })
     },
+    // 获取当前选择的矿池/模型的 walletMining 值
+    getCurrentWalletMining() {
+      const poolValue = Array.isArray(this.configDialog.poolValue) ? this.configDialog.poolValue : []
+      if (poolValue.length !== 2) {
+        return null
+      }
+      const poolId = poolValue[0]
+      const coinConfigId = poolValue[1]
+      const poolOption = (this.configDialog.poolOptions || []).find(p => p.value === poolId)
+      if (poolOption) {
+        const modelOption = (poolOption.children || []).find(m => m.value === coinConfigId)
+        if (modelOption && modelOption.raw) {
+          return modelOption.raw.walletMining || false
+        }
+      }
+      return null
+    },
+    // 处理机器钱包地址输入
+    handleMachineWalletAddressInput(machine, val) {
+      if (!val) {
+        this.$set(machine, '_walletAddress', '')
+        return
+      }
+      // 只过滤中文字符，其他字符都可以输入
+      // 匹配中文字符范围：\u4e00-\u9fa5 (基本汉字), \u3400-\u4dbf (扩展A), \u3000-\u303f (CJK符号和标点), \uff00-\uffef (全角字符)
+      let filtered = val.replace(/[\u4e00-\u9fa5\u3400-\u4dbf\u3000-\u303f\uff00-\uffef]/g, '')
+      // 限制最大长度95
+      if (filtered.length > 95) {
+        filtered = filtered.substring(0, 95)
+      }
+      this.$set(machine, '_walletAddress', filtered)
+    },
+    // 处理机器挖矿账户输入
+    handleMachineMiningAccountInput(machine, val) {
+      if (!val) {
+        this.$set(machine, '_miningAccount', '')
+        return
+      }
+      // 只限制最大长度40，不限制其他输入
+      let filtered = String(val)
+      if (filtered.length > 40) {
+        filtered = filtered.substring(0, 40)
+      }
+      this.$set(machine, '_miningAccount', filtered)
+    },
+    // 处理机器矿工号输入
+    handleMachineWorkerIdInput(machine, val) {
+      if (!val) {
+        this.$set(machine, '_workerId', '')
+        return
+      }
+      // 只限制最大长度40，不限制其他输入
+      let filtered = String(val)
+      if (filtered.length > 40) {
+        filtered = filtered.substring(0, 40)
+      }
+      this.$set(machine, '_workerId', filtered)
+    },
     // 钱包地址输入（过滤中文，限制长度26-95）
     handleWalletAddressInput(val) {
       if (!val) {
@@ -2095,8 +2336,6 @@ export default {
         // 验证表单完整性
         const coinAlgo = Array.isArray(this.configDialog.coinAlgoValue) ? this.configDialog.coinAlgoValue : []
         const pool = Array.isArray(this.configDialog.poolValue) ? this.configDialog.poolValue : []
-        const wallet = String(this.configDialog.walletAddress || '').trim()
-        const account = String(this.configDialog.miningAccount || '').trim()
         
         if (coinAlgo.length !== 2) {
           this.$message.warning('请选择币种和算法')
@@ -2108,22 +2347,6 @@ export default {
           return
         }
         
-        if (!wallet || wallet.length === 0) {
-          this.$message.warning('请输入钱包地址')
-          return
-        }
-        
-        // 验证钱包地址长度（26-95个字符）
-        if (wallet.length < 26 || wallet.length > 95) {
-          this.$message.warning('钱包地址长度应在26-95个字符之间')
-          return
-        }
-        
-        if (!account || account.length === 0) {
-          this.$message.warning('请输入挖矿账户')
-          return
-        }
-        
         // 获取选中的机器（使用上面验证时获取的 selectedIds）
         const selectedMachines = unconfigured.filter(m => 
           selectedIds.includes(m.id)
@@ -2134,7 +2357,7 @@ export default {
           return
         }
         
-        // 获取矿池和模型名称
+        // 获取矿池和模型名称以及 walletMining
         const poolValue = this.configDialog.poolValue || []
         const poolId = poolValue[0]
         const coinConfigId = poolValue[1]
@@ -2142,7 +2365,7 @@ export default {
         // 从 poolOptions 中查找名称和原始数据
         let poolName = ''
         let modelName = ''
-        let walletMining = ''
+        let walletMining = false
         const poolOption = (this.configDialog.poolOptions || []).find(p => p.value === poolId)
         if (poolOption) {
           poolName = poolOption.label || ''
@@ -2150,13 +2373,47 @@ export default {
           if (modelOption && modelOption.raw) {
             modelName = modelOption.label || ''
             // 从原始数据中获取 walletMining
-            walletMining = modelOption.raw.walletMining || ''
+            walletMining = modelOption.raw.walletMining || false
+          }
+        }
+        
+        // 验证统一输入字段
+        if (walletMining) {
+          // 支持钱包地址挖矿，需要验证钱包地址
+          const wallet = String(this.configDialog.walletAddress || '').trim()
+          if (!wallet || wallet.length === 0) {
+            this.$message.warning('请输入钱包地址')
+            return
+          }
+          // 验证钱包地址长度（26-95个字符）
+          if (wallet.length < 26 || wallet.length > 95) {
+            this.$message.warning('钱包地址长度应在26-95个字符之间')
+            return
+          }
+        } else {
+          // 不支持钱包地址挖矿，需要验证挖矿账户
+          const account = String(this.configDialog.miningAccount || '').trim()
+          if (!account || account.length === 0) {
+            this.$message.warning('请输入挖矿账户')
+            return
+          }
+        }
+        
+        // 验证每台机器的矿工号
+        for (const machine of selectedMachines) {
+          const workerId = String(machine._workerId || '').trim()
+          if (!workerId || workerId.length === 0) {
+            this.$message.warning(`机器ID ${machine.id} 请输入矿工号`)
+            return
           }
         }
         
         // 保存配置（使用上面已经验证过的 coinAlgo）
         const coin = this.toUpperText(coinAlgo[0] || '')
         const algorithm = String(coinAlgo[1] || '')
+        // 统一输入框的值
+        const walletAddress = walletMining ? String(this.configDialog.walletAddress || '').trim() : ''
+        const miningAccount = walletMining ? '' : String(this.configDialog.miningAccount || '').trim()
         
         selectedMachines.forEach(machine => {
           this.configDialog.configuredMachines.push({
@@ -2165,9 +2422,9 @@ export default {
             algorithm: algorithm,
             poolName: poolName,
             modelName: modelName,
-            walletAddress: String(this.configDialog.walletAddress || '').trim(),
-            miningAccount: String(this.configDialog.miningAccount || '').trim(),
-            workerId: String(this.configDialog.workerId || '').trim(),
+            walletAddress: walletAddress,
+            miningAccount: miningAccount,
+            workerId: String(machine._workerId || '').trim(), // 矿工号从每行获取
             walletMining: walletMining,
             type: machine.type,
             // 保存原始数据用于后续提交
@@ -2179,15 +2436,66 @@ export default {
           })
         })
         
+        // 计算剩下待配置的机器ID
+        const allMachineIds = new Set((this.configDialog.selectedMachines || []).map(m => m.id))
+        const configuredIds = new Set((this.configDialog.configuredMachines || []).map(m => m.id))
+        const remainingMachineIds = Array.from(allMachineIds).filter(id => !configuredIds.has(id))
+        
+        // 如果有待配置的机器，重新请求币种/算法支持数据
+        if (remainingMachineIds.length > 0) {
+          this.fetchGetMachineSupportCoinAndAlgorithm(remainingMachineIds).then(() => {
+            // 检查是否获取到数据
+            if (!this.machineSupportData || this.machineSupportData.length === 0) {
+              this.$message({
+                message: '加载配置信息失败，请重试',
+                type: 'error',
+                showClose: true
+              })
+              return
+            }
+            // 更新币种/算法选项
+            const coins = Array.isArray(this.machineSupportData) ? this.machineSupportData : []
+            this.configDialog.coinAlgoOptions = (coins || []).map(c => ({
+              label: this.toUpperText(c && c.coin),
+              value: c && c.coin,
+              children: Array.isArray(c && c.algorithmList) ? c.algorithmList.map(a => ({
+                label: a && a.algorithm ? String(a.algorithm) : '',
+                value: a && a.algorithm ? String(a.algorithm) : ''
+              })) : []
+            }))
+            // 如果更新后没有选项，清空选项
+            if (this.configDialog.coinAlgoOptions.length === 0) {
+              this.configDialog.coinAlgoOptions = []
+            }
+          }).catch(e => {
+            console.error('重新获取币种/算法支持数据失败:', e)
+            this.$message({
+              message: '加载配置信息失败，请重试',
+              type: 'error',
+              showClose: true
+            })
+          })
+        } else {
+          // 如果没有待配置的机器，清空币种/算法选项
+          this.configDialog.coinAlgoOptions = []
+        }
+        
         // 清空当前输入，准备下一批配置
         this.$set(this.configDialog, 'selectedMachineIds', [])
-        this.$set(this.configDialog, 'walletAddress', '')
-        this.$set(this.configDialog, 'miningAccount', '')
-        this.$set(this.configDialog, 'workerId', '')
         this.$set(this.configDialog, 'poolValue', [])
         this.$set(this.configDialog, 'coinAlgoValue', [])
         this.$set(this.configDialog, 'coin', '')
         this.$set(this.configDialog, 'algorithm', '')
+        // 清空统一输入框
+        this.$set(this.configDialog, 'walletAddress', '')
+        this.$set(this.configDialog, 'miningAccount', '')
+        
+        // 清空所有未配置机器的矿工号
+        const remainingUnconfigured = this.unconfiguredMachinesList
+        remainingUnconfigured.forEach(machine => {
+          this.$set(machine, '_workerId', '')
+          this.$set(machine, '_walletMining', null)
+        })
         
         // 清空表格选择
         this.$nextTick(() => {
@@ -2254,6 +2562,14 @@ export default {
       // 恢复勾选状态
       this.reapplySelectionsForPendingShop()
     },
+    // 配置弹窗的上一步：返回到下单须知弹窗
+    handleConfigPrev() {
+      this.configDialog.visible = false
+      // 重新打开下单须知弹窗
+      this.noticeDialog.visible = true
+      this.noticeDialog.checked = false
+      this.startNoticeCountdown()
+    },
     openPaySelectDialog() {
       // 已取消支付方式选择步骤，此函数保留空实现以兼容旧调用
       return
@@ -2466,6 +2782,19 @@ export default {
       this.reapplySelectionsForPendingShop()
       this.pendingCheckoutShop = null
     },
+    // 谷歌验证码弹窗的上一步：返回到确认结算弹窗
+    handleGoogleCodePrev() {
+      this.googleCodeDialog.visible = false
+      this.googleCodeDialog.code = ''
+      this.googleCodeDialog.error = ''
+      this.googleCodeDialog.loading = false
+      // 重新打开确认结算弹窗
+      if (this.pendingCheckoutAll && this.pendingCheckoutAll.length) {
+        this.showConfirmDialogAll()
+      } else {
+        this.showConfirmDialog()
+      }
+    },
     // 处理租赁天数输入变化
     handleLeaseTimeChange(machine) {
       // 确保租赁天数是大于等于1的整数
diff --git a/power_leasing/src/views/productDetail/index.vue b/power_leasing/src/views/productDetail/index.vue
index 5693861..df8fc71 100644
--- a/power_leasing/src/views/productDetail/index.vue
+++ b/power_leasing/src/views/productDetail/index.vue
@@ -435,23 +435,54 @@ export default {
      */
     hasAnyPrice(row) {
       try {
-        if (!row) return false
+        if (!row) {
+          console.log('[hasAnyPrice] 行数据为空')
+          return false
+        }
         if (Array.isArray(row.priceList) && row.priceList.length) {
-          return row.priceList.some(it => it && it.price !== null && it.price !== undefined)
+          const hasValidPrice = row.priceList.some(it => it && it.price !== null && it.price !== undefined)
+          if (!hasValidPrice) {
+            console.log(`[hasAnyPrice] 机器ID ${row.id || 'unknown'} priceList 中无有效价格:`, row.priceList)
+          }
+          return hasValidPrice
         }
         const v = row.price
-        return v !== null && v !== undefined && v !== ''
-      } catch (e) { return false }
+        const hasPrice = v !== null && v !== undefined && v !== ''
+        if (!hasPrice) {
+          console.log(`[hasAnyPrice] 机器ID ${row.id || 'unknown'} row.price 无效:`, v)
+        }
+        return hasPrice
+      } catch (e) {
+        console.error('[hasAnyPrice] 异常:', e, row)
+        return false
+      }
     },
     /**
      * 该行是否应禁用选择：已售出/售出中 或 无价格
      */
     isRowDisabled(row) {
       try {
-        if (!row) return true
-        if (row.saleState === 1 || row.saleState === 2) return true
-        return !this.hasAnyPrice(row)
-      } catch (e) { return true }
+        if (!row) {
+          console.log('[isRowDisabled] 行数据为空')
+          return true
+        }
+        if (row.saleState === 1 || row.saleState === 2) {
+          console.log(`[isRowDisabled] 机器ID ${row.id || 'unknown'} 已售出或售出中, saleState:`, row.saleState)
+          return true
+        }
+        const hasPrice = this.hasAnyPrice(row)
+        if (!hasPrice) {
+          console.log(`[isRowDisabled] 机器ID ${row.id || 'unknown'} 无价格:`, {
+            priceList: row.priceList,
+            price: row.price,
+            hasPriceList: Array.isArray(row.priceList) && row.priceList.length > 0
+          })
+        }
+        return !hasPrice
+      } catch (e) {
+        console.error('[isRowDisabled] 异常:', e, row)
+        return true
+      }
     },
     /**
      * 获取行的最大可租赁天数