이exchange.Buy()이 기능은 구매 주문을 배치하는 데 사용됩니다.Buy()함수는 교환 객체 {@var/EXCHANGE exchange}의 멤버 함수입니다.Buy()함수는 교환 대상과 연결된 교환 계좌에서 작동합니다.exchange의 구성원 기능 (방법) 의 목적exchange객체와만 관련이 있습니다.exchange, 그리고 문서화 후에 반복되지 않을 것입니다.
성공한 명령은 명령 Id를 반환하고 실패한 명령은 null 값을 반환합니다.
속성IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id포트 거래 쌍의 형식ETH_USDTOKX 거래소의 순서는ETH-USDT,1547130415509278720...
전화할 때exchange.Buy()주문을 할 수 있는 함수, 반환 값 주문Id의 내용과 일치합니다.Id명령어 {@struct/Order Order} 구조의 속성.
문자열, null 값
교환.구매 (가격, 금액) 교환.구매 (가격, 금액,...args)
이price매개 변수는 주문 가격을 설정하는 데 사용됩니다.
가격
사실
번호
의amount매개 변수는 주문 금액을 설정하는 데 사용됩니다.
금액
사실
번호
이 주문 로그에 첨부 정보를 출력할 수 있는 확장된 매개 변수arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
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);
}
반환된 순서 번호exchange.Buy()주문 정보를 검색하고 주문을 취소하는 데 사용할 수 있습니다.
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error 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 an error 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, the trading pair: ETH_BTC, place a buy order at the market price
function main() {
// Place a buy order at the market price and buy ETH coins with a value of 0.1 BTC (denominated currency)
exchange.Buy(-1, 0.1)
}
def main():
exchange.Buy(-1, 0.1)
void main() {
exchange.Buy(-1, 0.1);
}
현금 시장 주문.
선물 계약에 대한 주문을 할 때, 거래 방향과 거래 기능이 일치하지 않으면 오류가 보고되기 때문에 거래 방향이 올바르게 설정되었는지에주의를 기울여야합니다. 암호화폐 선물 계약의 주문 크기는 지정되지 않은 경우 계약 수입니다.
매개 변수price설정되어 있습니다-1시장 주문을 배치하기 위해, 거래소의 주문 배치 인터페이스가 시장 주문을 지원하도록 요구합니다.amount화폐 선물 계약에 대한 시장 주문을 할 때, 금액 매개 변수amount계약의 수입니다. 라이브 거래 중에 시장 주문 인터페이스를 지원하지 않는 몇 개의 암호화폐 거래소가 있습니다. 일부 스팟 거래소에서 시장 구매 주문의 주문 양은 거래 코인의 수입니다.교환에 관한 특별 지침자세한 내용은 Id의exchange.Buy()함수는 명령의 반환 값과 다를 수 있습니다Id현재 문서에 설명되어 있습니다.
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
이exchange.Sell()이 함수는 판매 주문을 하기 위해 사용 됩니다.
성공한 명령은 명령 Id를 반환, 실패한 명령은 null 값을 반환. 속성IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id포트 거래 쌍의 형식ETH_USDTOKX 거래소의 순서는ETH-USDT,1547130415509278720전화할 때exchange.Sell()주문을 할 수 있는 함수, 반환 값 주문Id의 내용과 일치합니다.Id명령어 {@struct/Order Order} 구조의 속성.
문자열, null 값
교환.판매 (가격, 금액) 교환.판매 (가격, 금액,...args)
이price매개 변수는 주문 가격을 설정하는 데 사용됩니다.
가격
사실
번호
의amount매개 변수는 주문 금액을 설정하는 데 사용됩니다.
금액
사실
번호
이 주문 로그에 첨부 정보를 출력할 수 있는 확장된 매개 변수arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
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);
}
반환된 순서 번호exchange.Sell()주문 정보를 검색하고 주문을 취소하는 데 사용할 수 있습니다.
// The following is an error call
function main() {
exchange.SetContractType("quarter")
// Set the shorting direction
exchange.SetDirection("sell")
// If you place a buy order, an error will be reported, and shorting can only be sold
var id = exchange.Buy(50, 1)
// Set the long direction
exchange.SetDirection("buy")
// If you place a sell order, it will report an error, go long, only buy
var id2 = exchange.Sell(60, 1)
// Set direction to close long positions
exchange.SetDirection("closebuy")
// If you place a buy order, it will report an error, close long, only sell
var id3 = exchange.Buy(-1, 1)
// Set direction to close short positions
exchange.SetDirection("closesell")
// If you place a sell order, it will report an error, close short, only buy
var id4 = exchange.Sell(-1, 1)
}
# The following is an error 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 an error 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, the trading pair: ETH_BTC, place a sell order at the market price
function main() {
// Note: place a market order to sell, sell 0.2 ETH
exchange.Sell(-1, 0.2)
}
def main():
exchange.Sell(-1, 0.2)
void main() {
exchange.Sell(-1, 0.2);
}
현금 시장 주문.
선물 계약에 대한 주문을 할 때 거래 방향이 올바르게 설정되었는지에주의를 기울여야합니다. 거래 방향과 거래 기능이 일치하지 않으면 오류가 보고됩니다. 암호화폐 선물 계약의 주문 금액은 지정되지 않은 경우 계약 수입니다.
매개 변수price설정되어 있습니다-1시장 주문을 배치하는 데 필요한 거래소amount거래 화폐의 금액입니다. 암호화폐 선물 계약에 대한 시장 주문을 할 때 금액 매개 변수amount계약의 수입니다. 라이브 거래 중에 시장 주문 인터페이스를 지원하지 않는 몇 개의 암호화폐 거래소가 있습니다.
당신이 도커의 오래된 버전을 사용하는 경우, 순서의 반환 값Id의exchange.Sell()함수는 명령의 반환 값과 다를 수 있습니다Id현재 문서에 설명되어 있습니다.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
이exchange.CreateOrder()함수는 주문을 하기 위해 사용 됩니다.
주문이 성공적으로 배치되면 주문 ID가 반환됩니다. 주문이 실패하면 null 값이 반환됩니다.IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id스팟 거래 쌍의 주문 형식ETH_USDTOKX 거래소의 경우:ETH-USDT,1547130415509278720전화할 때exchange.CreateOrder(symbol, side, price, amount)주문을 할 수 있는 함수, 주문의 반환 값Id의 내용과 일치합니다.Id명령어 {@struct/Order Order} 구조의 속성.
문자열, null 값
exchange.CreateOrder (표자, 측면, 가격, 금액) exchange.CreateOrder ((기호, 측면, 가격, 금액,...args)
매개 변수symbol주문의 특정 거래 쌍 및 계약 코드를 지정하는 데 사용됩니다.exchange.CreateOrder(symbol, side, price, amount)주문을 하는 기능exchange즉석 교환 대상이 됩니다. 주문의 화폐가 USDT이고 거래 화폐가 BTC라면,symbol이 경우:"BTC_USDT", FMZ 플랫폼에 의해 정의 거래 쌍의 형식으로.exchange.CreateOrder(symbol, side, price, amount)주문을 하는 기능exchange선물 거래 대상입니다. 주문이 BTCsymbol이 경우:"BTC_USDT.swap", 그리고 형식은거래 쌍그리고계약 코드FMZ 플랫폼에 의해 정의, 문자 exchange.CreateOrder(symbol, side, price, amount)주문을 하는 기능exchange선물 거래 대상입니다. 주문이 BTCsymbol이 경우:"BTC_USDT.BTC-240108-40000-C"(예를 들어 Binance Option BTC-240108-40000-C를 사용 하 여), 그리고 형식은거래 쌍FMZ 플랫폼에서 정의하고 거래소에서 정의한 특정 옵션 계약 코드,
기호
사실
문자열
의side매개 변수는 명령의 거래 방향을 지정하는 데 사용됩니다.
스팟 교환 대상의 경우,side매개 변수는 다음과 같습니다.buy, sell. buy구매를 의미하며,sell판매하는 것을 의미합니다.
미래에셋 거래 대상의 경우,side매개 변수는 다음과 같습니다.buy, closebuy, sell, closesell. buy긴 포지션을 개설하는 것을 의미합니다.closebuy긴 포지션을 닫는 것을 의미합니다.sell단기 포지션 개설을 의미하며,closesell즉, 짧은 포지션을 닫는 것을 의미합니다.
옆면
사실
문자열
매개 변수price명령의 가격을 설정하는 데 사용됩니다. -1의 가격은 명령이 시장 명령이라는 것을 나타냅니다.
가격
사실
번호
매개 변수amount주문 양을 설정하는 데 사용됩니다. 주문이 시장 구매 주문이라면, 주문 양은 구매 금액이며, 일부 스팟 거래소의 시장 구매 주문의 주문 양은 거래 코인의 수입니다. 자세한 내용은교환에 관한 특별 지침arg매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 값 등과 같은 시스템에서 지원되는 모든 유형
function main() {
var id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// var id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
}
def main():
id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01) # Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
# id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01) # Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id)
void main() {
auto id = exchange.CreateOrder("BTC_USDT", "buy", 60000, 0.01); // Spot exchange objects place orders for currency-to-currency transactions BTC_USDT trading pairs
// auto id = exchange.CreateOrder("BTC_USDT.swap", "buy", 60000, 0.01); // Futures exchange objects place orders for BTC's U-standard perpetual contracts
Log("Order Id:", id);
}
스팟 거래 대상과 미래에셋 거래 대상exchange.CreateOrder()주문을 하는 기능입니다.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
이exchange.CancelOrder()함수는 주문을 취소하는 데 사용됩니다.
속성IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id스팟 거래 쌍의 주문 형식ETH_USDTOKX 거래소의 경우:ETH-USDT,1547130415509278720...
매개 변수orderId전화 할 때 통과exchange.CancelOrder()주문을 취소하는 기능이Id명령어 {@struct/Order Order} 구조의 속성.
이exchange.CancelOrder()함수는 실제 값을 반환, 예를 들어true취소 주문 요청이 성공적으로 전송되었다는 것을 의미합니다.false, 취소 주문 요청이 전송되지 않았다는 것을 의미합니다. 반환 값은 교환이 주문을 취소하는지 여부를 결정하기 위해 전송 요청의 성공 또는 실패를 나타냅니다.exchange.GetOrders()명령이 취소되었는지 여부를 결정하기 위해서입니다.
bool
교환. 주문 취소 (orderId) 교환. 주문 취소 (orderId,...args)
이orderId이 매개 변수는 취소될 주문을 지정하는 데 사용됩니다.
명령
사실
숫자, 문자열
확장된 매개 변수, 당신은 이 철회 로그에 첨부 정보를 출력 할 수 있습니다,arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
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);
}
주문을 취소해
function main() {
if (exchange.GetName().includes("Futures_")) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
}
var ticker = exchange.GetTicker()
exchange.Buy(ticker.Last * 0.5, 0.1)
var orders = exchange.GetOrders()
for (var i = 0 ; i < orders.length ; i++) {
exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i])
Sleep(500)
}
}
def main():
if exchange.GetName().find("Futures_") != -1:
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.")
exchange.SetContractType("swap")
exchange.SetDirection("buy")
ticker = exchange.GetTicker()
exchange.Buy(ticker["Last"] * 0.5, 0.1)
orders = exchange.GetOrders()
for i in range(len(orders)):
exchange.CancelOrder(orders[i]["Id"], "Cancelled orders:", orders[i])
Sleep(500)
void main() {
if (exchange.GetName().find("Futures_") != std::string::npos) {
Log("Set the contract as: perpetual contract, set the trade direction as: open long position.");
exchange.SetContractType("swap");
exchange.SetDirection("buy");
}
auto ticker = exchange.GetTicker();
exchange.Buy(ticker.Last * 0.5, 0.1);
auto orders = exchange.GetOrders();
for (int i = 0 ; i < orders.size() ; i++) {
exchange.CancelOrder(orders[i].Id, "Cancelled orders:", orders[i]);
Sleep(500);
}
}
FMZ API 함수들은 다음과 같은 로그 출력 함수를 생성할 수 있습니다.Log(), exchange.Buy(), exchange.CancelOrder()필요한 매개 변수에 따라 몇 가지 동반 출력 매개 변수가 따라갈 수 있습니다. 예를 들어:exchange.CancelOrder(orders[i].Id, orders[i]), 그래서 주문을 취소 할 때orders[i].Id즉, {@struct/Order Order} 구조의orders[i].
만약 당신이 더 오래된 버전의 도커를 사용한다면, exchange.CancelOrder() 함수의 orderId 매개 변수는 현재 문서에서 설명된 orderId와 다를 수 있습니다.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
이exchange.GetOrder()함수는 주문 정보를 얻기 위해 사용됩니다.
질서 번호에 따라 순서 세부 정보를 검색하고 질서가 성공하면 {@struct/Order Order} 구조를 반환하거나 질서가 실패하면 null을 반환합니다. {@struct/Order Order}, null 값
교환.GetOrder
이orderId매개 변수는 질의 할 순서를 지정하는 데 사용됩니다.
속성IdFMZ 플랫폼의 순서 {@struct/Order Order} 구조는 교환 제품 코드와 교환 원본 주문 ID로 구성되어 있으며 영어 koma로 분리됩니다. 예를 들어, 속성Id스팟 거래 쌍의 주문 형식ETH_USDTOKX 거래소의 경우:ETH-USDT,1547130415509278720...
매개 변수orderId전화 할 때 통과exchange.GetOrder()명령어에 대한 쿼리 함수가Id명령어 {@struct/Order Order} 구조의 속성.
명령 사실 문자열
function main(){
var id = exchange.Sell(1000, 1)
// 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);
}
이exchange.GetOrder()이 기능은 일부 거래소에서 지원되지 않습니다.AvgPrice반환 값의 {@struct/Order Order} 구조의 속성은 트랜잭션의 평균 가격입니다. 일부 거래소는 이 필드를 지원하지 않으며, 그렇지 않으면 0로 설정됩니다.
더 오래된 버전의 도커를 사용하는 경우,orderId매개 변수exchange.GetOrder()기능이orderId현재 문서에 설명되어 있습니다.
거래소를 지원하지 않는 거래소exchange.GetOrder()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetOrder | 자이프 / 코인체크 / 비트스탬프 | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
이exchange.GetOrders()이 함수는 미수된 주문을 얻기 위해 사용됩니다.
이exchange.GetOrders()이 함수는 데이터 요청이 성공하면 {@struct/Order Order} 구조의 배열을 반환하고, 데이터 요청이 실패하면 null 값을 반환합니다.
{@struct/Order Order} 배열, null 값
교환.GetOrders() 교환.GetOrders (신호)
매개 변수symbol사용 됩니다거래 기호또는거래 기호 범위조사를 받을 수 있습니다.
스팟 교환 대상을 위해,symbol매개 변수가 전달되지 않으면 모든 스팟 제품의 완료되지 않은 주문 데이터가 요청됩니다.
미래에셋 거래 대상의 경우symbol매개 변수가 전달되지 않으면, 기본값은 현재 거래 쌍과 계약 코드 차원의 모든 품종의 완료되지 않은 주문 데이터를 요청하는 것입니다.
기호 거짓 문자열
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01)
}
var spotOrders = exchange.GetOrders()
var tbls = []
for (var orders of [spotOrders]) {
var tbl = {type: "table", title: "test GetOrders", cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 0.01)
spotOrders = exchange.GetOrders()
tbls = []
for orders in [spotOrders]:
tbl = {"type": "table", "title": "test GetOrders", "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"ETH_USDT", "BTC_USDT", "LTC_USDT", "SOL_USDT"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 0.01);
}
auto spotOrders = exchange.GetOrders();
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {spotOrders};
for (const auto& orders : arr) {
json tbl = R"({
"type": "table",
"title": "test GetOrders",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back("Symbol");
arrJson.push_back("Id");
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
스팟 교환 객체를 사용하여 현재 가격의 절반에 여러 개의 다른 거래 쌍에 대한 구매 주문을 배치하고 그 다음 미수 주문 정보를 검색합니다.
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
function main() {
var arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for (var symbol of arrSymbol) {
var t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1)
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1)
}
var defaultOrders = exchange.GetOrders()
var swapOrders = exchange.GetOrders("USDT.swap")
var futuresOrders = exchange.GetOrders("USDT.futures")
var btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
var tbls = []
var arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
var tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for (var index in arr) {
var orders = arr[index]
var tbl = {type: "table", title: tblDesc[index], cols: ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], rows: []}
for (var order of orders) {
tbl.rows.push([order.Symbol, order.Id, order.Price, order.Amount, order.DealAmount, order.AvgPrice, order.Status, order.Type, order.Offset, order.ContractType])
}
tbls.push(tbl)
}
LogStatus("`" + JSON.stringify(tbls) + "`")
// Print out the information once and then return to prevent the order from being executed during the subsequent backtest and affecting data observation
return
}
'''backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
'''
import json
def main():
arrSymbol = ["BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"]
for symbol in arrSymbol:
t = exchange.GetTicker(symbol)
exchange.CreateOrder(symbol, "buy", t["Last"] / 2, 1)
exchange.CreateOrder(symbol, "sell", t["Last"] * 2, 1)
defaultOrders = exchange.GetOrders()
swapOrders = exchange.GetOrders("USDT.swap")
futuresOrders = exchange.GetOrders("USDT.futures")
btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap")
tbls = []
arr = [defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders]
tblDesc = ["defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"]
for index in range(len(arr)):
orders = arr[index]
tbl = {"type": "table", "title": tblDesc[index], "cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"], "rows": []}
for order in orders:
tbl["rows"].append([order["Symbol"], order["Id"], order["Price"], order["Amount"], order["DealAmount"], order["AvgPrice"], order["Status"], order["Type"], order["Offset"], order["ContractType"]])
tbls.append(tbl)
LogStatus("`" + json.dumps(tbls) + "`")
return
/*backtest
start: 2024-05-21 00:00:00
end: 2024-09-05 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
void main() {
auto arrSymbol = {"BTC_USDT.swap", "BTC_USDT.quarter", "ETH_USDT.swap", "ETH_USDT.quarter"};
for (const auto& symbol : arrSymbol) {
auto t = exchange.GetTicker(symbol);
exchange.CreateOrder(symbol, "buy", t.Last / 2, 1);
exchange.CreateOrder(symbol, "sell", t.Last * 2, 1);
}
auto defaultOrders = exchange.GetOrders();
auto swapOrders = exchange.GetOrders("USDT.swap");
auto futuresOrders = exchange.GetOrders("USDT.futures");
auto btcUsdtSwapOrders = exchange.GetOrders("BTC_USDT.swap");
json tbls = R"([])"_json;
std::vector<std::vector<Order>> arr = {defaultOrders, swapOrders, futuresOrders, btcUsdtSwapOrders};
std::string tblDesc[] = {"defaultOrders", "swapOrders", "futuresOrders", "btcUsdtSwapOrders"};
for (int index = 0; index < arr.size(); index++) {
auto orders = arr[index];
json tbl = R"({
"type": "table",
"cols": ["Symbol", "Id", "Price", "Amount", "DealAmount", "AvgPrice", "Status", "Type", "Offset", "ContractType"],
"rows": []
})"_json;
tbl["title"] = tblDesc[index];
for (const auto& order : orders) {
json arrJson = R"([])"_json;
arrJson.push_back(order.Symbol);
arrJson.push_back(to_string(order.Id)); // The Id attribute type in the Order structure is TId, which is encoded using a C++ function to_string built into the FMZ platform.
arrJson.push_back(order.Price);
arrJson.push_back(order.Amount);
arrJson.push_back(order.DealAmount);
arrJson.push_back(order.AvgPrice);
arrJson.push_back(order.Status);
arrJson.push_back(order.Type);
arrJson.push_back(order.Offset);
arrJson.push_back(order.ContractType);
tbl["rows"].push_back(arrJson);
}
tbls.push_back(tbl);
}
LogStatus(_D(), "\n", "`" + tbls.dump() + "`");
return;
}
선물 거래소 객체를 사용하여 여러 가지 다른 거래 쌍 및 계약 코드를 주문합니다. 상대방 가격에서 멀리 떨어진 가격에 주문을 배치하고, 채무되지 않은 상태에서 주문을 보관하고, 여러 가지 방법으로 주문을 문의하십시오.
function main() {
var orders = exchange.GetOrders("BTC_USDT") // Examples of spot products
// var orders = exchange.GetOrders("BTC_USDT.swap") // Examples of futures products
Log("orders:", orders)
}
def main():
orders = exchange.GetOrders("BTC_USDT") # Examples of spot products
# orders = exchange.GetOrders("BTC_USDT.swap") # Examples of futures products
Log("orders:", orders)
void main() {
auto orders = exchange.GetOrders("BTC_USDT"); // Examples of spot products
// auto orders = exchange.GetOrders("BTC_USDT.swap"); // Examples of futures products
Log("orders:", orders);
}
전화할 때exchange.GetOrders()기능, 통과Symbol특정 거래 쌍 및 계약 코드에 대한 주문 데이터를 요청하는 매개 변수
이 지역에서는GetOrders함수, 기호 매개 변수의 사용 시나리오는 다음과 같이 요약됩니다.
| 교환 객체 분류 | 기호 매개 변수 | 쿼리 범위 | 언급 |
|---|---|---|---|
| 스팟 | 기호 매개 변수를 전달하지 마십시오 | 모든 스팟 거래 쌍을 검색합니다. | 모든 호출 시나리오에 대해, 교환 인터페이스가 지원하지 않으면 오류가 보고되고 null 값이 반환됩니다. 더 이상의 설명은 주어지지 않습니다. |
| 스팟 | 거래 유형을 지정합니다. 기호 매개 변수는: |
지정된 BTC_USDT 거래 쌍을 검색 | 스팟 거래소 개체에 대한 기호 매개 변수 형식은: |
| 선물 | 기호 매개 변수를 전달하지 마십시오 | 현재 거래 쌍 및 계약 코드 차원 범위 내의 모든 거래 제품을 검색합니다. | 현재 거래 쌍이 BTC_USDT이고 계약 코드가 swap인 경우, USDT 마진을 가진 모든 영구 계약이 검색됩니다.GetOrders("USDT.swap") |
| 선물 | 거래 유형을 지정합니다. 기호 매개 변수는: |
특정 BTC에 대한 USDT 기반 상시계약을 검색 | 미래에셋 거래소 대상의 경우 매개 변수 기호 형식은:거래 쌍그리고계약 코드FMZ 플랫폼에 의해 정의되며, 문자로 구분됩니다.".. |
| 선물 | 거래 상품 범위를 지정합니다. 기호 매개 변수는: |
모든 USDT 기반 상시계약을 검색합니다. | - |
| 옵션을 지원하는 선물 거래소 | 기호 매개 변수를 전달하지 마십시오 | 현재 거래 쌍 차원 범위 내의 모든 옵션 계약을 검색 | 현재 거래 쌍이 BTC_USDT인 경우 계약은 옵션 계약으로 설정됩니다. 예를 들어 Binance 옵션 계약: BTC-240108-40000-C |
| 옵션을 지원하는 선물 거래소 | 특정 거래 상품을 지정 | 지정된 옵션 계약을 검색 | 예를 들어, 바이낸스 선물 거래소에서 기호 매개 변수는: BTC_USDT.BTC-240108-40000-C |
| 옵션을 지원하는 선물 거래소 | 거래 상품 범위를 지정합니다. 기호 매개 변수는: |
모든 USDT 기반 옵션 계약을 검색 | - |
이 지역에서는GetOrders함수, 선물 거래소 객체 질의
차원 범위는 다음과 같이 요약됩니다.
| 기호 매개 변수 | 요청 범위 정의 | 언급 |
|---|---|---|
| USDT.swap | USDT 기반의 영구계약 범위 | 에 대해 |
교환 API 인터페이스에서 지원되지 않는 차원, 오류가 보고되고 null 값이 반환됩니다. 전화합니다. ♫ USDT.futures ♫ ♫ USDT 기반 배송 계약 범위 ♫ ♫ USDT 기반 배달 계약 범위 ♫ ♫ USDT.futures ♫ USD.swap. 계약입니다. USD.futures. 통화 기반의 배송 범위 계약입니다. USDT 옵션 USDT 기반 옵션 계약 범위 USD 옵션 통화 기반 옵션 계약 범위 USDT.futures_combo CFD 조합의 범위 퓨처스_데리빗 거래소 USD.futures_ff 혼합 마진 배송 계약의 범위. 미래_크래켄 거래소 USD.swap_pf. 혼합 마진 영구 계약의 범위. ∙∙미래_크래켄 거래소
교환 대상으로 대표되는 계좌가exchange그 안에 대기 명령이 없습니다질의 범위또는특정 거래 도구이 함수를 호출하면 빈 배열을 반환합니다.[]- 네
다음 교환은 현재 완료되지 않은 주문을 검색 할 때 도구가 도구 매개 변수에 전달되도록 요구합니다. 이러한 교환에서 GetOrders 함수를 호출 할 때, 도구 매개 변수가 전달되지 않으면 현재 도구의 완료되지 않은 주문만 요청되며 모든 도구의 완료되지 않은 주문이 요청되지 않습니다. (교환 인터페이스가 이것을 지원하지 않기 때문에).
자이프, MEXC, LBank, 코르비트, 코인, 비트마트, 비트럼브, 비트플라이어, 빅온
거래소를 지원하지 않는 거래소exchange.GetOrders()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetOrders | – | 퓨처스_비박스 |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
이exchange.GetHistoryOrders()이 함수는 현재 거래 쌍, 계약에 대한 역사적 주문을 얻기 위해 사용됩니다. 특정 거래 품종의 사양을 지원합니다.
이exchange.GetHistoryOrders()function는 데이터 요청이 성공하면 {@struct/Order Order} 구조의 배열을 반환하고 요청이 실패하면 null을 반환합니다.
{@struct/Order Order} 배열, null 값
교환.GetHistoryOrders() 교환.GetHistoryOrders (신호) exchange.GetHistoryOrders (기호, 이후) exchange.GetHistoryOrders (표자, 이후, 제한) 교환.GetHistoryOrders (그때부터) exchange.GetHistoryOrders (역시, 제한)
이symbol매개 변수를 사용 하 여 상표 를 지정 합니다.BTC_USDT예를 들어,exchange즉석 교환 객체입니다.symbol이BTC_USDT· 만약 선물 거래 대상인 경우, 예를 들어 상시계약으로,symbol이 경우:BTC_USDT.swap- 네
옵션 계약의 주문 데이터를 검색하는 경우, 매개 변수를 설정symbol에"BTC_USDT.BTC-240108-40000-C"(예를 들어 Binance Option BTC-240108-40000-C를 사용합니다.)거래 쌍FMZ 플랫폼에서 정의하고 거래소에서 정의한 특정 옵션 계약 코드,
이 매개 변수가 통과되지 않으면 현재 설정된 거래 쌍과 계약 코드의 주문 데이터가 기본적으로 요청됩니다.
기호
거짓
문자열
의since매개 변수는 질의의 시작 시간표를 밀리 초로 지정하는 데 사용됩니다.
그 이후로
거짓
번호
의limit매개 변수는 질의 할 명령의 수를 지정하는 데 사용됩니다.
한계
거짓
번호
function main() {
var historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
}
def main():
historyOrders = exchange.GetHistoryOrders()
Log(historyOrders)
void main() {
auto historyOrders = exchange.GetHistoryOrders();
Log(historyOrders);
}
symbol, since, limit매개 변수가 지정되지 않은 경우, 기본 질의는 현재 거래 쌍, 계약의 역사 주문입니다. 현재 시간으로 가장 가까운 특정 범위 내에서 역사 주문을 질의하면 질의 범위는 교환 인터페이스의 단일 질의 범위에 달려 있습니다.symbol매개 변수가 지정되면, 설정된 거래 유형에 대한 명령어 역사를 검색합니다.since매개 변수를 지정하면, 현재 시간 방향으로 질의since시작시간으로 시간표가 붙여져 있습니다.limit매개 변수가 지정되면 충분한 수의 입력 후에 질의가 반환됩니다.거래소를 지원하지 않는 거래소exchange.GetHistoryOrders()기능:
| 함수 이름 | 지원되지 않는 스팟 교환 | 지원되지 않은 선물 거래 |
|---|---|---|
| GetHistory 명령어 | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | 선물_dYdX / 선물_비박스 / 선물_아폴로X |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
exchange.SetPrecision()함수는 정밀도를 설정하는 데 사용됩니다exchange교환 대상가격그리고주문 금액, 설정 후, 시스템은 과도한 데이터를 자동으로 무시합니다.
교환.SetPrecision ((가격Precision, 금액Precision)
이pricePrecision이 매개 변수는 가격 데이터의 정확성을 제어하는 데 사용됩니다.
가격정확성
사실
번호
의amountPrecision이 매개 변수는 주문해야 하는 데이터 양의 정확성을 제어하는 데 사용됩니다.
금액정확성
사실
번호
function main(){
// Set the decimal precision of price to 2 bits, and the decimal precision of variety order amount to 3 bits
exchange.SetPrecision(2, 3)
}
def main():
exchange.SetPrecision(2, 3)
void main() {
exchange.SetPrecision(2, 3);
}
백테스팅 시스템은 이 기능을 지원하지 않으며 백테스팅 시스템의 수치 정확도는 자동으로 처리됩니다.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
교환 대상의 현재 환율을 설정합니다.
교환.SetRate (비율)
이rate변수는 전환 환율을 지정하는 데 사용됩니다.
비율
사실
번호
function main(){
Log(exchange.GetTicker())
// Set exchange rate conversion
exchange.SetRate(7)
Log(exchange.GetTicker())
// Set to 1, no 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()7과 같은 기능. 그러면 현재에 의해 대표되는 교환에 대한 틱어, 깊이, 주문 가격 등과 같은 모든 가격 정보exchange교환 대상은 7의 설정 환율에 곱하여 변환됩니다. 예를 들어,exchange미국 달러로 통화를 교환하는 것입니다.exchange.SetRate(7), 실시간 시장에서의 모든 가격은CNY7로 곱하면
{@fun/Market/exchange.GetRate exchange.GetRate}
이exchange.IO()이 함수는 교환 객체와 관련된 다른 인터페이스 호출에 사용됩니다.
이exchange.IO()함수는 교환 객체와 관련된 다른 인터페이스를 호출하고, 성공적인 호출에서 요청된 응답 데이터를 반환하고 실패한 호출에서 null을 반환합니다.
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
exchange.IO(k,...args)
이k매개 변수는 호출 유형을 설정하는 데 사용되며 선택값이 있습니다."api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unified그리고 그 밖의 것들이죠.
k
사실
문자열
확장된 매개 변수, 특정 호출 시나리오에 따라 통과,arg매개 변수는 하나 이상의 전달 될 수 있습니다.exchange.IO()기능, 다른 매개 변수 설정은 다른 기능에 대응합니다.exchange.IO()기능이 불분명합니다.
아그
사실
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
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 access the exchange's bulk order interface directly
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);
}
사용exchange.IO("api", httpMethod, resource, params, raw)청원 형태exchange.IO()기능, 교환의 API 인터페이스를 이해하고 관련 문서를 먼저 확인하는 것이 필요합니다. 이것은 FMZ 플랫폼에 추가되지 않은 기능을 확장 할 수 있습니다.POST요청은 당신이 해당 매개 변수를 채우면 아래쪽에 이미 FMZ에 의해 처리되는 매개 변수를 암호화, 서명 또는 확인하는 것에 대해 걱정할 필요가 없습니다. 당신은 대량 순서 예제를 참조할 수 있습니다OKX 거래소선물 계약, 그리고 매개 변수를 사용raw순서 매개 변수를 전달하기 위해:
var amount = 1
var price = 10
var basecurrency = "ltc"
function main () {
// Note that both amount.toString() and price.toString() have a ' character on the left and right side
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);
}
만약 키값이params매개 변수 (즉, Http 요청 매개 변수) 는 문자열입니다. 매개 변수 값을 포장하기 위해 매개 변수 값 주위에서 단일 인용구 (즉, 기호 ') 로 작성해야합니다.
function main() {
var ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
}
def main():
ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC")
Log(ret)
void main() {
auto ret = exchange.IO("api", "GET", "https://www.okx.com/api/v5/account/max-withdrawal", "ccy=BTC");
Log(ret);
}
그것은 완전한 url 매개 변수를 전달하는 것을 지원합니다.exchange.SetBase()함수).
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);
}
매개 변수 없는 호출 예제raw:
function main() {
// For example, if you set the current trading pair of the exchange object to BTC_USDT at the beginning of the live trading, print the current trading pair tickers
Log(exchange.GetTicker())
// Switch the 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());
}
현재 교환의 거래 쌍을 변경하여 코드로 구성된 거래 쌍을 변경합니다.라이브 트레이딩 생성또는백테스트에서.
function main () {
// exchanges[0] is the first exchange object added when the live trading is created
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");
}```
For example, the default base address when the exchange object is wrapped is ```https://api.huobipro.com```, and when you need to switch to ```https://api.huobi.pro```, use the following code to switch:
```javascript
function main() {
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
}
def main():
exchange.SetBase("https://api.bitfinex.com")
exchange.IO("mbase", "https://api-pub.bitfinex.com")
void main() {
exchange.SetBase("https://api.bitfinex.com");
exchange.IO("mbase", "https://api-pub.bitfinex.com");
}
예를 들어, 틱어 인터페이스와 거래 인터페이스에 대한 다른 기본 주소를 가진 거래소에 Bitfinex 선물은 틱어 인터페이스에 대한 하나, 거래 인터페이스에 대한 다른 두 개의 주소를 가지고 있습니다. Bitfinex 선물은 개인 인터페이스 기본 주소를 사용하여 전환합니다.exchange.SetBase("xxx")Bitfinex 선물은 공개 인터페이스 기본 주소를 사용exchange.IO("mbase", "xxx").
I. 암호화폐 중심의 거래소에서 다른 API 인터페이스 호출을 위해k설정"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GET, 등등URL.이exchange.IO("api", httpMethod, resource, params, raw)함수 호출은 교환 인터페이스에 액세스하고 호출이 실패하고 오류가 발생하면 null을 반환합니다.
오직 실제 거래는exchange.IO("api", httpMethod, resource, params, raw) function.
II. 거래 쌍을 전환하는 경우k설정되어 있습니다"currency":
exchange.IO("currency", currency)
currency: 매개 변수는 통일된 대문자 형식을 가진 문자열 타입이며,baseCurrency에서quoteCurrency, 예를 들어BTC_USDT.
ETH_BTC그냥 켜면 됩니다LTC_BTC, 아니LTC_USDT.exchange.IO("currency", currency)거래 쌍을 바꾸기 위해서요.III. 암호화폐 스팟 거래소 객체 레버리지드 계정 모드를 전환하는 데 사용됩니다.
k설정되어 있습니다"trade_margin"현금 레버리지 계정 모드로 전환합니다. 주문을 배치하고 계정 자산을 획득하면 거래소의 현금 레버리지 인터페이스에 액세스 할 수 있습니다.
만약 거래소가 스팟 레버리지에서 전체 마진과 격리된 마진을 구분한다면,exchange.IO("trade_super_margin")레버레이드 계좌의 전체 마진으로 전환하고,exchange.IO("trade_margin")레버레이드 계좌의 격리된 마진으로 전환합니다.k설정되어 있습니다"trade_normal"정상 스팟 계좌로 전환하기 위해레버레이드 계정 모델의 전환을 지원하는 스팟 거래소:
| 교환 | 특별 언급 |
|---|---|
| OKX | 레버레이드 계정 모드에서 거래 쌍은 정상적인 것과 다릅니다. 일부 거래 쌍은 그렇지 않을 수 있습니다.exchange.IO("trade_super_margin")레버레이드 계좌의 전체 지점으로 전환하고 사용exchange.IO("trade_margin")위치별로 위치로 전환합니다.trade_normal정상 스팟 모드로 전환합니다.exchange.IO("tdMode", "cross")레버리지 모드를 직접 지정하기 위해서 |
| 후오비 | 레버리지드 계정 모드 거래 쌍은 정상적인 거래 쌍과 다르며 일부 거래 쌍에는 그렇지 않을 수 있습니다. Huobi 레버리지드 계정에는 전체 위치와 위치별로 위치가 있습니다. 사용trade_margin지점별로 레버리지 계좌로 전환하기 위해,trade_super_margin레버리지 계좌 전체 위치로 전환하기 위해.trade_normal통상 통화-화폐 모드로 전환합니다. |
| 바이낸스 | 레버레이드 계정 모드는 포지션별로 포지션과 전체 포지션, 사용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.IO("trade_margin")레버리지 계정으로 전환하고exchange.IO("trade_normal")정상 계정 모드로 돌아가기 위해 |
| 코인 엑스 | 사용exchange.IO("trade_margin")레버레이드 계정으로 전환하고exchange.IO("trade_normal")정상 계정 모드로 돌아가기 위해 |
다른 스위치 기능:이봐요exchange.IO()함수다른 스위치 기능사용 설명서에서
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}
이exchange.Log()이 함수는 로그 열 영역에서 주문 배치 및 철수의 로그를 출력하는 데 사용됩니다. 호출되면 주문이 배치되지 않으며 거래 로그만 출력되고 기록됩니다.
교환.예약기록 (order log) 종류, 가격, 금액 교환.오더 로그 (오더 타입, 가격, 금액,...args)
이orderType이 매개 변수는 출력 로그 타입을 설정하는 데 사용되며 선택 값은 {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}.
순서 타입
사실
번호
의price이 매개 변수는 출력 로그에 표시되는 가격을 설정하는 데 사용됩니다.
가격
사실
번호
의amount이 매개 변수는 출력 로그에 표시되는 주문 수를 설정하는 데 사용됩니다.
금액
사실
번호
이 로그에 첨부 정보를 출력할 수 있는 확장된 매개 변수,arg한 개 이상의 매개 변수를 전달할 수 있습니다.
아그
거짓
문자열, 숫자, bool, 객체, 배열, null 및 시스템에서 지원하는 다른 유형
var id = 123
function main() {
// Order type buy, price 999, amount 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);
}
사용exchange.Log(orderType, price, amount)테스트를 따라 라이브 거래 주문, 시뮬레이션 주문 배치에 사용할 수 있으며 주문 배치 로깅에 도움이 될 수 있습니다. 가장 일반적인 시나리오 중 하나는 {@fun/Trade/exchange.IOexchange.IO} 함수는 조건부 주문을 생성하기 위해 거래소 인터페이스에 액세스 할 수 있지만exchange.IO()이 함수는 실시간 거래 로그 기록에서 거래 로그 정보를 출력하지 않습니다.exchange.Log()이 함수는 출력 로그를 보완하여 주문 배치 정보를 기록할 수 있고, 주문 철회 작업에도 마찬가지입니다.
그 때orderType매개 변수는LOG_TYPE_CANCEL, 그price매개 변수는 철회된 주문의 순서 Id입니다.exchange.IO()기능.exchange.Log()function는 {@var/EXCHANGE exchange} 교환 객체의 멤버 함수이며, 글로벌 함수 {@fun/Log Log}와 구별된다.
{@fun/Log Log}, {@var/EXCHANGE exchange}, {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY}, {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL}, {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL}
이exchange.Encode()이 함수는 서명 암호화 계산에 사용됩니다.
이exchange.Encode()함수는 계산된 해시 값의 인코딩을 반환합니다.
문자열
exchange.Encode ((algo, inputFormat, outputFormat, data) 를 입력할 수 있습니다. exchange.Encode ((algo, inputFormat, outputFormat, data, keyFormat, key) 를 입력할 수 있습니다.
매개 변수algoalgo또한 지원합니다: algo또한: algoed25519.seed계산
뭔가
사실
문자열
데이터 형식을 지정하는 데 사용됩니다.data매개 변수inputFormat이 매개 변수는 hex암호화된 경우, base64암호화된 것이고, outputFormat이 매개 변수는 다음 설정을 지원합니다: hex암호화된 경우, base64암호화된 것이고, data처리해야 할 데이터입니다.
데이터
사실
문자열
데이터 형식을 지정하는 데 사용됩니다.key매개 변수key이 매개 변수는 hex암호화된 경우, base64암호화된 것이고, key이 매개 변수는 서명 계산에 사용되는 키를 지정하는 데 사용됩니다. 이 매개 변수는 평문 문자열로 사용될 수 있습니다."{{accesskey}}", "{{secretkey}}"에 대한 언급accessKey그리고secretKey{@var/EXCHANGE exchange} 교환 객체에서 구성됩니다.
키
거짓
문자열
function main() {
var APIKEY = "your Access Key(Bitmex API ID)"
var expires = parseInt(Date.now() / 1000) + 10
var signature = exchange.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{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.Encode("sha256", "string", "hex", "GET/realtime" + expires, "hex", "{{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.Encode("sha256", "string", "hex", format("GET/realtime%d", expires), "hex", "{{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"];
}
}
}
BitMEX 위치 변경 푸시 예제 (wss 프로토콜):
오직 실제 거래는exchange.Encode()기능."{{accesskey}}", "{{secretkey}}"참고 자료는exchange.Encode()함수가 사용됩니다.
{@var/EXCHANGE exchange}, {@fun/Global/Encode Encode}
멀티 스레드 어시크론 지원 기능은 모든 지원 기능의 동작을 어시크론 동시 실행으로 전환할 수 있습니다.
이exchange.Go()함수는 동시 객체를 즉시 반환하고,wait()동시 요청의 결과를 얻기 위해 동시 객체의 메소드.
물체
교환.Go (방법) 교환.Go (방법,...args)
이method이 매개 변수는 함수의 이름을 지정하는 데 사용됩니다. 매개 변수는 함수 이름 문자열이므로 함수 참조가 아닙니다.
방법
사실
문자열
매개 변수동시에 기능을 실행하는, 한 개 이상의 매개 변수가 있을 수 있습니다.arg파라미터의 종류와 번호arg그 매개 변수에 따라동시 실행 기능- 네
아그
거짓
문자열, 숫자, bool, 객체, 배열, 함수, null 및 시스템에서 지원하는 다른 모든 유형
function main(){
// The following four operations are concurrently executed asynchronously by multiple threads and do not take time and return immediately
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 ticker results asynchronously
var ticker = a.wait()
// Returns the depth, or null if it fails
var depth = b.wait()
// return order number, limited to 1 second timeout, if timeout, returns undefined, the object can continue to call wait if the last wait 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);
}
Exchange.Go()함수 사용 예제, 결정undefined사용typeof(xx) === "undefined"왜냐하면null == undefined자바스크립트에서 유효합니다.
function main() {
var d = exchange.Go("GetRecords", PERIOD_H1)
// Waiting for K-line results
var records = d.wait()
// Here waits an asynchronous operation that has been waited and finished, it will return null, and log the error message
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);
}
전화wait()방출된 동시 객체에 대한 메소드는 오류를 보고합니다.
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: "ticker",
cols: ["index", "name", "latest-deal-price"],
rows: []
}
for(var i = 0; i < arrTicker.length; i++) {
tbl.rows.push([i, arrName[i], arrTicker[i].Last])
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", 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": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
}
for i in range(len(arrTicker)):
tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", 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 several exchange objects, several exchanges[n].Go functions have to be executed here, this example is to add four exchange objects, the details can be modified
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": "ticker",
"cols": ["index", "name", "latest-deal-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(), "Total time taken to obtain tickers from multiple exchanges concurrently:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
Sleep(500);
}
}
여러 교환 틱에 동시에 액세스:
function main() {
/*
Testing with OKX futures order interface
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("Concurrent order placement time consumption:", 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("Concurrent order placement time consumption:", 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("Concurrent order placement time consumption:", endTS - beginTS, "millisecond");
}
동시 발탁exchange.IO("api", ...)기능:
이 함수는 실제 거래에서 실행될 때만 다중 스레드 실행 작업을 생성합니다. 백테스팅은 다중 스레드 동시에 작업 실행을 지원하지 않습니다.
그 후exchange.Go()함수는 객체를 반환합니다.wait()함수는 스레드에서 반환된 데이터를 얻기 위해 그 객체를 통해 호출됩니다.wait()스레드가 자동으로 풀리기 전에 데이터를 얻기 위해 함수가 호출되어야 합니다.wait()이 함수는 정해진 경우, 타임아웃이 발생하더라도 스레드는 자동으로 풀리지 않습니다. 스레드의 결과는 자동으로 풀리기 전에 얻어야 합니다 (동시 접속을 위한 인터페이스 호출의 성공 또는 실패와 상관없이). 간단하게 말하면, 요청된 스레드는wait()실행이 성공하거나 실패하든 상관없이, 그리고 스레드의 리소스가exchange.Go()함수는 도커에 의해 자동으로 풀어야 합니다.
의wait()메소드는 타임아웃 매개 변수를 지원합니다.
타임아웃 파라미터 없이,wait(), 또는 타임아웃 매개 변수가 0이거나,wait(0).wait()함수 블록 및 동시 스레드가 실행을 완료할 때까지 기다립니다. 동시 스레드wait(-1).wait()함수는 다른 프로그래밍 언어에 대한 다른 반환 값으로 즉시 반환합니다. 예를 들어 이 하위 섹션을 참조하십시오.
특정 타임아웃 파라미터 설정,wait(300), 그리고wait()이 기능은 복귀하기 전에 최대 300 밀리초를 기다립니다.
만약 최종 결과를 반환wait()이 함수가 이루어지지 않으면 스레드 자원이 자동으로 풀리지 않을 것이고, 이는 요청된 스레드의 축적으로 이어질 것이고, 2000 이상의 스레드가 오류를 보고할 것입니다."too many routine wait, max is 2000"...
지원 함수:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO이 모든 함수는 동시 호출할 때 현재 {@var/EXCHANGE exchange} 교환 객체에 기초하여 실행됩니다.
파이썬 언어와 자바스크립트 언어의 차이점은wait()파이썬 언어의 동시 객체의 함수는 두 개의 매개 변수를 반환합니다. 첫 번째 매개 변수는 비동기 API 호출에 의해 반환 된 결과이며 두 번째 매개 변수는 비동기 호출이 완료되었는지 여부를 나타냅니다.
def main():
d = exchange.Go("GetRecords", PERIOD_D1)
# ok will return True definitely, unless the strategy is stopped
ret, ok = d.wait()
# If the wait times out, or if it waits for an instance that has already ended, ok returns False
ret, ok = d.wait(100)
{@fun/Global/Mail_Go Mail_Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}, {@fun/Global/EventLoop EventLoop}
시장 계좌