FMZ API 지침

pp 공백 주식 (() { 거래소[0].IO(base, https://api.huobipro.com”); }

The ZB exchange is special. There are two addresses: one is the market data interface address, and the other is the trading interface address. Switch the address:
```js
function main() {
    // The second parameter of exchange.IO is the trading interface address, and the third parameter is the market interface address, which is switched to an address that can be accessed domestically
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus")    
    // Print the account information
    Log(exchange.GetAccount())                                            
}

def main():
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus")
    Log(exchange.GetAccount())

void main() {
    exchange.IO("base", "https://trade.zb.plus", "http://api.zb.plus");
    Log(exchange.GetAccount());
}

• 시장 모드 전환 현재 지원되는 거래소:

  교환	언급
  후오비 스팟	웹소켓 프로토콜을 지원 한 후, 코드는exchange.IO(currency, ETH) 는 통화 전환에 사용할 수 없습니다.

  • exchange.IO("websocket")

    시장 통신 프로토콜을websocket(예정값은 휴식), 시장 코팅을 얻는 방법은 전환 후 변경됩니다.exchange.GetTicker()그리고exchange.GetDepth()이럴 때websocket시장 데이터의 비동기 인수 시장 데이터의 비동기 인수로부터 프로토콜을 업데이트 할 때 현재 Huobi 거래소만 지원됩니다.

  시장 모드가 푸시 메커니즘일 때 다음 함수를 호출하여 설정할 수 있습니다.

  • exchange.IO("mode", 0)즉시 반환 모드. 현재 시장 데이터 푸시가 거래소에서 수신되지 않은 경우, 오래된 시장 데이터는 즉시 반환됩니다. 새로운 데이터가 있다면 새로운 데이터가 반환됩니다.

  • exchange.IO("mode", 1)캐시 모드 (디폴트 모드). 거래소의 최신 시장 데이터가 수신되지 않은 경우 (전기 인터페이스에서 얻은 데이터와 비교하면), 수신을 기다리고 반환합니다. 이 기능을 호출하기 전에 최신 시장 데이터가 수신 된 경우 최신 데이터가 즉시 반환됩니다.

  • exchange.IO("mode", 2)강제 업데이트 모드. 입력하고 교환의 다음 최신 푸시 데이터가 수신 될 때까지 기다립니다.

  가장 최신 시장 정보를 처음 얻고 싶다면,websocket그리고 부르지 말라Sleep그 다음 데이터들을 즉시 테스트합니다.exchange.GetTicker()그리고exchange.GetDepth()함수들은 캐시 모드에서 작동합니다.

  function main () {
      exchange.IO("websocket")
      while (true) {
          Log(exchange.GetTicker())
      }
  }
  

  def main():
      exchange.IO("websocket")
      while True:
          Log(exchange.GetTicker())
  

  void main() {
      exchange.IO("websocket");
      while(true) {
          Log(exchange.GetTicker());
      }
  }
  

• 거래소 레버리지 계정 모드

  사용exchange.IO("trade_margin")레버리지 계정 모드로 전환하려면 거래소의 레버리지 인터페이스를 사용하여 주문을 배치하고 계정 자산을 액세스합니다. 사용exchange.IO("trade_normal")정상 계정 모드로 돌아가기 위해

  지원되는 교환:

  교환	특별 언급
  OKX	레버리지 계정 모드의 거래 쌍은 일반 거래 쌍과 다르며 일부 거래 쌍은 사용할 수 없을 수 있습니다.exchange.IO("cross", true)레버레이드 계좌 전체 포지션으로 전환하고exchange.IO("cross", false)격리된 위치로 전환합니다.
  후오비	레버리지 계정 모드의 거래 쌍은 일반 거래 쌍과 다르며 일부 거래 쌍은 사용할 수 없을 수 있습니다. Huobi 레버리지 계정은 교차 위치와 격리 위치로 나뉘어 있습니다. 사용trade_margin레버리지 계정에서 격리된 위치로 전환하기 위해;trade_super_margin레버리지 계정으로 전환하기 위해trade_normal통상 통화 모드로 전환
  ZB	자금은 QC에서만 전송할 수 있습니다. 레버리지 거래 부문에서 다른 거래 쌍 사이의 자금은 독립적입니다. 즉, ETH_QC 거래 쌍의 QC 코인의 수는 BTC_QC에서 보이지 않습니다.
  바이낸스	레버리지 계정은 크로스 포지션과 격리된 포지션으로 나다.trade_margin격리된 위치로 전환하기 위해trade_super_margin횡단 위치로 전환하기 위해 사용trade_normal통상 통화 모드로 전환
  게이트IO	레버리지 계정은 크로스 포지션과 격리된 포지션으로 나다.trade_margin격리된 위치로 전환하기 위해trade_super_margin횡단 위치로 전환하기 위해 사용trade_normal통상 통화 모드로 전환
  AscendEx	사용exchange.IO("trade_margin")레버리지 계정으로 전환하고exchange.IO("trade_normal")정상 계정 모드로 돌아가기 위해

교환. 로그.

exchange.Log(LogType, Price, Amount)호출할 때 주문을 하지 않고 거래 로그 정보를 출력하기 위해 거래 정보를 기록합니다.

참고:

• 이 함수는exchange객체, 이는 글로벌 함수와 다릅니다Log().
• 파라미터 값:LogType할 수 있습니다.LOG_TYPE_BUY, LOG_TYPE_SELL, LOG_TYPE_CANCEL그리고Price가격으로 그리고Amount수량으로LogType이LOG_TYPE_CANCEL, Price매개 변수는 주문 ID입니다.

사용exchange.Log(LogType, Price, Amount)실시간 거래 후속 테스트를 수행하고 시뮬레이션된 오더 배치 및 오더 기록에 지원합니다.

가장 일반적인 사용 사례는:exchange.IO조건부 주문을 배치하는 거래소의 조건부 주문 인터페이스를 생성하는 기능을 액세스합니다.exchange.IO이 함수는 봇 로그 기록에서 교환 로그 정보를 출력하지 않습니다.exchange.Log(LogType, Price, Amount)로그 출력을 보완하여 배치 주문 정보를 기록합니다.

var id = 123
function main() {
    // Order type: buy; price: 999; quantity: 0.1
    exchange.Log(LOG_TYPE_BUY, 999, 0.1)      
    // Cancel the order
    exchange.Log(LOG_TYPE_CANCEL, id)         
}

id = 123
def main():
    exchange.Log(LOG_TYPE_BUY, 999, 0.1)
    exchange.Log(LOG_TYPE_CANCEL, id)

void main() {
    auto id = 123;
    exchange.Log(LOG_TYPE_BUY, 999, 0.1);
    exchange.Log(LOG_TYPE_CANCEL, id);
}

교환.HMAC(...)

exchange.HMAC(Algo, OutputAlgo, Data, Key)지원합니다HMAC암호화 계산md5/SHA256/sha512/sha1, 그리고 라이브 거래 실행만 지원됩니다.

exchange.HMAC("sha256", "hex", "xxxxx", "{{secretkey}}")인용하자면accessKey, 사용"{{accesskey}}"- 그래요 인용하자면secretKey, 사용"{{secretkey}}"; 또는 일반 텍스트를 사용할 수 있습니다."abc-123-xxxx". "{{accessKey}}","{{secretkey}}"이 함수가 사용될 때만 유효합니다.OutputAlgo지원: hex, base64.구체적인 예제

BitMEX 위치 변경을 밀어 (wss 프로토콜)

function main() {
    var APIKEY = "your Access Key(Bitmex API ID)"
    var expires = parseInt(Date.now() / 1000) + 10
    var signature = exchange.HMAC("sha256", "hex", "GET/realtime" + expires, "{{secretkey}}")
    var client = Dial("wss://www.bitmex.com/realtime", 60)
    var auth = JSON.stringify({args: [APIKEY, expires, signature], op: "authKeyExpires"})
    var pos = 0
    client.write(auth)
    client.write('{"op": "subscribe", "args": "position"}')
    while (true) {
        bitmexData = client.read()
        if(bitmexData.table == 'position' && pos != parseInt(bitmexData.data[0].currentQty)){
            Log('position change', pos, parseInt(bitmexData.data[0].currentQty), '@')
            pos = parseInt(bitmexData.data[0].currentQty)
        }
    }
}

import time
def main():
    APIKEY = "your Access Key(Bitmex API ID)"
    expires = int(time.time() + 10)
    signature = exchange.HMAC("sha256", "hex", "GET/realtime" + str(expires), "{{secretkey}}")
    client = Dial("wss://www.bitmex.com/realtime", 60)
    auth = json.dumps({"args": [APIKEY, expires, signature], "op": "authKeyExpires"})
    pos = 0
    client.write(auth)
    client.write('{"op": "subscribe", "args": "position"}')
    while True:
        bitmexData = json.loads(client.read())
        if "table" in bitmexData and bitmexData["table"] == "position" and len(bitmexData["data"]) != 0 and pos != bitmexData["data"][0]["currentQty"]:   
            Log("position change", pos, bitmexData["data"][0]["currentQty"], "@")
            pos = bitmexData["data"][0]["currentQty"]

void main() {
    auto APIKEY = "your Access Key(Bitmex API ID)";
    auto expires = Unix() + 10;
    auto signature = exchange.HMAC("sha256", "hex", format("GET/realtime%d", expires), "{{secretkey}}");
    
    auto client = Dial("wss://www.bitmex.com/realtime", 60);
    json auth = R"({"args": [], "op": "authKeyExpires"})"_json;

    auth["args"].push_back(APIKEY);
    auth["args"].push_back(expires);
    auth["args"].push_back(signature);
    auto pos = 0;
    client.write(auth.dump());
    client.write("{\"op\": \"subscribe\", \"args\": \"position\"}");
    while(true) {
        auto bitmexData = json::parse(client.read());
        if(bitmexData["table"] == "position" && bitmexData["data"][0].find("currentQty") != bitmexData["data"][0].end() && pos != bitmexData["data"][0]["currentQty"]) {
            Log("Test");
            Log("position change", pos, bitmexData["data"][0]["currentQty"], "@");
            pos = bitmexData["data"][0]["currentQty"];
        }
    }
}

교환. 가자.

exchange.Go(Method, Args...)다중 스레드 아시크론 지원 함수이며, 모든 지원 함수의 동작을 아시크론 동시로 전환할 수 있습니다. 파라미터 값:Method, 문자열 유형, 즉 동시에 호출 함수 이름.

참고:

• 이 함수는 라이브 트레이딩에서 실행될 때만 멀티 스레드 실행 작업을 생성합니다. 백테스트는 멀티 스레드 동시 실행 작업을 지원하지 않습니다 (백테스트는 사용할 수 있지만 여전히 순차적으로 실행됩니다).
• 그 후exchange.Go함수는 객체를 반환합니다.wait이 함수는 스레드가 객체를 통해 반환한 데이터를 검색하기 위해 호출됩니다. 스레드는 호출하여 데이터 획득 후 자동으로 풀릴 것입니다.wait완료됩니다. 만약 시간 정지 매개 변수를 지정wait, 타임아웃이 발생하더라도 스레드는 풀리지 않을 것입니다. 이러한 방식으로 스레드는 스레드 결과를 얻는 것만으로 자동으로 풀릴 것입니다. (동시 접속된 인터페이스가 성공적으로 호출되었든 실패했든 상관없이).
• 간단히 말해서, 적용된 가닥이 성공하든 실패하든 상관없이, 결과는 가닥에 의해 얻어야 합니다.wait함수와 스레드 자원을 적용exchange.Go함수는 도커에 의해 자동으로 풀립니다.
• 만약wait기능이 최종적으로 달성되지 않으면 스레드 리소스가 자동으로 풀리지 않아 적용 스레드의 축적이 발생합니다. 스레드 수가 2000을 초과하면 오류가 보고됩니다."too many routine wait, max is 2000".

지원 함수:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPosition그리고IO.

function main(){
    // The following four operations are executed concurrently and asynchronously by multiple threads, without time-consuming, but with immediate return.
    var a = exchange.Go("GetTicker")
    var b = exchange.Go("GetDepth") 
    var c = exchange.Go("Buy", 1000, 0.1)
    var d = exchange.Go("GetRecords", PERIOD_H1)
           
    // Call the "wait" method, to wait for the return of the asynchronously obtained "ticker" result 
    var ticker = a.wait()            
    // Return the depth; it is possible to return null, if the acquisition fails 
    var depth = b.wait()             
    // Return the order number; limit the timeout in 1 second; the timeout returns "undefined"; this object can continue to call "wait" to wait if the last "wait" is timeout 
    var orderId = c.wait(1000)
    if(typeof(orderId) == "undefined") {
        // Timeout, reacquire
        orderId = c.wait()
    }
    var records = d.wait()
}

def main():
    a = exchange.Go("GetTicker")
    b = exchange.Go("GetDepth")
    c = exchange.Go("Buy", 1000, 0.1)
    d = exchange.Go("GetRecords", PERIOD_H1)

    ticker, ok = a.wait()
    depth, ok = b.wait()
    orderId, ok = c.wait(1000)
    if ok == False:
        orderId, ok = c.wait()
    records, ok = d.wait()

void main() {
    auto a = exchange.Go("GetTicker");
    auto b = exchange.Go("GetDepth");
    auto c = exchange.Go("Buy", 1000, 0.1);
    auto d = exchange.Go("GetRecords", PERIOD_H1);

    Ticker ticker;
    Depth depth;
    Records records;
    TId orderId;
    a.wait(ticker);
    b.wait(depth);
    if(!c.wait(orderId, 300)) {
        c.wait(orderId);
    }
    d.wait(records);
}

참고:

• 판단하기 위해undefined, 사용typeof(xx)==="undefined"왜냐하면null == undefined자바스크립트에서 사용할 수 있습니다.

function main() {
    var d = exchange.Go("GetRecords", PERIOD_H1)
    // Wait for K-line result
    var records = d.wait()
    // Here we wait for an asynchronous operation that has been waited and ended; it will return null, and record the error
    var ret = d.wait()
}

def main():
    d = exchange.Go("GetRecords", PERIOD_H1)
    records, ok = d.wait()
    ret, ok = d.wait()

void main() {
    auto d = exchange.Go("GetRecords", PERIOD_H1);
    Records records;
    d.wait(records);
    Records ret;
    d.wait(ret);
}

이 두 가지의 차이점은Python그리고JavaScript그게...Python's 'wait함수는 두 개의 매개 변수를 반환합니다. 첫 번째는 비동기 API가 반환하는 결과입니다. 두 번째는 비동기 호출이 완료되었는지 여부를 나타냅니다.

Python예를 들어:

def main():
    d = exchange.Go("GetRecords", PERIOD_D1)
    # "ok" must return "True", unless the strategy is stopped
    ret, ok = d.wait()          
    # If the waiting times out, or "wait" for an ended instance, "ok" returns "False"
    ret, ok = d.wait(100)       
    ret, ok = d.wait(100)       

여러 거래소 코트를 동시에 획득:

function main() {
    while(true) {
        var beginTS = new Date().getTime()
        var arrRoutine = []
        var arrTicker = []
        var arrName = []
        for(var i = 0; i < exchanges.length; i++) {
            arrRoutine.push(exchanges[i].Go("GetTicker"))
            arrName.push(exchanges[i].GetName())
        }

        for(var i = 0; i < arrRoutine.length; i++) {
            arrTicker.push(arrRoutine[i].wait())
        }
        var endTS = new Date().getTime()

        var tbl = {
            type: "table", 
            title: "Market Quotes", 
            cols: ["Index", "Name", "Latest Executed Price"], 
            rows: []
        }
        
        for(var i = 0; i < arrTicker.length; i++) {
            tbl.rows.push([i, arrName[i], arrTicker[i].Last])
        }

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", endTS - beginTS, "millisecond", "\n", "`" + JSON.stringify(tbl) + "`")
        Sleep(500)
    }
}

import time 
import json
def main():
    while True:
        beginTS = time.time()
        arrRoutine = []
        arrTicker = []
        arrName = []
        for i in range(len(exchanges)):
            arrRoutine.append(exchanges[i].Go("GetTicker"))
            arrName.append(exchanges[i].GetName())

        for i in range(len(exchanges)):
            ticker, ok = arrRoutine[i].wait()
            arrTicker.append(ticker)

        endTS = time.time()
        tbl = {
            "type": "table", 
            "title": "Market Quote", 
            "cols": ["Index", "Name", "Latest Executed Price"], 
            "rows": [] 
        }

        for i in range(len(arrTicker)):
            tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", endTS - beginTS, "second", "\n", "`" + json.dumps(tbl) + "`")
        Sleep(500)

void main() {
    while(true) {
        int length = exchanges.size();
        auto beginTS = UnixNano() / 1000000;
        Ticker arrTicker[length] = {};
        string arrName[length] = {};
        
        // Note that to add a few exchange objects, here we need to execute the "exchanges[n].Go" function several times. In this example, we need to add four exchange objects, which can be modified in details
        auto r0 = exchanges[0].Go("GetTicker");
        auto r1 = exchanges[1].Go("GetTicker");
        auto r2 = exchanges[2].Go("GetTicker");
        auto r3 = exchanges[3].Go("GetTicker");
        GoObj *arrRoutine[length] = {&r0, &r1, &r2, &r3};
        
        for(int i = 0; i < length; i++) {
            arrName[i] = exchanges[i].GetName();
        }

        for(int i = 0; i < length; i++) {
            Ticker ticker;
            arrRoutine[i]->wait(ticker);
            arrTicker[i] = ticker;
        }        
        auto endTS = UnixNano() / 1000000;

        json tbl = R"({
            "type": "table", 
            "title": "Market Quote", 
            "cols": ["Index", "Name", "Latest Executed Price"], 
            "rows": [] 
        })"_json;

        for(int i = 0; i < length; i++) {
            json arr = R"(["", "", ""])"_json;
            arr[0] = format("%d", i);
            arr[1] = arrName[i];
            arr[2] = format("%f", arrTicker[i].Last);
            tbl["rows"].push_back(arr);
        }

        LogStatus(_D(), "The total time to acquire multiple platforms concurrently is:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
        Sleep(500);
    }
}

동시다발적인 호출exchange.IO("api", ...)기능:

function main() {
    /*  
       Use the OKX placing order interface to test
        POST /api/v5/trade/order        
    */
    
    var beginTS = new Date().getTime()
    var param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
    var ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    var ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    var ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
    
    var id1 = ret1.wait()
    var id2 = ret2.wait()
    var id3 = ret3.wait()
    var endTS = new Date().getTime()    

    Log("id1:", id1)
    Log("id2:", id2)
    Log("id3:", id3)
    Log("Time for placing orders concurrently:", endTS - beginTS, "millisecond")
}

import time
import json
def main():
    beginTS = time.time()
    param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
    ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
    ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
    ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))

    id1, ok1 = ret1.wait()
    id2, ok2 = ret2.wait()
    id3, ok3 = ret3.wait()
    endTS = time.time()

    Log("id1:", id1)
    Log("id2:", id2)
    Log("id3:", id3)
    Log("Time for placing orders concurrently:", endTS - beginTS, "second")

void main() {
    auto beginTS = UnixNano() / 1000000;
    json param = R"({"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"})"_json;
    auto ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
    auto ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
    auto ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());

    json id1 = R"({})"_json;
    json id2 = R"({})"_json;
    json id3 = R"({})"_json;

    ret1.wait(id1);
    ret2.wait(id2);
    ret3.wait(id3);
    auto endTS = UnixNano() / 1000000;

    Log("id1:", id1);
    Log("id2:", id2);
    Log("id3:", id3);
    Log("Time for placing orders concurrently:", endTS - beginTS, "millisecond");
}

계좌 정보

교환.GetAccount ((()

exchange.GetAccount()교환 계좌 정보를 반환 합니다. 반환 값:Account structure.

• Account구조

function main(){
    var account = exchange.GetAccount()
    Log("Account information, Balance:", account.Balance, "FrozenBalance:", account.FrozenBalance, "Stocks:",
        account.Stocks, "FrozenStocks:", account.FrozenStocks)
}

def main():
    account = exchange.GetAccount()
    Log("Account information, Balance", account["Balance"], "FrozenBalance:", account["FrozenBalance"], "Stocks:", 
        account["Stocks"], "FrozenStocks:", account["FrozenStocks"])

void main() {
    auto account = exchange.GetAccount();
    Log("Account information, Balance", account.Balance, "FrozenBalance:", account.FrozenBalance, "Stocks:", 
        account.Stocks, "FrozenStocks:", account.FrozenStocks);
}

만약 거래 대상이 암호화폐 선물 거래소에 설정되고USDT마진 (이 참조exchange.SetContractType어떻게 전환하는지를 알 수 있는 기능), 자산은USDT마진 (margin) 으로, 이 마진은Balance그리고FrozenBalance.

function main(){
    // Switch the trading pair
    exchange.IO("currency", "BTC_USDT")     
    // Take OKX futures as an example; set the contract as the contract of the week, and the current trading pair is BTC_USDT, so the current contract is BTC USDT-margined contract of this week
    exchange.SetContractType("this_week")   
    // Acquire the data of the current account assets
    var account = exchange.GetAccount()
    // The available balance of USDT as margin
    Log(account.Balance)
    // The frozen amount of USDT as margin
    Log(account.FrozenBalance)
}

def main():
    exchange.IO("currency", "BTC_USDT")
    exchange.SetContractType("this_week")    
    account = exchange.GetAccount()
    Log(account["Balance"])
    Log(account["FrozenBalance"])

void main() {
    exchange.IO("currency", "BTC_USDT");
    exchange.SetContractType("this_week");    
    auto account = exchange.GetAccount();
    Log(account.Balance);
    Log(account.FrozenBalance);
}

exchange.GetName (환송)

exchange.GetName()교환 이름을 반환 합니다. 반환 값: 문자열 유형. 일반적으로 그것은exchange또는exchanges[n]전략 코드에서 객체.

function main() {
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX")
}

def main():
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX")

void main() {
    Log("Determine the exchange object to be OKX:", exchange.GetName() == "OKEX");
}

도커의 라인 버전을 명령하려면,-1교환 이름 목록을 인쇄하는 명령어

교환.GetLabel()

exchange.GetLabel()교환의 사용자 지정 라벨을 반환합니다. 반환 값: 문자열 유형.

이exchange또는exchanges[n]전략 코드의 객체는 일반적으로 교환 객체를 구성할 때 설정된 라벨에 의해 결정됩니다.

교환.GetCurrency()

exchange.GetCurrency()거래소가 운영하는 통화 쌍의 이름을 반환하고 암호화폐 플랫폼은 문자열을 반환합니다.LTC_BTC반환 값: 문자열 유형.

교환.SetCurrency(...)

이exchange.SetCurrency(Symbol)교환 객체의 현재 거래 쌍을 전환하는 데 사용됩니다.exchange.IO ("currency","BTC_USDT")그것은 백테스팅 시스템에서 거래 쌍을 전환하는 것을 지원합니다.pricing currency배후 테스트 시스템에서 거래 쌍을 변경할 때 변경할 수 없습니다 (예를 들어,BTC_USDT로 전환할 수 있습니다.LTC_USDT, 하지만 이쪽으로 전환할 수 없습니다LTC_BTC(이하 "백테스팅"이 아닌 페이지에서 처음 설정된 거래 쌍으로 전환한 후,trading coins0입니다 (예를 들어, 백테스트 중에, 백테스트 페이지에서 거래 쌍의 초기 값은BTC_USDT, BTC의 수는 3이고 USDT의 수는 10000입니다.LTC_USDT,trading coins전환 후에는 0이 됩니다. 즉 계좌에 있는 LTC의 수는 0이지만 전환된 거래 쌍의 공유 USDT 금액은 여전히 10000입니다.

function main() {
    var ticker = exchange.GetTicker() 
    Log(ticker)
    Log(exchange.GetAccount())    
    // Switch trading pairs, and pay attention to changes in market quote data and account information after switching
    Log("Switch LTC_USDT: ", exchange.SetCurrency("LTC_USDT"))
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())
}

def main():
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())
    Log(" Switch LTC_USDT: ", exchange.SetCurrency("LTC_USDT"))
    ticker = exchange.GetTicker()
    Log(ticker)
    Log(exchange.GetAccount())

void main() {
    auto ticker = exchange.GetTicker();
    Log(ticker);
    Log(exchange.GetAccount());
    exchange.SetCurrency("LTC_USDT");
    Log(" Switch LTC_USDT: ");
    ticker = exchange.GetTicker();
    Log(ticker);
    Log(exchange.GetAccount());
}

백테스트 동작 결과:

교환.GetQuoteCurrency()

exchange.GetQuoteCurrency()예를 들어, 이식처가 운영하는 기본 통화 이름을 반환합니다.BTC_CNY수익CNY, 그리고ETH_BTC수익BTC반환 값: 문자열 유형.

선물 거래

암호화폐 선물 거래소 대상의 경우, 계약 코드를 호출하기 전에 지정해야합니다시장, 순서그리고 다른 인터페이스,exchange.SetContractType현재 계약 코드를 설정하는 데 사용되어야 합니다. 교환 객체의 현재 거래 쌍을 전환 할 때, 당신은exchange.SetContractType계약 코드를 재설정하는 기능입니다. 플랫폼에서 지원하는 디지털 통화 교환 계약 코드를 확인하려면exchange.SetContractType function.

교환.GetPosition()

exchange.GetPosition()현재 위치 정보를 얻습니다. 반환 값:position구조 배열. 위치가 없다면, 빈 배열을 반환합니다.[].

• Position구조

일반적으로 암호화폐 선물 계약은 두 가지 유형으로 나니다.

• 납품 계약 계약이 배달 계약으로 설정되면,exchange.GetPosition()현재 거래 쌍에 따라 배달 계약의 모든 포지션이 반환됩니다.

• 영구 계약 계약이 영구 계약으로 설정되면, 호출exchange.GetPosition()현재 거래 쌍에 대한 상시 계약의 모든 포지션은 반환됩니다.

/*
    Note: if there is no position, it will returns an empty array, so you should judge whether the data returned by the interface is a null array, before you use the returned data
    For example:
    When the exchange is set to OKX futures, if the contract is set to be a delivery contract, when the position data of the current week, the next week, and the quarter is obtained, the data type will be an array of position structure.
    When the exchange is set to OKX futures, if the contract is set to a perpetual contract, the array of position structure containing the position data of the perpetual contract will be obtained.
*/

function main(){
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(10)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    var position = exchange.GetPosition()
    if(position.length > 0){
        Log("Amount:", position[0].Amount, "FrozenAmount:", position[0].FrozenAmount, "Price:",
            position[0].Price, "Profit:", position[0].Profit, "Type:", position[0].Type,
            "ContractType:", position[0].ContractType)
    }
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(10)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    position = exchange.GetPosition()
    if len(position) > 0:
        Log("Amount:", position[0]["Amount"], "FrozenAmount:", position[0]["FrozenAmount"], "Price:", 
            position[0]["Price"], "Profit:", position[0]["Profit"], "Type:", position[0]["Type"], 
            "ContractType:", position[0]["ContractType"])

void main() {
    exchange.SetContractType("this_week");
    exchange.SetMarginLevel(10);
    exchange.SetDirection("buy");
    exchange.Buy(10000, 2);
    auto position = exchange.GetPosition();
    if(position.size() > 0) {
        Log("Amount:", position[0].Amount, "FrozenAmount:", position[0].FrozenAmount, "Price:", 
            position[0].Price, "Profit:", position[0].Profit, "Type:", position[0].Type, 
            "ContractType:", position[0].ContractType);
    } 
}

교환.변경수준을 설정합니다.

exchange.SetMarginLevel(MarginLevel)레버리지 크기를 설정합니다. 매개 변수 값: 숫자 유형.

예를 들어, 암호화폐 선물 주문을 할 때 레버리지의 크기를 설정합니다.

function main() {
    exchange.SetMarginLevel(10)
}

def main():
    exchange.SetMarginLevel(10)

void main() {
    exchange.SetMarginLevel(10);
}

암호화폐 선물에 대해, 암호화폐 선물 거래소의 레버리지 메커니즘은 균일하지 않습니다. 일부 거래소에서, 선물의 레버리지 값은 배치 주문 인터페이스의 매개 변수입니다.SetMarginLevel함수는 네트워크 요청을 생성 할 수 없지만 하층 (포스팅 오더 인터페이스에서 매개 변수를 전달하는 데 사용됩니다) 에 레버리지 변수를 설정합니다. 일부 거래소의 선물 레버지는 거래소 웹 사이트 페이지 또는 API 인터페이스를 사용하여 설정해야하는 거래소의 설정입니다. 이 시점에서 API를 호출합니다.SetMarginLevel이 함수는 네트워크 요청을 생성할 것이고, 다양한 이유로 레버리지를 설정하지 못할 수 있습니다. 예를 들어: 현재 포지션과 대기 주문이있는 경우, 이 거래 쌍과 기본 객체에 대한 레버리지 값이 설정되지 않을 수 있습니다.

전략 설계에서 레버리지를 설정하기 위한 참고:

• 암호화폐 선물만 지원됩니다.
• 백테스트는 레버를 전환하는 것을 지원합니다.

교류.SetDirection(...)

exchange.SetDirection(Direction)세트exchange.Buy또는exchange.Sell파러미터 값: 문자열 유형

이SetDirection이 함수는 선물 거래 방향과 주문 투입 함수 사이의 대응을 설정합니다.

주문 배치 함수	SetDirection 함수의 매개 변수 설정 방향	언급
exchange.Buy	구입	오픈 긴 포지션을 구매
exchange.Buy	결매	포지션을 닫는 것을 구매합니다.
exchange.Sell	판매	오픈 쇼트 포지션을 팔기
exchange.Sell	closebuy	긴 포지션을 닫습니다

매개 변수Direction네 가지 매개 변수를 취할 수 있습니다buy, closebuy, sell그리고closesell.

function main(){
    // Make an example for setting OKX futures weekly contract
    exchange.SetContractType("this_week")    
    // Set 5 times of leverage
    exchange.SetMarginLevel(5)
    // Set the order placing type into placing long order
    exchange.SetDirection("buy")
    // Place an order with the contract quantity of 2, at the price of 10,000
    exchange.Buy(10000, 2)              
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)
}

def main():
    exchange.SetContractType("this_week")
    exchange.SetMarginLevel(5)
    exchange.SetDirection("buy")
    exchange.Buy(10000, 2)
    exchange.SetMarginLevel(5)
    exchange.SetDirection("closebuy")
    exchange.Sell(1000, 2)

void main() {
    exchange.SetContractType("this_week");
    exchange.SetMarginLevel(5);
    exchange.SetDirection("buy");
    exchange.Buy(10000, 2);
    exchange.SetMarginLevel(5);
    exchange.SetDirection("closebuy");
    exchange.Sell(1000, 2);
}

exchange.SetContractType (계약형 설정)

exchange.SetContractType(ContractType)계약 유형을 설정합니다. 매개 변수 값: 문자열 유형. 암호화폐 전략에서 예를 들어 BTC_USDT을 사용하십시오.exchange.SetCurrency("BTC_USDT")또는exchange.IO("currency", "BTC_USDT"), 당신은 사용해야합니다exchange.SetContractType새로운 거래 쌍에 따라 운영되어야 하는 현재 계약을 결정하기 위해 계약을 재설정하는 기능.currency-based contract또는U-based contract에 근거하여거래 쌍예를 들어, 거래 쌍이BTC_ USDT, 사용 함수exchange.SetContractType계약 코드 설정swap, USDT 기반의 BTC의 영구 계약으로 설정됩니다.BTC_ USD, 사용 함수exchange.SetContractType계약 코드 설정swap, BTC의 통화 기반 영구 계약으로 설정됩니다.

다른 규정이 없는 한,배달 계약암호화폐 선물계약의 코드에는 일반적으로 다음을 포함합니다.

• this_week: 주간 계약
• next_week: 다음 주 계약
• quarter: 분기 계약
• next_quarter: 다음 분기 계약

다른 규정이 없는 한,영구 계약암호화폐 선물계약의 코드에는 일반적으로 다음을 포함합니다.

• swap: 영구계약

현재 계약을 주간 계약으로 설정합니다.

function main() {
    // Set to weekly contract
    exchange.SetContractType("this_week") 
}

def main():
    exchange.SetContractType("this_week")

void main() {
    exchange.SetContractType("this_week");
}

각 지원되는 암호화폐 거래소의 계약 이름에 대한 자세한 설명은 다음과 같습니다.

• OKX 영구 계약으로 설정:exchange.SetContractType("swap")이번 주 계약으로 설정:exchange.SetContractType("this_week")다음 주 계약으로 설정:exchange.SetContractType("next_week")분기 계약으로 설정:exchange.SetContractType("quarter")다음 분기 계약으로 설정:exchange.SetContractType("next_quarter")OKX USDT 마진 계약은 현재 계약에 대응하는 USDT 결제를 사용하는 계약으로 전환할 수 있습니다.trading pair(또는 교환 객체를 추가 할 때 직접 설정합니다.) 예를 들어:

  function main() {
      // The default trading pair is BTC_USD, the contract is set to the weekly contract, and the contract is the crypto-margined contract
      exchange.SetContractType("this_week")
      Log("ticker:", exchange.GetTicker())
      
      // Switch trading pairs, and then set a contract to a USDT-margined contract, which is different from the crypto-margined contract
      exchange.IO("currency", "BTC_USDT")   
      exchange.SetContractType("swap")
      Log("ticker:", exchange.GetTicker())
  }
  

  def main():
      exchange.SetContractType("this_week")
      Log("ticker:", exchange.GetTicker())
      exchange.IO("currency", "BTC_USDT")
      exchange.SetContractType("swap")
      Log("ticker:", exchange.GetTicker())
  

  void main() {
      exchange.SetContractType("this_week");
      Log("ticker:", exchange.GetTicker());
      exchange.IO("currency", "BTC_USDT");
      exchange.SetContractType("swap");
      Log("ticker:", exchange.GetTicker());
  }
  

• 미래에셋대우 이번 주 계약으로 설정:exchange.SetContractType("this_week")다음 주 계약으로 설정:exchange.SetContractType("next_week")분기 계약으로 설정:exchange.SetContractType("quarter")다음 분기 계약으로 설정:exchange.SetContractType("next_quarter")영구 계약으로 설정:exchange.SetContractType("swap")

  이 플랫폼은 USDT 마진 계약들을 지원합니다. 예를 들어 BTC 계약을 들어보죠.exchange.SetCurrency("BTC_USDT"), 또는 현재 거래 쌍을BTC_USDT직접 bot 매개 변수를 구성하고 교환 객체를 추가 할 때. 거래 쌍을 전환 한 후, 당신은 호출해야합니다exchange.SetContractType계약서를 다시 설정하는 기능을 합니다.

• 미래에셋자산 영구 계약으로 설정:exchange.SetContractType("XBTUSD"), exchange.SetContractType("APTUSDT")... 계약은 특정 시간에 결제되며 BitMEX의 공식 웹 사이트에 로그인하여 각 계약 코드를 확인하여 자세한 내용을 확인할 수 있습니다. 예를 들어:exchange.SetContractType("XBTM19").

• 퓨처스_게이트IO 이번 주 계약으로 설정:exchange.SetContractType("this_week")- 그래요 다음 주 계약으로 설정:exchange.SetContractType("next_week")- 그래요 분기 계약으로 설정:exchange.SetContractType("quarter")- 그래요 다음 분기 계약으로 설정:exchange.SetContractType("next_quarter")- 그래요 영구 계약으로 설정:exchange.SetContractType("swap")... 거래소는 USDT 마진 계약을 지원합니다. BTC 계약을 예로 들어보세요.exchange.SetCurrency("BTC_USDT"), 또는 현재 거래 쌍을BTC_USDT직접 라이브 거래 매개 변수를 구성하고 교환 객체를 추가 할 때. 거래 쌍을 전환 한 후, 당신은 호출해야합니다exchange.SetContractType계약서를 다시 설정하는 기능을 합니다.

• 미래에셋대우 영구 계약으로 설정:exchange.SetContractType("BTC-PERPETUAL")데리비트 USDC 계약 지원exchange.SetContractType("ADA_USDC-PERPETUAL")ADA USDC 마진 상속계약을 설정하기 위해서요. 계약은 특정 시간에 결제됩니다. 더 자세한 내용은 다음과 같은 각 계약 코드를 확인하기 위해 Deribit의 공식 웹 사이트에 로그인하십시오.exchange.SetContractType("BTC-27APR18").

• 미래에셋자산

  • 암호화 마진 계약 예를 들어, 거래 쌍을BTC_USD, 그 다음 암호화 마진 계약이라고 불리는 계약 코드를 설정합니다. 영구 계약으로 설정:exchange.SetContractType("swap")분기 계약으로 설정:exchange.SetContractType("quarter")다음 분기 계약으로 설정:exchange.SetContractType("next_quarter")
  • USDT 마진 계약: 예를 들어, 거래 쌍을BTC_USDT, 그 다음 USDT 마진 계약의 계약 코드를 설정합니다. 영구 계약으로 설정:exchange.SetContractType("swap").

• 미래에셋자산 바이낸스 퓨처스에서는 계약 상태를 설정하지 않습니다. 그래서 먼저 계약을 설정해야 합니다. 영구 계약으로 설정:exchange.SetContractType("swap")바이낸스 선물 상시 계약은 USDT 마진 계약이 될 수 있습니다.BTCUSDT 마진 계약, 거래 쌍은BTC_USDT. 바이낸스 미래에셋 상속 계약에는 암호화 마진 계약도 포함됩니다. 예를 들어 암호화 마진 계약에서 거래 쌍을BTC_USD.

  분기 계약으로 설정:exchange.SetContractType("quarter")배달 계약에는 암호화 마진 계약 (즉 사용 된 화폐를 마진으로 사용하는) 이 포함됩니다.BTC, 거래 쌍은BTC_USD, 그리고 계약 코드를 설정exchange.SetContractType("quarter"), BTC 암호화 마진 분기 계약을 설정합니다.

  다음 분기 계약으로 설정:exchange.SetContractType("next_quarter")예를 들어, 분기 암호화 마진 계약의BTC, 거래 쌍은BTC_USD, 그리고 계약 코드를 설정exchange.SetContractType("next_quarter). 바이낸스는 BTC 거래 쌍을 USDT 마진 배송 계약의 일부를 지원합니다.BTC_USDT그리고 계약 코드를 설정합니다.

• 퓨처스_비박스 바이박스 영구 계약 코드:swap- 그래요 영구 계약으로 설정:exchange.SetContractType("swap").

• 미래에셋대우 AOFEX 영구 계약 코드:swap- 그래요 영구 계약으로 설정:exchange.SetContractType("swap").

• 미래에셋자산 BFX 영구 계약 코드:swap- 그래요 영구 계약으로 설정:exchange.SetContractType("swap").

• 미래에셋자산 Bybit는 현재 거래 쌍의 영구 계약에 기본 설정됩니다. 계약 코드:swap- 그래요 분기 계약 코드:quarter- 그래요 다음 분기 계약 코드:next_quarter.

• 미래_크래켄 크라켄은 계약 상태를 설정하지 않습니다. 그래서 계약 코드를 설정해야 합니다. 계약 코드:swap: 영구 계약.month월계약quarter: 분기 계약.next_quarter다음 분기 계약.

• 퓨처스_비트피넥스 비트피넥스는 현재 거래 쌍의 영구 계약에 부과합니다. 계약 코드:swap.

• 퓨처스_비트젯 현재 거래 쌍의 영구 계약에 Bitget 기본 설정. 계약 코드:swap거래 쌍은BTC_USD, 암호화 마진 계약을 나타냅니다; 거래 쌍은BTC_USDT, USDT 마진 계약을 나타냅니다. 시뮬레이션 계약은 거래 쌍을 다음과 같이 설정할 수 있습니다.SBTC_USD그리고BTC_SUSDT.

• 선물_dYdX dYdX 영구 계약의 계약 코드:swap- 그래요 영구 계약으로 설정:exchange.SetContractType("swap"). dYdX는 USDT 마진 계약만 가지고 있습니다.

• 퓨처스_MEXC MEXC 상속 계약의 계약 코드:swap- 그래요 영구 계약으로 설정:exchange.SetContractType("swap")거래 쌍은BTC_USD, 암호화 마진 계약을 나타냅니다; 거래 쌍은BTC_USDT, USDT 마진 계약을 나타냅니다.

암호화폐 전략을 작성할 때,exchange.SetContractType(ContractType)기능 및 계약 매개 변수에 의해 설정된 세부 계약 정보ContractType반환됩니다.

예를 들어, 거래 대상으로 설정된 OKX 계약의 전략 코드를 실행:

function main(){
    // Set to weekly contract
    var ret = exchange.SetContractType("this_week")     
    // Return the information of the weekly contract
    Log(ret)
}

def main():
    ret = exchange.SetContractType("this_week")
    Log(ret)

void main() {
    auto ret = exchange.SetContractType("this_week");
    Log(ret);
}

전략 실행JavaScript언어, 인쇄ret데이터, 즉 자세한 정보this_week계약:

{
    "instrument":"BTC-USD-191101",
    "InstrumentID":"BTC-USD-191101"
}   

exchange.GetContractType (계약형)

exchange.GetContractType()교환 대상의 현재 설정된 계약 코드를 반환합니다 (exchange), 반환 값: 문자열.

function main () {
    Log(exchange.SetContractType("this_week")) 
    Log(exchange.GetContractType())
}

def main():
    Log(exchange.SetContractType("this_week"))
    Log(exchange.GetContractType())

void main() {
    Log(exchange.SetContractType("this_week"));
    Log(exchange.GetContractType());
}

Futures_OP 오류

다음 표는 암호화폐 선물 계약의 교환 대상과 관련된 오류 정보를 설명합니다.

가치	함수 표시 오류	트리거 함수	설명
0	선물_OP 0	exchange.SetMarginLevel	레버리지 함수를 호출하는 오류
1	선물_OP 1	exchange.SetDirection	선물 거래 방향 함수를 설정하는 오류
2	미래에셋_OP 2	exchange.SetContractType	계약 기능 설정 오류
3	미래_OP 3	exchange.GetPosition	위치 함수를 얻는 오류
4	미래_OP 4	exchange.IO	IO 함수를 호출하는 오류

옵션 거래

암호화폐 옵션

사용exchange.SetContractType다른 거래소에는 다른 옵션 계약 코드가 있습니다.

FMZ 퀀트 트레이딩 플랫폼에서 지원되는 암호화폐 옵션 거래소

• 데리비트 데리비트 거래소에선exchange.SetContractType옵션 계약을 설정 한 후, 시장 인터페이스와 같은 호출 할 때GetTicker, 옵션 계약의 모든 시장 데이터가 획득됩니다.exchange.Sell그리고exchange.Buy주문을 할 때 거래 방향에 주의를 기울이고,exchange.SetDirection.exchange.Cancel주문을 취소 할 수 있습니다.exchange.GetPosition위치 검색 함수

  참조 전략 코드:데리빗 옵션의 테스트 전략

• OKX 계약서 수립, 주문 배치, 주문 취소, 주문 조회 및 시장 코팅 등을 얻는 것은Deribit계약 코드 형식은BTC-USD-200626-4500-C. 당신은 인터페이스를 통해 계약과 관련된 정보를 검색 할 수 있습니다https://www.okx.com/api/v5/public/instruments.

  예를 들어, BTC 옵션 계약의 정보를 검색하려면:

  function main() {
      Log(HttpQuery("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD"))
  }
  

  import json
  import urllib.request
  def main():
      ret = json.loads(urllib.request.urlopen("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD").read().decode('utf-8'))
      Log(ret)
  

  void main() {
      Log(HttpQuery("https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD"));
  }
  

• 미래에셋대우 예를 들어, Huobi 옵션 계약 코드:BTC-USDT-201225-P-13000계약은BTC계약; 행사 날짜는 2020년 12월 25일입니다. 옵션은 Put Options (PUT) 입니다. 파업 가격은 $13,000입니다. 콜 옵션의 경우, 구매자가 지불하는 프리미엄은 USDT이며, 계좌 자산에 있는 USDT가 사용된다는 것을 나타냅니다. 판매자의 마진은 자산에 있는 통화로 보장되는 통화입니다. 파트 옵션의 경우, 구매자가 지불하는 프리미엄은 USDT이며, 계좌 자산에 있는 USDT가 사용된 것을 나타냅니다. 판매자의 마진은 USDT이며, 자산에 있는 USDT에 의해 보장됩니다.

• 미래에셋자산 그것은 Bybit 거래소의 USDC 옵션을 지원하고 거래 쌍을ETH_USDC, 호출 함수exchange.SetContractType계약서를 옵션 계약으로 설정합니다. 옵션 계약 코드 예:ETH-25NOV22-1375-P.

네트워크 설정

교환.SetBase(Base)

이exchange.SetBase(Base)이 함수는 교환 객체에 기록된 API 기본 주소를 전환하는 데 사용됩니다. 예를 들어,OKX도메인 이름https://aws.okx.com,exchange.IO("base","https://aws.okx.com")스위칭 방법. 백테스트 시스템은 교환의 API 기본 주소를 스위칭하는 것을 지원하지 않습니다 (백테스트 시스템은 샌드박스 환경이며 교환에 액세스하는 실제 인터페이스가 아닙니다).

function main() {
    // Use the default base address
    Log(exchange.GetTicker())
    // Switch to https://aws.okx.com
    exchange.SetBase("https://aws.okx.com")
    Log(exchange.GetTicker())
}

def main():
    Log(exchange.GetTicker())
    exchange.SetBase("https://aws.okx.com")
    Log(exchange.GetTicker())

void main() {
    Log(exchange.GetTicker());
    exchange.SetBase("https://aws.okx.com");
    Log(exchange.GetTicker());
}

교류.SetProxy(...)

exchange.SetProxy(...)교환에 액세스하기 위해 프록시 서버로 전환합니다. 이 함수는 반환 값이 없습니다 (변수들에 의해 얻어진, 그리고 당신이 얻는 것은undefined) 만약 프록시 설정이 실패하면, 인터페이스가 호출될 때 null 값이 반환됩니다.휴식모든 교환 객체exchanges[n]프록시를 설정하면 프록시를 통해 교환 인터페이스에 액세스할 수 있습니다.

첫 번째 추가 교환 객체를 가져exchange, 즉:exchanges[0]예를 들어:

• 사용자 이름과 비밀번호 없이 프록시를 설정합니다.exchange.SetProxy("socks5://127.0.0.1:8889")
• 프록시를 설정하고 사용자 이름과 암호를 입력합니다.exchange.SetProxy("socks5://username:password@127.0.0.1:8889") (username사용자 이름입니다password비밀번호입니다.)
• 프록시 없이 정상 모드로 전환합니다.exchange.SetProxy("")

교환 객체에 의해 요청된 IP 주소를 설정하는 것을 지원합니다.

• 글로벌 사양 닷커의windows시스템 인터페이스 버전을 직접 설정할 수 있습니다.

명령 프롬프트 사용 매개 변수로 작동하는 다른 항구-IIP 주소를 지정하기 위해:

• 교환에 기초하여 구체적으로:

  function main(){
      exchange.SetProxy("ip://10.0.3.15")
      exchange.GetTicker()                      // The reque

더 많은