आविष्कारकों ने नई सुविधाओं को मापाः _Serve फ़ंक्शन का उपयोग करके आसानी से HTTP सेवाएं बनाएं
लेखक:आविष्कारक मात्रा - छोटे सपने, बनाया गयाः 2024-11-12 22:10:49, अद्यतनः 2024-11-15 09:27:20[TOC]
क्वांटिफाइड ट्रेडिंग और ऑटोमेशन रणनीतियों के विकास में कभी-कभी HTTP सेवा का उपयोग किया जाता है।_Serve()फ़ंक्शन, जो उपयोगकर्ताओं को HTTP, HTTPS और TCP सेवाओं को बनाने के लिए लचीलापन प्रदान करता है। इस सुविधा के माध्यम से, डेवलपर्स सेवा विन्यास प्रक्रिया को सरल बना सकते हैं और एक मात्रात्मक वातावरण में अधिक अनुकूलन सेवाओं को लागू कर सकते हैं, जिससे रणनीति डिजाइन अधिक सुचारू और आसान हो जाता है।_Serve()फ़ंक्शन के उपयोग के परिदृश्य और बुनियादी ऑपरेशन, आपको जल्दी से इस नए आविष्कारक को मापने में मदद करते हैं।
के बारे में_Serve()मंच एपीआई दस्तावेज़ में अद्यतन किया गया हैः
जरूरतें
प्लेटफार्म को अपग्रेड किया गया_Serve()फ़ंक्शन (जैसा कि पहले जावास्क्रिप्ट भाषा में कोई सेवा बनाने का कार्य नहीं था, यह फ़ंक्शन केवल जावास्क्रिप्ट भाषा की नीतियों का समर्थन करता है), बस यह है कि नीति के पास नेटवर्क सेवा बनाने की क्षमता है। इस सुविधा के आधार पर हम कई सुविधाओं को विकसित कर सकते हैं, कई जरूरतों को हल कर सकते हैं। उदाहरण के लिए, नीति के पास बाहरी इंटरफ़ेस, डेटा ट्रांसमिशन, सामान्य प्रोटोकॉल सुविधाओं का समर्थन करने वाले प्लेटफार्मों के साथ एक एफएमजेड प्लेटफॉर्म का समर्थन नहीं करता है।
इस लेख में हम उदाहरण के रूप में इस आवश्यकता को पूरा करते हैंः "एक सामान्य प्रोटोकॉल सुविधा के साथ एक मंच के साथ एक एफएमजेड प्लेटफॉर्म द्वारा समर्थित एक्सचेंजों के लिए एक निर्बाध पैकेज" ।सामान्य प्रोटोकॉल गाइडहम ओकेएक्स लेन-देन के लिए पायथन भाषा का उपयोग करते हैं, इसलिए एपीआई (एपीआई) के लिए मौद्रिक मोड को पैक किया गया है ((क्योंकि एफएमजेड स्वयं ओकेएक्स का समर्थन करता है, यहां ओकेएक्स का उपयोग केवल एक उदाहरण है, जो अन्य एफएमजेड प्लेटफार्मों तक पहुंच के बिना एक्सचेंजों के लिए लागू होता है) । पाठ में पाइथन के सामान्य प्रोटोकॉल प्रोग्राम को अलग से चलाने की आवश्यकता होती है, जब जावास्क्रिप्ट भाषा का समर्थन किया जाता है।_Serve()फ़ंक्शन के बाद, जावास्क्रिप्ट भाषा के लिए सामान्य प्रोटोकॉल तक पहुंचने की रणनीति बहुत सरल है।
हम एक सामान्य प्रोटोकॉल के रूप में लिपटे हुए एक्सचेंज इंटरफेस को सीधे नीति में एकीकृत करते हैं, ताकि एफएमजेड पर असमर्थित एक्सचेंजों तक निर्बाध पहुंच हो सके।
-
मंच पर सामान्य प्रोटोकॉल एक्सचेंजों का कॉन्फ़िगरेशन इस प्रकार हैः
यह टेम्पलेट के डिजाइन के दौरान किया जा सकता
/OKXयह पहचानने के लिए कि कौन सा एक्सचेंज कॉन्फ़िगरेशन के लिए एक सामान्य प्रोटोकॉल एक्सचेंज ऑब्जेक्ट है।
सामान्य प्रोटोकॉल टेम्पलेट कार्यान्वयन
सबसे पहले, आविष्कारकों ने क्वांटिफाइड ट्रेडिंग प्लेटफॉर्म पर एक नई रणनीति बनाई, जिसमें रणनीति प्रकार को टेम्पलेट लाइब्रेरी और रणनीति भाषा को जावास्क्रिप्ट भाषा के रूप में सेट किया गया था।
टेम्पलेट पैरामीटर डिजाइन
एक अच्छा रणनीति टेम्पलेट बनाने के लिए तीन पैरामीटर जोड़े गए हैंः
इसके बाद, आप एक सामान्य प्रोटोकॉल टेम्पलेट के लिए कोड डिजाइन और लिखना शुरू कर सकते हैं।
कोड कार्यान्वयन
कोड TS शैली में लिखा गया है।$.startService()एक फ़ंक्शन एक टेम्पलेट का इंटरफ़ेस फ़ंक्शन है जिसका उपयोग सामान्य प्रोटोकॉल सेवा को शुरू करने के लिए किया जाता है।
// @ts-check
$.startService = function (address, port, proxyConfig) {
__Serve(`http://${address}:${port}`, function (ctx, proxyConfig) {
// interface
interface IData {
data: object
raw: object
}
interface IError {
error: any
}
// custom protocol for OKX
class CustomProtocolOKX {
apiBase: string = "https://www.okx.com"
accessKey: string
secretKey: string
passphrase: string
proxyConfig: string = ""
simulate: boolean = false
constructor(accessKey: string, secretKey: string, passphrase: string, simulate?: boolean, proxyConfig?: string) {
this.accessKey = accessKey
this.secretKey = secretKey
this.passphrase = passphrase
if (typeof(simulate) == "boolean") {
this.simulate = simulate
}
this.proxyConfig = proxyConfig
}
httpReq(method: string, path: string, query: string = "", params: {[key: string]: any} = {}, headers: {key: string, value: string | ArrayBuffer}[] = []): {[key: string]: any} {
let ret = null
let options = {
method: method,
headers: {
'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5.6',
'Content-Type': 'application/json; charset=UTF-8',
'x-simulated-trading': this.simulate ? "1" : "0"
},
}
// headers
if (Array.isArray(headers) && headers.length > 0) {
for (var pair of headers) {
options.headers[pair.key] = pair.value
}
}
let url = ""
if (method == "GET") {
if (typeof(query) == "string" && query.length > 0) {
url = `${this.apiBase}${path}?${query}`
} else {
url = `${this.apiBase}${path}`
}
} else {
url = `${this.apiBase}${path}`
options.body = JSON.stringify(params)
}
// request
try {
if (this.proxyConfig != "") {
url = `${this.proxyConfig}${url}`
}
ret = JSON.parse(HttpQuery(url, options))
} catch(e) {
return null
}
return ret
}
callSignedAPI(method: string, path: string, query: string = "", params: {[key: string]: any} = {}): {[key: string]: any} {
const strTime = new Date().toISOString().slice(0, -5) + 'Z'
let jsonStr = ""
if (method == "GET") {
jsonStr = Object.keys(params).length > 0 ? JSON.stringify(params) : ""
} else {
jsonStr = Object.keys(params).length > 0 ? JSON.stringify(params) : "{}"
}
let message = `${strTime}${method}${path}${jsonStr}`
if (method === "GET" && query !== "") {
message = `${strTime}${method}${path}?${query}${jsonStr}`
}
const signature = Encode("sha256", "string", "base64", message, "string", this.secretKey)
let headers = []
headers.push({key: "OK-ACCESS-KEY", value: this.accessKey})
headers.push({key: "OK-ACCESS-PASSPHRASE", value: this.passphrase})
headers.push({key: "OK-ACCESS-TIMESTAMP", value: strTime})
headers.push({key: "OK-ACCESS-SIGN", value: signature})
return this.httpReq(method, path, query, params, headers)
}
urlEncode(params: {[key: string]: string | number}): string {
let encodeParams: string[] = []
for (const [key, value] of Object.entries(params)) {
encodeParams.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
}
return encodeParams.join("&")
}
symbol2Inst(symbol: string): string {
let arr = symbol.split("_")
if (arr.length >= 2) {
return `${arr[0]}-${arr[1]}`.toUpperCase()
} else {
return `${arr[0]}-USDT`.toUpperCase()
}
}
getSymbol(inst: string): string {
let arr = inst.split("-")
if (arr.length >= 2) {
return `${arr[0]}_${arr[1]}`.toUpperCase()
} else {
return `${arr[0]}-USDT`.toUpperCase()
}
}
// The following code encapsulates OKX's interface
GetTicker(symbol: string): IData | IError {
// GET /api/v5/market/ticker , param: instId
let inst = this.symbol2Inst(symbol)
let ret = this.httpReq("GET", "/api/v5/market/ticker", `instId=${inst}`)
let retData = {}
for (var ele of ret["data"]) {
retData["symbol"] = this.getSymbol(ele["instId"])
retData["buy"] = ele["bidPx"]
retData["sell"] = ele["askPx"]
retData["high"] = ele["high24h"]
retData["low"] = ele["low24h"]
retData["open"] = ele["open24h"]
retData["last"] = ele["last"]
retData["vol"] = ele["vol24h"]
retData["time"] = ele["ts"]
}
return {data: retData, raw: ret}
}
GetAccount(): IData | IError {
// GET /api/v5/account/balance
let ret = this.callSignedAPI("GET", "/api/v5/account/balance")
let retData = []
for (var ele of ret["data"]) {
for (var detail of ele["details"]) {
let asset = {"currency": detail["ccy"], "free": detail["availEq"], "frozen": detail["ordFrozen"]}
if (detail["availEq"] == "") {
asset["free"] = detail["availBal"]
}
retData.push(asset)
}
}
return {data: retData, raw: ret}
}
IO(method: string, path: string, params: {[key: string]: any}): {[key: string]: any} {
let ret = null
if (method == "GET") {
ret = this.callSignedAPI(method, path, this.urlEncode(params))
} else {
ret = this.callSignedAPI(method, path, "", params)
}
return {data: ret}
}
}
// protocol factory
class ProtocolFactory {
static createExWrapper(accessKey: string, secretKey: string, exName: string): any {
let protocol = null
if (exName == "/OKX") {
try {
let passphrase = ""
let simulate = false
let arrSecretKey = secretKey.split(",")
if (arrSecretKey.length == 2) {
secretKey = arrSecretKey[0]
passphrase = arrSecretKey[1]
} else if (arrSecretKey.length == 3) {
secretKey = arrSecretKey[0]
passphrase = arrSecretKey[1]
simulate = arrSecretKey[2] == "simulate" ? true : false
} else {
return null
}
protocol = new CustomProtocolOKX(accessKey, secretKey, passphrase, simulate, proxyConfig)
} catch(e) {
Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
return null
}
}
return protocol
}
}
// http service
let resp = {}
let reqMethod = ctx.method()
let reqPath = ctx.path()
let httpMethod = ctx.header("Http-Method")
let reqBody = null
try {
reqBody = JSON.parse(ctx.body())
} catch(e) {
resp = {error: {name: e.name, stack: e.stack, message: e.message, errDesc: "JSON parse error."}}
}
// onPost
if (reqMethod == "POST") {
if (!["access_key", "secret_key", "method", "params"].every(key=> key in reqBody)) {
resp = {error: {reqBody: reqBody, errDesc: "reqBody error."}}
}
if ("error" in resp) {
ctx.write(JSON.stringify(resp))
return
}
let accessKey = reqBody["access_key"]
let secretKey = reqBody["secret_key"]
let method = reqBody["method"]
let params = reqBody["params"]
let protocol = ProtocolFactory.createExWrapper(accessKey, secretKey, reqPath)
if (!protocol) {
ctx.write(JSON.stringify({error: {errDesc: "createExWrapper error."}}))
return
}
// process GetTicker / GetAccount ...
if (method == "ticker") {
if (!["symbol"].every(key=> key in params)) {
resp = {error: {params: params, errDesc: "params error."}}
} else {
let symbol = params["symbol"]
resp = protocol.GetTicker(symbol)
}
} else if (method == "accounts") {
resp = protocol.GetAccount()
} else if (method.slice(0, 6) == "__api_") {
resp = protocol.IO(httpMethod, method.slice(6), params)
} else {
ctx.write(JSON.stringify({error: {method: method, errDesc: "method not support."}}))
return
}
ctx.write(JSON.stringify(resp))
}
}, proxyConfig)
}
function init() {
$.startService(address, port, proxyConfig)
Log("启动通用协议服务，address:", address, "，port:", port, "#FF0000")
if (proxyConfig != "") {
Log("设置代理：", proxyConfig, "#FF0000")
}
}
यह एक बहुत ही सीमित संस्करण है, इसलिए यह सभी इंटरफेस को लागू नहीं करता है, यह केवल लागू करता हैमामले की जांच、संपत्ति पूछताछ、आईओ कॉलसभी इंटरफेस को लागू किया जा सकता है; डिजाइन पूरा, टेम्पलेट कोड सहेजें, टेम्पलेट का नाम सहेजेंः
परीक्षण रणनीति
OKX एक्सचेंज के लिए apkey, secretkey, passphrase आदि को कॉन्फ़िगर करने के बाद, हम परीक्षण के लिए एक परीक्षण नीति लिख सकते हैं।
हमारी योजनाओं में से कुछ के लिए, हम अपने स्वयं के टेम्पलेट्स का उपयोग करते हैं।
परीक्षण रणनीति कोडः
function main() {
// 测试GetTicker
Log(`exchange.GetTicker():`, exchange.GetTicker())
// 测试GetAccount
Log(`exchange.GetAccount():`, exchange.GetAccount())
// 测试exchange.IO
Log(`exchange.IO("api", "POST", "/api/v5/trade/cancel-all-after", "timeOut=0"):`, exchange.IO("api", "POST", "/api/v5/trade/cancel-all-after", "timeOut=0"))
// 输出通用协议添加的交易所名称
Log(`exchange.GetName():`, exchange.GetName())
// 输出通用协议添加的交易所标签
Log(`exchange.GetLabel():`, exchange.GetLabel())
}
परीक्षण चलाएँ
जैसा कि आप देख सकते हैं, रणनीति केवल एक टेम्पलेट का चयन करने के लिए OKX एक्सचेंज (हालांकि OKX एक्सचेंज पहले से ही समर्थित है, उदाहरण के लिए यहां OKX को एक FMZ के रूप में प्रतिस्थापित किया गया है जो अभी तक नहीं जुड़ा है) के लिए निर्बाध पहुंच प्राप्त करती है।
- एफएमजेड क्वांट की नई विशेषताः आसानी से HTTP सेवाएँ बनाने के लिए _Serve फ़ंक्शन का प्रयोग करें
- FMZ क्वांट ट्रेडिंग प्लेटफॉर्म कस्टम प्रोटोकॉल एक्सेस गाइड
- एफएमजेड फंडिंग रेट अधिग्रहण और निगरानी रणनीति
- एफएमजेड के लिए धनराशि प्राप्त करने और निगरानी के लिए रणनीति
- एक रणनीति टेम्पलेट आपको वेबसॉकेट मार्केट का उपयोग करने की अनुमति देता है
- एक नीति टेम्पलेट जो आपको वेबसॉकेट के क्षेत्र का उपयोग करने के लिए अनुमति देता है
- आविष्कारकों के लिए क्वांटिफाइड ट्रेडिंग प्लेटफॉर्म के लिए सामान्य प्रोटोकॉल एक्सेस गाइड
- एफएमजेड उन्नयन के बाद एक सार्वभौमिक बहु-मुद्रा व्यापार रणनीति कैसे बनाएं
- एफएमजेड के उन्नयन के बाद एक सार्वभौमिक बहु-मुद्रा व्यापार रणनीति बनाने के लिए तेजी से कैसे?
- डीसीए ट्रेडिंगः एक व्यापक रूप से प्रयुक्त मात्रात्मक रणनीति
- डीसीए लेनदेनः व्यापक रूप से सामान्य मात्रा रणनीति