The resource loading... loading...

Inventors Quantified Exchange Platforms General Protocol Access Guide

Author: Inventors quantify - small dreams, Created: 2024-10-29 14:37:56, Updated: 2024-11-12 21:58:55

[TOC]

The inventor quantified trading platform supports a large number of cryptocurrency exchanges and encapsulates the mainstream exchanges on the market. However, there are still many exchanges that are not encapsulated, and users who need to use these exchanges can access them through the inventor quantified general protocol. Not limited to cryptocurrency exchanges, any supportRESTAgreement orFIXThe platforms of the protocol are also accessible.

This article will focus on:RESTProtocol access, for example, explains how to use the inventor's Quantified Trading Platform General Protocol to encapsulate and access the OKX Exchange API. This article refers to the REST General Protocol unless otherwise specified.

The workflow of the General Agreement is as follows: Request process: Policy instances running on the trustee -> General protocols -> Exchange API Response process: Exchange API -> General protocols -> Policy instances running on the custodian

1 Configure the exchange

Inventors of Quantitative Trading Platforms Configure their Exchanges:

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

Choose the protocol: Choose the "General Protocol".
Service address: The General Protocol Program is essentially an RPC service This is why it is necessary to specify the service address, port, etc. clearly when configuring the exchange.托管者上运行的策略实例 -> 通用协议程序In the process, the trustee knows where to access the protocol procedure. For example:http://127.0.0.1:6666/OKXThe protocol is usually run on the same device (server) as the host, so the service address is written to the localhost, and the port is used for an unoccupied system.
Access Key： 托管者上运行的策略实例 -> 通用协议程序In the process, exchange configuration information is passed on.
Secret Key： 托管者上运行的策略实例 -> 通用协议程序In the process, exchange configuration information is passed on.
This is not the first time. The inventor quantifies the exchange's object tags on the trading platform, which are used to identify an exchange object.

A screenshot of the OKX plug-in configuration that was made public in the article is below:

OKX's secret key configuration information:

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

2. Deploy hosts and common protocols (plugins)

1st, the administrator Any strategy that runs on the inventor's Quantitative Trading Platform must have a host deployed, and the specific deployment host can refer to the platform tutorial, which is not discussed here.
2, General protocol program (plugin) The host and the general protocol are usually deployed on the same device, and the general protocol ((service)) program can be written in any language to design, and this article is written in Python3 and can be executed directly (as with running any Python program) (pre-configured Python environment). Of course, there is also support for running python programs on FMZ, and the general protocol can also be run as a hard drive to provide inventors with a quantified trading platform for unpackaged exchange API access. After the General Protocol procedure is run, start listening:http://127.0.0.1:6666In general protocol procedures, a specific path can be used, for example/OKXI have to go to work.

3, Policy instance requests the FMZ API function

When the FMZ platform's API function is called in the policy, the UTP receives a request from the host. Debugging tools can also be tested using the platform, such as:

Debugging tools page:

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

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

Callingexchange.GetTicker()Function, the general protocol processor receives the request:

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

access_key: The exchange secret key configured when the platform "configures the exchange" in the above text
secret_key: The secret key of the exchange configured when the platform "configures the exchange" in the text above
method: Related to calling the interface in the policy, callingexchange.GetTicker()I'm not going to lie.methodI mean,ticker。
Nonce: The time when the request was made.
Params: Parameters that are relevant when an interface call occurs in the policy, in this caseexchange.GetTicker()When called, the relevant parameters are:{"symbol":"LTC_USDT"}。

4, General protocol procedure to access the exchange interface

When a protocol processor receives a request from a trustee, it can know the following information from the information carried in the request: the platform API function (including parameter information) requested by the policy, the secret key of the exchange, etc.

Based on this information, the general protocol program can access the exchange's interface, obtain the required data or perform certain operations.

Usually exchange interfaces have methods such as GET/POST/PUT/DELETE, divided into public and private interfaces.

Public Interface: Interface that does not require signature verification, requested directly in the general protocol procedure.
Private interfaces: Interfaces that require signature verification, which require a signature in a general protocol process, and then request API interfaces from these exchanges.

The General Protocol process receives exchange interface response data for further processing, which constitutes the data expected by the custodian (see below). Refer to OKX spot exchange, a custom protocol implementation of the OKX class in the Python General Protocol paradigmGetTicker、GetAccountLet's say that we have an even function.

5. The protocol processor returns the data to the host

When a general protocol program accesses an exchange's API interface, performs certain operations or obtains certain data, it needs to feed back the results to the custodian.

Feedback to the administrator data varies depending on the interface the policy calls from, and is first divided into two categories:

The exchange interface was successfully invoked by the General Protocol process:
```
{
    "data": null,  // "data" can be of any type 
    "raw": null    // "raw" can be of any type 
}
```
- data: the specific structure of the field and the request received by the general protocol processormethodRelated, the data structures that are used to construct the final return of the FMZ platform API function are listed below.
- raw: This field can pass raw data to the exchange API response, such asexchange.GetTicker()The ticker structure that the function returns, recorded in the Info field of the ticker structure israwFields anddataThe data of the fields; the API functions of the platform, some of which do not require this data.
Failed to call the exchange interface (business error, network error, etc.)
```
{
    "error": ""    // "error" contains an error message as a string
}
```
- error: error message, which is displayed in the error log of the page log area of the FMZ platform hard disk, debugging tool etc.;

The following is a summary of the general protocol response data received by the demonstration strategy program:

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

Data structure agreements in the common protocol

The above is a brief process for the general protocol program involved in accessing the FMZ unwrapped exchange API, which only explains the call in the FMZ platform debugging tool.exchange.GetTicker()The process when a function is created. The following details the interaction of all platform API functions.

The platform encapsulates the common functionality of the various exchanges and unifies them into a function, such as the GetTicker function, which requests the current market information of a certain variety, which is basically the API available to all exchanges. So when the policy instance accesses the API interface encapsulated by the platform, the administrator sends a request to the "General Protocol" plugin (as mentioned above):

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

When an API function (such as GetTicker) that is wrapped in a different inventor platform is called in the policy, the request format that the host sends to the universal protocol will also be different.methodandparams◦ When designing a general protocol, use the following principles:methodThe following are the request-response scenarios for all interfaces.

The spot market

For example, the current trading pair is:ETH_USDTThe data that the administrator expects to be responded to by the protocol is written primarily in the data field, and a raw field can be added to record the raw data of the exchange interface.

GetTicker

method field: ticker tick
Params field:
```
{"symbol":"ETH_USDT"}
```