发明者量化交易平台通用协议接入指南

[TOC]

发明者量化交易平台支持众多加密货币交易所，并且封装了市面上主流的交易所。然而，仍有许多交易所未被封装，对于需要使用这些交易所的用户，可以通过发明者量化的通用协议进行接入。不仅限于加密货币交易所，任何支持REST协议或FIX协议的平台也可以接入。

本篇将以REST协议接入为例，讲解如何使用发明者量化交易平台的通用协议来封装并接入 OKX 交易所的 API。本篇如无特殊说明均指的是REST通用协议。

• 通用协议的工作流程为： 请求过程：托管者上运行的策略实例 -> 通用协议程序 -> 交易所API 应答过程：交易所API -> 通用协议程序 -> 托管者上运行的策略实例

1、配置交易所

发明者量化交易平台配置交易所的页面：

https://www.fmz.com/m/platforms/add

• 选择协议：选择「通用协议」。
• 服务地址：通用协议程序本质是一个RPC服务 所以需要在配置交易所时明确指定服务地址、端口。这样在托管者上运行的策略实例 -> 通用协议程序过程时，托管者才知道去哪里访问通用协议程序。 例如：http://127.0.0.1:6666/OKX，通常把通用协议程序与托管者运行在同一台设备上（服务器），所以服务地址写本机（localhost），端口使用一个系统未占用的即可。
• Access Key： 托管者上运行的策略实例 -> 通用协议程序过程时，传递的交易所配置信息。
• Secret Key： 托管者上运行的策略实例 -> 通用协议程序过程时，传递的交易所配置信息。
• 标签： 在发明者量化交易平台上的交易所对象标签，用来标识某个交易所对象。

文章中公开的OKX插件程序配置截图如下：

OKX交易所秘钥配置信息：

accessKey:  accesskey123    // accesskey123 这些并不是实际秘钥，仅仅是演示
secretKey:  secretkey123
passphrase: passphrase123

2、部署托管者和通用协议程序（plugin）

• 1、托管者 在发明者量化交易平台上运行任何策略实盘都必须部署一个托管者，具体部署托管者可以参考平台教程，这里不再赘述。

• 2、通用协议程序（plugin） 托管者和通用协议通常部署在同一台设备上，通用协议（服务）程序可以使用任何语言来编写设计，本篇使用Python3编写。和运行任何Python程序一样，直接执行即可（事先做好Python环境的各种配置）。 当然在FMZ上也支持运行python程序，也可以把这个通用协议当做一个实盘来运行，来提供给发明者量化交易平台对于未封装的交易所API接入支持。 通用协议程序运行后，开始监听：http://127.0.0.1:6666，通用协议程序中可以对具体的path，例如/OKX进行处理。

3、策略实例请求FMZ的API函数

当策略中调用（FMZ）平台的API函数时，通用协议程序会收到来自托管者的请求。使用平台的调试工具也可以测试，例如：

调试工具页面：

https://www.fmz.com/m/debug

function main() {
    return exchange.GetTicker("LTC_USDT")
}

调用exchange.GetTicker()函数，通用协议程序收到请求：

POST /OKX HTTP/1.1 
{
    "access_key":"xxx",
    "method":"ticker",
    "nonce":1730275031047002000,
    "params":{"symbol":"LTC_USDT"},
    "secret_key":"xxx"
}

• access_key: 上文中在平台「配置交易所」时配置的交易所秘钥
• secret_key: 上文中在平台「配置交易所」时配置的交易所秘钥
• method: 与策略中调用接口有关，调用exchange.GetTicker()时，method即为ticker。
• nonce: 发生请求时的时间戳。
• params: 策略中发生接口调用时相关的参数，本例exchange.GetTicker()调用时，相关的参数为：{"symbol":"LTC_USDT"}。

4、通用协议程序访问交易所接口

当通用协议程序收到来自托管者的请求时，可以根据请求中携带的信息得知：策略请求的平台API函数（包括参数信息）、交易所秘钥等信息。

根据这些信息，通用协议程序可以去访问交易所接口，获取所要的数据或者执行某些操作。

通常交易所接口有GET / POST / PUT / DELETE 等方法，分为公共接口和私有接口。

• 公共接口：不需要签名验证的接口，通用协议程序中直接请求。
• 私有接口：需要签名验证的接口，通用协议程序中需要实现签名，进而请求这些交易所的API接口。

通用协议程序收到交易所接口应答数据，进一步进行处理，构造成托管者期望的数据（以下介绍）。 参考OKX现货交易所，Python通用协议范例中的CustomProtocolOKX类实现中的GetTicker、GetAccount等函数。

5、通用协议程序把数据应答给托管者

当通用协议程序访问交易所的API接口，执行了某些操作或者获取某些数据后，需要把结果反馈给托管者。

反馈给托管者的数据根据策略调用的接口不同而不同，首先分为两大类：

• 通用协议程序调用交易所接口成功：

  {
      "data": null,  // "data" can be of any type 
      "raw": null    // "raw" can be of any type 
  }
  

  • data：该字段具体结构与通用协议程序收到的请求中的method有关，用于构造FMZ平台API函数最终返回的数据结构，下文会有所有接口的列举。
  • raw：该字段可以传入交易所API接口应答的原始数据，例如exchange.GetTicker()函数返回的Ticker结构，Ticker结构的Info字段中记录的就是raw字段和data字段的数据；平台的API函数，有些不需要这个数据。

• 通用协议程序调用交易所接口失败（业务错误、网络错误等）

  {
      "error": ""    // "error" contains an error message as a string
  }
  

  • error：报错信息，会显示在（FMZ）平台实盘、调试工具等页面日志区域的报错日志中。

演示策略程序收到的通用协议应答数据：

// FMZ平台的调试工具中测试
function main() {
    Log(exchange.GetTicker("USDT"))       // 交易对不完整，缺少BaseCurrency部分，需要通用协议插件程序返回报错信息： {"error": "..."}
    Log(exchange.GetTicker("LTC_USDT"))
}

6、通用协议中的数据结构约定

以上内容就是通用协议程序参与到接入（FMZ未封装）交易所API的简要过程，这个过程只讲解了在（FMZ）平台调试工具中调用exchange.GetTicker()函数时的过程。接下来会详细说明所有平台API函数的交互细节。

平台封装了各个交易所的共有功能，都统一成了某个函数，例如GetTicker函数，请求当前某个品种的行情信息，这个基本上是所有交易所都有的API。所以当策略实例中访问平台封装的API接口时，托管者会向「通用协议」插件程序发送请求(上文中已经提及)：

POST /OKX HTTP/1.1 
{
    "access_key": "xxx",
    "method": "ticker",
    "nonce": 1730275031047002000,
    "params": {"symbol":"LTC_USDT"},
    "secret_key": "xxx"
}

在策略中调用不同的发明者平台封装的 API 函数时（例如GetTicker），托管者发送给通用协议的请求格式也会有所不同。正文（Body）中的数据（JSON）差别仅在于method和params。设计通用协议时，根据method的内容去执行具体的操作即可。以下是所有接口的请求-应答场景。

现货交易所

例如当前交易对为：ETH_USDT，后续不再赘述。托管者期望通用协议应答的数据主要写在data字段，也可以增加一个raw字段记录交易所接口原始数据。

• GetTicker

  • method字段：“ticker”
  • params字段：

    {"symbol":"ETH_USDT"}
    

  • 托管者期望通用协议应答的数据：

    {
        "data": {
            "symbol": "ETH_USDT",      // 对应GetTicker函数返回的Ticker结构中的Symbol字段
            "buy": "2922.18",          // ...对应Buy字段
            "sell": "2922.19", 
            "high": "2955", 
            "low": "2775.15", 
            "open": "2787.72", 
            "last": "2922.18", 
            "vol": "249400.888156", 
            "time": "1731028903911"
        },
        "raw": {}                      // 可以增加一个raw字段记录交易所API接口应答的原始数据
    }
    

• GetDepth

  • method字段：“depth”
  • params字段：

    {"limit":"30","symbol":"ETH_USDT"}
    

  • 托管者期望通用协议应答的数据：

    {
        "data" : {
            "time" : 1500793319499,
            "asks" : [
                [1000, 0.5], [1001, 0.23], [1004, 2.1]
                // ... 
            ],
            "bids" : [
                [999, 0.25], [998, 0.8], [995, 1.4]
                // ... 
            ]
        }
    }
    

• GetTrades

  • method字段：“trades”
  • params字段：

    {"symbol":"eth_usdt"}
    

  • 托管者期望通用协议应答的数据：

    { 
        "data": [
            {
                "id": 12232153,
                "time" : 1529919412968,
                "price": 1000,
                "amount": 0.5,
                "type": "buy",             // "buy"、"sell"、"bid"、"ask"
            }, {
                "id": 12545664,
                "time" : 1529919412900,
                "price": 1001,
                "amount": 1,
                "type": "sell",
            }
            // ...
        ]
    }
    

• GetRecords

  • method字段：“records”
  • params字段：

    {
        "limit":"500",
        "period":"60",          // 60分钟
        "symbol":"ETH_USDT"
    }
    

  • 托管者期望通用协议应答的数据：

    {
        "data": [
                // "Time":1500793319000,"Open":1.1,"High":2.2,"Low":3.3,"Close":4.4,"Volume":5.5
                [1500793319, 1.1, 2.2, 3.3, 4.4, 5.5],
                [1500793259, 1.01, 2.02, 3.03, 4.04, 5.05],
                // ...
        ]
    }
    

• GetMarkets 待实现

  • method字段：""
  • params字段：

    {}
    

  • 托管者期望通用协议应答的数据：

    {}
    

• GetTickers 待实现

  • method字段：""
  • params字段：

    {}
    

  • 托管者期望通用协议应答的数据：

    {}
    

• GetAccount

  • method字段：“accounts”
  • params字段：

    {}
    

  • 托管者期望通用协议应答的数据：

    {
        "data": [
            {"currency": "TUSD", "free": "3000", "frozen": "0"}, 
            {"currency": "BTC", "free": "0.2482982056277609", "frozen": "0"}, 
            // ...
        ]
    }
    

• GetAssets

  • method字段：“assets”
  • params字段：

    {}
    

  • 托管者期望通用协议应答的数据：

    {
        "data": [
            {"currency": "TUSD", "free": "3000", "frozen": "0"},
            {"currency": "BTC", "free": "0.2482982056277609", "frozen": "0"}, 
            // ...
        ]
    }
    

• CreateOrder / Buy / Sell

  • method字段：“trade”
  • params字段：

    {"amount":"0.1","price":"1000","symbol":"BTC_USDT","type":"buy"}
    

  • 托管者期望通用协议应答的数据：

    {
        "data": {
            "id": "BTC-USDT,123456"
        }
    }
    

• GetOrders

  • method字段：“orders”
  • params字段：

    {"symbol":"ETH_USDT"}
    

  • 托管者期望通用协议应答的数据：

    {
        "data": [
            {
                "id": "ETH-USDT,123456",
                "symbol": "ETH_USDT",
                "amount": 0.25,
                "price": 1005,
                "deal_amount": 0,
                "avg_price": "1000",
                "type": "buy",         // "buy"、"sell"
                "status": "pending",   // "pending", "pre-submitted", "submitting", "submitted", "partial-filled"
            }, 
            // ...
        ]
    }
    

• GetOrder

  • method字段：“order”
  • params字段：

    {
        "id":"ETH-USDT,123456",       // 策略中调用：exchange.GetOrder("ETH-USDT,123456")
        "symbol":"ETH_USDT"
    }
    

  • 托管者期望通用协议应答的数据：

    { 
        "data": {
            "id": "ETH-USDT,123456",
            "symbol": "ETH_USDT"
            "amount": 0.15,
            "price": 1002,
            "status": "pending",    // "pending", "pre-submitted", "submitting", "submitted", "partial-filled", "filled", "closed", "finished", "partial-canceled", "canceled"
            "deal_amount": 0,
            "type": "buy",          // "buy"、"sell"
            "avg_price": 0,         // 如果交易所没有提供，在处理时可以赋值为0
        }
    }
    

• GetHistoryOrders

  • method字段：“historyorders”
  • params字段：

    {"limit":0,"since":0,"symbol":"ETH_USDT"}
    

  • 托管者期望通用协议应答的数据：

    {
        "data": [
            {
                "id": "ETH-USDT,123456",
                "symbol": "ETH_USDT",
                "amount": 0.25,
                "price": 1005,
                "deal_amount": 0,
                "avg_price": 1000,
                "type": "buy",       // "buy"、"sell"
                "status": "filled",  // "filled"
            }, 
            // ...
        ]
    }
    

• CancelOrder

  • method字段：“cancel”
  • params字段：

    {"id":"ETH-USDT,123456","symbol":"ETH_USDT"}
    

  • 托管者期望通用协议应答的数据：

    {
        "data": true    // 只要该JSON中没有error字段，都默认为撤单成功
    }
    

• IO

  exchange.IO函数用于直接访问交易所接口，例如我们以GET /api/v5/trade/orders-pending, 参数：instType=SPOT，instId=ETH-USDT举例。

  // 策略实例中调用
  exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT&instId=ETH-USDT")
  

  • method字段："__api_/api/v5/trade/orders-pending"，method字段的内容由__api_开始，表示这个是由策略实例中的exchange.IO函数调用触发。
  • params字段：

    {"instId":"ETH-USDT","instType":"SPOT"}   // instType=SPOT&instId=ETH-USDT编码的参数会被还原为JSON
    

  • 托管者期望通用协议应答的数据：

    {
        "data": {"code": "0", "data": [], "msg": ""}    // data属性值为交易所API：GET /api/v5/trade/orders-pending 应答的数据
    }
    

• 其它 策略实例中使用的其它发明者平台API函数，例如： exchange.Go()、exchange.GetRawJSON()等函数无需封装，调用方式、功能不变。

期货交易所

期货交易所支持所有现货交易所的函数之外，还有一些期货交易所特有的API函数。

待实现

• GetPositions
• SetMarginLevel
• GetFundings

Python版本通用协议范例

REST通用协议–接入OKX交易所REST API接口，封装为现货交易所对象。 实现了一个公共接口的请求与应答数据封装。 实现了一个私有接口的签名、请求与应答数据封装。 本范例以测试学习为主，其余接口使用模拟的数据直接应答给托管者，用于测试

import http.server
import socketserver
import json
import urllib.request
import urllib.error
import argparse
import ssl
import hmac
import hashlib
import base64

from datetime import datetime

ssl._create_default_https_context = ssl._create_unverified_context

class BaseProtocol:
    ERR_NOT_SUPPORT = {"error": "not support"}

    def __init__(self, apiBase, accessKey, secretKey):
        self._apiBase = apiBase
        self._accessKey = accessKey
        self._secretKey = secretKey


    def _httpRequest(self, method, path, query="", params={}, addHeaders={}):
        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'
        }

        # add headers
        for key in addHeaders:
            headers[key] = addHeaders[key]

        if method == "GET":
            url = f"{self._apiBase}{path}?{query}" if query != "" else f"{self._apiBase}{path}"
            req = urllib.request.Request(url, method=method, headers=headers)
        else:
            url = f"{self._apiBase}{path}"
            req = urllib.request.Request(url, json.dumps(params, separators=(',', ':')).encode('utf-8'), method=method, headers=headers)
        
        print(f'send request by protocol: {self.exName}, req:', req.method, req.full_url, req.headers, req.data, "\n")

        try:
            with urllib.request.urlopen(req) as resp:
                data = json.loads(resp.read())
        except json.JSONDecodeError:
            data = {"error": "Invalid JSON response"}
        except urllib.error.HTTPError as e:
            data = {"error": f"HTTP error: {e.code}"}
        except urllib.error.URLError as e:
            data = {"error": f"URL error: {e.reason}"}
        except Exception as e:
            data = {"error": f"Exception occurred: {str(e)}"}

        print(f'protocol response received: {self.exName}, resp:', data, "\n")

        return data
    

    def GetTickers(self):
        return self.ERR_NOT_SUPPORT


    def GetMarkets(self):
        return self.ERR_NOT_SUPPORT


    def GetTicker(self, symbol):
        return self.ERR_NOT_SUPPORT


    def GetDepth(self, symbol=""):
        return self.ERR_NOT_SUPPORT


    def GetTrades(self, symbol=""):
        return self.ERR_NOT_SUPPORT


    def GetRecords(self, symbol, period, limit):
        return self.ERR_NOT_SUPPORT


    def GetAssets(self):
        return self.ERR_NOT_SUPPORT


    def GetAccount(self):
        return self.ERR_NOT_SUPPORT


    def CreateOrder(self, symbol, side, price, amount):
        return self.ERR_NOT_SUPPORT


    def GetOrders(self, symbol=""):
        return self.ERR_NOT_SUPPORT


    def GetOrder(self, orderId):
        return self.ERR_NOT_SUPPORT


    def CancelOrder(self, orderId):
        return self.ERR_NOT_SUPPORT


    def GetHistoryOrders(self, symbol, since, limit):
        return self.ERR_NOT_SUPPORT


    def GetPostions(self, symbol=""):
        return self.ERR_NOT_SUPPORT


    def SetMarginLevel(self, symbol, marginLevel):
        return self.ERR_NOT_SUPPORT


    def GetFundings(self, symbol=""):
        return self.ERR_NOT_SUPPORT


    def IO(self, params):
        return self.ERR_NOT_SUPPORT


class ProtocolFactory:
    @staticmethod
    def createExWrapper(apiBase, accessKey, secretKey, exName) -> BaseProtocol:
        if exName == "OKX":
            return CustomProtocolOKX(apiBase, accessKey, secretKey, exName)
        else:
            raise ValueError(f'Unknown exName: {exName}')


class CustomProtocolOKX(BaseProtocol):
    """
    CustomProtocolOKX - OKX API Wrapper

    # TODO: add information.
    """

    def __init__(self, apiBase, accessKey, secretKey, exName):
        secretKeyList = secretKey.split(",")
        self.exName = exName
        self._x_simulated_trading = 0
        if len(secretKeyList) > 1:
            self._passphrase = secretKeyList[1]
            if len(secretKeyList) > 2:
                if secretKeyList[2] == "simulate":
                    self._x_simulated_trading = 1
        else:
            raise ValueError(f"{self.exName}: invalid secretKey format.")
        super().__init__(apiBase, accessKey, secretKeyList[0])


    def getCurrencys(self, symbol):
        baseCurrency, quoteCurrency = "", ""
        arrCurrency = symbol.split("_")
        if len(arrCurrency) == 2:
            baseCurrency = arrCurrency[0]
            quoteCurrency = arrCurrency[1]
        return baseCurrency, quoteCurrency


    def getSymbol(self, instrument):
        arrCurrency = instrument.split("-")
        if len(arrCurrency) == 2:
            baseCurrency = arrCurrency[0]
            quoteCurrency = arrCurrency[1]
        else:
            raise ValueError(f"{self.exName}: invalid instrument: {instrument}")
        return f'{baseCurrency}_{quoteCurrency}'


    def callUnsignedAPI(self, httpMethod, path, query="", params={}):
        return self._httpRequest(httpMethod, path, query, params)


    def callSignedAPI(self, httpMethod, path, query="", params={}):
        strTime = datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S.%f')[:-3] + 'Z'
        if httpMethod == "GET":
            jsonStr = json.dumps(params, separators=(',', ':')) if len(params) > 0 else ""
        else:
            jsonStr = json.dumps(params, separators=(',', ':')) if len(params) > 0 else "{}"
        message = f'{strTime}{httpMethod}{path}{jsonStr}'
        if httpMethod == "GET" and query != "":
            message = f'{strTime}{httpMethod}{path}?{query}{jsonStr}'
        mac = hmac.new(bytes(self._secretKey, encoding='utf8'), bytes(message, encoding='utf-8'), digestmod='sha256')
        signature = base64.b64encode(mac.digest())
        
        headers = {}
        if self._x_simulated_trading == 1:
            headers["x-simulated-trading"] = str(self._x_simulated_trading)
        headers["OK-ACCESS-KEY"] = self._accessKey
        headers["OK-ACCESS-PASSPHRASE"] = self._passphrase
        headers["OK-ACCESS-TIMESTAMP"] = strTime        
        headers["OK-ACCESS-SIGN"] = signature
        return self._httpRequest(httpMethod, path, query, params, headers)

    
    # Encapsulates requests to the exchange API.
    def GetTicker(self, symbol):
        """
        GET /api/v5/market/ticker , param: instId 
        """

        baseCurrency, quoteCurrency = self.getCurrencys(symbol)
        if baseCurrency == "" or quoteCurrency == "":
            return {"error": "invalid symbol"}

        path = "/api/v5/market/ticker"
        query = f'instId={baseCurrency}-{quoteCurrency}'
        data = self.callUnsignedAPI("GET", path, query=query)
        if "error" in data.keys() and "data" not in data.keys():
            return data

        ret_data = {}
        if data["code"] != "0" or not isinstance(data["data"], list):
            return {"error": json.dumps(data, ensure_ascii=False)}
        for tick in data["data"]:
            if not all(k in tick for k in ("instId", "bidPx", "askPx", "high24h", "low24h", "vol24h", "ts")):
                return {"error": json.dumps(data, ensure_ascii=False)}

            ret_data["symbol"] = self.getSymbol(tick["instId"])
            ret_data["buy"] = tick["bidPx"]
            ret_data["sell"] = tick["askPx"]
            ret_data["high"] = tick["high24h"]
            ret_data["low"] = tick["low24h"]
            ret_data["open"] = tick["open24h"]
            ret_data["last"] = tick["last"]
            ret_data["vol"] = tick["vol24h"]
            ret_data["time"] = tick["ts"]

        return {"data": ret_data, "raw": data}


    def GetDepth(self, symbol):
        """
        TODO: Implementation code
        """
        
        # Mock data for testing.
        ret_data = {            
            "time" : 1500793319499,
            "asks" : [
                [1000, 0.5], [1001, 0.23], [1004, 2.1]
            ],
            "bids" : [
                [999, 0.25], [998, 0.8], [995, 1.4]
            ]            
        }
        
        return {"data": ret_data}


    def GetTrades(self, symbol):
        """
        TODO: Implementation code
        """

        # Mock data for testing.
        ret_data = [
            {
                "id": 12232153,
                "time" : 1529919412968,
                "price": 1000,
                "amount": 0.5,
                "type": "buy",
            }, {
                "id": 12545664,
                "time" : 1529919412900,
                "price": 1001,
                "amount": 1,
                "type": "sell",
            }
        ]

        return {"data": ret_data}


    def GetRecords(self, symbol, period, limit):
        """
        TODO: Implementation code
        """

        # Mock data for testing.
        ret_data = [
            [1500793319, 1.1, 2.2, 3.3, 4.4, 5.5],
            [1500793259, 1.01, 2.02, 3.03, 4.04, 5.05],
        ]

        return {"data": ret_data}


    def GetMarkets(self):
        """
        TODO: Implementation code
        """

        ret_data = {}

        return {"data": ret_data}


    def GetTickers(self):
        """
        TODO: Implementation code
        """

        ret_data = {}

        return {"data": ret_data}


    def GetAccount(self):
        """
        GET /api/v5/account/balance
        """

        path = "/api/v5/account/balance"
        data = self.callSignedAPI("GET", path)

        ret_data = []
        if data["code"] != "0" or "data" not in data or not isinstance(data["data"], list):
            return {"error": json.dumps(data, ensure_ascii=False)}
        for ele in data["data"]:
            if "details" not in ele or not isinstance(ele["details"], list):
                return {"error": json.dumps(data, ensure_ascii=False)}
            for detail in ele["details"]:
                asset = {"currency": detail["ccy"], "free": detail["availEq"], "frozen": detail["ordFrozen"]}
                if detail["availEq"] == "":
                    asset["free"] = detail["availBal"]
                ret_data.append(asset)
        return {"data": ret_data, "raw": data}


    def GetAssets(self):
        """
        TODO: Implementation code
        """
        
        # Mock data for testing.
        ret_data = [
            {"currency": "TUSD", "free": "3000", "frozen": "0"},
            {"currency": "BTC", "free": "0.2482982056277609", "frozen": "0"}
        ]

        return {"data": ret_data}


    def CreateOrder(self, symbol, side, price, amount):
        """
        TODO: Implementation code
        """
        
        # Mock data for testing.
        ret_data = {
            "id": "BTC-USDT,123456"
        }

        return {"data": ret_data}

    
    def GetOrders(self, symbol):
        """
        GET /api/v5/trade/orders-pending  instType SPOT instId  after limit
        """
        
        baseCurrency, quoteCurrency = self.getCurrencys(symbol)
        if baseCurrency == "" or quoteCurrency == "":
            return {"error": "invalid symbol"}

        path = "/api/v5/trade/orders-pending"
        after = ""
        limit = 100

        ret_data = []
        while True:
            query = f"instType=SPOT&instId={baseCurrency}-{quoteCurrency}&limit={limit}"
            if after != "":
                query = f"instType=SPOT&instId={baseCurrency}-{quoteCurrency}&limit={limit}&after={after}"
        
            data = self.callSignedAPI("GET", path, query=query)
            
            if data["code"] != "0" or not isinstance(data["data"], list):
                return {"error": json.dumps(data, ensure_ascii=False)}
            for ele in data["data"]:
                order = {}

                order["id"] = f'{ele["instId"]},{ele["ordId"]}'
                order["symbol"] = f'{baseCurrency}-{quoteCurrency}'
                order["amount"] = ele["sz"]
                order["price"] = ele["px"]
                order["deal_amount"] = ele["accFillSz"]
                order["avg_price"] = 0 if ele["avgPx"] == "" else ele["avgPx"]
                order["type"] = "buy" if ele["side"] == "buy" else "sell"
                order["state"] = "pending"

                ret_data.append(order)
                after = ele["ordId"]

            if len(data["data"]) < limit:
                break

        return {"data": ret_data}


    def GetOrder(self, orderId):
        """
        TODO: Implementation code
        """
        
        # Mock data for testing.
        ret_data = {
            "id": "ETH-USDT,123456",
            "symbol": "ETH_USDT",
            "amount": 0.15,
            "price": 1002,
            "status": "pending",
            "deal_amount": 0,
            "type": "buy",
            "avg_price": 0,
        }

        return {"data": ret_data}


    def GetHistoryOrders(self, symbol, since, limit):
        """
        TODO: Implementation code
        """

        # Mock data for testing.
        ret_data = [
            {
                "id": "ETH-USDT,123456",
                "symbol": "ETH_USDT",
                "amount": 0.25,
                "price": 1005,
                "deal_amount": 0,
                "avg_price": 1000,
                "type": "buy",
                "status": "filled"
            }
        ]

        return {"data": ret_data}


    def CancelOrder(self, orderId):
        """
        TODO: Implementation code
        """

        # Mock data for testing.
        ret_data = True

        return {"data": ret_data}


    def IO(self, httpMethod, path, params={}):
        if httpMethod == "GET":
            query = urllib.parse.urlencode(params)
            data = self.callSignedAPI(httpMethod, path, query=query)
        else:
            data = self.callSignedAPI(httpMethod, path, params=params)
        
        if data["code"] != "0":
            return {"error": json.dumps(data, ensure_ascii=False)}

        return {"data": data}


class HttpServer(http.server.SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        self.request_body = None
        self.request_path = None
        super().__init__(*args, **kwargs)


    def log_message(self, format, *args):
        return 


    def _sendResponse(self, body):
        self.send_response(200)
        self.send_header('Content-type', 'application/json; charset=utf-8')
        self.end_headers()
        self.wfile.write(json.dumps(body).encode('utf-8'))


    def do_GET(self):
        # The FMZ.COM custom protocol only send GET method request
        self._sendResponse({"error": "not support GET method."})


    def do_POST(self):
        """
        Returns:
            json: success, {"data": ...}
            json: error,   {"error": ...}
        """

        contentLen = int(self.headers['Content-Length'])
        self.request_body = self.rfile.read(contentLen)
        self.request_path = self.path
        exName = self.request_path.lstrip("/")

        # Print the request received from the FMZ.COM robot
        print(f"--------- request received from the FMZ.COM robot: --------- \n {self.requestline} | Body: {self.request_body} | Headers: {self.headers} \n")

        try:
            data = json.loads(self.request_body)
        except json.JSONDecodeError:
            data = {"error": self.request_body.decode('utf-8')}
            self._sendResponse(data)
            return 

        # fault tolerant
        if not all(k in data for k in ("access_key", "secret_key", "method", "params")):
            data = {"error": "missing required parameters"}
            self._sendResponse(data)
            return

        respData = {}
        accessKey = data["access_key"]
        secretKey = data["secret_key"]
        method = data["method"]
        params = data["params"]
        exchange = ProtocolFactory.createExWrapper("https://www.okx.com", accessKey, secretKey, exName)

        if method == "ticker":
            symbol = str(params["symbol"]).upper()
            respData = exchange.GetTicker(symbol)
        elif method == "depth":
            symbol = str(params["symbol"]).upper()
            respData = exchange.GetDepth(symbol)
        elif method == "trades":
            symbol = str(params["symbol"]).upper()
            respData = exchange.GetTrades(symbol)
        elif method == "records":
            symbol = str(params["symbol"]).upper()
            period = int(params["period"])
            limit = int(params["limit"])
            respData = exchange.GetRecords(symbol, period, limit)
        elif method == "accounts":
            respData = exchange.GetAccount()
        elif method == "assets":
            respData = exchange.GetAssets()
        elif method == "trade":
            amount = float(params["amount"])
            price = float(params["price"])
            symbol = str(params["symbol"])
            tradeType = str(params["type"])
            respData = exchange.CreateOrder(symbol, tradeType, price, amount)
        elif method == "orders":
            symbol = str(params["symbol"]).upper()
            respData = exchange.GetOrders(symbol)
        elif method == "order":
            orderId = str(params["id"])
            respData = exchange.GetOrder(orderId)
        elif method == "historyorders":
            symbol = str(params["symbol"])
            since = int(params["since"])
            limit = int(params["limit"])
            respData = exchange.GetHistoryOrders(symbol, since, limit)
        elif method == "cancel":
            orderId = str(params["id"])
            respData = exchange.CancelOrder(orderId)
        elif method[:6] == "__api_":
            respData = exchange.IO(self.headers["Http-Method"], method[6:], params)
        else:
            respData = {"error": f'invalid method: {method}'}

        # Print the response to send to FMZ.COM robot
        print(f"response to send to FMZ.COM robot: {respData} \n")

        self._sendResponse(respData)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Run a FMZ.COM custom protocol plugin.")
    parser.add_argument("--port", type=int, default=6666, help="Port to run the server on.")
    parser.add_argument("--address", type=str, default="localhost", help="Address to bind the server to.")
    args = parser.parse_args() 

    with socketserver.TCPServer((args.address, args.port), HttpServer) as httpd:
        print(f"running... {args.address}:{args.port}", "\n")
        httpd.serve_forever()