function getConfigParams() {
var config = {
// 币种选择
symbol: symbol || "BTC/USDT",

    // 网格参数（全部从界面输入，禁止硬编码）
    longGridSpacing: parseFloat(longGridSpacing) || 1.0,      // 多头网格间距（%），界面参数名：longGridSpacing
    shortGridSpacing: parseFloat(shortGridSpacing) || 1.0,     // 空头网格间距（%），界面参数名：shortGridSpacing
    orderAmount: parseFloat(orderAmount) || 100,               // 单个网格下单金额，界面参数名：orderAmount
    upperPrice: parseFloat(upperPrice),                        // 网格上边界价格，界面参数名：upperPrice
    lowerPrice: parseFloat(lowerPrice),                        // 网格下边界价格，界面参数名：lowerPrice
    
    // 可选：手动覆盖最小步长/数量精度（界面参数名：forceMinLotSize, forceAmountPrecision）
    forceMinLotSize: forceMinLotSize ? parseFloat(forceMinLotSize) : null,
    forceAmountPrecision: forceAmountPrecision ? parseInt(forceAmountPrecision, 10) : null,
};

// ❌ 禁止硬编码示例：
// config.longGridSpacing = 1.0;  // 错误！
// config.orderAmount = 100;       // 错误！

return config;

}

// ==================== 状态持久化修正版 ====================
// 使用FMZ平台的_G函数实现状态持久化
// 关机或重启后可以自动恢复状态

function saveState() {
/** 保存策略状态到全局存储 */
try {
var state = {
// 多头相关
MANY_NEXT_BUY_PRICE: MANY_NEXT_BUY_PRICE,
MANY_ORDER_LIST: MANY_ORDER_LIST,

        // 空头相关
        SHORT_NEXT_BUY_PRICE: SHORT_NEXT_BUY_PRICE,
        SHORT_ORDER_LIST: SHORT_ORDER_LIST,
        
        // 状态信息相关
        INIT_TIME: INIT_TIME,
        INITIAL_BALANCE: INITIAL_BALANCE,
        
        // 配置信息（用于参数迁移检测）
        config: config,
        
        // 收益历史（保留最近1000条）
        PROFIT_HISTORY: PROFIT_HISTORY.slice(-1000),
        
        // 参数迁移相关
        oldConfig: oldConfig,
        isMigrating: isMigrating,
        
        // 时间戳
        lastSaveTime: Unix()
    };
    
    // ✅ 修正：使用正确的FMZ全局存储函数
    _G("strategy_state", JSON.stringify(state));
    return true;
} catch (e) {
    Log("保存状态失败:", e);
    return false;
}

}

function loadState() {
/** 从全局存储恢复策略状态 */
try {
// ✅ 修正：使用正确的FMZ全局存储函数
var stateStr = _G("strategy_state");
if (!stateStr) {
Log("未找到保存的状态，使用初始状态");
return false;
}

    var state = JSON.parse(stateStr);
    
    // 恢复多头相关
    if (state.MANY_NEXT_BUY_PRICE !== undefined) {
        MANY_NEXT_BUY_PRICE = state.MANY_NEXT_BUY_PRICE;
    }
    if (state.MANY_ORDER_LIST && Array.isArray(state.MANY_ORDER_LIST)) {
        MANY_ORDER_LIST = state.MANY_ORDER_LIST;
    }
    
    // 恢复空头相关
    if (state.SHORT_NEXT_BUY_PRICE !== undefined) {
        SHORT_NEXT_BUY_PRICE = state.SHORT_NEXT_BUY_PRICE;
    }
    if (state.SHORT_ORDER_LIST && Array.isArray(state.SHORT_ORDER_LIST)) {
        SHORT_ORDER_LIST = state.SHORT_ORDER_LIST;
    }
    
    // 恢复状态信息
    if (state.INIT_TIME) {
        INIT_TIME = state.INIT_TIME;
    }
    if (state.INITIAL_BALANCE) {
        INITIAL_BALANCE = state.INITIAL_BALANCE;
    }
    
    // 恢复收益历史
    if (state.PROFIT_HISTORY && Array.isArray(state.PROFIT_HISTORY)) {
        PROFIT_HISTORY = state.PROFIT_HISTORY;
    }
    
    // 恢复参数迁移状态
    if (state.oldConfig) {
        oldConfig = state.oldConfig;
    }
    if (state.isMigrating !== undefined) {
        isMigrating = state.isMigrating;
    }
    
    Log("状态恢复成功 - 多头持仓数:", MANY_ORDER_LIST.length, "空头持仓数:", SHORT_ORDER_LIST.length);
    if (state.lastSaveTime) {
        var downtime = Unix() - state.lastSaveTime;
        Log("上次保存时间:", new Date(state.lastSaveTime * 1000).toLocaleString(), "停机时长:", Math.floor(downtime / 60), "分钟");
    }
    
    return true;
} catch (e) {
    Log("恢复状态失败:", e);
    return false;
}

}

function saveHistory(record) {
/** 保存历史记录到全局存储 */
try {
var historyKey = "strategy_history";
var historyStr = _G(historyKey);
var history = [];

    if (historyStr) {
        try {
            history = JSON.parse(historyStr);
        } catch (e) {
            history = [];
        }
    }
    
    // 添加新记录
    record.timestamp = Unix();
    history.push(record);
    
    // 只保留最近5000条记录
    if (history.length > 5000) {
        history = history.slice(-5000);
    }
    
    _G(historyKey, JSON.stringify(history));
    return true;
} catch (e) {
    Log("保存历史记录失败:", e);
    return false;
}

}

function getHistory(limit) {
/** 获取历史记录 */
try {
var historyKey = "strategy_history";
var historyStr = _G(historyKey);
if (!historyStr) {
return [];
}

    var history = JSON.parse(historyStr);
    limit = limit || 100;
    
    // 返回最近的记录
    return history.slice(-limit);
} catch (e) {
    Log("获取历史记录失败:", e);
    return [];
}

}

// ==================== 安全的状态保存 ====================
function safeSaveState() {
/** 安全保存状态，带错误处理 */
try {
if (saveState()) {
LAST_SAVE_TIME = Unix();
return true;
}
return false;
} catch (e) {
Log("安全保存状态失败:", e);
return false;
}
}

// ==================== 持仓对账 ====================
function reconcilePositions() {
try {
var positions = exchange.GetPosition();
if (!positions) {
return;
}
var hasLong = false;
var hasShort = false;
for (var i = 0; i < positions.length; i++) {
if (positions.Amount > 0) {
if (positions.Type === 0) hasLong = true;
if (positions.Type === 1) hasShort = true;
}
}
// 防抖：连续多次空才清空本地
if (!hasLong && !hasShort) {
RECONCILE_EMPTY_STREAK += 1;
} else {
RECONCILE_EMPTY_STREAK = 0;
}
var shouldClear = RECONCILE_EMPTY_STREAK >= RECONCILE_EMPTY_THRESHOLD;

    if (shouldClear) {
        if (!hasLong && MANY_ORDER_LIST.length > 0) {
            Log("对账：连续空结果，实际多头为空，清空本地多头持仓列表");
            MANY_ORDER_LIST = [];
            MANY_BUYING = false;
        }
        if (!hasShort && SHORT_ORDER_LIST.length > 0) {
            Log("对账：连续空结果，实际空头为空，清空本地空头持仓列表");
            SHORT_ORDER_LIST = [];
            SHORT_BUYING = false;
        }
        if ((!hasLong && MANY_ORDER_LIST.length === 0) || (!hasShort && SHORT_ORDER_LIST.length === 0)) {
            safeSaveState();
        }
    }
} catch (e) {
    Log("持仓对账失败:", e);
}

}

// ==================== 双轨制参数迁移 ====================
// 实现渐进式参数迁移，保持原有持仓的平仓逻辑，新开仓使用新参数

// ==================== 增强的参数迁移检测 ====================
function checkConfigChange(newConfig) {
/** 检查配置是否发生变化，如果变化则启动参数迁移 */
if (!oldConfig) {
// 首次运行，保存当前配置
oldConfig = JSON.parse(JSON.stringify(newConfig));
isMigrating = false;
return false;
}

// 详细检查参数变化
var configChanged = false;
var changes = [];

if (oldConfig.longGridSpacing !== newConfig.longGridSpacing) {
    configChanged = true;
    changes.push("多头间距: " + oldConfig.longGridSpacing + "% → " + newConfig.longGridSpacing + "%");
}
if (oldConfig.shortGridSpacing !== newConfig.shortGridSpacing) {
    configChanged = true;
    changes.push("空头间距: " + oldConfig.shortGridSpacing + "% → " + newConfig.shortGridSpacing + "%");
}
if (oldConfig.orderAmount !== newConfig.orderAmount) {
    configChanged = true;
    changes.push("下单金额: " + oldConfig.orderAmount + " → " + newConfig.orderAmount);
}
if (oldConfig.upperPrice !== newConfig.upperPrice) {
    configChanged = true;
    changes.push("上边界: " + oldConfig.upperPrice + " → " + newConfig.upperPrice);
}
if (oldConfig.lowerPrice !== newConfig.lowerPrice) {
    configChanged = true;
    changes.push("下边界: " + oldConfig.lowerPrice + " → " + newConfig.lowerPrice);
}

if (configChanged && !isMigrating) {
    Log("========== 🚀 检测到参数变化，启动双轨制迁移 ==========");
    changes.forEach(function(change) {
        Log("📝 " + change);
    });
    Log("🔄 迁移模式：旧持仓使用旧参数平仓，新开仓使用新参数");
    Log("📊 当前持仓 - 多头:", MANY_ORDER_LIST.length, "空头:", SHORT_ORDER_LIST.length);
    isMigrating = true;
    safeSaveState(); // 立即保存迁移状态
}

return configChanged;

}

function shouldUseOldConfig(side) {
/** 判断是否应该使用旧配置（用于平仓逻辑） */
if (!isMigrating || !oldConfig) {
return false;
}

// 如果还有旧持仓，使用旧配置平仓
if (side === LONG_SIDE) {
    return MANY_ORDER_LIST.length > 0;
} else if (side === SHORT_SIDE) {
    return SHORT_ORDER_LIST.length > 0;
}

return false;

}

function getGridSpacing(side, isClose) {
/** 获取网格间距（支持双轨制） */
if (isClose && shouldUseOldConfig(side)) {
// 平仓时，如果有旧持仓，使用旧参数
return side === LONG_SIDE ? oldConfig.longGridSpacing : oldConfig.shortGridSpacing;
} else {
// 开仓时，或旧持仓已平完，使用新参数
return side === LONG_SIDE ? config.longGridSpacing : config.shortGridSpacing;
}
}

function getOrderAmount(isClose) {
/** 获取下单金额（支持双轨制） */
if (isClose && (shouldUseOldConfig(LONG_SIDE) || shouldUseOldConfig(SHORT_SIDE))) {
// 平仓时，如果有旧持仓，使用旧参数
return oldConfig.orderAmount;
} else {
// 开仓时，使用新参数
return config.orderAmount;
}
}

function checkMigrationComplete() {
/** 检查参数迁移是否完成 */
if (!isMigrating) {
return true;
}

// 如果旧持仓已全部平完，迁移完成
var oldLongPositions = 0;
var oldShortPositions = 0;

// 这里需要根据实际持仓判断，简化处理：如果持仓列表为空，认为迁移完成
// 实际应该检查持仓是否是用旧参数开的
if (MANY_ORDER_LIST.length === 0 && SHORT_ORDER_LIST.length === 0) {
    Log("========== ✅ 参数迁移完成 ==========");
    oldConfig = null;
    isMigrating = false;
    safeSaveState(); // 保存迁移完成状态
    return true;
}

return false;

}

// ==================== 精度管理 ====================
function getDecimalPlaces(num) {
/** 获取数字的小数位数 */
var str = num.toString();
if (str.indexOf('.') > -1) {
return str.split('.')[1].length;
}
return 0;
}

function getPrecision() {
/**
* 获取下单精度
* 1) 若已从规则获取 tickSz/lotSz，则直接使用 DEFAULT_PRICE_PREC / MIN_LOT_DECIMALS
* 2) 否则从深度数据推断
* 3) 否则使用默认
*/
if (DEFAULT_PRICE_PREC && MIN_LOT_DECIMALS) {
return {
pricePrecision: DEFAULT_PRICE_PREC,
amountPrecision: forceAmountPrecision || MIN_LOT_DECIMALS
};
}
try {
var depth = exchange.GetDepth();
if (depth && depth.Bids && depth.Bids.length > 0) {
var bidPrice = depth.Bids[0].Price;
var bidAmount = depth.Bids[0].Amount;

        var pricePrecision = getDecimalPlaces(bidPrice);
        var amountPrecision = getDecimalPlaces(bidAmount);
        
        Log("从深度数据获取精度 - 买一价格:", bidPrice, "价格精度:", pricePrecision, "买一数量:", bidAmount, "数量精度:", amountPrecision);
        
        return {
            pricePrecision: Math.max(1, pricePrecision || DEFAULT_PRICE_PREC || 1),
            amountPrecision: Math.max(MIN_LOT_DECIMALS, amountPrecision || MIN_LOT_DECIMALS)
        };
    }
} catch (e) {
    Log("从深度数据获取精度失败:", e);
}

Log("使用默认精度 - 价格精度:", DEFAULT_PRICE_PREC, "数量精度:", MIN_LOT_DECIMALS);
return {
    pricePrecision: DEFAULT_PRICE_PREC,
    amountPrecision: forceAmountPrecision || MIN_LOT_DECIMALS
};

}

function formatPrice(price, precision) {
return parseFloat(price.toFixed(precision));
}

function formatAmount(amount, precision) {
return parseFloat(amount.toFixed(precision));
}

function calculateOrderAmount(price, orderValue, amountPrecision) {
/**
* 计算订单数量
* 确保数量是合约最小单位的整数倍
* ETH永续合约最小单位：0.01
*/
var minLotSize = MIN_LOT_SIZE; // ETH永续合约最小单位

// 计算基础数量
var amount = orderValue / price;

Log("计算订单数量 - 基础计算: 目标金额=" + orderValue + ", 价格=" + price + ", 基础数量=" + amount.toFixed(6));

// 确保数量是minLotSize的整数倍（向上取整）
amount = Math.round(amount / minLotSize) * minLotSize;
if (amount < minLotSize) {
    amount = minLotSize;
}
Log("计算订单数量 - 对齐到步长: " + amount.toFixed(amtPrecision));

// 应用精度格式化（数量精度改为2位）
var amtPrecision = Math.max(amountPrecision || (forceAmountPrecision || MIN_LOT_DECIMALS), MIN_LOT_DECIMALS);
amount = formatAmount(amount, amtPrecision);  // 按传入精度格式化

// 再次确保是minLotSize的整数倍（防止精度格式化后丢失）
amount = Math.ceil(amount / minLotSize) * minLotSize;
amount = parseFloat(amount.toFixed(amtPrecision));  // 确保符合数量精度

// 计算实际订单金额
var actualValue = amount * price;

// 容错处理：允许订单金额与目标金额有较大偏差（允许10-20%的偏差）
// 如果实际金额太小（小于目标金额的80%），则增加一个最小单位
if (actualValue < orderValue * 0.8) {
    amount = amount + minLotSize;
    amount = parseFloat(amount.toFixed(amtPrecision));
    actualValue = amount * price;
    Log("计算订单数量 - 金额太小，增加一个最小单位: " + amount.toFixed(amtPrecision));
}

var deviation = ((actualValue - orderValue) / orderValue * 100).toFixed(2);
Log("计算订单数量 - 最终结果: 目标金额=" + orderValue + ", 价格=" + price + ", 计算数量=" + amount.toFixed(2) + ", 实际金额=" + actualValue.toFixed(2) + ", 偏差=" + deviation + "%");

return amount;

}

// ==================== 工具函数 ====================
function safeAmount(raw) {
var val = Number(raw);
return (isNaN(val) || val <= 0) ? 0.001 : Math.max(val, 0.001);
}

function safePrice(raw) {
var val = Number(raw);
return (isNaN(val) || val <= 0) ? 1 : val;
}

// 统一判断EOF错误，便于回测数据结束或连接断开时优雅退出
function isEOFError(e) {
var msg = '';
try {
msg = (e && e.toString) ? e.toString() : String(e);
} catch (_) {
msg = '';
}
return msg && msg.indexOf('EOF') !== -1;
}

// ==================== 仓位记录 ====================
const LONG_SIDE = 1;
const SHORT_SIDE = -1;

function addPosition(list, price, amount, side) {
list.push({ price: price, amount: amount, side: side });
}

function removePosition(list, idx) {
list.splice(idx, 1);
}

// ==================== 全局变量 ====================
var config = null;
var precision = null;
// OKX ETH USDT 永续合约最小数量单位 0.01
var MIN_LOT_SIZE = 0.01; // 默认最小数量步长（OKX ETH 永续）
var MIN_LOT_DECIMALS = 2; // 默认数量小数位（与步长匹配）
var DEFAULT_PRICE_PREC = 1; // 默认价格精度
var forceMinLotSize = null; // 可选覆盖：最小步长
var forceAmountPrecision = null; // 可选覆盖：数量精度

function decimalPlaces(n) {
var s = n.toString();
return s.indexOf('.') > -1 ? s.split('.')[1].length : 0;
}

// ==================== 交易规则获取（OKX API） ====================
function loadInstrumentSpec() {
try {
// 仅当交易所支持 IO 方式直连 OKX V5 时生效
var symbolParts = (config && config.symbol ? config.symbol : "ETH/USDT").replace("_", "/").split("/");
var base = symbolParts[0];
var quote = symbolParts[1];
var uly = base + "-" + quote;
var params = "instType=SWAP&uly=" + encodeURIComponent(uly);
var res = exchange.IO("api", "GET", "/api/v5/public/instruments", params);
if (res && res.data && res.data.length > 0) {
var inst = res.data[0];
if (inst.lotSz) {
MIN_LOT_SIZE = parseFloat(inst.lotSz);
MIN_LOT_DECIMALS = decimalPlaces(inst.lotSz);
}
if (inst.tickSz) {
DEFAULT_PRICE_PREC = decimalPlaces(inst.tickSz);
}
Log("获取规则成功 lotSz:", inst.lotSz, "tickSz:", inst.tickSz);
return true;
} else {
Log("获取规则失败：无数据返回");
}
} catch (e) {
Log("获取规则异常（可能托管者/交易所不支持 IO）:", e);
}
return false;
}

// 应用用户覆盖的步长/精度（若提供）。若已获取到交易所规则，则忽略覆盖以防违规。
function applyForceLot() {
if (config && config.forceMinLotSize && !isNaN(config.forceMinLotSize)) {
var f = parseFloat(config.forceMinLotSize);
// 只有在未成功获取交易所规则时才采用用户覆盖
if (!DEFAULT_PRICE_PREC || DEFAULT_PRICE_PREC === 1) {
MIN_LOT_SIZE = f;
MIN_LOT_DECIMALS = decimalPlaces(MIN_LOT_SIZE);
Log("使用手动覆盖的最小步长:", MIN_LOT_SIZE, "小数位:", MIN_LOT_DECIMALS);
} else {
Log("已从交易所规则获取 lotSz，忽略手动最小步长覆盖");
}
}
if (config && config.forceAmountPrecision && !isNaN(config.forceAmountPrecision)) {
forceAmountPrecision = parseInt(config.forceAmountPrecision, 10);
Log("使用手动覆盖的数量精度:", forceAmountPrecision);
}
}

// 多头相关
var MANY_BUYING = false;
var MANY_NEXT_BUY_PRICE = 0;
var MANY_ORDER_LIST = [];

// 空头相关
var SHORT_BUYING = false;
var SHORT_NEXT_BUY_PRICE = 0;
var SHORT_ORDER_LIST = [];

// 状态信息相关
var INIT_TIME = null;
var INITIAL_BALANCE = 0;
var LAST_PROFIT_TIME = null;
var PROFIT_HISTORY = [];
var CYCLE_START_TIME = 0;

// 参数迁移相关
var oldConfig = null;
var isMigrating = false;

// 状态保存间隔（每5分钟保存一次）
var LAST_SAVE_TIME = 0;
var SAVE_INTERVAL = 300; // 5分钟
var LAST_RECONCILE_TIME = 0;
var RECONCILE_INTERVAL = 60; // 每60秒对账一次
var RECONCILE_EMPTY_STREAK = 0; // 连续空结果计数，用于防抖
var RECONCILE_EMPTY_THRESHOLD = 2; // 连续2次空才清空本地持仓

// ==================== 下单函数 ====================
function placeOrder(dir, price, amount) {
/** 下单函数，带错误处理和重试机制 */
try {
exchange.SetDirection(dir);
var finalPrice = safePrice(price);
var finalAmount = safeAmount(amount);

    // 按交易所精度要求格式化价格与数量
    var pricePrecision = (precision && precision.pricePrecision) ? precision.pricePrecision : 2;
var amountPrecision = (precision && precision.amountPrecision) ? Math.max(precision.amountPrecision, MIN_LOT_DECIMALS) : (forceAmountPrecision || MIN_LOT_DECIMALS);
    finalPrice = formatPrice(finalPrice, pricePrecision);
    
    // 确保数量是0.01的整数倍（ETH永续合约最小单位）
var minLotSize = MIN_LOT_SIZE;
    finalAmount = Math.round(finalAmount / minLotSize) * minLotSize;
    if (finalAmount < minLotSize) {
        finalAmount = minLotSize;
    }
    finalAmount = parseFloat(finalAmount.toFixed(amountPrecision));  // 按数量精度保留小数
    
    // 确保数量至少是最小单位
    if (finalAmount < minLotSize) {
        finalAmount = minLotSize;
    }
    
    var orderValue = finalPrice * finalAmount;
    Log("下单 - 方向:", dir, "价格:", finalPrice, "数量:", finalAmount, "金额:", orderValue.toFixed(2), "数量验证: 是0.01的", (finalAmount / minLotSize).toFixed(0), "倍");
    
    var orderId = dir === 'buy' || dir === 'closebuy'
        ? exchange.Buy(finalPrice, finalAmount)
        : exchange.Sell(finalPrice, finalAmount);
    
    if (!orderId) {
        Log("下单失败 - 方向:", dir, "价格:", finalPrice, "数量:", finalAmount, "返回订单ID为空");
        // 重试一次（如果数量不是最小单位的整数倍，尝试调整）
        if (finalAmount % minLotSize !== 0) {
            finalAmount = Math.ceil(finalAmount / minLotSize) * minLotSize;
            finalAmount = parseFloat(finalAmount.toFixed(2));
            Log("下单重试 - 调整数量为:", finalAmount);
            orderId = dir === 'buy' || dir === 'closebuy'
                ? exchange.Buy(finalPrice, finalAmount)
                : exchange.Sell(finalPrice, finalAmount);
        }
    } else {
        Log("下单成功 - 方向:", dir, "订单ID:", orderId, "价格:", finalPrice, "数量:", finalAmount);
    }
    
    return orderId;
} catch (e) {
    Log("下单异常 - 方向:", dir, "价格:", price, "数量:", amount, "错误:", e);
    return null;
}

}

// 轮询订单成交，带超时和自定义回调，避免重复代码
function waitOrderFilled(orderId, timeoutSec, onFilled, onTimeout) {
var deadline = Unix() + timeoutSec;
while (true) {
if (Unix() > deadline) {
if (onTimeout) onTimeout(orderId);
return false;
}
var order = exchange.GetOrder(orderId);
if (order && (order.Status === 1 || order.Status === 2)) {
onFilled(order);
return true;
}
Sleep(100);
}
}

// ==================== 多头网格策略 ====================
function firstManyBuy() {
/** 首次多头买入，带超时和重试机制 */
if (MANY_BUYING) return;

var ticker = exchange.GetTicker();
if (!ticker) {
    Log("首次多头买入失败：无法获取行情");
    return;
}

var price = safePrice(ticker.Last);
var orderValue = getOrderAmount(false);  // 使用新参数
Log("准备首次多头买入 - 当前价格:", price, "目标金额:", orderValue);

var amount = calculateOrderAmount(price, orderValue, precision.amountPrecision);
Log("首次多头买入 - 计算出的数量:", amount, "价格:", price);

var orderId = placeOrder('buy', price, amount);
if (!orderId) {
    Log("首次多头买入失败：下单返回空，尝试重试...");
    // 重试一次，使用调整后的数量
    Sleep(1000);
    amount = calculateOrderAmount(price, orderValue, precision.amountPrecision);
    orderId = placeOrder('buy', price, amount);
    if (!orderId) {
        Log("首次多头买入重试失败：下单返回空");
        return;
    }
}

Log("首次多头买入 - 订单ID:", orderId, "价格:", price, "数量:", amount);

MANY_BUYING = true;
var timeoutSec = 60;  // 60秒超时
var filled = waitOrderFilled(
    orderId,
    timeoutSec,
    function(order) {
        var gridSpacing = getGridSpacing(LONG_SIDE, false);
        MANY_NEXT_BUY_PRICE = formatPrice(
            order.Price * (1 - gridSpacing / 100),
            precision.pricePrecision
        );
        MANY_BUYING = false;
        addPosition(MANY_ORDER_LIST, order.Price, order.Amount, LONG_SIDE);
        Log("多头首次买入成功，价格:", order.Price, "数量:", order.Amount, "下一个买入价格:", MANY_NEXT_BUY_PRICE);
        
        saveHistory({
            type: 'first_many_buy',
            price: order.Price,
            amount: order.Amount,
            value: order.Price * order.Amount
        });
        
        safeSaveState();
    },
    function(orderIdTimeout) {
        Log("首次多头买入超时，取消订单:", orderIdTimeout);
        exchange.CancelOrder(orderIdTimeout);
        MANY_BUYING = false;
    }
);
if (!filled) {
    return;
}

}

function manyBuy() {
/** 多头加仓（网格买入） */
if (MANY_BUYING) return;

var ticker = exchange.GetTicker();
if (!ticker) {
    Log("多头加仓失败：无法获取行情");
    return;
}

if (ticker.Last > MANY_NEXT_BUY_PRICE) {
    Log("多头加仓跳过：当前价格", ticker.Last, "高于下一个买入价格", MANY_NEXT_BUY_PRICE);
    return;
}

var price = safePrice(ticker.Last);
var orderValue = getOrderAmount(false);  // 使用新参数
Log("准备多头加仓 - 当前价格:", price, "下一个买入价格:", MANY_NEXT_BUY_PRICE, "目标金额:", orderValue);

var amount = calculateOrderAmount(price, orderValue, precision.amountPrecision);
Log("多头加仓 - 计算出的数量:", amount, "价格:", price);

var orderId = placeOrder('buy', price, amount);
if (!orderId) {
    Log("多头加仓失败：下单返回空");
    return;
}

Log("多头加仓 - 订单ID:", orderId, "价格:", price, "数量:", amount);

MANY_BUYING = true;
var timeoutSec = 60 * 30;  // 30分钟超时
var filled = waitOrderFilled(
    orderId,
    timeoutSec,
    function(order) {
        var gridSpacing = getGridSpacing(LONG_SIDE, false);
        MANY_NEXT_BUY_PRICE = formatPrice(
            order.Price * (1 - gridSpacing / 100),
            precision.pricePrecision
        );
        MANY_BUYING = false;
        addPosition(MANY_ORDER_LIST, order.Price, order.Amount, LONG_SIDE);
        Log("多头加仓成功，价格:", order.Price, "数量:", order.Amount, "持仓数:", MANY_ORDER_LIST.length, "下一个买入价格:", MANY_NEXT_BUY_PRICE);
        
        saveHistory({
            type: 'many_buy',
            price: order.Price,
            amount: order.Amount,
            value: order.Price * order.Amount
        });
        
        safeSaveState();
    },
    function(orderIdTimeout) {
        exchange.CancelOrder(orderIdTimeout);
        MANY_BUYING = false;
        Log("多头加仓订单超时，已取消订单:", orderIdTimeout);
    }
);
if (!filled) {
    return;
}

}

function manySell() {
/** 多头平仓（网格卖出）- 支持双轨制 */
var ticker = exchange.GetTicker();
if (!ticker) return;

// 从最新持仓开始检查（倒序）
for (var i = MANY_ORDER_LIST.length - 1; i >= 0; i--) {
    var pos = MANY_ORDER_LIST[i];
    
    // 计算盈利价格（支持双轨制：旧持仓用旧参数，新持仓用新参数）
    var gridSpacing = getGridSpacing(LONG_SIDE, true);  // 平仓时检查是否用旧参数
    var profitPrice = formatPrice(
        pos.price * (1 + gridSpacing / 100),
        precision.pricePrecision
    );
    
    // 如果当前价格达到盈利价格，平仓
    if (ticker.Last >= profitPrice) {
        var position = exchange.GetPosition();
        var longPos = null;
        if (position && position.length > 0) {
            for (var j = 0; j < position.length; j++) {
                if (position[j].Type === 0 && position[j].Amount > 0) {
                    longPos = position[j];
                    break;
                }
            }
        }
        
        if (!longPos || longPos.Amount <= 0) break;
        
        var qty = safeAmount(Math.min(pos.amount, longPos.Amount));
        // 确保数量是0.01的整数倍（ETH永续合约最小单位）
        var minLotSize = MIN_LOT_SIZE;
        qty = Math.floor(qty / minLotSize) * minLotSize;
        qty = parseFloat(qty.toFixed(2));  // 保留2位小数
        
        if (qty < minLotSize) {
            Log("多头平仓跳过：数量太小", qty, "最小单位:", minLotSize);
            break;
        }
        
        Log("准备多头平仓 - 持仓价格:", pos.price, "当前价格:", ticker.Last, "盈利价格:", profitPrice, "平仓数量:", qty, "使用参数:", shouldUseOldConfig(LONG_SIDE) ? "旧参数" : "新参数");
        
        // 多头平仓应使用 closesell（卖出平多）
        var orderId = placeOrder('closesell', ticker.Last, qty);
        
        if (!orderId) continue;
        
        while (true) {
            var order = exchange.GetOrder(orderId);
            if (!order) {
                Sleep(100);
                continue;
            }
            
            if (order.Status === 1 || order.Status === 2) {
                // 计算下一个买入价格（基于新参数的多头网格间距）
                var nextGridSpacing = getGridSpacing(LONG_SIDE, false);
                MANY_NEXT_BUY_PRICE = formatPrice(
                    ticker.Last * (1 - nextGridSpacing / 100),
                    precision.pricePrecision
                );
                removePosition(MANY_ORDER_LIST, i);
                Log("多头平仓成功，价格:", order.Price, "数量:", order.Amount, "剩余持仓:", MANY_ORDER_LIST.length, "下一个买入价格:", MANY_NEXT_BUY_PRICE);
                
                // 保存历史记录
                var profit = (order.Price - pos.price) * order.Amount;
                saveHistory({
                    type: 'many_sell',
                    price: order.Price,
                    amount: order.Amount,
                    value: order.Price * order.Amount,
                    entryPrice: pos.price,
                    profit: profit
                });
                
                // ✅ 成交后立即保存状态
                safeSaveState();
                
                // 检查迁移是否完成
                checkMigrationComplete();
                
                break;
            }
            Sleep(100);
        }
    }
}

}

// ==================== 空头网格策略 ====================
function firstShortBuy() {
/** 首次空头卖出，带超时和重试机制 */
if (SHORT_BUYING) return;

var ticker = exchange.GetTicker();
if (!ticker) {
    Log("首次空头卖出失败：无法获取行情");
    return;
}

var price = safePrice(ticker.Last);
var orderValue = getOrderAmount(false);  // 使用新参数
Log("准备首次空头卖出 - 当前价格:", price, "目标金额:", orderValue);

var amount = calculateOrderAmount(price, orderValue, precision.amountPrecision);
Log("首次空头卖出 - 计算出的数量:", amount, "价格:", price);

var orderId = placeOrder('sell', price, amount);
if (!orderId) {
    Log("首次空头卖出失败：下单返回空，尝试重试...");
    // 重试一次，使用调整后的数量
    Sleep(1000);
    amount = calculateOrderAmount(price, orderValue, precision.amountPrecision);
    orderId = placeOrder('sell', price, amount);
    if (!orderId) {
        Log("首次空头卖出重试失败：下单返回空");
        return;
    }
}

Log("首次空头卖出 - 订单ID:", orderId, "价格:", price, "数量:", amount);

SHORT_BUYING = true;
var timeoutSec = 60;  // 60秒超时
var filled = waitOrderFilled(
    orderId,
    timeoutSec,
    function(order) {
        var gridSpacing = getGridSpacing(SHORT_SIDE, false);
        SHORT_NEXT_BUY_PRICE = formatPrice(
            order.Price * (1 + gridSpacing / 100),
            precision.pricePrecision
        );
        SHORT_BUYING = false;
        addPosition(SHORT_ORDER_LIST, order.Price, order.Amount, SHORT_SIDE);
        Log("空头首次卖出成功，价格:", order.Price, "数量:", order.Amount, "下一个卖出价格:", SHORT_NEXT_BUY_PRICE);
        
        saveHistory({
            type: 'first_short_sell',
            price: order.Price,
            amount: order.Amount,
            value: order.Price * order.Amount
        });
        
        safeSaveState();
    },
    function(orderIdTimeout) {
        Log("首次空头卖出超时，取消订单:", orderIdTimeout);
        exchange.CancelOrder(orderIdTimeout);
        SHORT_BUYING = false;
    }
);
if (!filled) {
    return;
}

}

function shortBuy() {
/** 空头加仓（网格卖出） */
if (SHORT_BUYING) return;

var ticker = exchange.GetTicker();
if (!ticker) {
    Log("空头加仓失败：无法获取行情");
    return;
}

if (ticker.Last < SHORT_NEXT_BUY_PRICE) {
    Log("空头加仓跳过：当前价格", ticker.Last, "低于下一个卖出价格", SHORT_NEXT_BUY_PRICE);
    return;
}

var price = safePrice(ticker.Last);
var orderValue = getOrderAmount(false);  // 使用新参数
Log("准备空头加仓 - 当前价格:", price, "下一个卖出价格:", SHORT_NEXT_BUY_PRICE, "目标金额:", orderValue);

var amount = calculateOrderAmount(price, orderValue, precision.amountPrecision);
Log("空头加仓 - 计算出的数量:", amount, "价格:", price);

var orderId = placeOrder('sell', price, amount);
if (!orderId) {
    Log("空头加仓失败：下单返回空");
    return;
}

Log("空头加仓 - 订单ID:", orderId, "价格:", price, "数量:", amount);

SHORT_BUYING = true;
var timeoutSec = 60 * 30;  // 30分钟超时
var filled = waitOrderFilled(
    orderId,
    timeoutSec,
    function(order) {
        var gridSpacing = getGridSpacing(SHORT_SIDE, false);
        SHORT_NEXT_BUY_PRICE = formatPrice(
            order.Price * (1 + gridSpacing / 100),
            precision.pricePrecision
        );
        SHORT_BUYING = false;
        addPosition(SHORT_ORDER_LIST, order.Price, order.Amount, SHORT_SIDE);
        Log("空头加仓成功，价格:", order.Price, "数量:", order.Amount, "持仓数:", SHORT_ORDER_LIST.length, "下一个卖出价格:", SHORT_NEXT_BUY_PRICE);
        
        saveHistory({
            type: 'short_sell',
            price: order.Price,
            amount: order.Amount,
            value: order.Price * order.Amount
        });
        
        safeSaveState();
    },
    function(orderIdTimeout) {
        exchange.CancelOrder(orderIdTimeout);
        SHORT_BUYING = false;
        Log("空头加仓订单超时，已取消订单:", orderIdTimeout);
    }
);
if (!filled) {
    return;
}

}

function shortSell() {
/** 空头平仓（网格买入）- 支持双轨制 */
var ticker = exchange.GetTicker();
if (!ticker) return;

// 从最新持仓开始检查（倒序）
for (var i = SHORT_ORDER_LIST.length - 1; i >= 0; i--) {
    var pos = SHORT_ORDER_LIST[i];
    
    // 计算盈利价格（支持双轨制：旧持仓用旧参数，新持仓用新参数）
    var gridSpacing = getGridSpacing(SHORT_SIDE, true);  // 平仓时检查是否用旧参数
    var profitPrice = formatPrice(
        pos.price * (1 - gridSpacing / 100),
        precision.pricePrecision
    );
    
    // 如果当前价格达到盈利价格，平仓
    if (ticker.Last <= profitPrice) {
        var position = exchange.GetPosition();
        var shortPos = null;
        if (position && position.length > 0) {
            for (var j = 0; j < position.length; j++) {
                if (position[j].Type === 1 && position[j].Amount > 0) {
                    shortPos = position[j];
                    break;
                }
            }
        }
        
        if (!shortPos || shortPos.Amount <= 0) break;
        
        var qty = safeAmount(Math.min(pos.amount, shortPos.Amount));
        // 确保数量是0.01的整数倍（ETH永续合约最小单位）
        var minLotSize = MIN_LOT_SIZE;
        qty = Math.floor(qty / minLotSize) * minLotSize;
        qty = parseFloat(qty.toFixed(2));  // 保留2位小数
        
        if (qty < minLotSize) {
            Log("空头平仓跳过：数量太小", qty, "最小单位:", minLotSize);
            break;
        }
        
        Log("准备空头平仓 - 持仓价格:", pos.price, "当前价格:", ticker.Last, "盈利价格:", profitPrice, "平仓数量:", qty, "使用参数:", shouldUseOldConfig(SHORT_SIDE) ? "旧参数" : "新参数");
        
        // 空头平仓应使用 closebuy（买入平空）
        var orderId = placeOrder('closebuy', ticker.Last, qty);
        
        if (!orderId) continue;
        
        while (true) {
            var order = exchange.GetOrder(orderId);
            if (!order) {
                Sleep(100);
                continue;
            }
            
            if (order.Status === 1 || order.Status === 2) {
                // 计算下一个卖出价格（基于新参数的空头网格间距）
                var nextGridSpacing = getGridSpacing(SHORT_SIDE, false);
                SHORT_NEXT_BUY_PRICE = formatPrice(
                    ticker.Last * (1 + nextGridSpacing / 100),
                    precision.pricePrecision
                );
                removePosition(SHORT_ORDER_LIST, i);
                Log("空头平仓成功，价格:", order.Price, "数量:", order.Amount, "剩余持仓:", SHORT_ORDER_LIST.length, "下一个卖出价格:", SHORT_NEXT_BUY_PRICE);
                
                // 保存历史记录
                var profit = (pos.price - order.Price) * order.Amount;
                saveHistory({
                    type: 'short_buy',
                    price: order.Price,
                    amount: order.Amount,
                    value: order.Price * order.Amount,
                    entryPrice: pos.price,
                    profit: profit
                });
                
                // ✅ 成交后立即保存状态
                safeSaveState();
                
                // 检查迁移是否完成
                checkMigrationComplete();
                
                break;
            }
            Sleep(100);
        }
    }
}

}

// ==================== 边界检查 ====================
function checkPriceBounds() {
/** 检查价格是否在网格边界内 */
var ticker = exchange.GetTicker();
if (!ticker) return true;

var currentPrice = ticker.Last;

// 如果价格超出上边界，暂停多头买入
if (currentPrice >= config.upperPrice) {
    return false;
}

// 如果价格低于下边界，暂停空头卖出
if (currentPrice <= config.lowerPrice) {
    return false;
}

return true;

}

// ==================== 状态信息计算 ====================
function calculateLiquidationPrice(account, positions, leverage) {
/** 计算爆仓价 */
var longLiquidationPrice = null;
var shortLiquidationPrice = null;

if (!account || !positions || positions.length === 0) {
    return { long: longLiquidationPrice, short: shortLiquidationPrice };
}

var margin = account.Margin || 0;
var balance = account.Balance || 0;
var available = account.Available || 0;

// 计算多头和空头持仓
var longAmount = 0;
var longPrice = 0;
var shortAmount = 0;
var shortPrice = 0;

for (var i = 0; i < positions.length; i++) {
    var pos = positions[i];
    if (pos.Type === 0 && pos.Amount > 0) {
        // 多头
        longAmount += pos.Amount;
        longPrice = pos.Price;
    } else if (pos.Type === 1 && pos.Amount > 0) {
        // 空头
        shortAmount += pos.Amount;
        shortPrice = pos.Price;
    }
}

// 计算多头爆仓价（价格下跌导致爆仓）
if (longAmount > 0 && longPrice > 0 && leverage > 0) {
    // 简化计算：爆仓价 = 持仓价 * (1 - 维持保证金率)
    // 维持保证金率通常为 0.5% - 1%
    var maintenanceMarginRate = 0.01; // 1%
    longLiquidationPrice = longPrice * (1 - maintenanceMarginRate);
}

// 计算空头爆仓价（价格上涨导致爆仓）
if (shortAmount > 0 && shortPrice > 0 && leverage > 0) {
    var maintenanceMarginRate = 0.01; // 1%
    shortLiquidationPrice = shortPrice * (1 + maintenanceMarginRate);
}

return { long: longLiquidationPrice, short: shortLiquidationPrice };

}

function calculateProfit(account, initialBalance) {
/** 计算收益信息 */
if (!account || !initialBalance) {
return {
totalProfit: 0,
totalProfitRate: 0,
dailyProfit: 0,
avgDailyReturn: 0,
estimatedMonthlyReturn: 0,
estimatedYearlyReturn: 0
};
}

var currentBalance = account.Balance || 0;
var totalProfit = currentBalance - initialBalance;
var totalProfitRate = initialBalance > 0 ? (totalProfit / initialBalance) : 0;

// 计算当日收益（简化处理，使用最近一次收益记录）
var dailyProfit = 0;
if (PROFIT_HISTORY.length > 0) {
    var today = new Date();
    today.setHours(0, 0, 0, 0);
    var todayTimestamp = Math.floor(today.getTime() / 1000);
    
    var yesterdayProfit = 0;
    for (var i = PROFIT_HISTORY.length - 1; i >= 0; i--) {
        if (PROFIT_HISTORY[i].time < todayTimestamp) {
            yesterdayProfit = PROFIT_HISTORY[i].profit;
            break;
        }
    }
    dailyProfit = totalProfit - yesterdayProfit;
}

// 计算平均日化收益率
var avgDailyReturn = 0;
var estimatedMonthlyReturn = 0;
var estimatedYearlyReturn = 0;

if (INIT_TIME && INIT_TIME > 0) {
    var days = (Unix() - INIT_TIME) / (24 * 3600);
    if (days > 0) {
        avgDailyReturn = totalProfitRate / days;
        estimatedMonthlyReturn = avgDailyReturn * 30;
        estimatedYearlyReturn = avgDailyReturn * 365;
    }
}

return {
    totalProfit: totalProfit,
    totalProfitRate: totalProfitRate,
    dailyProfit: dailyProfit,
    avgDailyReturn: avgDailyReturn,
    estimatedMonthlyReturn: estimatedMonthlyReturn,
    estimatedYearlyReturn: estimatedYearlyReturn
};

}

function getPositionInfo() {
/** 获取持仓详细信息 */
var positions = [];
var ticker = exchange.GetTicker();
var currentPrice = ticker ? ticker.Last : 0;

// 获取实际持仓
var exchangePositions = exchange.GetPosition();
if (!exchangePositions || exchangePositions.length === 0) {
    return positions;
}

for (var i = 0; i < exchangePositions.length; i++) {
    var pos = exchangePositions[i];
    if (pos.Amount <= 0) continue;
    
    var direction = pos.Type === 0 ? 'long' : 'short';
    var positionValue = pos.Amount * pos.Price;
    var unrealizedPnl = pos.Profit || 0;
    
    // 计算预估回归收益（基于网格间距）
    var gridSpacing = direction === 'long' ? config.longGridSpacing : config.shortGridSpacing;
    var estimatedReturn = positionValue * (gridSpacing / 100);
    var estimatedTotalReturn = estimatedReturn * (direction === 'long' ? MANY_ORDER_LIST.length : SHORT_ORDER_LIST.length);
    
    // 网格初始价格和转向间距
    var gridInitialPrice = currentPrice;
    var turnSpacing = gridSpacing;
    
    // 挂单价格
    var buyOrderPrice = direction === 'long' ? MANY_NEXT_BUY_PRICE : 0;
    var sellOrderPrice = direction === 'short' ? SHORT_NEXT_BUY_PRICE : 0;
    
    // 计算成交额（简化处理）
    var tradeVolume = positionValue;
    
    positions.push({
        symbol: config.symbol,
        direction: direction,
        quantity: pos.Amount,
        positionPrice: pos.Price,
        positionValue: positionValue,
        estimatedReturn: estimatedReturn,
        estimatedTotalReturn: estimatedTotalReturn,
        gridInitialPrice: gridInitialPrice,
        turnSpacing: turnSpacing,
        currentPrice: currentPrice,
        buyOrderPrice: buyOrderPrice,
        sellOrderPrice: sellOrderPrice,
        unrealizedPnl: unrealizedPnl,
        tradeVolume: tradeVolume
    });
}

return positions;

}

function updateStatusInfo() {
/** 更新并输出状态信息（FMZ原生表格格式，框架式布局） */
try {
var account = exchange.GetAccount();
var positions = exchange.GetPosition();
var ticker = exchange.GetTicker();

    if (!account) return;
    
    // 计算爆仓价
    var leverage = 1;
    var liquidationPrices = calculateLiquidationPrice(account, positions, leverage);
    
    // 计算收益
    var profitInfo = calculateProfit(account, INITIAL_BALANCE);
    
    // 计算循环延时
    var cycleDelay = 0;
    if (CYCLE_START_TIME > 0) {
        cycleDelay = (Unix() - CYCLE_START_TIME) * 1000;
    }
    CYCLE_START_TIME = Unix();
    
    // 获取持仓信息
    var positionInfo = getPositionInfo();
    
    // 格式化时间
    var initTimeStr = '-';
    if (INIT_TIME) {
        var initDate = new Date(INIT_TIME * 1000);
        var pad = function(n) { return n < 10 ? '0' + n : n; };
        initTimeStr = initDate.getFullYear() + '-' + 
                     pad(initDate.getMonth() + 1) + '-' + 
                     pad(initDate.getDate()) + ' ' +
                     pad(initDate.getHours()) + ':' + 
                     pad(initDate.getMinutes()) + ':' + 
                     pad(initDate.getSeconds());
    }
    
    // 计算运行时长
    var runTime = '-';
    if (INIT_TIME) {
        var seconds = Unix() - INIT_TIME;
        var days = Math.floor(seconds / 86400);
        var hours = Math.floor((seconds % 86400) / 3600);
        var minutes = Math.floor((seconds % 3600) / 60);
        runTime = days + '天' + hours + '小时' + minutes + '分钟';
    }
    
    // 构造纯文本表格（按行输出），在移动端也能清晰显示
    var lines = [];
    var addTextSection = function(title, rows) {
        lines.push(title);
        lines.push('字段 | 值');
        lines.push('---- | ----');
        for (var i = 0; i < rows.length; i++) {
            lines.push(rows[i][0] + ' | ' + rows[i][1]);
        }
        lines.push(''); // 空行分隔
    };
    
    addTextSection('📊 基础', [
        ['初始化时间', initTimeStr],
        ['运行时长', runTime],
        ['当前价格', ticker ? ticker.Last.toFixed(2) : '-'],
        ['做多爆仓价', liquidationPrices.long ? liquidationPrices.long.toFixed(2) : '-'],
        ['做空爆仓价', liquidationPrices.short ? liquidationPrices.short.toFixed(2) : '-'],
        ['参数迁移', isMigrating ? '迁移中' : '正常'],
        isMigrating && oldConfig ? ['旧多头间距', oldConfig.longGridSpacing + '%'] : null,
        isMigrating && oldConfig ? ['旧空头间距', oldConfig.shortGridSpacing + '%'] : null
    ].filter(Boolean));
    
    addTextSection('💰 账户', [
        ['初始余额', INITIAL_BALANCE.toFixed(2)],
        ['钱包余额', (account.Balance || 0).toFixed(2)],
        ['保证金余额', (account.Margin || 0).toFixed(2)],
        ['可用保证金', (account.Available || 0).toFixed(2)],
        ['已用杠杆', leverage + 'x']
    ]);
    
    addTextSection('📈 收益', [
        ['总收益', profitInfo.totalProfit.toFixed(2)],
        ['总收益率', (profitInfo.totalProfitRate * 100).toFixed(2) + '%'],
        ['当日收益', profitInfo.dailyProfit.toFixed(2)],
        ['平均日化', (profitInfo.avgDailyReturn * 100).toFixed(2) + '%'],
        ['预估月化', (profitInfo.estimatedMonthlyReturn * 100).toFixed(2) + '%'],
        ['预估年化', (profitInfo.estimatedYearlyReturn * 100).toFixed(2) + '%']
    ]);
    
    addTextSection('🔲 网格', [
        ['多头持仓数', MANY_ORDER_LIST.length],
        ['下一个买入价', MANY_NEXT_BUY_PRICE > 0 ? MANY_NEXT_BUY_PRICE.toFixed(2) : '-'],
        ['多头间距', config.longGridSpacing + '%'],
        ['空头持仓数', SHORT_ORDER_LIST.length],
        ['下一个卖出价', SHORT_NEXT_BUY_PRICE > 0 ? SHORT_NEXT_BUY_PRICE.toFixed(2) : '-'],
        ['空头间距', config.shortGridSpacing + '%'],
        ['单网格金额', config.orderAmount.toFixed(2)]
    ]);
    
    var posRows = [];
    if (positionInfo.length > 0) {
        for (var i = 0; i < positionInfo.length; i++) {
            var pos = positionInfo[i];
            posRows.push(['持仓' + (i + 1) + ' (' + (pos.direction === 'long' ? '多' : '空') + ')', '']);
            posRows.push(['数量', pos.quantity.toFixed(2)]);
            posRows.push(['持仓价', pos.positionPrice.toFixed(2)]);
            posRows.push(['当前价', pos.currentPrice.toFixed(2)]);
            posRows.push(['持仓价值', pos.positionValue.toFixed(2)]);
            posRows.push(['未实现盈亏', pos.unrealizedPnl.toFixed(2)]);
            if (i < positionInfo.length - 1) {
                posRows.push(['---', '---']);
            }
        }
    } else {
        posRows.push(['暂无持仓', '']);
    }
    addTextSection('📦 持仓', posRows);
    
    addTextSection('⚙️ 系统', [
        ['循环延时', cycleDelay.toFixed(0) + 'ms'],
        ['状态保存', LAST_SAVE_TIME > 0 ? new Date(LAST_SAVE_TIME * 1000).toLocaleTimeString() : '-'],
        ['收益记录数', PROFIT_HISTORY.length]
    ]);
    
    LogStatus(lines.join('\n'));
    
    // 记录收益曲线（使用LogProfit，FMZ平台会自动显示收益曲线）
    var currentProfit = profitInfo.totalProfit;
    LogProfit(currentProfit);
    
    // 保存收益历史
    PROFIT_HISTORY.push({
        time: Unix(),
        profit: currentProfit
    });
    
    // 只保留最近1000条记录
    if (PROFIT_HISTORY.length > 1000) {
        PROFIT_HISTORY.shift();
    }
    
    // 定期保存状态（每5分钟）
    if (Unix() - LAST_SAVE_TIME >= SAVE_INTERVAL) {
        safeSaveState();
    }
    
} catch (e) {
    Log("更新状态信息失败:", e);
}

}

// ==================== 主循环 ====================
function onTick() {
var ticker = exchange.GetTicker();
if (!ticker) return;

// 定期持仓对账，防止本地列表与实际仓位不一致（尤其防止空头被抵消后仍显示）
if (Unix() - LAST_RECONCILE_TIME >= RECONCILE_INTERVAL) {
    reconcilePositions();
    LAST_RECONCILE_TIME = Unix();
}

// 检查价格边界
if (!checkPriceBounds()) {
    Log("价格超出网格边界，暂停交易");
    return;
}

// 检查参数迁移是否完成
checkMigrationComplete();

// 如果多头持仓为空，首次买入
if (MANY_ORDER_LIST.length === 0) {
    firstManyBuy();
} else {
    // 多头加仓和平仓
    manyBuy();
    manySell();
}

// 如果空头持仓为空，首次卖出
if (SHORT_ORDER_LIST.length === 0) {
    firstShortBuy();
} else {
    // 空头加仓和平仓
    shortBuy();
    shortSell();
}

// 更新状态信息
updateStatusInfo();

}

// ==================== 主函数 ====================
function main() {
// 设置交易所类型（OKX）
exchange.SetContractType("swap"); // 或 "spot" 根据需求
// 尝试设置双向持仓（对冲）模式，若不支持则忽略，避免 TypeError
if (typeof exchange.SetPositionMode === 'function') {
try {
exchange.SetPositionMode(1);
Log("已尝试设置对冲模式 (SetPositionMode=1)");
} catch (e) {
Log("设置对冲模式失败，继续运行（可能交易所/托管者不支持）：", e);
}
} else {
Log("SetPositionMode 不可用，跳过对冲模式设置");
}

// ✅ 从FMZ界面获取配置参数（禁止硬编码）
// 注意：FMZ平台中，界面设置的参数名称会自动成为JavaScript全局变量
config = getConfigParams();

// 尝试获取交易规则（tickSz/lotSz），以便自动设置步长与精度
loadInstrumentSpec();
// 应用用户手动覆盖（如有）
applyForceLot();
// 最终将精度写回 precision 供后续使用
precision = getPrecision();

// 验证配置
if (!config.symbol) {
    throw new Error("请设置币种选择（界面参数名：symbol）");
}
if (!config.upperPrice || !config.lowerPrice) {
    throw new Error("请设置网格上边界价格和下边界价格（界面参数名：upperPrice, lowerPrice）");
}
if (config.upperPrice <= config.lowerPrice) {
    throw new Error("上边界价格必须大于下边界价格");
}
if (!config.orderAmount || config.orderAmount <= 0) {
    throw new Error("单个网格下单金额必须大于0（界面参数名：orderAmount）");
}
if (!config.longGridSpacing || config.longGridSpacing <= 0) {
    throw new Error("多头网格间距必须大于0（界面参数名：longGridSpacing）");
}
if (!config.shortGridSpacing || config.shortGridSpacing <= 0) {
    throw new Error("空头网格间距必须大于0（界面参数名：shortGridSpacing）");
}

// 尝试恢复状态
Log("========== 策略启动 ==========");
var stateRestored = loadState();
if (stateRestored) {
    Log("✅ 状态恢复成功");
} else {
    Log("ℹ️ 首次运行，使用初始状态");
}

// 检查配置变化（启动参数迁移检测）
checkConfigChange(config);

// 获取精度
precision = getPrecision();

Log("========== 策略配置 ==========");
Log("币种选择:", config.symbol);
Log("多头网格间距:", config.longGridSpacing, "%");
Log("空头网格间距:", config.shortGridSpacing, "%");
Log("单个网格下单金额:", config.orderAmount);
Log("网格上边界价格:", config.upperPrice);
Log("网格下边界价格:", config.lowerPrice);
Log("价格精度:", precision.pricePrecision);
Log("数量精度:", precision.amountPrecision);
Log("合约最小单位: 0.01 (ETH永续合约)");
Log("============================");

// 初始化价格（如果状态未恢复）
if (!stateRestored) {
    var ticker = exchange.GetTicker();
    if (!ticker || !ticker.Last || ticker.Last <= 0) {
        throw new Error("无法获取初始价格");
    }
    
    var initPrice = ticker.Last;
    
    // 初始化多头和空头的下一个买入/卖出价格
    MANY_NEXT_BUY_PRICE = formatPrice(
        initPrice * (1 - config.longGridSpacing / 100),
        precision.pricePrecision
    );
    SHORT_NEXT_BUY_PRICE = formatPrice(
        initPrice * (1 + config.shortGridSpacing / 100),
        precision.pricePrecision
    );
    
    Log("初始价格:", initPrice);
    Log("多头下一个买入价格:", MANY_NEXT_BUY_PRICE);
    Log("空头下一个卖出价格:", SHORT_NEXT_BUY_PRICE);
    
    // 初始化状态信息
    INIT_TIME = Unix();
    var account = exchange.GetAccount();
    if (account) {
        INITIAL_BALANCE = account.Balance || 0;
        Log("初始余额:", INITIAL_BALANCE);
    }
    
    // 初始化收益记录
    LogProfit(0);
} else {
    Log("使用恢复的状态继续运行");
}

CYCLE_START_TIME = Unix();
LAST_SAVE_TIME = Unix();

// 保存初始状态
safeSaveState();

Log("========== 策略运行中 ==========");
Log("状态将每5分钟自动保存，支持关机/重启后恢复");

// 主循环
while (true) {
    try {
        onTick();
    } catch (e) {
        if (isEOFError(e)) {
            Log("检测到 EOF，可能是回测数据结束或连接被关闭，保存状态后退出主循环");
            safeSaveState();
            break;
        }
        Log("策略执行错误:", e);
    }
    
    Sleep(3000);  // 每3秒执行一次
}

}