पिछले कुछ लेखों में, हमने मुख्यधारा DEX तक पहुंच पर चर्चा की है, और यह लेख वास्तविक उपयोग पर ध्यान केंद्रित करेगा और वास्तविक रणनीति परिनियोजन परीक्षण आयोजित करेगा। FMZ प्लेटफॉर्म ने हाल ही में WOOFi और EdgeX विकेन्द्रीकृत एक्सचेंजों के लिए समर्थन जोड़ा है। इस लेख में, हम इन दोनों एक्सचेंजों पर कुछ सरल शिक्षण रणनीतियों का अभ्यास करेंगे।

WOOFi

अपने वॉलेट को WOOFi से कनेक्ट करें, और फिर API KEY पेज पर, आप API कुंजी जानकारी देख सकते हैं, उसे कॉपी और पेस्ट कर सकते हैं और FMZ पर कॉन्फ़िगर कर सकते हैं।

डाउनलोड और परिनियोजन के बाद FMZ के नवीनतम होस्ट का उपयोग करें, जो पहले से ही WOOFi DEX और EdgeX DEX का समर्थन करता है। पृष्ठ पर एक्सचेंज ऑब्जेक्ट को कॉन्फ़िगर करें: https://www.fmz.com/m/platforms/add, और WOOFi के AccountId, AccessKey और SecretKey को कॉन्फ़िगर करें।

इस परीक्षण में, हमने एकबुनियादी बाजार बनाने की रणनीति प्रोटोटाइपबाजार अस्थिरता सूचक (एटीआर) के साथ संयुक्त, लंबित आदेशों के बीच अंतराल की गतिशील रूप से गणना की जाती है, और पदों की बुद्धिमान पहचान और समापन पदों पर प्राथमिकता के साथ ऑर्डर देने के तर्क को साकार किया जाता है। यह रणनीति प्रत्येक दौर में ऑर्डर बुक को ताज़ा करती है, गहराई और स्थिति की जानकारी पुनः प्राप्त करती है, तथा निर्धारित मूल्य अंतराल और ऑर्डर मात्रा के अनुसार ऑर्डर देती है। संपूर्ण प्रक्रिया में निम्नलिखित शामिल हैं:

• वास्तविक समय बाजार सूचना निष्कर्षण और संकेतक विश्लेषण;
• दीर्घ एवं लघु दोनों दिशाओं में लंबित आदेशों का तर्क नियंत्रण;
• समापन और प्रारंभिक स्थिति का निर्णय और मोड़;
• पदों और खाते की स्थिति का दृश्य आउटपुट.

इस रणनीति के माध्यम से, हम WOOFi पर वास्तविक लेनदेन दक्षता, ऑर्डर विलंब और मिलान अनुभव का निरीक्षण कर सकते हैं, जो बाद में अधिक जटिल रणनीतियों के डिजाइन की नींव रखेगा।

हम WOOFi के परीक्षण वातावरण और परीक्षण नेटवर्क: आर्बिट्रम सेपोलिया का उपयोग करते हैं।

exchange.SetBase(”https://testnet-api.orderly.org”)

WOOFi परीक्षण नेटवर्क पर एक नल है जो आपको परीक्षण के लिए आसानी से USDC प्राप्त करने की अनुमति देता है।

रणनीति कोड:

function createOrders(e, symbol, side, ordersNum, beginPrice, firstAmount, spacing, pos) {
    if (side == "buy" || side == "closesell") {
        if (spacing > 0) {
            throw "spacing error"
        }
    } else if (side == "sell" || side == "closebuy") {
        if (spacing < 0) {
            throw "spacing error"
        }
    } else {
        throw "side error"
    }
    
    var holdAmount = 0
    if (pos) {
        holdAmount = pos.Amount
    }

    var amount = firstAmount
    for (var i = 0 ; i < ordersNum ; i++) {
        var id = null 
        amount = amount * 2
        var price = beginPrice + i * spacing

        if (price <= 0 || amount <= 0) {
            Log("continue loop:", price, amount, "#FF0000")
            continue 
        }

        if (holdAmount - amount >= 0) {
            id = e.CreateOrder(symbol, side == "buy" ? "closesell" : "closebuy", price, holdAmount)
            holdAmount = 0
        } else {
            id = e.CreateOrder(symbol, side, price, amount)
        }

        Sleep(100)
    }
}

function cancelAll(e, symbol) {
    while (true) {
        var orders = _C(e.GetOrders, symbol)
        var sideOrders = []
        for (var o of orders) {
            sideOrders.push(o)
        }
        if (sideOrders.length == 0) {
            break
        }

        for (var o of sideOrders) {
            e.CancelOrder(o.Id, o)
        }

        Sleep(500)
    }
}

function main() {
    LogReset(1)
    LogProfitReset()
    exchange.SetBase("https://testnet-api.orderly.org")

    // 参数
    var symbol = "ETH_USDC.swap"
    var ordersNum = 5
    var orderAmount = 0.01
    var priceSpace = 0

    // 初始化
    exchange.SetPrecision(2, 3)    
    var msg = []
    var buyOrdersNum = ordersNum
    var sellOrdersNum = ordersNum

    while (true) {
        cancelAll(exchange, symbol)

        var r = _C(exchange.GetRecords, symbol, 60 * 5)
        var art = TA.ATR(r, 20)
        priceSpace = art[art.length - 1]
        var pos = _C(exchange.GetPositions, symbol)        

        // depth
        var depth = _C(exchange.GetDepth, symbol)
        if (depth.Bids.length == 0 || depth.Asks.length == 0) {
            msg.push("invalid depth")
        } else {
            var bid1Price = depth.Bids[0].Price
            var ask1Price = depth.Asks[0].Price

            var longPos = null
            var shortPos = null
            for (var p of pos) {
                if (p.Type == PD_LONG) {
                    longPos = p
                } else if (p.Type == PD_SHORT) {
                    shortPos = p
                }
            }

            // long
            createOrders(exchange, symbol, "buy", buyOrdersNum, bid1Price, orderAmount, -priceSpace, shortPos)
            // short
            createOrders(exchange, symbol, "sell", sellOrdersNum, ask1Price, orderAmount, priceSpace, longPos)
        }
        
        var acc = _C(exchange.GetAccount)
        var orders = _C(exchange.GetOrders, symbol)
        LogProfit(acc.Equity, "&")

        var posTbl = {"type": "table", "title": "pos", "cols": ["Symbol", "Type", "Price", "Amount"], "rows": []}
        for (var p of pos) {
            posTbl["rows"].push([p.Symbol, p.Type == PD_LONG ? "多" : "空", p.Price, p.Amount])
        }

        var ordersTbl = {"type": "table", "title": "orders", "cols": ["Symbol", "Type", "Price", "Amount"], "rows": []}
        for (var o of orders) {
            ordersTbl["rows"].push([o.Symbol, o.Type == ORDER_TYPE_BUY ? "买" : "卖", o.Price, o.Amount])
        }

        LogStatus(_D(), "priceSpace:", priceSpace, "\n`" + JSON.stringify([posTbl, ordersTbl]) + "`")
        Sleep(1000 * 60)
        LogReset(1000)
    }
}

WOOFi पर रणनीति अभ्यास

EdgeX

FMZ पर EdgeX को कॉन्फ़िगर करने के लिए API जानकारी मूलतः WOOFi के समान ही है, लेकिन विभिन्न एक्सचेंजों को अलग-अलग API जानकारी की आवश्यकता होती है। EdgeX पर, आपको केवल AccountId और SecretKey को कॉन्फ़िगर करना होगा। इन्हें एजएक्स फ्रंट एंड से कनेक्ट करने के लिए वॉलेट का उपयोग करने के बाद खाता एपीआई प्रबंधन पृष्ठ पर भी देखा जा सकता है।

एजएक्स पर हम जो रणनीति लागू करने जा रहे हैं, वह इस पर आधारित हैमल्टी-लेयर बोलिंगर बैंडरिवर्स ओपनिंग + मिड-ट्रैक क्लोजिंग का मात्रात्मक ट्रेडिंग तर्क अल्पकालिक अस्थिरता मध्यस्थता को साकार कर सकता है।

रणनीति बहुत सरल है, मूल विचार यह है:

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

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

रणनीति कोड:

function main() {
    var symbol = "ETH_USDT.swap"
    var arrUp = []
    var arrDown = []
    let c = KLineChart({
        overlay: true
    }) 
    while (true) {
        var bolls = []
        var r = _C(exchange.GetRecords, symbol)
        for (var i = 0; i < 3; i++) {
            var boll = TA.BOLL(r, 20, i + 1)
            bolls.push(boll)
            var up = boll[0][boll[0].length - 1]
            var mid = boll[1][boll[1].length - 1]
            var down = boll[2][boll[2].length - 1]
            var close = r[r.length - 1].Close
            if (close > up && i >= arrUp.length) {
                exchange.CreateOrder(symbol, "sell", -1, 0.01 * (i + 1))
                arrUp.push({"symbol": symbol, "amount": 0.01 * (i + 1)})
            } else if (close < down && i >= arrDown.length) {
                exchange.CreateOrder(symbol, "buy", -1, 0.01 * (i + 1))
                arrDown.push({"symbol": symbol, "amount": 0.01 * (i + 1)})
            } else if ((arrUp.length > 0 && close < mid) || (arrDown.length > 0 && close > mid)) {
                var pos = exchange.GetPositions(symbol)
                for (var p of pos) {
                    if (p.Type == PD_LONG) {
                        exchange.CreateOrder(symbol, "closebuy", -1, p.Amount)
                    } else if (p.Type == PD_SHORT) {
                        exchange.CreateOrder(symbol, "closesell", -1, p.Amount)
                    }
                }
                arrUp = []
                arrDown = []
            }
        }
        r.forEach(function(bar, index) {
            c.begin(bar)
            for (var i in bolls) {
                var b = bolls[i]
                c.plot(b[0][index], 'up_' + (i + 1))
                c.plot(b[1][index], 'mid_' + (i + 1))
                c.plot(b[2][index], 'down_' + (i + 1))
            }
            c.close()
        })
        LogStatus(_D(), "\n", arrUp, "\n", arrDown)
        Sleep(500)
    }
}

आइए पहले एक दीर्घकालिक बैकटेस्ट करें:

EdgeX परीक्षण तैनात करें

END

उपरोक्त रणनीतियाँ केवल शिक्षण और अनुसंधान उद्देश्यों के लिए हैं। कृपया इन्हें प्रयोग करते समय सावधानी बरतें। पढ़ने के लिए आपका शुक्रिया।