इस रणनीति की प्रेरणा झिहु लेखक “ड्रीम डीलर” द्वारा लिखे गए अवसर पोस्ट - “ट्रम्प और मेलानिया कम जोखिम सहसंबंध मध्यस्थता मॉडल” से आती है। यह आलेख बी.एन. पर शुरू किए गए दो अनुबंधों (ट्रम्प और मेलानिया) के बीच मूल्य सहसंबंध का पता लगाता है, तथा दोनों के बीच सूक्ष्म समय विलंब का उपयोग करके अल्पकालिक बाजार में उतार-चढ़ाव को पकड़ने और कम जोखिम वाले मध्यस्थता को प्राप्त करने का प्रयास करता है। इसके बाद, हम इस रणनीति के सिद्धांतों, कोड कार्यान्वयन तर्क की व्याख्या करेंगे और संभावित अनुकूलन दिशाओं का पता लगाएंगे।

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

1. रणनीति सिद्धांत और बाजार प्रासंगिकता

1.1 रणनीतिक पृष्ठभूमि

ट्रम्प और मेलानिया दोनों अनुबंध एक ही जारीकर्ता टीम द्वारा जारी किए जाते हैं और उनके नियंत्रण कोष भी एक ही होते हैं, इसलिए अधिकांश समय उनके मूल्य रुझान अत्यधिक समकालिक होते हैं। हालाँकि, अनुबंध डिजाइन या बाजार निष्पादन जैसे कारकों के कारण, मेलानिया की कीमत ट्रम्प की तुलना में 1-2 सेकंड पीछे रहती है। यह छोटी सी देरी मध्यस्थों को मूल्य अंतर को पकड़ने और उच्च आवृत्ति कॉपी ट्रेडिंग का संचालन करने का अवसर प्रदान करती है। सीधे शब्दों में कहें तो जब ट्रम्प की चाल में तेज़ी से उतार-चढ़ाव होता है, तो मेलानिया भी उसके तुरंत बाद उसी चाल पर चलने लगती हैं। इस देरी का फ़ायदा उठाकर, कम जोखिम के साथ लेन-देन पूरे किए जा सकते हैं।

1.2 क्रिप्टो बाज़ार में प्रचलन

क्रिप्टो बाजार में समान सहसंबंध घटनाएं असामान्य नहीं हैं:

• एक ही परियोजना के विभिन्न अनुबंध या व्युत्पन्नएक ही अंतर्निहित परिसंपत्तियों या टीम पृष्ठभूमि के कारण, विभिन्न उत्पादों की कीमतों में अक्सर मजबूत संबंध होते हैं।
• क्रॉस-एक्सचेंज आर्बिट्रेजविभिन्न एक्सचेंजों पर एक ही परिसंपत्ति में तरलता और मिलान तंत्र में अंतर के कारण मूल्य में मामूली अंतर हो सकता है।
• स्थिर सिक्के और फिएट-पेग्ड उत्पादइन उत्पादों में अक्सर विनिमय दर में विचलन की संभावना रहती है, तथा मध्यस्थ मामूली उतार-चढ़ाव से भी लाभ कमा सकते हैं।

यह सहसंबंध उच्च आवृत्ति वाले व्यापारियों और मध्यस्थों को स्थिर व्यापारिक संकेत और कम जोखिम वाले परिचालन अवसर प्रदान करता है, लेकिन इसके लिए यह भी आवश्यक है कि व्यापारिक रणनीति सूक्ष्म बाजार परिवर्तनों के प्रति अत्यधिक संवेदनशील हो और वास्तविक समय में प्रतिक्रिया करने में सक्षम हो।

2. कोड लॉजिक का विस्तृत विवरण

कोड में मुख्य रूप से कई भाग होते हैं, प्रत्येक मॉड्यूल आर्बिट्रेज रणनीति के प्रमुख चरणों से मेल खाता है।

2.1 सहायक फ़ंक्शन विवरण

स्थिति की जानकारी प्राप्त करें

function GetPosition(pair){
    let pos = exchange.GetPosition(pair)
    if(pos.length == 0){
        return {amount:0, price:0, profit:0}
    }else if(pos.length > 1){
        throw '不支持双向持仓'
    }else if(pos.length == 1){
        return {amount:pos[0].Type == 0 ? pos[0].Amount : -pos[0].Amount, price:pos[0].Price, profit:pos[0].Profit}
    }else{
        Log('未获取仓位数据')
        return null
    }
}

• कार्यइस फ़ंक्शन का उपयोग निर्दिष्ट ट्रेडिंग जोड़ी की स्थिति की जानकारी समान रूप से प्राप्त करने और लंबी और छोटी स्थिति को सकारात्मक और नकारात्मक संख्याओं में परिवर्तित करने के लिए किया जाता है।
• तर्कयदि स्थिति रिक्त है, तो डिफ़ॉल्ट शून्य स्थिति लौटाएं; यदि एक से अधिक ऑर्डर हैं, तो एक त्रुटि रिपोर्ट की जाती है (एकतरफा स्थिति सुनिश्चित करने के लिए); अन्यथा, वर्तमान स्थिति की दिशा, मूल्य और अस्थायी लाभ और हानि लौटाएं।

खाता आरंभ करें

function InitAccount(){
    let account = _C(exchange.GetAccount)
    let total_eq = account.Equity

    let init_eq = 0
    if(!_G('init_eq')){
        init_eq = total_eq
        _G('init_eq', total_eq)
    }else{
        init_eq = _G('init_eq')
    }

    return init_eq
}

• कार्यइस फ़ंक्शन का उपयोग बाद के लाभ और हानि गणनाओं के आधार के रूप में खाता इक्विटी को आरंभ करने और रिकॉर्ड करने के लिए किया जाता है।

लंबित ऑर्डर रद्द करें

function CancelPendingOrders() {
    orders = exchange.GetOrders();  // 获取订单
    for (let order of orders) {
        if (order.Status == ORDER_STATE_PENDING) {  // 只取消未完成的订单
            exchange.CancelOrder(order.Id);  // 取消挂单
        }
    }
}

• कार्यऑर्डर देने से पहले, ऑर्डर विवादों या डुप्लिकेट ऑर्डर को रोकने के लिए पहले से अधूरे ऑर्डर को रद्द करना सुनिश्चित करें।

2.2 मुख्य लेनदेन तर्क

मुख्य फ़ंक्शन निम्नलिखित चरणों को लगातार निष्पादित करने के लिए अनंत लूप का उपयोग करता है:

1. डेटा अधिग्रहण और बाजार गणना
   प्रत्येक चक्र की शुरुआत होती हैexchange.GetRecords क्रमशः Pair_A और Pair_B का बाजार डेटा प्राप्त करें।

   • गणना सूत्र: [ ratio = \frac{Close{A} - Open{A}}{Open{A}} - \frac{Close{B} - Open{B}}{Open{B}} ] दोनों के उतार-चढ़ाव की तुलना करके हम यह निर्धारित कर सकते हैं कि क्या कोई असामान्य मूल्य अंतर है। जब मूल्य अंतर पूर्व निर्धारित diffLevel से अधिक हो जाता है, तो उद्घाटन स्थिति सक्रिय हो जाती है।

2. आरंभिक शर्तें निर्धारित करें और ऑर्डर दें
   जब कोई वर्तमान स्थिति नहीं है (position_B.amount == 0) और व्यापार की अनुमति है (afterTrade==1):

   • यदि अनुपात diffLevel से अधिक है, तो यह माना जाता है कि बाजार बढ़ने वाला है, इसलिए Pair_B (लंबी स्थिति खरीदें) के लिए खरीद आदेश जारी किया जाता है।
   • यदि अनुपात -diffLevel से कम है, तो यह माना जाता है कि बाजार गिरने वाला है और विक्रय आदेश जारी किया जाता है (एक छोटी स्थिति खोली जाती है)। ऑर्डर देने से पहले, ऑर्डर रद्दीकरण फ़ंक्शन को कॉल किया जाएगा ताकि यह सुनिश्चित किया जा सके कि वर्तमान ऑर्डर स्थिति साफ़ हो गई है।

3. स्टॉप-प्रॉफिट और स्टॉप-लॉस तर्क
   एक बार स्थिति स्थापित हो जाने पर, रणनीति स्थिति की दिशा के अनुसार संबंधित लाभ-लेने और हानि-रोकने के आदेश निर्धारित करेगी:

   • लंबी स्थिति (खरीदें): लाभ लेने की कीमत को स्थिति कीमत में (1 + stopProfitLevel) से गुणा करके निर्धारित करें, तथा हानि रोकने की कीमत को स्थिति कीमत में (1 - stopLossLevel) से गुणा करके निर्धारित करें।
   • लघु स्थिति (बेचना)लाभ लेने का मूल्य स्थिति मूल्य को (1 - स्टॉपप्रॉफिटलेवल) से गुणा करके निर्धारित किया जाता है, और स्टॉप लॉस मूल्य स्थिति मूल्य को (1 + स्टॉपलॉसलेवल) से गुणा करके निर्धारित किया जाता है। सिस्टम वास्तविक समय के बाजार मूल्य की निगरानी करेगा। एक बार जब लाभ-हानि या स्टॉप-लॉस की स्थिति शुरू हो जाती है, तो मूल लंबित ऑर्डर रद्द कर दिया जाएगा और स्थिति को बंद करने के लिए एक ऑर्डर दिया जाएगा।

4. किसी स्थिति को बंद करने के बाद लाभ के आँकड़े और लॉग रिकॉर्ड
   प्रत्येक स्थिति के बंद होने के बाद, सिस्टम खाता इक्विटी में परिवर्तन प्राप्त करेगा और लाभ की संख्या, हानि की संख्या और संचयी लाभ/हानि राशि की गणना करेगा।
   साथ ही, वर्तमान स्थिति की जानकारी, लेनदेन के आंकड़े और चक्र विलंब को वास्तविक समय में प्रदर्शित करने के लिए तालिकाओं और ग्राफ का उपयोग किया जाता है, जो बाद के रणनीति प्रभाव विश्लेषण के लिए सुविधाजनक है।

3. रणनीति अनुकूलन और विस्तार के तरीके

यद्यपि यह रणनीति दो अत्यधिक सहसंबद्ध अनुबंधों के बीच सूक्ष्म विलंब का फायदा उठाती है, फिर भी ऐसे कई क्षेत्र हैं जिनमें सुधार किया जा सकता है:

3.1 पैरामीटर अनुकूलन और गतिशील समायोजन

• सीमा समायोजनdiffLevel, stopProfitLevel और stopLossLevel जैसे मापदंडों को विभिन्न बाजार परिवेशों में समायोजित करने की आवश्यकता हो सकती है। इन मापदंडों को ऐतिहासिक डेटा के बैकटेस्टिंग के माध्यम से या वास्तविक समय में मॉडल को गतिशील रूप से समायोजित करके (उदाहरण के लिए, मशीन लर्निंग एल्गोरिदम) स्वचालित रूप से अनुकूलित किया जा सकता है।
• स्थिति प्रबंधनवर्तमान रणनीति एक स्थिति खोलने के लिए एक निश्चित Trade_Number का उपयोग करती है। भविष्य में, हम एक गतिशील स्थिति प्रबंधन या बैचों में पदों को खोलने और एकल लेनदेन के जोखिम को कम करने के लिए धीरे-धीरे लाभ लेने के तंत्र को शुरू करने पर विचार कर सकते हैं।

3.2 ट्रेडिंग सिग्नल फ़िल्टरिंग

• बहुघटकीय संकेतकेवल मूल्य वृद्धि और कमी के आधार पर अनुपात की गणना शोर से प्रभावित हो सकती है। आप गलत संकेतों को और अधिक फ़िल्टर करने के लिए ट्रेडिंग वॉल्यूम, ऑर्डर बुक की गहराई और तकनीकी संकेतक (जैसे RSI, MACD, आदि) को शामिल करने पर विचार कर सकते हैं।
• विलंब मुआवजायह देखते हुए कि मेलानिया में 1-2 सेकंड की देरी होती है, अधिक सटीक समय तुल्यकालन और संकेत भविष्यवाणी तंत्र विकसित करने से प्रवेश समय की सटीकता में सुधार करने में मदद मिलेगी।

3.3 प्रणाली की मजबूती और जोखिम नियंत्रण

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

3.4 कोड और आर्किटेक्चर अनुकूलन

• अतुल्यकालिक प्रसंस्करण: वर्तमान में, रणनीति लूप को हर 100 मिलीसेकंड में निष्पादित किया जाता है। एसिंक्रोनस प्रोसेसिंग और मल्टी-थ्रेडेड ऑप्टिमाइज़ेशन के माध्यम से, देरी और निष्पादन अवरोधन जोखिम को कम किया जा सकता है।
• रणनीति बैकटेस्टिंग और सिमुलेशनविभिन्न बाजार स्थितियों के तहत रणनीतियों के प्रदर्शन को सत्यापित करने और रणनीतियों को वास्तविक व्यापार में अधिक स्थिरता से चलाने में मदद करने के लिए एक पूर्ण बैकटेस्टिंग सिस्टम और वास्तविक समय सिम्युलेटेड ट्रेडिंग वातावरण का परिचय दें।

IV. निष्कर्ष

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

यद्यपि यह रणनीति विशिष्ट रूप से प्रेरित और कार्यान्वयन में सरल है, फिर भी उच्च आवृत्ति और अस्थिर क्रिप्टो बाजार में किसी भी मध्यस्थता संचालन को सावधानी के साथ किया जाना चाहिए। मुझे आशा है कि यह लेख उन मित्रों के लिए बहुमूल्य संदर्भ और प्रेरणा प्रदान करेगा जो मात्रात्मक व्यापार और मध्यस्थता रणनीतियों में रुचि रखते हैं।

नोट: रणनीति परीक्षण वातावरण OKX सिमुलेशन ट्रेडिंग है, और विशिष्ट विवरण को विभिन्न एक्सचेंजों के लिए संशोधित किया जा सकता है

function GetPosition(pair){
    let pos = exchange.GetPosition(pair)
    if(pos.length == 0){
        return {amount:0, price:0, profit:0}
    }else if(pos.length > 1){
        throw '不支持双向持仓'
    }else if(pos.length == 1){
        return {amount:pos[0].Type == 0 ? pos[0].Amount : -pos[0].Amount, price:pos[0].Price, profit:pos[0].Profit}
    }else{
        Log('未获取仓位数据')
        return null
    }
}

function InitAccount(){
    let account = _C(exchange.GetAccount)
    let total_eq = account.Equity

    let init_eq = 0
    if(!_G('init_eq')){
        init_eq = total_eq
        _G('init_eq', total_eq)
    }else{
        init_eq = _G('init_eq')
    }

    return init_eq
}

function CancelPendingOrders() {
    orders = exchange.GetOrders();  // 获取订单
    for (let order of orders) {
        if (order.Status == ORDER_STATE_PENDING) {  // 只取消未完成的订单
            exchange.CancelOrder(order.Id);  // 取消挂单
        }
    }
}

var pair_a = Pair_A + "_USDT.swap";
var pair_b = Pair_B + "_USDT.swap";


function main() {
    exchange.IO('simulate', true);
    LogReset(0);
    Log('策略开始运行')

    var precision = exchange.GetMarkets();
    var ratio = 0

    var takeProfitOrderId = null;
    var stopLossOrderId = null;
    var successCount = 0;
    var lossCount = 0;
    var winMoney = 0;
    var failMoney = 0;
    var afterTrade = 1;

    var initEq = InitAccount();

    var curEq = initEq

    var pricePrecision = precision[pair_b].PricePrecision;

    while (true) {
        try{
            let startLoopTime = Date.now();
            let position_B = GetPosition(pair_b);
            let new_r_pairB = exchange.GetRecords(pair_b, 1).slice(-1)[0];

            if (!new_r_pairB || !position_B) {
                Log('跳过当前循环');
                continue;
            }
            
            // 合并交易条件：检查是否可以开仓并进行交易
            if (afterTrade == 1 && position_B.amount == 0) {
                
                let new_r_pairA = exchange.GetRecords(pair_a, 1).slice(-1)[0];
                if (!new_r_pairA ) {
                    Log('跳过当前循环');
                    continue;
                }
                
                ratio = (new_r_pairA.Close - new_r_pairA.Open) / new_r_pairA.Open - (new_r_pairB.Close - new_r_pairB.Open) / new_r_pairB.Open;

                if (ratio > diffLevel) {
                    CancelPendingOrders();
                    Log('实时ratio：', ratio, '买入：', pair_b, position_B.amount);
                    exchange.CreateOrder(pair_b, "buy", -1, Trade_Number);
                    afterTrade = 0;
                } else if (ratio < -diffLevel) {
                    CancelPendingOrders();
                    Log('实时ratio：', ratio, '卖出：', pair_b, position_B.amount);
                    exchange.CreateOrder(pair_b, "sell", -1, Trade_Number);
                    afterTrade = 0;
                }            
            }

            

            // 判断止盈止损
            if (position_B.amount > 0 && takeProfitOrderId == null && stopLossOrderId == null && afterTrade == 0) {
                Log('多仓持仓价格：', position_B.price, '止盈价格：', position_B.price * (1 + stopProfitLevel), '止损价格：', position_B.price * (1 - stopLossLevel));
                takeProfitOrderId = exchange.CreateOrder(pair_b, "closebuy", position_B.price * (1 + stopProfitLevel), position_B.amount);
                Log('止盈订单：', takeProfitOrderId);
            }

            if (position_B.amount > 0 && takeProfitOrderId != null && stopLossOrderId == null && new_r_pairB.Close < position_B.price * (1 - stopLossLevel) && afterTrade == 0) {
                CancelPendingOrders();
                takeProfitOrderId = null
                Log('多仓止损');
                stopLossOrderId = exchange.CreateOrder(pair_b, "closebuy", -1, position_B.amount);
                Log('多仓止损订单：', stopLossOrderId);
            }

            if (position_B.amount < 0 && takeProfitOrderId == null && stopLossOrderId == null && afterTrade == 0) {
                Log('空仓持仓价格：', position_B.price, '止盈价格：', position_B.price * (1 - stopProfitLevel), '止损价格：', position_B.price * (1 + stopLossLevel));
                takeProfitOrderId = exchange.CreateOrder(pair_b, "closesell", position_B.price * (1 - stopProfitLevel), -position_B.amount);
                Log('止盈订单：', takeProfitOrderId, '当前价格：', new_r_pairB.Close );
            }

            if (position_B.amount < 0 && takeProfitOrderId != null && stopLossOrderId == null && new_r_pairB.Close > position_B.price * (1 + stopLossLevel) && afterTrade == 0) {
                CancelPendingOrders();
                takeProfitOrderId = null
                Log('空仓止损');
                stopLossOrderId = exchange.CreateOrder(pair_b, "closesell", -1, -position_B.amount);
                Log('空仓止损订单：', stopLossOrderId);
            }


            // 平市价单未完成
            if (takeProfitOrderId == null && stopLossOrderId != null && afterTrade == 0) {
                
                let stoplosspos = GetPosition(pair_b)
                if(stoplosspos.amount > 0){
                    Log('平多仓市价单未完成')
                    exchange.CreateOrder(pair_b, 'closebuy', -1, stoplosspos.amount)
                }
                if(stoplosspos.amount < 0){
                    Log('平空仓市价单未完成')
                    exchange.CreateOrder(pair_b, 'closesell', -1, -stoplosspos.amount)
                }
            }

            // 未平仓完毕
            if (Math.abs(position_B.amount) < Trade_Number && Math.abs(position_B.amount) > 0 && afterTrade == 0){
                Log('未平仓完毕')
                if(position_B.amount > 0){
                    exchange.CreateOrder(pair_b, 'closebuy', -1, position_B.amount)
                }else{
                    exchange.CreateOrder(pair_b, 'closesell', -1, -position_B.amount)
                }
            }

            // 计算盈亏
            if (position_B.amount == 0 && afterTrade == 0) {
                if (stopLossOrderId != null || takeProfitOrderId != null) {
                    stopLossOrderId = null;
                    takeProfitOrderId = null;

                    let afterEquity = exchange.GetAccount().Equity;
                    let curAmount = afterEquity - curEq;

                    curEq = afterEquity

                    if (curAmount > 0) {
                        successCount += 1;
                        winMoney += curAmount;
                        Log('盈利金额：', curAmount);
                    } else {
                        lossCount += 1;
                        failMoney += curAmount;
                        Log('亏损金额：', curAmount);
                    }
                    afterTrade = 1;
                }
            }

            if (startLoopTime % 10 == 0) {  // 每 10 次循环记录一次
                let curEquity = exchange.GetAccount().Equity

                // 输出交易信息表
                let table = {
                    type: "table",
                    title: "交易信息",
                    cols: [
                        "初始权益", "当前权益", Pair_B + "仓位", Pair_B + "持仓价", Pair_B + "收益", Pair_B + "价格", 
                        "盈利次数", "盈利金额", "亏损次数", "亏损金额", "胜率", "盈亏比"
                    ],
                    rows: [
                        [
                            _N(_G('init_eq'), 2),  // 初始权益
                            _N(curEquity, 2),  // 当前权益
                            _N(position_B.amount, 1),  // Pair B 仓位
                            _N(position_B.price, pricePrecision),  // Pair B 持仓价
                            _N(position_B.profit, 1),  // Pair B 收益
                            _N(new_r_pairB.Close, pricePrecision),  // Pair B 价格
                            _N(successCount, 0),  // 盈利次数
                            _N(winMoney, 2),  // 盈利金额
                            _N(lossCount, 0),  // 亏损次数
                            _N(failMoney, 2),  // 亏损金额
                            _N(successCount + lossCount === 0 ? 0 : successCount / (successCount + lossCount), 2),  // 胜率
                            _N(failMoney === 0 ? 0 : winMoney / failMoney * -1, 2)  // 盈亏比
                        ]
                    ]
                };

                $.PlotMultLine("ratio plot", "幅度变化差值", ratio, startLoopTime);
                $.PlotMultHLine("ratio plot", diffLevel, "差价上限", "red", "ShortDot");
                $.PlotMultHLine("ratio plot", -diffLevel, "差价下限", "blue", "ShortDot");

                LogStatus("`" + JSON.stringify(table) + "`");
                LogProfit(curEquity - initEq, '&')
            }
        }catch(e){
            Log('策略出现错误：', e)
        }

        
        Sleep(200);
    }
}