[TOC]

प्रस्तावना

हाल ही में, FMZ क्वांटिटेटिव प्लेटफॉर्म को आधिकारिक तौर पर एकीकृत किया गया।Lighter DEXसच कहूँ तो, जब मैंने पहली बार यह खबर देखी तो मैंने इस पर ज्यादा ध्यान नहीं दिया—आखिरकार, बाजार में अनगिनत DEX मौजूद हैं। लेकिन इसके बारे में और जानने के बाद, एक खासियत ने मेरा ध्यान खींचा: कोई लेनदेन शुल्क नहीं।

जी हां, आपने बिल्कुल सही पढ़ा। लाइटर डेक्स नियमित ट्रेडर्स के लिए शून्य कमीशन शुल्क प्रदान करता है। इससे मुझे तुरंत एक बात याद आई: क्या मैं आखिरकार उन रणनीतियों को फिर से अपना सकता हूं जिन्हें मैंने कमीशन लागत के कारण वर्षों पहले “छोड़” दिया था? इसलिए, मैंने FMZ खोला…रणनीति स्क्वायरउन “प्राचीन काल” की रणनीतियों की खोज…

1. Lighter

मैं इस नए जोड़े गए DEX के बारे में ज़्यादा विस्तार से नहीं बताऊंगा; इच्छुक लोग अधिक जानकारी के लिए खोज कर सकते हैं। फिलहाल, उपयोगकर्ता अनुभव काफी अच्छा है। उपयोगकर्ता अनुभव के लिहाज़ से, Lighter केंद्रीकृत एक्सचेंजों के समान प्रदर्शन प्रदान करता है, साथ ही विकेंद्रीकृत पारदर्शिता भी बनाए रखता है, और उच्च आवृत्ति वाले API एक्सेस के बावजूद भी यह अपेक्षाकृत स्थिर रहता है।

डेटा सारांश

यहां कुछ जानकारियों का संकलन दिया गया है:

• एप्लिकेशन यूआरएल: https://app.lighter.xyz/
• आधिकारिक दस्तावेज़ का पता: https://apidocs.lighter.xyz
• मेननेट एपीआई एंडपॉइंट: https://mainnet.zklighter.elliot.ai
• टेस्टनेट एपीआई एंडपॉइंट: https://testnet.zklighter.eliot.ai
• अनुबंध का प्रकार: मुख्य रूप से USDC अनुबंध, जिसमें मार्जिन USDC में होता है।

विन्यास

आगे, मैं संक्षेप में FMZ को कॉन्फ़िगर करने का तरीका बताऊंगा।LighterFMZ प्लेटफॉर्म के एक्सचेंज पेज पर लाइटर API KEY कॉन्फ़िगरेशन जानकारी जोड़ें।

तीन चीजों को कॉन्फ़िगर करने की आवश्यकता है:

• हस्ताक्षर एपीआई निजी कुंजी यह वॉलेट की निजी कुंजी नहीं है। यह हस्ताक्षर करने वाली निजी कुंजी ऑर्डर और लेनदेन करने के लिए उपयोग की जाती है, जो लाइटर में लॉग इन करने और https://app.lighter.xyz पर अपने वॉलेट को कनेक्ट करने के बाद बनाई जाती है।

• यदि आप लाइटर टेस्ट एनवायरनमेंट में लॉग इन कर रहे हैं, तो बनाई गई कुंजी टेस्ट एनवायरनमेंट कुंजी होगी, जिसका विवरण यहां नहीं दिया जाएगा।
• हस्ताक्षर करने वाली निजी कुंजी बनाते समय, आपको एक इंडेक्स निर्दिष्ट करना होगा। 0 से 2 तक आरक्षित बिट्स हैं, और आप 3 से आगे निर्दिष्ट कर सकते हैं।
• लॉगिन और वॉलेट बनाने के इन सभी चरणों में वॉलेट साइनिंग की आवश्यकता होती है, और मैंने बाइनेंस वॉलेट का उपयोग किया और मेरा अनुभव अच्छा रहा।

निर्मितहस्ताक्षर निजी कुंजीयह कॉन्फ़िगरेशन FMZ ऐड एक्सचेंज पेज पर संबंधित कंट्रोल एडिट बॉक्स में किया जा सकता है।

• महत्वपूर्ण नोट: लाइटर फ्यूचर्स कॉन्ट्रैक्ट एक्सचेंज को सपोर्ट करने के लिए आपको कस्टोडियन प्रोग्राम का नवीनतम संस्करण डाउनलोड करना होगा।

• एपीआई सूचकांक हस्ताक्षर करने वाली निजी कुंजी से संबंधित इंडेक्स दर्ज करें।

• खाता सूचकांक लाइटर के एपीआई के माध्यम से खाता सूचकांक प्राप्त किए जा सकते हैं:

  • एपीआई इंटरफ़ेस:https://mainnet.zklighter.elliot.ai/api/v1/account?by=l1_address&value={钱包地址} उदाहरण के लिए, ब्राउज़र में सीधे पते पर जाएं:https://mainnet.zklighter.elliot.ai/api/v1/account?by=l1_address&value=0x123xxxx，0x123xxxxयह केवल एक उदाहरण पता है; व्यवहार में इसका उपयोग करते समय इस सामग्री को बदलें। लौटाया गया डेटा:

  {
    "code": 200,
    "total": 1,
    "accounts": [
      {
        "code": 0,
        "account_type": 0,
        "index": 1234567,
        "l1_address": "0x123xxxx",
  

  में"index": 1234567यह आपका खाता सूचकांक है।

  • प्रारंभिक निर्माण प्रक्रिया तभी शुरू होगी जब परिसंपत्तियां (जैसे कि यूएसडीसी) स्थानांतरित की जाएंगी।Lighterखाता

  • ध्यान दें कि मेननेट एंडपॉइंट का उपयोग करके प्राप्त इंटरफ़ेस मेननेट खाता इंडेक्स को पुनः प्राप्त करता है, जबकि टेस्टनेट एंडपॉइंट का उपयोग करके प्राप्त इंटरफ़ेस टेस्टनेट खाता इंडेक्स को पुनः प्राप्त करता है।

हमें इस खाता सूची को भरने की आवश्यकता क्यों है? क्योंकिLighterयहां एक उप-खाता प्रणाली है जो खाता सूचकांक के आधार पर विभिन्न खातों को अलग करती है। यदि आपको उप-खाते का उपयोग करना है, तो आप यहां उप-खाते का खाता सूचकांक कॉन्फ़िगर कर सकते हैं (उप-खाते का खाता सूचकांक ऊपर दिए गए क्वेरी लिंक द्वारा लौटाए गए JSON डेटा में दिखाई देगा)।

2. FMZ पर प्राचीन रणनीतियाँ

शून्य शुल्क: एक क्रांतिकारी बदलाव

यही वो खासियत है जो मुझे सबसे ज्यादा उत्साहित करती है। लाइटर नियमित व्यापारियों के लिए शून्य शुल्क नीति प्रदान करता है।

• शून्य लेनदेन शुल्क का क्या अर्थ है?

अब हाई-फ्रीक्वेंसी ट्रेडिंग रणनीतियों के मुनाफे लेनदेन शुल्क के कारण खत्म नहीं हो रहे हैं। मेश रणनीति सघन मेश स्पेसिंग निर्धारित करने की अनुमति देती है। आर्बिट्रेज रणनीतियों के लिए ब्रेक-ईवन पॉइंट में काफी कमी आई है। वे रणनीतियाँ जो “सैद्धांतिक रूप से संभव थीं लेकिन व्यवहार में लेनदेन शुल्क के कारण विफल हो गईं” अंततः उपयोग में आने के लिए एक जगह पा गईं।

एक प्राचीन रणनीति का अनावरण: शून्य लेनदेन शुल्क का आकर्षण

रणनीति पुस्तकालय पुरातत्व

“बिना किसी लेनदेन शुल्क के किन रणनीतियों को पुनर्जीवित किया जा सकता है?” इस सवाल को ध्यान में रखते हुए, मैंने FMZ रणनीति लाइब्रेरी और समुदाय में खोजबीन शुरू की। जल्द ही, एक जानी-पहचानी रणनीति ने मेरा ध्यान खींचा:

https://www.fmz.com/digest-topic/1211

यह रणनीति सरल और सीधी है, लेकिन लेन-देन शुल्क वाले वातावरण में, इससे लगभग हमेशा नुकसान ही होता है। हालांकि, लाइटर के शून्य-लेन-देन शुल्क वाले वातावरण में, इसे आज़माना फायदेमंद हो सकता है।

तो सवाल यह है:

तो समस्या यह है: कोड बहुत पुराना है। रणनीति को देखें तो, कोड सरल और सीधे-सादे तरीके से बनाया गया है, जिसमें लगभग कोई यूआई सामग्री नहीं है और कुछ एक्सेसिबिलिटी सुविधाओं का अभाव है। यहां कुछ उदाहरण दिए गए हैं कि क्या-क्या गायब है:

• कुछ एपीआई इंटरफेस अप्रचलित हो चुके हैं।
• इसमें आधुनिक जोखिम नियंत्रण मॉड्यूल का अभाव है।
• जानकारी अधूरी है।
• राजस्व संबंधी आंकड़े अनुपलब्ध हैं।

इस कोड को मैन्युअल रूप से रिफैक्टर करना? सच कहूँ तो, यह थोड़ा मुश्किल है। हालाँकि, मैंने एक आसान सा उपाय खोज लिया है—एआई को मेरे लिए रिफैक्टरिंग करने दें।

3. पुनर्गठन रणनीति

सबसे पहले, एक सुरक्षा उपाय स्थापित कर लेते हैं: यह लेख उभरते हुए DEX एक्सचेंज पर AI का उपयोग करके एक रणनीति को पुनर्निर्मित करने का मात्र एक प्रारंभिक प्रयास है, और हम पुनर्निर्मित रणनीति की लाभप्रदता की गारंटी नहीं देते हैं। तो चलिए, क्लाउड का उपयोग करके इस प्राचीन रणनीति को पुनर्निर्मित करना शुरू करते हैं। मैं शुरू से कोड नहीं लिखना चाहता; मेरी आवश्यकताएँ इस प्रकार हैं:

• मूल रणनीति के मूल तर्क को बरकरार रखें।
• FMZ के नवीनतम API विनिर्देशों के अनुरूप अनुकूलित
• आवश्यक जोखिम नियंत्रण और लॉगिंग मॉड्यूल जोड़ें
• यहां अपेक्षाकृत पूर्ण और स्पष्ट जानकारी प्रदर्शित की गई है।
• कोड लॉजिक को उचित रूप से अनुकूलित करें

मूल कोड एआई को दें

मैंने मूल रणनीति कोड की प्रतिलिपि बनाई और अपनी आवश्यकताओं के साथ एआई को भेज दी। कई दौर के संवाद और समायोजन के बाद, एआई ने मेरे लिए संशोधित कोड तैयार कर दिया:

bash: while :; do cat PROMPT.md | claude-code ; done

） (सीखने योग्य विचार)

/*
高频做市策略 - FMZ期货版（带仓位矫正）
策略参数:
- sleeptime: 休眠时间(毫秒) - 默认3500
- floatamountbuy: 买单深度阈值 - 默认20
- floatamountsell: 卖单深度阈值 - 默认20
- diffprice: 最小套利差价 - 默认50
- baseAmount: 基础下单量 - 默认0.1
- maxPosition: 最大单边持仓量 - 默认10
- stopLossRatio: 止损比例 - 默认0.9 (90%)
- closeOnExit: 退出时清仓 - 默认false
*/

// 全局变量
var pricePrecision = 2;
var amountPrecision = 3;
var tickSize = 0.01;
var minQty = 0.001;
var symbol = "ETH_USDT.swap";

// 统计信息
var stats = {
    startTime: 0,
    cycleCount: 0,
    orderCount: 0,
    cancelCount: 0,
    initialEquity: 0,
    currentEquity: 0,
    maxEquity: 0,
    maxDrawdown: 0,
    isStopLoss: false,
    lastLogCleanTime: 0,
    lastEmergencyTime: 0
};

// 日志清理配置
var LOG_CLEAN_INTERVAL = 60 * 60 * 1000;
var LOG_RESERVE_COUNT = 10000;
var EMERGENCY_COOLDOWN = 5000;

// ==================== 精度工具函数 ====================

/**
 * 从数值推断精度（小数位数）
 * 例如: 0.005 -> 3, 0.0001 -> 4, 0.1 -> 1, 1 -> 0
 */
function GetPrecisionFromValue(value) {
    if (!value || value >= 1) return 0;
    
    var str = value.toString();
    
    // 处理科学计数法 (如 1e-4)
    if (str.indexOf('e') !== -1) {
        var match = str.match(/e-(\d+)/);
        return match ? parseInt(match[1]) : 0;
    }
    
    // 处理普通小数
    if (str.indexOf('.') === -1) return 0;
    
    return str.split('.')[1].length;
}

/**
 * 规范化下单量
 * 1. 按精度取整
 * 2. 确保是 minQty 的整数倍
 * 3. 不小于 minQty
 */
function NormalizeAmount(amount) {
    if (amount <= 0) return 0;
    
    // 按精度取整
    var normalized = _N(amount, amountPrecision);
    
    // 确保是 minQty 的整数倍
    if (minQty > 0) {
        normalized = Math.floor(normalized / minQty) * minQty;
        normalized = _N(normalized, amountPrecision);
    }
    
    // 检查最小下单量
    if (normalized < minQty) {
        return 0;
    }
    
    return normalized;
}

/**
 * 规范化价格
 */
function NormalizePrice(price) {
    if (tickSize > 0) {
        price = Math.round(price / tickSize) * tickSize;
    }
    return _N(price, pricePrecision);
}

// 取消全部订单
function CancelPendingOrders() {
    var orders = _C(exchange.GetOrders, symbol);
    var count = 0;
    for (var j = 0; j < orders.length; j++) {
        exchange.CancelOrder(orders[j].Id, orders[j]);
        count++;
    }
    if (count > 0) {
        stats.cancelCount += count;
    }
    return count;
}

// 计算将要下单的价格
function GetPrice(Type, depth) {
    var amountBids = 0;
    var amountAsks = 0;
    
    if (Type == "Buy") {
        for (var i = 0; i < 20 && i < depth.Bids.length; i++) {
            amountBids += depth.Bids[i].Amount;
            if (amountBids > floatamountbuy) {
                return NormalizePrice(depth.Bids[i].Price + tickSize);
            }
        }
    }
    
    if (Type == "Sell") {
        for (var j = 0; j < 20 && j < depth.Asks.length; j++) {
            amountAsks += depth.Asks[j].Amount;
            if (amountAsks > floatamountsell) {
                return NormalizePrice(depth.Asks[j].Price - tickSize);
            }
        }
    }
    
    return NormalizePrice(depth.Asks[0].Price);
}

// 获取持仓信息
function GetPosition() {
    var positions = _C(exchange.GetPositions, symbol);
    var pos = {
        long: { amount: 0, price: 0, profit: 0 },
        short: { amount: 0, price: 0, profit: 0 }
    };
    
    for (var i = 0; i < positions.length; i++) {
        var p = positions[i];
        if (p.Type === PD_LONG || p.Type === 0) {
            pos.long.amount = p.Amount;
            pos.long.price = p.Price;
            pos.long.profit = p.Profit || 0;
        } else {
            pos.short.amount = p.Amount;
            pos.short.price = p.Price;
            pos.short.profit = p.Profit || 0;
        }
    }
    return pos;
}

// 计算账户权益
function GetEquity(account, pos) {
    var equity = account.Balance + account.FrozenBalance + pos.long.profit + pos.short.profit;
    return equity;
}

// 检查资金是否足够下单
function CheckFunds(account, price, amount, leverage) {
    leverage = leverage || 10;
    var requiredMargin = (price * amount) / leverage;
    var availableBalance = account.Balance;
    var safeBalance = availableBalance * 0.9;
    return safeBalance >= requiredMargin;
}

// ==================== 仓位矫正机制 ====================

/**
 * 计算动态开仓量（负反馈机制）
 */
function CalcOpenAmount(pos, direction) {
    var currentPos = (direction === "long") ? pos.long.amount : pos.short.amount;
    var posRatio = currentPos / maxPosition;
    
    if (currentPos >= maxPosition) {
        return 0;
    }
    
    var amount = baseAmount;
    if (posRatio > 0.8) {
        amount = baseAmount * 0.2;
    } else if (posRatio > 0.6) {
        amount = baseAmount * 0.4;
    } else if (posRatio > 0.4) {
        amount = baseAmount * 0.6;
    } else if (posRatio > 0.2) {
        amount = baseAmount * 0.8;
    }
    
    var netPos = pos.long.amount - pos.short.amount;
    if (direction === "long" && netPos > maxPosition * 0.3) {
        amount = amount * 0.5;
    } else if (direction === "short" && netPos < -maxPosition * 0.3) {
        amount = amount * 0.5;
    }
    
    return NormalizeAmount(amount);
}

/**
 * 计算动态平仓量
 */
function CalcCloseAmount(pos, direction) {
    var currentPos = (direction === "long") ? pos.long.amount : pos.short.amount;
    if (currentPos <= 0) return 0;
    
    var posRatio = currentPos / maxPosition;
    var amount = baseAmount;
    
    if (posRatio > 1.0) {
        amount = currentPos;
    } else if (posRatio > 0.8) {
        amount = baseAmount * 3.0;
    } else if (posRatio > 0.6) {
        amount = baseAmount * 2.0;
    } else if (posRatio > 0.4) {
        amount = baseAmount * 1.5;
    }
    
    amount = Math.min(amount, currentPos);
    
    return NormalizeAmount(amount);
}

/**
 * 计算平仓价格（仓位重时更激进）
 */
function CalcClosePrice(pos, depth, direction) {
    var currentPos = (direction === "long") ? pos.long.amount : pos.short.amount;
    var posRatio = currentPos / maxPosition;
    
    if (direction === "long") {
        if (posRatio > 1.0) {
            return NormalizePrice(depth.Bids[0].Price - tickSize * 3);
        } else if (posRatio > 0.8) {
            return NormalizePrice(depth.Bids[0].Price);
        } else if (posRatio > 0.5) {
            var midPrice = (depth.Bids[0].Price + depth.Asks[0].Price) / 2;
            return NormalizePrice(midPrice);
        }
        return NormalizePrice(depth.Asks[0].Price - tickSize);
    } else {
        if (posRatio > 1.0) {
            return NormalizePrice(depth.Asks[0].Price + tickSize * 3);
        } else if (posRatio > 0.8) {
            return NormalizePrice(depth.Asks[0].Price);
        } else if (posRatio > 0.5) {
            var midPrice = (depth.Bids[0].Price + depth.Asks[0].Price) / 2;
            return NormalizePrice(midPrice);
        }
        return NormalizePrice(depth.Bids[0].Price + tickSize);
    }
}

/**
 * 紧急减仓
 */
function EmergencyReduce(pos, depth) {
    var now = new Date().getTime();
    
    if (now - stats.lastEmergencyTime < EMERGENCY_COOLDOWN) {
        return false;
    }
    
    var needReduce = false;
    
    if (pos.long.amount > maxPosition * 1.2) {
        var reduceAmount = NormalizeAmount(pos.long.amount - maxPosition);
        if (reduceAmount > 0) {
            Log("⚠️ 多头严重超标 (" + pos.long.amount + "/" + maxPosition + ")，市价减仓: " + reduceAmount, "#FF0000");
            var orderId = exchange.CreateOrder(symbol, "closebuy", -1, reduceAmount);
            if (orderId) {
                stats.orderCount++;
                stats.lastEmergencyTime = now;
            }
            needReduce = true;
        }
    }
    
    if (pos.short.amount > maxPosition * 1.2) {
        var reduceAmount = NormalizeAmount(pos.short.amount - maxPosition);
        if (reduceAmount > 0) {
            Log("⚠️ 空头严重超标 (" + pos.short.amount + "/" + maxPosition + ")，市价减仓: " + reduceAmount, "#FF0000");
            var orderId = exchange.CreateOrder(symbol, "closesell", -1, reduceAmount);
            if (orderId) {
                stats.orderCount++;
                stats.lastEmergencyTime = now;
            }
            needReduce = true;
        }
    }
    
    if (needReduce) {
        Sleep(1000);
    }
    
    return needReduce;
}

function IsPositionOverload(pos) {
    return pos.long.amount > maxPosition || pos.short.amount > maxPosition;
}

// ==================== 日志清理 ====================

function CleanLogs() {
    var now = new Date().getTime();
    if (now - stats.lastLogCleanTime > LOG_CLEAN_INTERVAL) {
        LogReset(LOG_RESERVE_COUNT);
        stats.lastLogCleanTime = now;
        Log("日志已清理，保留最近 " + LOG_RESERVE_COUNT + " 条", "#0000FF");
    }
}

// ==================== 清仓相关 ====================

function CloseAllPositions(reason) {
    reason = reason || "手动触发";
    Log("========== 触发清仓 [" + reason + "] ==========", "#FF0000");
    
    CancelPendingOrders();
    Sleep(500);
    
    var pos = GetPosition();
    
    if (pos.long.amount > 0) {
        var orderId = exchange.CreateOrder(symbol, "closebuy", -1, pos.long.amount);
        if (orderId) {
            Log("市价平多: " + pos.long.amount, "#FF0000");
        }
    }
    
    if (pos.short.amount > 0) {
        var orderId = exchange.CreateOrder(symbol, "closesell", -1, pos.short.amount);
        if (orderId) {
            Log("市价平空: " + pos.short.amount, "#FF0000");
        }
    }
    
    Sleep(2000);
    
    var finalPos = GetPosition();
    if (finalPos.long.amount > 0 || finalPos.short.amount > 0) {
        Log("⚠️ 警告：仍有未平仓位！多头: " + finalPos.long.amount + ", 空头: " + finalPos.short.amount, "#FF0000");
        if (finalPos.long.amount > 0) {
            exchange.CreateOrder(symbol, "closebuy", -1, finalPos.long.amount);
        }
        if (finalPos.short.amount > 0) {
            exchange.CreateOrder(symbol, "closesell", -1, finalPos.short.amount);
        }
        Sleep(1000);
    } else {
        Log("✅ 所有仓位已清空", "#00FF00");
    }
    
    Log("========== 清仓完成 ==========", "#FF0000");
}

function CheckStopLoss(equity) {
    if (stats.isStopLoss) {
        return true;
    }
    
    var threshold = stats.initialEquity * stopLossRatio;
    
    if (equity < threshold) {
        stats.isStopLoss = true;
        var lossPercent = ((stats.initialEquity - equity) / stats.initialEquity * 100).toFixed(2);
        Log("⚠️ 触发止损! 当前权益: " + _N(equity, 4) + " USDT, 损失: " + lossPercent + "%", "#FF0000");
        return true;
    }
    
    return false;
}

function UpdateProfitChart(equity) {
    var profit = equity - stats.initialEquity;
    
    if (equity > stats.maxEquity) {
        stats.maxEquity = equity;
    }
    var drawdown = (stats.maxEquity - equity) / stats.maxEquity * 100;
    if (drawdown > stats.maxDrawdown) {
        stats.maxDrawdown = drawdown;
    }
    
    LogProfit(_N(profit, 4), "&");
}

function UpdateStatus(account, pos, depth, buyPrice, sellPrice, equity) {
    var runTime = (new Date().getTime() - stats.startTime) / 1000 / 60;
    var hours = Math.floor(runTime / 60);
    var mins = Math.floor(runTime % 60);
    
    var spread = sellPrice - buyPrice;
    var marketSpread = depth.Asks[0].Price - depth.Bids[0].Price;
    
    var profit = equity - stats.initialEquity;
    var profitPercent = (profit / stats.initialEquity * 100).toFixed(2);
    var drawdown = stats.maxEquity > 0 ? ((stats.maxEquity - equity) / stats.maxEquity * 100).toFixed(2) : 0;
    
    var longRatio = (pos.long.amount / maxPosition * 100).toFixed(1);
    var shortRatio = (pos.short.amount / maxPosition * 100).toFixed(1);
    var netPos = _N(pos.long.amount - pos.short.amount, amountPrecision);
    
    var table1 = {
        type: "table",
        title: "💰 账户信息",
        cols: ["项目", "数值"],
        rows: [
            ["可用余额", _N(account.Balance, 4) + " USDT"],
            ["冻结余额", _N(account.FrozenBalance, 4) + " USDT"],
            ["当前权益", _N(equity, 4) + " USDT"],
            ["初始权益", _N(stats.initialEquity, 4) + " USDT"],
            ["最高权益", _N(stats.maxEquity, 4) + " USDT"]
        ]
    };
    
    var table2 = {
        type: "table",
        title: "📈 收益统计",
        cols: ["项目", "数值"],
        rows: [
            ["累计收益", _N(profit, 4) + " USDT"],
            ["收益率", profitPercent + " %"],
            ["最大回撤", drawdown + " %"],
            ["止损阈值", (stopLossRatio * 100) + " %"],
            ["止损状态", stats.isStopLoss ? "⚠️ 已触发" : "✅ 正常"]
        ]
    };
    
    var longStatus, shortStatus;
    if (longRatio > 120) {
        longStatus = "🔴 紧急减仓";
    } else if (longRatio > 100) {
        longStatus = "🟠 超标";
    } else if (longRatio > 80) {
        longStatus = "🟡 控量";
    } else {
        longStatus = "🟢 正常";
    }
    
    if (shortRatio > 120) {
        shortStatus = "🔴 紧急减仓";
    } else if (shortRatio > 100) {
        shortStatus = "🟠 超标";
    } else if (shortRatio > 80) {
        shortStatus = "🟡 控量";
    } else {
        shortStatus = "🟢 正常";
    }
    
    var table3 = {
        type: "table",
        title: "📊 持仓信息（仓位矫正）",
        cols: ["方向", "数量", "上限", "使用率", "状态", "浮盈"],
        rows: [
            ["多头", pos.long.amount, maxPosition, longRatio + "%", longStatus, _N(pos.long.profit, 4)],
            ["空头", pos.short.amount, maxPosition, shortRatio + "%", shortStatus, _N(pos.short.profit, 4)],
            ["净仓", netPos, "-", "-", netPos > 0 ? "偏多" : (netPos < 0 ? "偏空" : "均衡"), "-"]
        ]
    };
    
    var table4 = {
        type: "table",
        title: "🎯 做市信息",
        cols: ["项目", "数值"],
        rows: [
            ["买一价", _N(depth.Bids[0].Price, pricePrecision)],
            ["卖一价", _N(depth.Asks[0].Price, pricePrecision)],
            ["盘口价差", _N(marketSpread, pricePrecision)],
            ["挂单买价", _N(buyPrice, pricePrecision)],
            ["挂单卖价", _N(sellPrice, pricePrecision)],
            ["做市价差", _N(spread, pricePrecision)]
        ]
    };
    
    var table5 = {
        type: "table",
        title: "⏱️ 运行统计",
        cols: ["项目", "数值"],
        rows: [
            ["运行时间", hours + "时" + mins + "分"],
            ["循环次数", stats.cycleCount],
            ["下单次数", stats.orderCount],
            ["撤单次数", stats.cancelCount],
            ["休眠时间", sleeptime + " ms"]
        ]
    };
    
    var table6 = {
        type: "table",
        title: "⚙️ 精度与参数",
        cols: ["参数", "值"],
        rows: [
            ["交易符号", symbol],
            ["价格精度", pricePrecision],
            ["数量精度", amountPrecision],
            ["最小下单量", minQty],
            ["价格步长", tickSize],
            ["基础下单量", baseAmount],
            ["最大持仓量", maxPosition],
            ["退出时清仓", closeOnExit ? "✅ 是" : "❌ 否"]
        ]
    };
    
    var statusIcon = stats.isStopLoss ? "🛑 已止损" : (IsPositionOverload(pos) ? "⚠️ 仓位超标" : "🤖 运行中");
    var statusStr = statusIcon + " | " + _D() + " | 收益: " + _N(profit, 2) + " USDT (" + profitPercent + "%)\n";
    statusStr += "多仓: " + pos.long.amount + "/" + maxPosition + " (" + longRatio + "%) | ";
    statusStr += "空仓: " + pos.short.amount + "/" + maxPosition + " (" + shortRatio + "%) | 净: " + netPos + "\n";
    statusStr += "`" + JSON.stringify([table1, table2, table3, table4, table5, table6]) + "`";
    
    LogStatus(statusStr);
}

// 主交易逻辑
function onTick() {
    stats.cycleCount++;
    
    CleanLogs();
    
    var depth = _C(exchange.GetDepth);
    if (!depth || !depth.Bids || !depth.Asks || depth.Bids.length < 20 || depth.Asks.length < 20) {
        Log("深度数据不足，跳过本轮");
        Sleep(1000);
        return;
    }
    
    var account = _C(exchange.GetAccount);
    var pos = GetPosition();
    
    var equity = GetEquity(account, pos);
    stats.currentEquity = equity;
    
    if (stats.cycleCount % 10 === 0) {
        UpdateProfitChart(equity);
    }
    
    var buyPrice = GetPrice("Buy", depth);
    var sellPrice = GetPrice("Sell", depth);
    
    if ((sellPrice - buyPrice) <= diffprice) {
        // buyPrice = NormalizePrice(buyPrice - 10 * tickSize);
        // sellPrice = NormalizePrice(sellPrice + 10 * tickSize);

        buyPrice = NormalizePrice(buyPrice - diffprice/2);
        sellPrice = NormalizePrice(sellPrice + diffprice/2);
    }
    
    UpdateStatus(account, pos, depth, buyPrice, sellPrice, equity);
    
    if (CheckStopLoss(equity)) {
        if (pos.long.amount > 0 || pos.short.amount > 0) {
            CloseAllPositions("止损触发");
        } else {
            CancelPendingOrders();
        }
        Log("策略已止损，停止交易。如需继续，请手动重启策略。", "#FF0000");
        return;
    }
    
    CancelPendingOrders();
    
    EmergencyReduce(pos, depth);
    
    pos = GetPosition();
    
    var openLongAmount = CalcOpenAmount(pos, "long");
    var openShortAmount = CalcOpenAmount(pos, "short");
    var closeLongAmount = CalcCloseAmount(pos, "long");
    var closeShortAmount = CalcCloseAmount(pos, "short");
    
    var closeLongPrice = CalcClosePrice(pos, depth, "long");
    var closeShortPrice = CalcClosePrice(pos, depth, "short");
    
    if (openLongAmount > 0 && CheckFunds(account, buyPrice, openLongAmount)) {
        var orderId = exchange.CreateOrder(symbol, "buy", buyPrice, openLongAmount);
        if (orderId) stats.orderCount++;
    }
    
    if (pos.short.amount > 0 && closeShortAmount > 0) {
        var orderId = exchange.CreateOrder(symbol, "closesell", closeShortPrice, closeShortAmount);
        if (orderId) stats.orderCount++;
    }
    
    if (openShortAmount > 0 && CheckFunds(account, sellPrice, openShortAmount)) {
        var orderId = exchange.CreateOrder(symbol, "sell", sellPrice, openShortAmount);
        if (orderId) stats.orderCount++;
    }
    
    if (pos.long.amount > 0 && closeLongAmount > 0) {
        var orderId = exchange.CreateOrder(symbol, "closebuy", closeLongPrice, closeLongAmount);
        if (orderId) stats.orderCount++;
    }
}

// 初始化交易精度
function InitPrecision() {
    try {
        var markets = exchange.GetMarkets();
        if (markets && markets[symbol]) {
            var market = markets[symbol];
            
            // 获取基础精度信息
            pricePrecision = market.PricePrecision || 2;
            tickSize = market.TickSize || 0.01;
            minQty = market.MinQty || 0.001;
            
            // 从 MinQty 推断数量精度
            // 例如: MinQty=0.005 -> 精度3, MinQty=0.0001 -> 精度4
            var minQtyPrecision = GetPrecisionFromValue(minQty);
            
            // 从 TickSize 推断价格精度（作为备选验证）
            var tickSizePrecision = GetPrecisionFromValue(tickSize);
            
            // 数量精度取 AmountPrecision 和 MinQty推断精度 的较小值
            var declaredAmountPrecision = market.AmountPrecision || 8;
            amountPrecision = Math.min(declaredAmountPrecision, minQtyPrecision);
            
            // 价格精度取 PricePrecision 和 TickSize推断精度 的较小值
            pricePrecision = Math.min(pricePrecision, tickSizePrecision);
            
            Log("========== 精度信息 ==========");
            Log("市场返回 - PricePrecision:", market.PricePrecision, ", AmountPrecision:", market.AmountPrecision);
            Log("市场返回 - TickSize:", tickSize, ", MinQty:", minQty);
            Log("推断精度 - TickSize精度:", tickSizePrecision, ", MinQty精度:", minQtyPrecision);
            Log("最终使用 - 价格精度:", pricePrecision, ", 数量精度:", amountPrecision);
            Log("==============================");
            
            // 检查 baseAmount 是否满足最小下单量
            if (baseAmount < minQty) {
                Log("⚠️ 警告: baseAmount(" + baseAmount + ") 小于最小下单量(" + minQty + ")，已自动调整", "#FF9900");
                baseAmount = minQty;
            }
            
            // 规范化 baseAmount
            baseAmount = NormalizeAmount(baseAmount);
            if (baseAmount === 0) {
                baseAmount = minQty;
            }
            Log("规范化后 baseAmount:", baseAmount);
        }
    } catch (e) {
        Log("获取精度失败，使用默认值: " + e.message, "#FF9900");
    }
}

// 初始化收益图表
function InitChart() {
    var chart = {
        __isStock: true,
        tooltip: { xDateFormat: '%Y-%m-%d %H:%M:%S, %A' },
        title: { text: '高频做市策略收益曲线' },
        xAxis: { type: 'datetime' },
        yAxis: {
            title: { text: '收益 (USDT)' },
            opposite: false
        },
        series: [{
            name: '收益',
            data: []
        }]
    };
    Chart(chart);
}

// 程序入口
function main() {
    LogReset(LOG_RESERVE_COUNT);
    LogProfitReset();
    
    InitChart();
    
    exchange.SetContractType("swap");
    
    symbol = exchange.GetCurrency() + ".swap";
    Log("交易符号:", symbol);
    
    // 测试是否支持Lighter
    if (!exchange.GetAccount()) {
        Log("账户初始化失败，请检查配置是否正确，托管者是否为最新版本！")
    }

    InitPrecision();
    
    stats.startTime = new Date().getTime();
    stats.lastLogCleanTime = stats.startTime;
    
    var initAccount = _C(exchange.GetAccount);
    var initPos = GetPosition();
    stats.initialEquity = GetEquity(initAccount, initPos);
    stats.maxEquity = stats.initialEquity;
    stats.currentEquity = stats.initialEquity;
    
    Log("========== 策略启动 ==========", "#00FF00");
    Log("初始权益:", _N(stats.initialEquity, 4), "USDT");
    Log("止损阈值:", _N(stats.initialEquity * stopLossRatio, 4), "USDT", "(" + (stopLossRatio * 100) + "%)");
    Log("最大持仓:", maxPosition);
    Log("退出时清仓:", closeOnExit ? "是" : "否");
    Log("初始账户:", initAccount);
    Log("初始持仓:", _C(exchange.GetPositions, symbol));
    
    while (true) {
        try {
            onTick();
        } catch (e) {
            Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message, "#FF0000");
        }
        Sleep(sleeptime);
    }
}

// 退出清理
function onexit() {
    Log("========== 策略停止 ==========", "#FF0000");
    
    if (closeOnExit) {
        Log("closeOnExit=true，执行退出清仓...", "#FF9900");
        CloseAllPositions("策略退出");
    } else {
        Log("closeOnExit=false，保留当前持仓和挂单", "#0000FF");
    }
    
    Log("----------------------------------------");
    Log("总循环: " + stats.cycleCount + ", 下单: " + stats.orderCount + ", 撤单: " + stats.cancelCount);
    Log("初始权益: " + _N(stats.initialEquity, 4) + " USDT");
    Log("最终权益: " + _N(stats.currentEquity, 4) + " USDT");
    Log("总收益: " + _N(stats.currentEquity - stats.initialEquity, 4) + " USDT");
    Log("收益率: " + _N((stats.currentEquity - stats.initialEquity) / stats.initialEquity * 100, 2) + " %");
    Log("最大回撤: " + _N(stats.maxDrawdown, 2) + " %");
    Log("----------------------------------------");
}

आप FMZ पर पैरामीटर के संपादन नियम AI को बताते हैं, और AI आपके लिए इंटरफ़ेस पैरामीटर को सीधे कॉन्फ़िगर भी कर सकता है। स्पष्टीकरण के लिए, मैंने रणनीति इंटरफ़ेस पर पैरामीटर को मैन्युअल रूप से कॉन्फ़िगर किया है, जैसा कि ऊपर चित्र में दिखाया गया है।

4. लाइव ट्रेडिंग

सच कहूँ तो, AI द्वारा लिखा गया कोड मेरे कोड से कहीं बेहतर है, और यह शायद ही कभी गलतियाँ करता है (जब तक आवश्यकताएँ स्पष्ट रूप से बताई गई हों, मुझे इसे स्थिर रूप से चलाने के लिए केवल 3-4 बार ही दोहराना पड़ता है)। मुझे ऐसा लग रहा है जैसे मेरी उत्पादकता में ज़बरदस्त उछाल आया है 💥 हालाँकि अभी ऐसा लग रहा है कि यह रणनीति मुनाफा नहीं कमा रही है 😂, लेकिन ट्रेडिंग वॉल्यूम में काफी वृद्धि हुई है।

5. सारांश

FMZ + AI + लाइटर की रासायनिक अभिक्रिया

इस अनुभव पर पीछे मुड़कर देखने पर मेरे मन में कुछ विचार आते हैं:

• शून्य शुल्क वास्तव में एक क्रांतिकारी बदलाव है। कई रणनीतियाँ जो पहले सैद्धांतिक रूप से कारगर थीं, लेन-देन शुल्क, यानी “अदृश्य हत्यारा”, के कारण विफल हो गईं। लाइटर की शून्य-शुल्क नीति ने इन रणनीतियों को पुनर्जीवित होने का मौका दिया है। यदि आपके पास भी ऐसी ही “निष्क्रिय रणनीतियाँ” हैं, तो आप उन्हें फिर से सक्रिय करके देख सकते हैं।

• कृत्रिम बुद्धिमत्ता ने रणनीति विकास की बाधाओं को काफी हद तक कम कर दिया है। इस बार मैंने हाथ से बहुत कम कोड लिखा; पूरी रणनीति का पुनर्गठन एआई की मदद से किया गया। यह पहले अकल्पनीय था। जिनके पास ट्रेडिंग के विचार तो हैं लेकिन प्रोग्रामिंग कौशल सीमित हैं, उनके लिए एआई और एफएमजेड का संयोजन निस्संदेह वरदान है।

• FMZ का नए एक्सचेंजों के साथ तेजी से एकीकरण का महत्व FMZ, Lighter जैसे उभरते एक्सचेंजों के साथ तेजी से एकीकृत हो सकता है, जिससे उपयोगकर्ता तुरंत अवसरों का लाभ उठा सकते हैं। एकीकृत API का मतलब यह भी है कि आपकी रणनीतियों को आसानी से नए प्लेटफॉर्म पर स्थानांतरित किया जा सकता है।

अगले कदम

इसके बाद, मेरी योजना है:

• इस रणनीति के मापदंडों को लगातार अनुकूलित करते रहें।
• शून्य शुल्क वाले वातावरण के लिए उपयुक्त अधिक प्रकार की रणनीतियों को आजमाएं।
• लाइटर के लिए लागू होने वाली प्रासंगिक रणनीतियों का अन्वेषण करें।

अन्य प्राचीन रणनीतियों में शामिल हैं: ओके लीक हार्वेस्टर, आदि।

आपके समर्थन के लिए धन्यवाद।

पढ़ने के लिए धन्यवाद। कृपया अपने सुझाव या अनुरोध बेझिझक दें।

6. अस्वीकरण

यह लेख केवल तकनीकी आदान-प्रदान और सीखने के उद्देश्य से है और इसे किसी भी प्रकार की निवेश सलाह नहीं माना जाना चाहिए।

• रणनीति संबंधी जोखिम: इस लेख में दर्शाई गई रणनीति केवल तकनीकी प्रदर्शन के लिए है और लाभप्रदता की गारंटी नहीं देती है। मात्रात्मक व्यापार में स्वाभाविक रूप से जोखिम शामिल होते हैं, और ऐतिहासिक बैकटेस्टिंग या अल्पकालिक लाइव ट्रेडिंग प्रदर्शन भविष्य के प्रतिफल का सूचक नहीं है। कृपया रणनीति के तर्क को पूरी तरह से समझने के बाद ही इसका सावधानीपूर्वक उपयोग करें।
• DEX से जुड़े जोखिम: विकेंद्रीकृत एक्सचेंजों (DEX) में स्मार्ट कॉन्ट्रैक्ट जोखिम, तरलता जोखिम और नेटवर्क जाम होने का जोखिम शामिल होता है। एक उभरते हुए प्लेटफॉर्म के रूप में, लाइटर DEX की दीर्घकालिक स्थिरता और सुरक्षा का बाजार द्वारा सत्यापन किया जाना बाकी है।
• शून्य लेनदेन शुल्क नीति: विनिमय शुल्क नीतियों में किसी भी समय बदलाव किया जा सकता है। कृपया लाइटर की नवीनतम आधिकारिक घोषणाओं को देखें। भले ही लेनदेन निःशुल्क हो, ऑन-चेन गैस शुल्क लागू हो सकते हैं।
• कृत्रिम बुद्धिमत्ता द्वारा निर्मित कोड: इस लेख में प्रयुक्त रणनीति कोड कृत्रिम बुद्धिमत्ता की सहायता से तैयार किया गया है। हालांकि इसका परीक्षण किया जा चुका है, फिर भी इसमें कुछ त्रुटियाँ या तार्किक खामियाँ हो सकती हैं। यह केवल सीखने और अनुसंधान के उद्देश्यों के लिए है।
• उपयोगकर्ता सभी जोखिमों के लिए स्वयं जिम्मेदार हैं: इस लेख में दी गई किसी भी जानकारी, कोड या रणनीति के उपयोग से उत्पन्न होने वाले किसी भी परिणाम के लिए उपयोगकर्ता पूरी तरह से जिम्मेदार हैं। लेखक और FMZ प्लेटफॉर्म किसी भी प्रत्यक्ष या अप्रत्यक्ष नुकसान के लिए उत्तरदायी नहीं हैं।

क्रिप्टोकरेंसी ट्रेडिंग में उच्च स्तर का जोखिम होता है। कृपया अपने जोखिमों को ध्यानपूर्वक प्रबंधित करें और सोच-समझकर व्यापार करें।