发明者量化新功能：使用 _Serve 函数轻松创建 HTTP 服务
Author: 发明者量化-小小梦, Created: 2024-11-12 22:10:49, Updated: 2024-11-15 09:27:20[TOC]
在量化交易和自动化策略开发中，有时会用到http服务。发明者量化平台近日新增了 _Serve() 函数，为用户提供了灵活的 HTTP、HTTPS 和 TCP 服务创建能力。通过该功能，开发者可以简化服务配置过程，并在量化环境中实现更多自定义服务，使策略设计更加流畅便捷。本文将介绍 _Serve() 函数的使用场景和基本操作，帮助您快速上手发明者量化的这一全新功能。
关于_Serve()已更新在平台API文档：
需求
平台升级了_Serve()函数（由于之前JavaScript语言没有创建服务的功能，该函数只支持JavaScript语言的策略），简单说就是让策略拥有了可以创建网络服务的能力。基于此功能我们能开发出很多功能，解决很多需求。例如让策略拥有对外的接口、数据转发、配合平台的通用协议功能无缝封装FMZ平台不支持的交易所等。
本篇我们就以：「配合平台的通用协议功能无缝封装FMZ平台不支持的交易所」这个需求来举例实现。在往期文章「通用协议指南」中我们使用Python语言对OKX交易所以现货模式封装了API（由于FMZ本身支持OKX，这里使用OKX只是举例，对于其它FMZ平台没有接入的交易所都适用）。文中Python的通用协议程序需要单独运行起来，当JavaScript语言支持了_Serve()函数之后，JavaScript语言的策略接入通用协议就更加简单了。
我们将待封装的交易所接口的通用协议封装为「模板类库」直接集成在策略中，这样策略就无缝接入了在FMZ上未支持的交易所。对于如何配置「通用协议」交易所对象这里就不再赘述，可以查阅文章：
-
在平台上通用协议交易所配置如图：
可以在模板设计时，通过
/OKX识别配置的通用协议交易所对象属于哪一个交易所。
通用协议模板实现
首先在发明者量化交易平台创建一个新策略，策略类型设置为模板类库，策略语言为JavaScript语言。
模板参数设计
给创建好的策略模板增加3个参数：
然后就可以开始设计、编写通用协议模板的代码了。
代码实现
代码使用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")
}
}
篇幅有限，这里就不把所有接口都实现了，仅实现了行情查询、资产查询、IO调用，有兴趣的同学可以实现所有接口；设计完成，保存模板代码，模板名称保存为：“TypeScript版本通用协议范例”。
测试策略
将OKX交易所的apikey、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还未接入的交易所）的无缝接入。
More
- FMZ平台外部信号接收的探讨：策略内置Http服务接收信号的完整方案
- Introduction to Lead-Lag Arbitrage in Cryptocurrency (1)
- 数字货币中的Lead-Lag套利介绍（1）
- Discussion on External Signal Reception of FMZ Platform: Extended API VS Strategy Built-in HTTP Service
- FMZ平台外部信号接收的探讨：扩展API vs 策略内置HTTP服务
- Discussion on Strategy Testing Method Based on Random Ticker Generator
- 基于随机行情生成器的策略测试方法探讨
- New Feature of FMZ Quant: Use _Serve Function to Create HTTP Services Easily
- FMZ Quant Trading Platform Custom Protocol Access Guide
- FMZ Funding Rate Acquisition and Monitoring Strategy
- FMZ资金费率获取与监控策略策略
- A Strategy Template Allows You to Use WebSocket Market Seamlessly
- 一个策略模板让你无缝使用WebSocket行情
- 发明者量化交易平台通用协议接入指南
- How to Build a Universal Multi-Currency Trading Strategy Quickly after FMZ Upgrade
- FMZ升级后，如何快捷构建通用多币种交易策略
- DCA Trading: A Widely Used Quantitative Strategy
- DCA交易：广泛通用的量化策略