리소스 로딩... 로딩...
  1. 포럼
  2. 도움
  3. FMZ API 지침

FMZ API 지침

저자:제로, 제작: 2020-04-20 10:19:00, 업데이트: 2023-04-12 14:44:56

마지막 10 로그에서 나머지 삭제 로그리셋 (LogReset))
}


```Python
def main():
    LogReset(10)

void main() {
    LogReset(10);
}

로그바큐움

LogVacuum()전화 한 후LogReset()로그를 청소하는 기능, 저장 공간을 복구SQLite데이터를 삭제할 때 함수는 값을 반환하지 않습니다. 그 이유는SQLite데이터를 삭제할 때 점유된 공간을 복구하지 않습니다, 그래서 수행해야 합니다VACUUM이 함수가 호출되면 파일 이동 작업은 큰 지연으로 발생합니다. 적절한 시간 간격에서 호출하는 것이 좋습니다.

시장 코팅 API

주요 시장 인터페이스 기능:

함수 이름 설명
GetTicker 틱 코타 데이터
GetRecords K-라인 데이터를 가져오세요
깊이를 얻으십시오 주문서 데이터 (오더 깊이 데이터) 를 얻는다
GetTrades 시장에서 최신 거래 기록을 얻으십시오

다음 함수들을 호출할 수 있습니다exchange또는exchanges[0]물체, 예를 들어: 함수,exchange.GetTicker();또는exchanges[0].GetTicker();, 현재 거래 쌍의 시장 코트를 반환하고 계약 설정.

네트워크 접속으로 API 함수를 호출하는 중요한 팁:플랫폼 인터페이스에 액세스하는 API 함수를 호출할 때 (예:exchange.GetTicker(), exchange.Buy(Price, Amount), exchange.CancelOrder(Id), 등), 액세스 실패는 아마도 여러 가지 이유로 인해 발생합니다. 따라서 우리는 이러한 함수의 호출을 위해 오류 용인 처리해야합니다. 예를 들어:exchange.GetTicker()시장 데이터를 얻기 위한 기능이 플랫폼 서버 문제와 네트워크 전송 문제 등으로 인해exchange.GetTicker()함수는null그러면, 반환 값은exchange.GetTicker()오류 용인 처리로 처리되어야 합니다.

이 자료는exchange.GetTicker()다음 코드의 함수는ticker변수, 그리고 우리는 사용 하기 전에 결함 관용을 처리해야합니다ticker variable.

function main() {
    var ticker = exchange.GetTicker()
    if(!ticker){
        // Recall once, or use other processing logic
        ticker = exchange.GetTicker()
    }
}

def main():
    ticker = exchange.GetTicker()
    if not ticker:
        ticker = exchange.GetTicker()

void main() {
    auto ticker = exchange.GetTicker();
    if(!ticker.Valid) {
        ticker = exchange.GetTicker();
        Log("Test");
    }
}

또한 FMZ는 전략의 장애 내성 성능 테스트를 위해결함 용인 모드백테스트 시스템. 백테스트 시스템은 설정된 매개 변수에 따라 네트워크에 액세스 할 때 발생하는 일부 API 호출을 무작위로 반환하고 일부 실패한 호출의 반환 값을 반환 할 수 있습니다. 당신은 봇에서 프로그램의 견고성을 빠르게 테스트 할 수 있습니다. 전략 편집 페이지의 백테스트 시스템 페이지로 전환,역삼각형Start Backtest 버튼의 오른쪽에 있는 드롭다운 컨트롤, 그리고 Backtest Fault Tolerant 버튼이 팝업합니다.

교환.GetTicker()

exchange.GetTicker()현재 거래 쌍과 계약의 현재 시장 코팅을 얻으며 수익값은:Ticker구조. 백테스트 시스템에서는Ticker이 자료는exchange.GetTicker()함수,High그리고Low현재 판매 1 및 구입 1의 현재 시간에서 가져온 시뮬레이션 값입니다. 실제 실행에서 암호화폐는 거래소에서 정의된 특정 기간 동안 가장 높은 가격과 가장 낮은 가격입니다.Tick interface.

function main(){
    var ticker = exchange.GetTicker()
    /*
        The platform interface may not be accessible due to network problems (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, ticker is null, when accessing ticker. When it is "High", it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Volume:", ticker.Volume)
}

def main():
    ticker = exchange.GetTicker()
    Log("High:", ticker["High"], "Low:", ticker["Low"], "Sell:", ticker["Sell"], "Buy:", ticker["Buy"], "Last:", ticker["Last"], "Volume:", ticker["Volume"])

void main() {
    auto ticker = exchange.GetTicker();
    Log("High:", ticker.High, "Low:", ticker.Low, "Sell:", ticker.Sell, "Buy:", ticker.Buy, "Last:", ticker.Last, "Volume:", ticker.Volume);
}

실제 봇에서 (백테스트가 아닌)Info귀환 값의 속성exchange.GetTicker()이 함수는 인터페이스가 호출될 때 반환된 원래 데이터를 저장합니다.

교환.그트데프스 (GetDepth))

exchange.GetDepth()현재 거래 쌍과 계약의 교환 주문 서적 데이터를 얻습니다. 반환 값:Depth structure.

Depth구조는 구조의 두 배열을 포함합니다.Asks[]그리고Bids[], Asks그리고Bids다음의 구조 변수를 포함합니다.

데이터 타입 변수 이름 설명
번호 가격 가격
번호 금액 금액

예를 들어, 만약 제가 현재 판매 2차 가격을 얻고 싶다면,

function main(){
    var depth = exchange.GetDepth()
    /*
       The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
       At this time, depth is null. When accessing depth.Asks[1].Price, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    var price = depth.Asks[1].Price
    Log("Sell 2 price is:", price)
}

def main():
    depth = exchange.GetDepth()
    price = depth["Asks"][1]["Price"]
    Log("Sell 2 price is:", price)

void main() {
    auto depth = exchange.GetDepth();
    auto price = depth.Asks[1].Price;
    Log("Sell 2 price is:", price);
}

거래소.GetTrades

exchange.GetTrades()플랫폼 거래 역사 (당신의 것이 아닙니다) 를 얻습니다. 반환 값:Trade구조 배열. 일부 거래소는 그것을 지원하지 않습니다. 특정 상황에 따라 범위 내의 거래 기록에 따라 반환되는 특정 데이터는 다릅니다. 반환된 데이터는 배열입니다. 각 요소의 시간 순서는exchange.GetRecords함수, 즉, 배열의 마지막 요소는 현재 시간에 가장 가까운 데이터입니다.

// In the simulated backtest, the data is empty; to have a trading history, there must be a real bot running
function main(){
    var trades = exchange.GetTrades()
    /*
        The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, "trades" is null. When accessing trades[0].Id, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type)
}

def main():
    trades = exchange.GetTrades()
    Log("id:", trades[0]["Id"], "time:", trades[0]["Time"], "Price:", trades[0]["Price"], "Amount:", trades[0]["Amount"], "type:", trades[0]["Type"])

void main() {
    auto trades = exchange.GetTrades();
    Log("id:", trades[0].Id, "time:", trades[0].Time, "Price:", trades[0].Price, "Amount:", trades[0].Amount, "type:", trades[0].Type);
}

교환.GetRecords()

exchange.GetRecords(Period)K-라인 기간은 로봇을 만들 때 지정됩니다.exchange.GetRecords()함수가 호출되면, 얻은 데이터는 매개 변수 기간에 대응하는 K-라인 데이터입니다. 지정된 매개 변수가 없다면, K-라인 데이터는 bot 매개 변수에서 설정된 K-라인 기간 또는 백테스트 페이지에서 설정된 K-라인 기간에 따라 반환됩니다.

매개 변수Period:

  • PERIOD_M1: 1분
  • PERIOD_M5: 5분
  • PERIOD_M15: 15분
  • PERIOD_M30: 30분
  • H1 기간: 1시간을 의미합니다
  • 기간_D1: 1일 파라미터 값Period위와 같이 정의된 표준 기간을 통과할 수 있을 뿐 아니라 초 단위로 숫자를 통과할 수도 있습니다.

반환 값은exchange.GetRecords(Period)기능: 반환 값은 배열입니다Record구조, 반환 K-선 데이터는 시간이 지남에 따라 축적됩니다, 축적된 K-선 바의 상한 한계는exchange.SetMaxBarLen함수 설정. 설정되지 않은 경우 기본 상위 제한은 5000 K-라인 바입니다. K-라인 데이터가 K-라인 바 축적 제한에 도달하면 K-라인 바를 추가하고 가장 오래된 K-라인 바를 삭제하여 업데이트됩니다. 일부 거래소는 K-라인 인터페이스를 제공하지 않으므로 도커는 K-라인을 생성하기 위해 실시간으로 시장 거래 기록을 수집합니다.

K-라인 바의 수GetRecords이 함수는 처음에 호출됩니다.

  • 백트테스팅 기간의 시작 순간에 처음 1000개의 K-라인 바를 백트테스팅 시스템에서 초기 K-라인 데이터로 미리 취합니다.
  • 실제 봇에서 획득해야 하는 K-라인 바의 특정 수는 거래소의 K-라인 인터페이스를 통해 획득할 수 있는 최대 양의 데이터에 기반합니다.

의 경우exchange.GetRecords(Period)기능, bot 및 backtest암호화폐둘 다 사용자 정의 기간을 지원, 그리고 매개 변수Period초의 수입니다. 예를 들어:

function main() {
    // Print K-line data with a K-line period of 120 seconds (2 minutes)
    Log(exchange.GetRecords(60 * 2))         
    // Print K-line data with a K-line period of 5 minutes
    Log(exchange.GetRecords(PERIOD_M5))      
}

def main():
    Log(exchange.GetRecords(60 * 2))
    Log(exchange.GetRecords(PERIOD_M5))

void main() {
    Log(exchange.GetRecords(60 * 2)[0]);
    Log(exchange.GetRecords(PERIOD_M5)[0]);
}

설정Period파라미터 5는 5초의 기간으로 K-라인 데이터를 요청하는 것입니다. 만약Period매개 변수 60에 의해 균등하게 나뉘지 않습니다 (즉, 표시된 기간은 사용할 수 없는 분의 기간입니다), 시스템의 하단 계층은GetTrades거래 기록 데이터를 얻고 필요한 K-라인 데이터를 합성합니다. 만약Period매개 변수를 60로 균등하게 나누면, 필요한 K선 데이터를 최소 1분 K선 데이터를 사용하여 합성합니다 (가능하면 필요한 K선 데이터를 합성하기 위해 더 큰 기간을 사용하십시오).

function main(){
    var records = exchange.GetRecords(PERIOD_H1)
    /*
        The platform interface may not be accessible due to network reasons (even if the device's docker program can open the platform website, the API may not be accessible)
        At this time, "records" is null. When accessing records[0].Time, it will cause an error; so when testing, ensure that you can access the platform interface
    */
    Log("The first k-line data is, Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High)
    Log("The second k-line data is, Time:", records[1].Time ,"Close:", records[1].Close)
    Log("Current K-line (latest)", records[records.length-1], "Current K-line (latest)", records[records.length-2])
}

def main():
    records = exchange.GetRecords(PERIOD_H1)
    Log("The first k-line data is, Time:", records[0]["Time"], "Open:", records[0]["Open"], "High:", records[0]["High"])
    Log("The second k-line data is, Time:", records[1]["Time"], "Close:", records[1]["Close"])
    Log("Current K-line (latest)", records[-1], "Current K-line (latest)", records[-2])

void main() {
    auto records = exchange.GetRecords(PERIOD_H1);
    Log("The first k-line data is, Time:", records[0].Time, "Open:", records[0].Open, "High:", records[0].High);
    Log("The second k-line data is, Time:", records[1].Time, "Close:", records[1].Close);
    Log("Current K-line (latest)", records[records.size() - 1], "Current K-line (latest)", records[records.size() - 2]);
}

exchange.GetRecords()함수는 K선 데이터를 얻기 위해 두 가지 조건을 가지고 있습니다.

  • 교환은 K-라인 데이터 인터페이스를 제공합니다. 이 경우 획득 된 데이터는 교환이 직접 반환하는 데이터입니다.

  • 거래소는 K-라인 데이터 인터페이스를 제공하지 않습니다. FMZ 도커 프로그램은 전략 프로그램이 호출 할 때마다 거래소의 최신 거래 기록을 얻습니다.exchange.GetRecords(), 즉, 그것은exchange.GetTrades()데이터를 얻고 K-라인 데이터를 합성하는 기능.

시스템에서 시뮬레이션 수준의 백테스트는하위 K-라인 기간(백테스팅 시스템이 백테스팅의 수준을 시뮬레이션 할 때, 해당 K-라인 데이터는 세트에 따라 틱 데이터를 생성하는 데 사용됩니다.하위 K-라인 기간이 전략에서 얻은 K-라인 데이터의 기간은하위 K-라인 기간왜냐하면 시뮬레이션 수준의 백테스트에서 각 기간의 K-라인 데이터는 백테스트 시스템에서 기본 K-라인 기간에 대응하는 K-라인 데이터에 의해 합성되기 때문입니다.

들어와cpp만약 여러분이 여러분의 K-라인 데이터를 구축해야 한다면, 다음의 코드 예가 있습니다.

#include <sstream>
void main() { 
    Records r;
    r.Valid = true;
    for (auto i = 0; i < 10; i++) {
        Record ele;
        ele.Time = i * 100000;
        ele.High = i * 10000;
        ele.Low = i * 1000;
        ele.Close = i * 100;
        ele.Open = i * 10;
        ele.Volume = i * 1;
        r.push_back(ele);
    }
    // Output display: Records[10]
    Log(r);                      
    auto ma = TA.MA(r,10);       
    // Output display: [nan,nan,nan,nan,nan,nan,nan,nan,nan,450]
    Log(ma);                     
}

교환.GetPeriod (()

이exchange.GetPeriod()함수는 FMZ 플랫폼 웹사이트 페이지에 설정된 K-라인 기간을 반환합니다.백테스트그리고bot. 반환 값은 초 단위의 정수입니다. 반환 값: 숫자 유형.

function main() {
    // For example, in the backtest and bot, set the K-line period on the website page of FMZ platform to 1 hour
    var period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hour")
}

def main():
    period = exchange.GetPeriod()
    Log("K-line period:", period / (60 * 60), "hour")

void main() {
    auto period = exchange.GetPeriod();
    Log("K-line period:", period / (60 * 60.0), "hour");
}

교환.SetMaxBarLen(Len)

이exchange.SetMaxBarLen(Len)이 기능은 암호화폐 전략의 실행 기간 동안 두 가지 측면에 영향을 미칩니다.

  • 처음 얻은 K-라인 바 (BAR) 의 수에 영향을 미칩니다.
  • K-라인 바 (BAR) 의 상한 한계에 영향을 미칩니다.
function main() {
    exchange.SetMaxBarLen(50)
    var records = exchange.GetRecords()
    Log(records.length, records)
}

def main():
    exchange.SetMaxBarLen(50)
    r = exchange.GetRecords()
    Log(len(r), r)

void main() {
    exchange.SetMaxBarLen(50);
    auto r = exchange.GetRecords();
    Log(r.size(), r[0]);
}

교환.GetRawJSON (()

exchange.GetRawJSON()마지막에 의해 반환된 원자재 (strings) 를 반환합니다.RESTrequest, which can be used to parse data by yourself. 반환 값: 문자열 유형, 암호화폐 라이브 거래 환경에서만 유효합니다. 백테스트는 기능을 지원하지 않습니다. 전략cpp언어는 기능을 지원하지 않습니다.

function main(){
    exchange.GetAccount(); 
    var obj = JSON.parse(exchange.GetRawJSON());
    Log(obj);
}

import json
def main():
    exchange.GetAccount()
    obj = json.loads(exchange.GetRawJSON())
    Log(obj)

void main() {
    auto obj = exchange.GetAccount();
    // C++ doe not support "GetRawJSON" function
    Log(obj);
}

교환.GetRate()

exchange.GetRate()현재 거래소에서 사용되는 통화와 현재 표시된 가격 통화의 환율을 반환하고, 환율 전환이 비활성화되었음을 표시하는 1의 환율을 반환합니다. 환율: 숫자 유형.

참고:

  • 만약exchange.SetRate()환율을 설정하기 위해 호출되지 않았다면, 환율 값은exchange.GetRate()기본값은 1, 즉 현재 표시된 환율 전환은 교환되지 않았습니다.
  • 만약exchange.SetRate()환율값을 설정하는데 사용되었습니다. 예를 들어,exchange.SetRate(7), 거래 플랫폼의 유통 통화를 나타내는 현재 교환 대상의 모든 가격 정보, 예를 들어 코팅, 깊이, 주문 가격 등은 변환을 위해 이전에 설정된 환율 7으로 곱됩니다.
  • 만약exchangeUSD를 가격화로 교환하는 것과 일치합니다.exchange.SetRate(7), 모든 가격의 bot는 CNY에 가까운 가격으로 변환됩니다.exchange.GetRate()7입니다.

교환.GetUSDCNY()

exchange.GetUSDCNY()가장 최근의 미국 달러 환율을 반환합니다.yahoo() 반환 값: 숫자 유형.

exchange.SetData ((키, 값)

이exchange.SetData(Key, Value)함수는 전략 실행 시에 로드 된 데이터를 설정하는 데 사용됩니다. 이는 모든 경제 지표, 산업 데이터, 관련 인덱스 등이 될 수 있습니다. 거래 전략에 대한 모든 정량화 가능한 정보를 정량화하는 데 사용할 수 있으며 백테스트 시스템에서 사용하는 것을 지원합니다.

호출 방법exchange.SetData(Key, Value)기능:

  • 데이터를 전략에 직접 적어 데이터 포맷은data다음 예제에서 변수

    /*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    var data = [
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
    exchange.SetData("test", data)
    while(true) {
        Log(exchange.GetData("test"))
        Sleep(1000)
    }
}

    '''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''  

def main():
    data = [
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
    exchange.SetData("test", data)
    while True:
        Log(exchange.GetData("test"))
        Sleep(1000)

    /*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/  

void main() {
    json data = R"([
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ])"_json;
    
    exchange.SetData("test", data);
    while(true) {
        Log(exchange.GetData("test"));
        Sleep(1000);
    }
}

    위의 시험 코드가 실행될 때, 그림과 같이 해당 시간에 해당 데이터를 얻을 수 있다.

    img

    우리가 볼 수 있듯이, 시간표의 대응 시간1579622400000이2020-01-22 00: 00: 00이 시간 이후 전략 프로그램이 실행되면 다음 데이터 시간표 전에1579708800000, 즉,2020-01-23 00: 00: 00전화해exchange.GetData(Source)데이터의 함수를 얻을 수 있습니다.[1579622400000, 123]프로그램이 계속 실행되고 시간이 바뀌면서, 이렇게 조각별로 데이터를 얻습니다.

  • 외부 링크를 통해 데이터를 요청

    요청된 데이터 형식

    {
    "schema":["time","data"],
    "data":[
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
}

    어디?schema로드 된 데이터의 주요 부분의 각 레코드의 데이터 형식입니다.["time", "data"],data데이터의 속성 형식을 하나씩data이 속성은 데이터의 주체를 저장하고, 데이터의 각 조각은 밀리초 수준 타임 스탬프와 데이터 내용으로 구성됩니다 (데이터 콘텐츠는 JSON 암호화 된 데이터일 수 있습니다).

    테스트를 위한 서비스 프로그램은Go언어:

    package main
import (
    "fmt"
    "net/http"
    "encoding/json"
)  

func Handle (w http.ResponseWriter, r *http.Request) {
    defer func() {
        fmt.Println("req:", *r)
        ret := map[string]interface{}{
            "schema": []string{"time","data"},
            "data": []interface{}{
                []interface{}{1579536000000, "abc"},
                []interface{}{1579622400000, 123},
                []interface{}{1579708800000, map[string]interface{}{"price":123}},
                []interface{}{1579795200000, []interface{}{"abc", 123, map[string]interface{}{"price":123}}},
            },
        }
        b, _ := json.Marshal(ret)
        w.Write(b)
    }()
}  

func main () {
    fmt.Println("listen http://localhost:9090")
    http.HandleFunc("/data", Handle)
    http.ListenAndServe(":9090", nil)
}

    요청을 받은 후, 프로그램은 데이터에 반응합니다.

    {
    "schema":["time","data"],
    "data":[
        [1579536000000, "abc"],
        [1579622400000, 123],
        [1579708800000, {"price": 123}],
        [1579795200000, ["abc", 123, {"price": 123}]]
    ]
}

    테스트 전략 코드:

    /*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    while(true) {
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
        Sleep(1000)
    }
}

    '''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''  

def main():
    while True:
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
        Sleep(1000)

    /*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/  

void main() {
    while(true) {
        Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
        Sleep(1000);
    }
}

교환.GetData (출처)

이exchange.GetData(Source)이 함수는 데이터 로딩을 얻기 위해 사용됩니다exchange.SetData(Key, Value)기능 또는 외부 링크에 의해 제공 된 데이터는 백테스트 시스템에서 사용할 수 있습니다. 데이터는 백테스트 중에 한 번에 얻으며 실제 거래 중에 1 분 동안 캐시됩니다.

  • 직접 입력된 데이터의 호출 방법을 얻는

    /*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/
function main() {
    exchange.SetData("test", [[1579536000000, _D(1579536000000)], [1579622400000, _D(1579622400000)], [1579708800000, _D(1579708800000)]])
    while(true) {
        Log(exchange.GetData("test"))
        Sleep(1000 * 60 * 60 * 24)
    }
}

    '''backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
'''  
def main():
    exchange.SetData("test", [[1579536000000, _D(1579536000000/1000)], [1579622400000, _D(1579622400000/1000)], [1579708800000, _D(1579708800000/1000)]])
    while True:
        Log(exchange.GetData("test"))
        Sleep(1000 * 60 * 60 * 24)

    /*backtest
start: 2020-01-21 00:00:00
end: 2020-02-12 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Bitfinex","currency":"BTC_USD"}]
*/    
void main() {
    json arr = R"([[1579536000000, ""], [1579622400000, ""], [1579708800000, ""]])"_json;
    arr[0][1] = _D(1579536000000);
    arr[1][1] = _D(1579622400000);
    arr[2][1] = _D(1579708800000);
    exchange.SetData("test", arr);
    while(true) {
        Log(exchange.GetData("test"));
        Sleep(1000 * 60 * 60 * 24);
    }
}

  • 외부 링크에서 데이터를 호출하는 방법

    function main() {
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))
}

    def main():
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"))
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"))

    void main() {
    Log(exchange.GetData("http://xxx.xx.x.xx:9090/data"));
    Log(exchange.GetData("https://www.fmz.com/upload/asset/32bf73a69fc12d36e76.json"));
}

  • 플랫폼 데이터 센터의 기본 데이터를 사용 사용exchange.GetData(Source)함수를 얻는 것기본 자료.

전화할 때exchange.GetData(Source)함수, 당신은 밀리 초에 캐시 타임 아웃을 설정하기 위해 두 번째 매개 변수를 통과 할 수 있습니다. 기본값은 실제 봇에서 1 분 캐시 타임 아웃입니다. 백테스트 시스템에서 데이터를 요청하기 위해 액세스 인터페이스를 사용할 때 백테스트 시스템은 요청에 자동으로 매개 변수 from (시간표초), to (시간표초), period (아저씨 K-line period, timestamp milliseconds) 및 기타 매개 변수를 추가하여 얻을 데이터의 시간 범위를 결정합니다.

거래 API

다음 함수들은exchange또는exchanges[0]예를 들어:exchange.Sell(100, 1);다음 주문은 거래소에서 100의 가격과 1의 양을 가진 판매 주문입니다.

교환.구매 (가격, 금액)

exchange.Buy(Price, Amount)구매 주문을 하고 주문 ID를 반환하는 데 사용됩니다. 매개 변수 값:Price번호로 표시된 주문 가격, 그리고Amount순서 유형 또는 숫자 유형 (특정 유형은 각 거래소의 반환 유형에 따라 다릅니다).

반환된 주문 번호는 주문 정보를 검색하고 주문을 취소하는 데 사용할 수 있습니다.

function main() {
    var id = exchange.Buy(100, 1);
    Log("id:", id);
}

def main():
    id = exchange.Buy(100, 1)
    Log("id:", id)

void main() {
    auto id = exchange.Buy(100, 1);
    Log("id:", id);
}

  • 선물 주문

    선물에 대한 주문을 할 때, 거래 방향이 올바르게 설정되었는지에주의를 기울여야합니다. 거래 방향과 거래 기능이 일치하지 않으면 오류가 보고됩니다. 암호화폐 선물 거래소에 배치된 주문의 수는 다른 내용이 명시되지 않는 한 계약의 수입니다. 예를 들어:

    // The following is the wrong call
function main() {
    exchange.SetContractType("quarter")
  
    // Set short direction
    exchange.SetDirection("sell")     
    // Place a buy order, and you will get an error, so you can only sell short
    var id = exchange.Buy(50, 1)      

    // Set short direction
    exchange.SetDirection("buy")      
    // Place a sell order, and you will get an error, so you can only buy long
    var id2 = exchange.Sell(60, 1)    
  
    // Set close long position direction
    exchange.SetDirection("closebuy")    
    // Place a buy order, and you will get an error, so you can only sell short
    var id3 = exchange.Buy(-1, 1)        
  
    // Set close short position direction
    exchange.SetDirection("closesell")   
    // Place a sell order, and you will get an error, so you can only buy long
    var id4 = exchange.Sell(-1, 1)       
}

    # The following is the wrong call
def main():
    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    id = exchange.Buy(50, 1)
    exchange.SetDirection("buy")
    id2 = exchange.Sell(60, 1)
    exchange.SetDirection("closebuy")
    id3 = exchange.Buy(-1, 1)
    exchange.SetDirection("closesell")
    id4 = exchange.Sell(-1, 1)

    // The following is the wrong call
void main() {
    exchange.SetContractType("quarter");
    exchange.SetDirection("sell");
    auto id = exchange.Buy(50, 1);
    exchange.SetDirection("buy");
    auto id2 = exchange.Sell(60, 1);
    exchange.SetDirection("closebuy");
    auto id3 = exchange.Buy(-1, 1);
    exchange.SetDirection("closesell");
    auto id4 = exchange.Sell(-1, 1);
}

    오류 메시지:

    direction is sell, invalid order type Buy
direction is buy, invalid order type Sell
direction is closebuy, invalid order type Buy
direction is closesell, invalid order type Sell

  • 시장 질서

    참고: 교환 주문 인터페이스는 시장 주문을 지원하는 데 필요합니다 (오더 유형이 구매 주문이 될 때, 주문 금액 매개 변수는 코팅 통화의 금액입니다), 그리고 암호화폐 선물의 시장 주문 방법은 주문을 배치하는 데 사용됩니다. 양 매개 변수의 단위는계약자 수디지털 화폐를 위한 몇 개의 라이브 거래소는 시장 주문 인터페이스를 지원하지 않습니다.

    // For example, trading pairs: ETH_BTC, bought in by market order
function main() {
    // Buy a market order, and buy ETH coins equal to 0.1 BTC (quote currency) 
    exchange.Buy(-1, 0.1)    
}

    def main():
    exchange.Buy(-1, 0.1)

    void main() {
    exchange.Buy(-1, 0.1);
}

교환.판매 ((가격, 금액)

exchange.Sell(Price, Amount)판매 주문을 하고 주문 ID를 반환합니다. 매개 변수 값:Price순서값, 숫자형.Amount명령 금액, 숫자 유형입니다. 반환 값: 문자열 유형 또는 숫자 유형 (특정 유형은 각 교환의 반환 유형에 따라 다릅니다).

반환된 주문 번호, 주문 정보를 검색하고 주문을 취소하는 데 사용할 수 있습니다.

function main(){
    var id = exchange.Sell(100, 1)
    Log("id:", id)
}

def main():
    id = exchange.Sell(100, 1)
    Log("id:", id)

void main() {
    auto id = exchange.Sell(100, 1);
    Log("id:", id);
}

  • 선물 주문

    선물 거래 주문을 할 때 거래 방향이 올바르게 설정되었는지에주의를 기울여야합니다. 거래 방향과 거래 기능이 일치하지 않으면 오류가 보고됩니다. 암호화폐 선물 플랫폼의 주문 금액은 다른 내용이 명시되지 않는 한 계약 수입니다.

  • 시장 주문

    참고: 플랫폼 주문 배치 인터페이스는 시장 주문을 지원하는 데 필요합니다. (오더 유형이 판매 주문이 될 때, 주문 금액 매개 변수는 판매 된 운영 코인의 수입니다.)계약자 수실제 거래에서 디지털 화폐 거래소는 시장 주문 인터페이스를 지원하지 않습니다.

    // For example, trading pairs: ETH_BTC, sold out by market order 
function main() {
    // Note: Sell by a market order, and sell 0.2 ETH coins 
    exchange.Sell(-1, 0.2)   
}

    def main():
    exchange.Sell(-1, 0.2)

    void main() {
    exchange.Sell(-1, 0.2);
}

교환. 주문 취소 (Id)

exchange.CancelOrder(orderId), 이 함수의 목적은 Id와 함께 명령을 취소하는 것입니다. 매개 변수 값:Id문자열 타입 또는 숫자 타입의 주문 번호 (특정 타입은 각 플랫폼에서 주문을 할 때 반환 유형에 따라 달라집니다); 반환 값: bool 타입.

동작 결과를 반환합니다.true주문 취소 요청이 성공적으로 전송되었음을 의미합니다.false취소 주문 요청이 전송되지 않는다는 것을 의미합니다 (귀환 값은 전송 요청이 성공했는지 여부를 나타냅니다.exchange.GetOrders()플랫폼이 주문을 취소하는지 확인하기 위해).

function main(){
    var id = exchange.Sell(99999, 1)
    exchange.CancelOrder(id)
}

def main():
    id = exchange.Sell(99999, 1)
    exchange.CancelOrder(id)

void main() {
    auto id = exchange.Sell(99999, 1);
    exchange.CancelOrder(id);
}

FMZ의 API 함수는 로그 출력 함수를 생성할 수 있습니다.Log(...), exchange.Buy(Price, Amount)그리고exchange.CancelOrder(Id). 당신은 몇 가지 추가 출력 매개 변수와 함께 필요한 매개 변수를 따를 수 있습니다.exchange.CancelOrder(orders[j].Id, orders[j])이 방법으로, 그것은 취소orders[j]이 순서 정보의 출력, 즉Order구조orders[j].

function main() {
    Log("data1", "data2", "data3", "...")
    var data2 = 200
    var id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...")
    exchange.CancelOrder(id, "Incidental data1", data2, "...")
    LogProfit(100, "Incidental data1", data2, "...")
}

def main():
    Log("data1", "data2", "data3", "...")
    data2 = 200
    id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...")
    exchange.CancelOrder(id, "Incidental data1", data2, "...")
    LogProfit(100, "Incidental data1", data2, "...")

void main() {
    Log("data1", "data2", "data3", "...");
    int data2 = 200;
    auto id = exchange.Sell(100000, 0.1, "Incidental data1", data2, "...");
    exchange.CancelOrder(id, "Incidental data1", data2, "...");
    LogProfit(100, "Incidental data1", data2, "...");
}

교환.GetOrder ((Id)

exchange.GetOrder(orderId)순서 번호에 따라 순서 세부 정보를 얻습니다. 매개 변수 값:Id얻어야 하는 순위 번호, 그리고Id문자열 또는 숫자 타입입니다 (특정 타입은 각 교환의 반환 유형에 따라 다릅니다). 반환 값:Order구조. (일부 거래소에서는 지원되지 않습니다.)

  • Order구조
  • AvgPrice평균 실행값을 나타냅니다 (어떤 거래소는 이 필드를 지원하지 않습니다. 지원하지 않는 경우 0으로 설정합니다.)
function main(){
    var id = exchange.Sell(1000, 1)
    // The parameter id is the order number, you need to fill in the number of the order you want to query
    var order = exchange.GetOrder(id)      
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:",
        order.DealAmount, "Status:", order.Status, "Type:", order.Type)
}

def main():
    id = exchange.Sell(1000, 1)
    order = exchange.GetOrder(id)
    Log("Id:", order["Id"], "Price:", order["Price"], "Amount:", order["Amount"], "DealAmount:", 
        order["DealAmount"], "Status:", order["Status"], "Type:", order["Type"])

void main() {
    auto id = exchange.Sell(1000, 1);
    auto order = exchange.GetOrder(id);
    Log("Id:", order.Id, "Price:", order.Price, "Amount:", order.Amount, "DealAmount:", 
        order.DealAmount, "Status:", order.Status, "Type:", order.Type);
}

교환.GetOrders()

exchange.GetOrders()모든 미완성 주문을 얻습니다. 반환 값:Order구조 배열 에 대해Order구조, 참조하십시오exchange.GetOrder()기능 설명. 교환 객체에 의해 대표되는 계정exchange주문이 없으니 전화해exchange.GetOrders()빈 배열을 반환하기 위해, 즉:[].

function main(){
    exchange.Sell(1000, 1)
    exchange.Sell(1000, 1)
    var orders = exchange.GetOrders()
    Log("Information for unfinished order 1, ID:", orders[0].Id, "Price:", orders[0].Price, "Amount:", orders[0].Amount,
        "DealAmount:", orders[0].DealAmount, "type:", orders[0].Type)
    Log("Information for unfinished order 2, ID:", orders[1].Id, "Price:", orders[1].Price, "Amount:", orders[1].Amount,
        "DealAmount:", orders[1].DealAmount, "type:", orders[1].Type)
}

def main():
    exchange.Sell(1000, 1)
    exchange.Sell(1000, 1)
    orders = exchange.GetOrders()
    Log("Information for unfinished order 1, ID:", orders[0]["Id"], "Price:", orders[0]["Price"], "Amount:", orders[0]["Amount"], 
        "DealAmount:", orders[0]["DealAmount"], "type:", orders[0]["Type"])
    Log("Information for unfinished order 2, ID:", orders[1]["Id"], "Price:", orders[1]["Price"], "Amount:", orders[1]["Amount"],
        "DealAmount:", orders[1]["DealAmount"], "type:", orders[1]["Type"])

void main() {
    exchange.Sell(1000, 1);
    exchange.Sell(1000, 1);
    auto orders = exchange.GetOrders();
    Log("Information for unfinished order 1, ID:", orders[0].Id, "Price:", orders[0].Price, "Amount:", orders[0].Amount, 
        "DealAmount:", orders[0].DealAmount, "type:", orders[0].Type);
    Log("Information for unfinished order 2, ID:", orders[1].Id, "Price:", orders[1].Price, "Amount:", orders[1].Amount,
        "DealAmount:", orders[1].DealAmount, "type:", orders[1].Type);
}

이exchange.GetOrders()함수는 현재 세트의 미완성 순서 정보를 얻습니다거래 쌍암호화폐 선물은 거래 쌍뿐만 아니라 계약 코드에도 차이가 있다는 점에 유의해야합니다.

// Test OKX contract tradings, to know whether "GetOrders" gets all unfinished contract orders
function main(){
    // The next weekly buy order; the price of the order minus 50 guarantees no execution; pending orders
    exchange.SetContractType("this_week")
    exchange.SetDirection("buy")
    var ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Buy(ticker.Last - 50, 1)

    // The next quarterly sell order; the price plus 50 guarantees that it will not be executed, and the pending order has been switched to a quarterly contract
    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Sell(ticker.Last + 50, 1)

    // Get the unfinished orders
    Log("orders", exchange.GetOrders())
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetDirection("buy")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Buy(ticker["Last"] - 50, 1)

    exchange.SetContractType("quarter")
    exchange.SetDirection("sell")
    ticker = exchange.GetTicker()
    Log(ticker)
    exchange.Sell(ticker["Last"] + 50, 1)

    Log("orders", exchange.GetOrders())

void main() {
    exchange.SetContractType("this_week");
    exchange.SetDirection("buy");
    auto ticker = exchange.GetTicker();
    Log(ticker);
    exchange.Buy(ticker.Last - 50, 1);

    exchange.SetContractType("quarter");
    exchange.SetDirection("sell");
    ticker = exchange.GetTicker();
    Log(ticker);
    exchange.Sell(ticker.Last + 50, 1);

    Log("orders", exchange.GetOrders());
}

완료되지 않은 주문 정보:

[{"Id":17116430886,"Amount":1,"Price":808.4,"DealAmount":0,"AvgPrice":0,"Status":0,"Type":1,"ContractType":"quarter"}]

암호화폐 거래에서,exchange.GetOrders()현재 정해진 계약의 미완성된 주문만 포함됩니다.

교환. 세트 정확도 ((...)

exchange.SetPrecision(PricePrecision, AmountPrecision)가격과 기호 순서 금액의 소수 정밀도를 설정합니다. 설정 후 자동으로 줄입니다. 매개 변수 값:PricePrecision가격 데이터의 소수점을 제어하기 위해 사용되는 숫자 타입입니다.AmountPrecision숫자의 종류입니다.PricePrecision그리고AmountPrecision정수여야 합니다. 백테스트는 함수를 지원하지 않습니다. 백테스트의 수치 정밀도는 자동으로 처리됩니다.

function main(){
    // Set the decimal precision of the price to 2 digits, and set the precision of the quantity of the symbol order to 3 digits
    exchange.SetPrecision(2, 3)
}    

def main():
    exchange.SetPrecision(2, 3)

void main() {
    exchange.SetPrecision(2, 3);
}

교환.SetRate(Rate)

exchange.SetRate(Rate)거래소에서 유통 통화의 환율을 설정합니다. 파라미터 값:Rate의number타입 반환 값:number type.

function main(){
    Log(exchange.GetTicker())
    // Set the exchange rate conversion
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    // Set to 1, without conversion
    exchange.SetRate(1)
}

def main():
    Log(exchange.GetTicker())
    exchange.SetRate(7)
    Log(exchange.GetTicker())
    exchange.SetRate(1)

void main() {
    Log(exchange.GetTicker());
    exchange.SetRate(7);
    Log(exchange.GetTicker());
    exchange.SetRate(1);
}

참고:

  • 환율 값을 설정하면exchange.SetRate(Rate)7, 그렇다면, 현재 시장 가격, 깊이, 주문 가격을 포함한 모든 가격 정보,exchange물품은 환율을 위해 정한 환율 7으로 곱됩니다.

  • 예를 들어,exchange미국 달러로 표기된 환율입니다.exchange.SetRate(7)실제 거래의 모든 가격은 7로 곱하여 CNY에 가까운 가격으로 변환됩니다.

exchange.IO(…)

exchange.IO("api", httpMethod, resource, params, raw), 교환의 다른 기능적 인터페이스를 호출. 매개 변수 값:httpMehod문자열 타입입니다. 요청 타입을 채우죠.POST또는GET. resource문자열 타입이 되면 요청 경로를 채우죠.params문자열 타입이 되면 요청 매개 변수를 채우죠.raw원래 JSON 문자열 매개 변수이고, 생략할 수 있습니다.exchange.IO("api", httpMethod, resource, params, raw)함수 호출은 교환 인터페이스에 액세스합니다. 오류가 발생하고 호출이 실패하면 null 값을 반환합니다.GetTicker()그리고GetAccount(), etc, 호출 실패 경우 null 값을 반환.) 오직 라이브 거래는 호출을 지원exchange.IO("api", ...) function.

OKX 대량 순서를 예로, 매개 변수를 사용raw명령 매개 변수를 전달하기 위해:

function main() {
    var arrOrders = [
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ]
    
    // Call exchange.IO to directly access the platform batch ordering interface
    var ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", JSON.stringify(arrOrders))
    Log(ret)
}

import json
def main():
    arrOrders = [
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}, 
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ]
    ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", json.dumps(arrOrders))
    Log(ret)

void main() {
    json arrOrders = R"([
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"},
        {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"2","posSide":"long"}
    ])"_json;
    auto ret = exchange.IO("api", "POST", "/api/v5/trade/batch-orders", "", arrOrders.dump());
    Log(ret);
}

이 함수를 사용하려면, 당신은 교환에 가서APIFMZ가 추가하지 않은 기능을 확장하기 위해 교환의 인터페이스 (당신은 매개 변수 암호화, 서명 및 확인 과정에 대해 걱정할 필요가 없습니다POSTFMZ는 아래층에서 완전히 처리, 그래서 당신은 단지 해당 매개 변수를 채워야 합니다.)

참고: 만약 키값이params매개 변수 (즉, Http 요청 매개 변수) 는 문자열입니다, 그것은 단일 인용구 (기호') 는 매개 변수 값의 양쪽에 있습니다. 예를 들어:bitfinex exchange.

var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
    // Notice that amount.toString() and price.toString() both have a ' character on the left and right
    var message = "symbol=" + basecurrency + "&amount='" + amount.toString() + "'&price='" + price.toString() + "'&side=buy" + "&type=limit"
    var id = exchange.IO("api", "POST", "/v1/order/new", message)
}

amount = 1
price = 10
basecurrency = "ltc"
def main():
    message = "symbol=" + basecurrency + "&amount='" + str(amount) + "'&price='" + str(price) + "'&side=buy" + "&type=limit"
    id = exchange.IO("api", "POST", "/v1/order/new", message)

void main() {
    auto amount = 1.0;
    auto price = 10.0;
    auto basecurrency = "ltc";
    string message = format("symbol=%s&amount=\"%.1f\"&price=\"%.1f\"&side=buy&type=limit", basecurrency, amount, price);
    auto id = exchange.IO("api", "POST", "/v1/order/new", message);
}

접근 예제OKX인터페이스:

function main(){
    var ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
    Log(ret)
}

def main():
    ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT")
    Log(ret)

void main() {
    auto ret = exchange.IO("api", "GET", "/api/v5/trade/orders-pending", "instType=SPOT");
    Log(ret);
}

테스트 중에 반환된 데이터:

{"code":"0","data":[],"msg":""}

다른 설정exchange.IO기능:

  • 현재 거래소의 거래 쌍을 변경

    exchange.IO("currency", "ETH_BTC")

    function main() {
    // For example, set the current trading pair of the exchange object on the bot to BTC_USDT, and print the current trading pair market
    Log(exchange.GetTicker())
    // Switch trading pair to LTC_BTC      
    exchange.IO("currency", "LTC_BTC")
    Log(exchange.GetTicker())
}

    def main():
    Log(exchange.GetTicker())
    exchange.IO("currency", "LTC_BTC")
    Log(exchange.GetTicker())

    void main() {
    Log(exchange.GetTicker());
    exchange.IO("currency", "LTC_BTC");
    Log(exchange.GetTicker());
}

    이런 식으로,거래 쌍구성봇이 추가될 때또는백테스트가 실행되었습니다암호를 통해 전환됩니다.

    참고:

      1. 백테스트 시스템은 이제 거래 쌍을 전환하는 것을 지원합니다. 백테스트 중에 동일한 코트 화폐의 거래 쌍만 전환 할 수 있다는 점에 유의해야합니다. 예를 들어 현재 거래 쌍은ETH_BTC, 오직LTC_BTC아니LTC_USDT.
      1. 만약websocket프로토콜 모드는 Huobi 스팟 교환 객체에 전환됩니다, 당신은 사용할 수 없습니다exchange.IO("currency", "XXX_YYY")통화를 바꾸기 위해서요.
      1. 암호화폐 선물 거래소에서는 거래 쌍이 전환되면 어떤 계약과 거래하고 싶은지 결정하기 위해 계약을 다시 설정해야 합니다.
      1. 또한 새로운exchange.SetCurrency(Symbol)거래 쌍을 전환하는 기능과 사용exchange.IO("currency","XXX_YYY")호환성을 유지하기 위한 방법

  • exchange.IO이 함수는 교환 API 기본 주소를 전환합니다. (RESET 계약, 일부 교환은 지원하지 않습니다.) 이제 사용exchange.SetBase(Base)기능이 지원되었습니다 교환 API 기본 주소를 전환하고 사용exchange.IO("base","https://xxx.xxx.xxx")호환성을 유지하기 위한 방법

    예를 들어: 교환 객체가 캡슐화되면 기본 기본 주소는https://api.huobipro.com, 다음으로 전환합니다:https://api.huobi.pro, 다음 코드를 사용하세요.

    function main () {
    // exchanges[0] is the first exchange object added when the bot is added 
    exchanges[0].IO("base", "https://api.huobi.pro")        
}

    def main():
    exchanges[0].IO("base", "https://api.huobi.pro")

    void main() {
    exchanges[0].IO("base", "https://api.huobi.pro");
}

    기본 주소를 다시 바꾸어:https://api.huobipro.com.

    function main () {
    exchanges[0].IO("base", "https://api.huobipro.com")
}

    def main():
    exchanges[0].IO("base", "https://api.huobipro.com")
다음 페이지 다음 페이지
더 많은

2019 FMZ - 모든 권리 보호