우리는 FMZ 양자 거래 플랫폼은 많은 암호화폐 거래소를 지원하고 시장의 주류 거래소를 캡슐화합니다. 그러나 아직 캡슐화되지 않은 많은 거래소가 있습니다. 이러한 거래소를 사용해야하는 사용자는 FMZ 양자 사용자 지정 프로토콜을 통해 액세스 할 수 있습니다. 암호화폐 거래소에 국한되지 않고,REST프로토콜 또는FIX또한 프로토콜에 액세스 할 수 있습니다.
이 기사 는REST접근 프로토콜은 예를 들어 FMZ 퀀트 트레이딩 플랫폼의 사용자 지정 프로토콜을 사용하여 OKX 거래소의 API를 캡슐화하고 액세스하는 방법을 설명합니다. 달리 명시되지 않는 한이 기사는 REST 사용자 지정 프로토콜을 참조합니다.
FMZ 양자 거래 플랫폼에서 교환을 구성하는 페이지:
https://www.fmz.com/m/platforms/add
Strategy instance running on the docker -> Custom protocol program
...
예를 들어:http://127.0.0.1:6666/OKX
, 사용자 지정 프로토콜 프로그램과 도커는 일반적으로 동일한 장치 (서버) 에서 실행되므로 서비스 주소는 로컬 머신 (localhost) 으로 작성되며 포트는 시스템에서 차지하지 않는 포트로 사용될 수 있습니다.Strategy instance running on the docker -> Custom protocol program
.Strategy instance running on the docker -> Custom protocol program
.문서에서 공개된 OKX 플러그인 구성의 스크린샷은 다음과 같습니다.
OKX 교환 비밀 키 구성 정보:
accessKey: accesskey123 // accesskey123, these are not actual keys, just for demonstration
secretKey: secretkey123
passphrase: passphrase123
http://127.0.0.1:6666
사용자 지정 프로토콜 프로그램은 특정 경로를 처리할 수 있습니다./OKX
.전략에서 (FMZ) 플랫폼 API 함수가 호출되면 사용자 지정 프로토콜 프로그램은 도커로부터 요청을 받게 됩니다. 또한 플랫폼의 디버깅 도구를 사용하여 테스트 할 수 있습니다. 예를 들어:
디버깅 도구 페이지:
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"
}
exchange.GetTicker()
, method
이ticker
.exchange.GetTicker()
, 관련 매개 변수는 다음과 같습니다:{"symbol":"LTC_USDT"}
.사용자 지정 프로토콜 프로그램이 도커로부터 요청을 수신할 때, 요청에 포함된 정보에 기초하여 전략에 의해 요청된 플랫폼 API 함수 (패라미터 정보 포함) 와 같은 정보를 얻을 수 있다.
이 정보에 기초하여, 사용자 지정 프로토콜 프로그램은 교환 인터페이스에 액세스하여 필요한 데이터를 얻거나 특정 작업을 수행 할 수 있습니다.
일반적으로 교환 인터페이스는 공개 인터페이스와 개인 인터페이스로 나뉘는 GET/POST/PUT/DELETE와 같은 방법을 가지고 있습니다.
사용자 지정 프로토콜 프로그램은 교환 인터페이스에서 응답 데이터를 수신하고 더 나아가 처리하여 도커가 기대하는 데이터를 구성합니다.GetTicker
, GetAccount
그리고 파이썬 사용자 지정 프로토콜 예제에서 CustomProtocolOKX 클래스 구현에 있는 다른 함수.
커스텀 프로토콜 프로그램이 교환 API 인터페이스에 액세스하여 특정 작업을 수행하거나 특정 데이터를 얻으면 결과를 도커에 전달해야합니다.
도커에 다시 입력되는 데이터는 전략에 의해 호출되는 인터페이스에 따라 다양하며 먼저 두 가지 범주로 나
{
"data": null, // "data" can be of any type
"raw": null // "raw" can be of any type
}
데이터: 이 필드의 특정 구조는method
사용자 지정 프로토콜 프로그램에서 수신된 요청에서, 그리고 FMZ 플랫폼 API 함수로 최종적으로 반환된 데이터 구조를 구성하는 데 사용됩니다. 모든 인터페이스는 아래에 나열됩니다.
raw: 이 필드는 교환 API 인터페이스 응답의 RAW 데이터를 전달하는 데 사용할 수 있습니다.exchange.GetTicker()
틱커 구조의 정보 필드는raw
현장 및data
일부 플랫폼의 API 기능은 이 데이터를 필요로 하지 않습니다.
{
"error": "" // "error" contains an error message as a string
}
오류: 오류 정보, 이는 FMZ 플랫폼 라이브 거래, 디버깅 도구 및 다른 페이지의 로그 영역의 오류 로그에 표시됩니다.
전략 프로그램에서 수신된 사용자 지정 프로토콜 응답 데이터를 보여줍니다.
// Tested in the debugging tool of the FMZ platform
function main() {
Log(exchange.GetTicker("USDT")) // The trading pair is incomplete, the BaseCurrency part is missing, and the custom protocol plug-in is required to return an error message: {"error": "..."}
Log(exchange.GetTicker("LTC_USDT"))
}
위는 (FMZ unpackaged) 교환 API에 액세스하는 데 참여하는 사용자 지정 프로토콜 프로그램의 간단한 과정입니다. 이 과정은 단지 프로세스를 설명합니다.exchange.GetTicker()
(FMZ) 플랫폼 디버깅 툴의 기능입니다. 다음은 모든 플랫폼 API 기능의 상호 작용 세부 사항을 자세히 설명합니다.
이 플랫폼은 다양한 거래소의 공통 기능을 캡슐화하고 특정 제품의 현재 시장 정보를 요청하는 GetTicker 함수와 같은 특정 기능으로 통합합니다. 이것은 기본적으로 모든 거래소가 가진 API입니다. 따라서 전략 인스턴스에서 플랫폼에 의해 캡슐화 된 API 인터페이스에 액세스 할 때 도커는
POST /OKX HTTP/1.1
{
"access_key": "xxx",
"method": "ticker",
"nonce": 1730275031047002000,
"params": {"symbol":"LTC_USDT"},
"secret_key": "xxx"
}
다른 FMZ 플랫폼에서 캡슐화된 API 함수를 전략 (GetTicker와 같이) 으로 호출할 때, 사용자 지정 프로토콜로 도커가 보내는 요청 형식도 다를 것입니다. 몸의 데이터 (JSON) 는method
그리고params
. 사용자 지정 프로토콜을 설계할 때, 메소드의 내용에 따라 특정 작업을 수행합니다. 다음은 모든 인터페이스의 요청-대응 시나리오입니다.
예를 들어, 현재 거래 쌍은:ETH_USDT
도커가 사용자 지정 프로토콜이 응답하기를 기대하는 데이터는 주로 데이터 필드에 기록되며 원시 필드도 추가하여 교환 인터페이스의 원래 데이터를 기록할 수 있습니다.
방법 필드:
{"symbol":"ETH_USDT"}
사용자 지정 프로토콜 응답에서 도커가 기대하는 데이터:
{
"data": {
"symbol": "ETH_USDT", // Corresponds to the Symbol field in the Ticker structure returned by the GetTicker function
"buy": "2922.18", // ...corresponds to the Buy field
"sell": "2922.19",
"high": "2955",
"low": "2775.15",
"open": "2787.72",
"last": "2922.18",
"vol": "249400.888156",
"time": "1731028903911"
},
"raw": {} // A raw field can be added to record the raw data of the exchange API interface response
}
방법 필드:
{"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]
// ...
]
}
}
방법 필드:
{"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",
}
// ...
]
}
방법 필드:
{
"limit":"500",
"period":"60", // 60 minutes
"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],
// ...
]
}
방법 필드:
{}
사용자 지정 프로토콜 응답에서 도커가 기대하는 데이터:
{}
방법 필드:
{}
사용자 지정 프로토콜 응답에서 도커가 기대하는 데이터:
{}
방법 필드:
{}
사용자 지정 프로토콜 응답에서 도커가 기대하는 데이터:
{
"data": [
{"currency": "TUSD", "free": "3000", "frozen": "0"},
{"currency": "BTC", "free": "0.2482982056277609", "frozen": "0"},
// ...
]
}
방법 필드:
{}
사용자 지정 프로토콜 응답에서 도커가 기대하는 데이터:
{
"data": [
{"currency": "TUSD", "free": "3000", "frozen": "0"},
{"currency": "BTC", "free": "0.2482982056277609", "frozen": "0"},
// ...
]
}
방법 필드:
{"amount":"0.1","price":"1000","symbol":"BTC_USDT","type":"buy"}
사용자 지정 프로토콜 응답에서 도커가 기대하는 데이터:
{
"data": {
"id": "BTC-USDT,123456"
}
}
방법 필드:
{"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"
},
// ...
]
}
방법 필드:
{
"id":"ETH-USDT,123456", // Calling in the strategy: 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, // If the exchange does not provide it, it can be assigned a value of 0 during processing.
}
}
방법 필드:
{"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"
},
// ...
]
}
방법 필드:
{"id":"ETH-USDT,123456","symbol":"ETH_USDT"}
사용자 지정 프로토콜 응답에서 도커가 기대하는 데이터:
{
"data": true // As long as there is no error field in the JSON, the order cancellation is considered successful by default.
}
이exchange.IO이 함수는 교환 인터페이스에 직접 액세스하는 데 사용됩니다. 예를 들어,
GET /api/v5/trade/orders-pending, parameters: instType=SPOT, instId=ETH-USDT
예를 들어
// Called in the strategy instance
exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT&instId=ETH-USDT")
방법 필드:"__api_/api/v5/trade/orders-pending"
, 방법 필드는 _로 시작합니다.아피, 이 현상이exchange.IO전략 인스턴스에서 함수 호출.
패람스 필드:
{"instId":"ETH-USDT","instType":"SPOT"} // instType=SPOT&instId=ETH-USDT encoded parameters will be restored to JSON
사용자 지정 프로토콜 응답에서 도커가 기대하는 데이터:
{
"data": {"code": "0", "data": [], "msg": ""} // The data attribute value is the data of the exchange API: GET /api/v5/trade/orders-pending response
}
exchange.Go()
, exchange.GetRawJSON()
그리고 다른 함수는 캡슐화 할 필요가 없으며 호출 방법과 함수는 변하지 않습니다.포트 거래소의 모든 기능을 지원하는 것 외에도 미래에셋 거래소는 미래에셋 거래소에 고유한 일부 API 기능을 가지고 있습니다.
시행될 것
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'
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()