Oexchange.Buy()A função é utilizada para colocar ordens de compra.Buy()função é uma função membro do objeto de troca {@var/EXCHANGE exchange}.Buy()função opera na conta de câmbio ligada ao objeto de câmbioexchangeO objectivo das funções (métodos) dos membros doexchangeObjeto está relacionado apenas comexchange, e não será repetido após a documentação.
Uma ordem bem-sucedida retorna o ID da ordem, uma ordem falhada retorna um valor nulo.
O atributoIdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato do par de negociação à vistaETH_USDTa ordem da troca OKX é:ETH-USDT,1547130415509278720- Não.
Ao ligar para oexchange.Buy()função para colocar uma ordem, a ordem de valor de retornoIdé consistente com oIdAtributo da estrutura da ordem {@struct/Order Order}.
string, valor nulo
troca.Comprar ((preço, montante) troca.Comprar ((preço, quantidade,...args)
OpriceO parâmetro é utilizado para definir o preço da ordem.
Preço
verdade
Número
OamountParâmetro utilizado para definir o montante da encomenda.
quantidade
verdade
Número
Parâmetros estendidos que podem fornecer informações de acompanhamento para este diário de encomendas,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
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);
}
O número de ordem devolvido porexchange.Buy()Pode ser utilizado para consultar as informações da encomenda e cancelar a encomenda.
// 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);
}
Quando se faz uma encomenda para um contrato de futuros de criptomoedas, deve ser tomado cuidado para garantir que a direção do comércio seja definida corretamente, uma vez que uma incompatibilidade entre a direção do comércio e a função do comércio resultará em um erro:
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);
}
Ordem de mercado à vista.
Ao colocar uma ordem para um contrato de futuros, você deve prestar atenção se a direção do comércio está definida corretamente, pois um erro será relatado se a direção do comércio e a função do comércio não coincidirem.
O parâmetropriceestá definido em-1para a colocação de ordens de mercado, o que requer que a interface de colocação de ordens da exchange suporte ordens de mercado.amounté a quantidade de dinheiro na moeda da ordem. Ao colocar ordens de mercado para contratos futuros de criptomoeda, o parâmetro de quantidadeamounté o número de contratos. Há algumas casas de câmbio de criptomoedas que não suportam a interface de ordem de mercado durante a negociação ao vivo. A quantidade de ordem para ordens de compra de mercado em algumas casas de câmbio é o número de moedas de negociação.Instruções especiais para as trocasIddoexchange.Buy()função pode ser diferente do valor de retorno da ordemIdDescrito no documento actual.
{@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Oexchange.Sell()Função utilizada para colocar ordens de venda.
Uma ordem bem-sucedida retorna o ID da ordem, uma ordem falhada retorna um valor nulo.IdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato do par de negociação à vistaETH_USDTa ordem da troca OKX é:ETH-USDT,1547130415509278720. Ao ligar para oexchange.Sell()função para colocar uma ordem, a ordem de valor de retornoIdé consistente com oIdAtributo da estrutura da ordem {@struct/Order Order}.
string, valor nulo
troca.Venda ((preço, montante) troca.Venda ((preço, montante,...args)
OpriceO parâmetro é utilizado para definir o preço da ordem.
Preço
verdade
Número
OamountParâmetro utilizado para definir o montante da encomenda.
quantidade
verdade
Número
Parâmetros estendidos que podem fornecer informações de acompanhamento para este diário de encomendas,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
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);
}
O número de ordem devolvido porexchange.Sell()Pode ser utilizado para consultar informações de encomendas e cancelar encomendas.
// 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);
}
Quando se faz uma encomenda para um contrato de futuros de criptomoedas, deve ser tomado cuidado para garantir que a direção do comércio seja definida corretamente, uma vez que uma incompatibilidade entre a direção do comércio e a função do comércio resultará em um erro:
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);
}
Ordem de mercado à vista.
Ao colocar uma ordem para um contrato de futuros, você deve prestar atenção se a direção do comércio está definida corretamente, pois um erro será relatado se a direção do comércio e a função do comércio não coincidirem.
O parâmetropriceestá definido em-1para a colocação de ordens de mercado, o que exige que a interface de colocação de ordens da exchange suporte ordens de mercado.amounté o valor em moeda de negociação. Ao colocar ordens de mercado para contratos futuros de criptomoeda, o parâmetro de valoramountHá algumas exchanges de criptomoedas que não suportam a interface de ordem de mercado durante a negociação ao vivo.
Se você estiver usando uma versão mais antiga do docker, o valor de retorno da ordemIddoexchange.Sell()função pode ser diferente do valor de retorno da ordemIdDescrito no documento actual.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}
Oexchange.CreateOrder()A função é usada para fazer uma encomenda.
Se a ordem for efetuada com sucesso, o ID da ordem é devolvido; se a ordem falhar, um valor nulo é devolvido.IdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato da ordem do par de negociação à vistaETH_USDTda bolsa OKX é:ETH-USDT,1547130415509278720. Ao ligar para oexchange.CreateOrder(symbol, side, price, amount)Função para colocar uma ordem, o valor de retorno da ordemIdé consistente com oIdPropriedade da estrutura da ordem {@struct/Order Order}.
string, valor nulo
exchange.CreateOrder (símbolo, lado, preço, quantia) exchange.CreateOrder ((símbolo, lado, preço, quantidade,...args)
O parâmetrosymbolO código da ordem é utilizado para especificar o par de negociação específico e o código do contrato da ordem.exchange.CreateOrder(symbol, side, price, amount)função de encomenda,exchangeSe a moeda denominada da ordem for USDT e a moeda de transacção for BTC, o parâmetrosymbolé:"BTC_USDT", no formato do par de negociação definido pela plataforma FMZ.exchange.CreateOrder(symbol, side, price, amount)função de encomenda,exchangeé o objeto de troca de futuros. Se a ordem for uma ordem de contrato perpétuo padrão BTCsymbolé:"BTC_USDT.swap", e o formato é uma combinação dospar de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelo carácter exchange.CreateOrder(symbol, side, price, amount)função de encomenda,exchangeé o objeto de troca de futuros. Se a ordem for uma ordem de contrato de opção U-standard do BTCsymbolé:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como exemplo), e o formato é uma combinação dopar de negociaçãodefinidos pela plataforma FMZ e o código do contrato de opção específico definido pela bolsa, separados pelo carácter sideO parâmetro é utilizado para especificar a direção de negociação da ordem.
Para os objectos de troca à vista, os valores facultativos dosideOs parâmetros são:buy, sell. buysignifica compra, esellsignifica vender.
Para os objectos de troca de futuros, os valores opcionais dosideOs parâmetros são:buy, closebuy, sell, closesell. buysignifica abrir uma posição longa,closebuysignifica fechar uma posição longa,sellsignifica abrir uma posição curta, eclosesellsignifica fechar uma posição curta.
lado
verdade
cordel
O parâmetropriceO preço de -1 indica que a ordem é de mercado.
Preço
verdade
Número
O parâmetroamountA quantidade de ordem é a quantidade da ordem de compra de mercado de algumas bolsas spot, que é o número de moedas de negociação.Instruções especiais para as trocasno argOs parâmetros podem ser transmitidos.
arg
Falso
Qualquer tipo suportado pelo sistema, como cadeia, número, bool, objeto, matriz, valor nulo, etc.
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);
}
Os objectos de troca spot e os objetos de troca de futuros chamam-se deexchange.CreateOrder()Função para fazer uma encomenda.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
Oexchange.CancelOrder()A função é usada para cancelar a ordem.
O atributoIdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato da ordem do par de negociação à vistaETH_USDTda bolsa OKX é:ETH-USDT,1547130415509278720- Não.
O parâmetroorderIdPassado em quando chamar oexchange.CancelOrder()A função para cancelar uma ordem é consistente com oIdPropriedade da estrutura da ordem {@struct/Order Order}.
Oexchange.CancelOrder()função retorna um valor verdadeiro, por exemplotruesignifica que a solicitação de ordem de cancelamento foi enviada com sucesso.false, significa que o pedido de ordem de cancelamento não foi enviado. O valor devolvido representa apenas o sucesso ou fracasso do pedido enviado para determinar se a troca cancela a ordem.exchange.GetOrders()Para determinar se a ordem é cancelada.
Bool
troca.Cancelar encomenda ((identificação da encomenda) troca.Cancelar encomenda ((identificação da encomenda,... args)
OorderIdO parâmetro é utilizado para especificar a ordem a cancelar.
Ordenado
verdade
número, cadeia
Parâmetros estendidos, você pode exportar as informações anexadas a este registro de retirada,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
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);
}
Cancele a ordem.
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);
}
}
Funções FMZ API que podem produzir funções de saída de log como:Log(), exchange.Buy(), exchange.CancelOrder()podem ser seguidos por alguns parâmetros de saída de acompanhamento após os parâmetros necessários.exchange.CancelOrder(orders[i].Id, orders[i]), de modo que, ao cancelar a encomenda cujo ID éorders[i].Id, a informação da ordem é produzida com ele.orders[i].
Se estiver a utilizar uma versão mais antiga do docker, o parâmetro orderId da função exchange.CancelOrder() pode ser diferente do orderId descrito no documento actual.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
Oexchange.GetOrder()A função é utilizada para obter as informações de encomenda.
Consultar os detalhes da ordem de acordo com o número da ordem e retornar a estrutura {@struct/Order Order} se a consulta for bem sucedida, ou retornar null se a consulta falhar. {@struct/Order Order}, valor nulo
troca.GetOrder (identificação de ordem)
OorderIdO parâmetro é utilizado para especificar a ordem a ser consultada.
O atributoIdA estrutura da ordem {@struct/Order Order} da plataforma FMZ consiste no código do produto da bolsa e no ID de ordem original da bolsa, separados por vírgulas em inglês.Idformato da ordem do par de negociação à vistaETH_USDTda bolsa OKX é:ETH-USDT,1547130415509278720- Não.
O parâmetroorderIdPassado em quando chamar oexchange.GetOrder()função para consultar uma ordem é consistente com oIdPropriedade da estrutura da ordem {@struct/Order Order}.
Ordenado verdade cordel
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);
}
Oexchange.GetOrder()A função não é suportada por algumas trocas.AvgPriceO atributo na estrutura {@struct/Order Order} do valor de retorno é o preço médio da transação.
Se você estiver usando uma versão mais antiga do docker, oorderIdParâmetro doexchange.GetOrder()A sua função pode diferir daorderIddescrito na documentação actual.
As trocas que não suportam oexchange.GetOrder()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetOrder | Zaif / Coincheck / Bitstamp | – |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
Oexchange.GetOrders()A função é usada para obter encomendas pendentes.
Oexchange.GetOrders()A função retorna uma matriz de estruturas {@struct/Order Order} se a solicitação de dados for bem-sucedida, e retorna valores nulos se a solicitação de dados falhar.
{@struct/Order Order} matriz, valor nulo
troca.GetOrders ((() Troca.GetOrders (símbolo)
O parâmetrosymbolé utilizado para definir osímbolo da transacçãoouIntervalo de símbolos de transacçãoPara ser interrogado.
Para os objectos de troca à vista, se osymbolSe o parâmetro não for transmitido, serão solicitados os dados de encomenda incompletos de todos os produtos spot.
Para os objectos de troca de futuros, se osymbolSe o parâmetro não for transmitido, o padrão é solicitar os dados de ordem incompletos de todas as variedades na faixa de dimensões do par de negociação atual e do código do contrato.
símbolo Falso cordel
/*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;
}
Utilize o objeto de troca à vista para colocar ordens de compra para vários pares de negociação diferentes à metade do preço atual e, em seguida, consultar as informações sobre ordens pendentes.
/*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;
}
Usar objetos de troca de futuros para colocar ordens para vários pares de negociação diferentes e códigos de contrato. Colocar ordens a preços longe do preço da contraparte, manter ordens em um estado não cumprido e consultar ordens de várias maneiras.
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);
}
Ao ligar para oexchange.GetOrders()função, passar noSymbolParâmetro para solicitar dados de ordem para um par de negociação específico e código de contrato.
EmGetOrdersfunção, os cenários de utilização do parâmetro símbolo são resumidos do seguinte modo:
| Classificação do objeto Exchange | símbolo Parâmetros | Alcance da consulta | Observação |
|---|---|---|---|
| Espetáculo | Não passe o parâmetro de símbolo | Consultar todos os pares de negociação spot | Para todos os cenários de chamada, se a interface de troca não o suportar, um erro será relatado e um valor nulo será devolvido. |
| Espetáculo | Especificar o tipo de negociação, o parâmetro do símbolo é: |
Consultar o par de negociação BTC_USDT especificado | Para os objetos de câmbio à vista, o formato do parâmetro do símbolo é: |
| Futuros | Não passe o parâmetro de símbolo | Consultar todos os produtos de negociação dentro do intervalo de dimensões do par de negociação e do código do contrato corrente | Se o par de negociação atual for BTC_USDT e o código do contrato for swap, todos os contratos perpétuos com margem USDT serão consultados.GetOrders("USDT.swap") |
| Futuros | Especificar o tipo de negociação, o parâmetro do símbolo é: |
Consultar o contrato perpétuo baseado em USDT para um determinado BTC | Para os objectos de troca de futuros, o formato do símbolo do parâmetro é:par de negociaçãoeCódigo do contratodefinidos pela plataforma FMZ, separados pelos caracteres".. |
| Futuros | Especificar a gama de produtos de negociação, o parâmetro do símbolo é: |
Consultar todos os contratos perpétuos baseados em USDT | - |
| Bolsas de futuros que suportam opções | Não passe o parâmetro de símbolo | Consultar todos os contratos de opção dentro do intervalo de dimensão do par de negociação corrente | Se o par de negociação atual for BTC_USDT, o contrato é definido como um contrato de opção, por exemplo, contrato de opção da Binance: BTC-240108-40000-C |
| Bolsas de futuros que suportam opções | Especificar produtos comerciais específicos | Consultar o contrato de opção especificado | Por exemplo, para a Binance Futures Exchange, o parâmetro do símbolo é: BTC_USDT.BTC-240108-40000-C |
| Bolsas de futuros que suportam opções | Especificar a gama de produtos de negociação, o parâmetro do símbolo é: |
Consultar todos os contratos de opções baseados em USDT | - |
EmGetOrdersfunção, a consulta do objeto de troca de futuros
A gama de dimensões é resumida do seguinte modo:
| símbolo Parâmetros | Definição do intervalo de solicitação | Observação |
|---|---|---|
| USDT.swap | Intervalo de contratos perpétuos baseados em USDT. | Para |
dimensões não suportadas pela interface de API de troca, um erro será relatado e um valor nulo será devolvido quando Está a chamar-me. ♫ USDT.futures ♫ ♫ uma gama de contratos de entrega baseados em USDT ♫ O USD.swap é uma variedade de moeda baseada em perpétuos Contratos. USD.futures. Variação de entrega baseada em moeda. Contratos. O opção baseada em opções de contrato baseado em USDT. O que é que é uma opção? Combo USDT.futures. Uma gama de combinações de CFD. Futures_Deribit Exchange USD.futures_ff Uma gama de contratos de entrega de margem mista. Futures_Kraken Exchange. USD.swap_pf Uma gama de contratos perpétuos de margem mista. Futuros_Kraken Exchange.
Quando a conta representada pelo objecto de trocaexchangeNão tem ordens pendentes nointervalo de consultaouInstrumentos de negociação especificados(ordens ativas em um estado não cumprido), chamando esta função retorna uma matriz vazia, ou seja:[]- Não.
As seguintes trocas exigem que o instrumento passe no parâmetro do instrumento ao consultar as ordens atualmente incompletas. Ao chamar a função GetOrders com essas trocas, se o parâmetro do instrumento não for passado, apenas as ordens incompletas do instrumento atual são solicitadas, não as ordens incompletas de todos os instrumentos (porque a interface de troca não suporta isso).
Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE.
As trocas que não suportam oexchange.GetOrders()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| GetOrders | – | Futures_Bibox |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}
Oexchange.GetHistoryOrders()A função é utilizada para obter o par de negociação actual, as ordens históricas para contratos; suporta a especificação de variedades de negociação específicas.
Oexchange.GetHistoryOrders()função retorna uma matriz de estruturas {@struct/Order Order} se a solicitação de dados for bem-sucedida, e nulo se a solicitação falhar.
{@struct/Order Order} matrizes, valores nulos
troca.GetHistoryOrders ((() troca.GetHistoryOrders (símbolo) exchange.GetHistoryOrders (símbolo, desde) exchange.GetHistoryOrders (símbolo, desde, limite) troca.GetHistoryOrders (desde) exchange.GetHistoryOrders (desde, limite)
OsymbolPara a definição do símbolo comercial, o parâmetro é utilizado para especificar o símbolo comercial.BTC_USDTOs dois tipos de transacções são os seguintes:exchangeé um objeto de troca spot, o formato do parâmetro parasymboléBTC_USDTSe se tratar de um objecto de troca de futuros, tendo por exemplo um contrato perpétuo, o formato do parâmetro parasymbolé:BTC_USDT.swap- Não.
Se você está consultando os dados de ordem de contratos de opção, definir o parâmetrosymbolpara"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como exemplo).par de negociaçãodefinidos pela plataforma FMZ e o código do contrato de opção específico definido pela bolsa, separados pelo carácter
símbolo
Falso
cordel
OsinceO parâmetro é utilizado para especificar a data de início da consulta em milissegundos.
Desde
Falso
Número
OlimitO parâmetro é utilizado para especificar o número de ordens a consultar.
limite
Falso
Número
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, limitQuando os parâmetros não são especificados, a consulta padrão é o par de negociação atual, as ordens históricas de contrato.symbolSe o parâmetro for especificado, consultar o histórico de ordens para o tipo de negociação definido.sinceParâmetro é especificado, consulta na direção do tempo atual usando osinceMarcar a hora como a hora de início.limitSe o parâmetro for especificado, a consulta é devolvida após um número suficiente de entradas.As trocas que não suportam oexchange.GetHistoryOrders()Função:
| Nome da função | Trocas spot não suportadas | Atividades de negociação |
|---|---|---|
| Ordens do GetHistory | Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE | Futures_dYdX / Futures_Bibox / Futures_ApolloX |
{@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}
exchange.SetPrecision()A função é utilizada para definir a precisão doexchangeObjeto de trocaPreçoemontante da encomenda, após a definição, o sistema irá ignorar automaticamente os dados em excesso.
-Precisação (preço, quantidade)
OpricePrecisionO parâmetro é utilizado para controlar a precisão dos dados de preços.
PreçoPrecisione
verdade
Número
OamountPrecisionParâmetro utilizado para controlar a precisão da quantidade de dados a ordenar.
quantidadePrecisione
verdade
Número
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);
}
O sistema de backtesting não suporta esta função e a precisão numérica do sistema de backtesting é manipulada automaticamente.
{@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}
Definir a taxa de câmbio corrente do objeto de câmbio.
Taxa de câmbio.SetRate (Taxa)
OrateO parâmetro é utilizado para especificar a taxa de câmbio de conversão.
taxa
verdade
Número
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);
}
Se o valor da taxa de câmbio tiver sido fixado utilizando oexchange.SetRate()Em seguida, todas as informações de preço, tais como tickers, profundidades, preços de encomenda, etc para a troca representada pela correnteexchangeO objeto de câmbio será convertido multiplicando-o pela taxa de câmbio definida de 7.exchangeé uma troca com o dólar dos EUA como moeda nominal.exchange.SetRate(7), todos os preços no mercado em tempo real serão convertidos em preços próximos deCNYdenominatória multiplicada por 7.
Não, não, não, não.
Oexchange.IO()A função é utilizada para outras chamadas de interface relacionadas com o objeto de troca.
Oexchange.IO()função chama outras interfaces relacionadas com o objeto de troca, devolvendo os dados de resposta solicitados em uma chamada bem-sucedida e devolve nulo em uma chamada falhada.
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
exchange.IO(k,...args)
OkParâmetro utilizado para definir o tipo de chamada, com valores opcionais"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiede assim por diante.
k
verdade
cordel
Parâmetros estendidos, transmitidos de acordo com o cenário de chamada específico,argO mecanismo polimórfico do sistema permite que os parâmetros possam ser passados para mais de um.exchange.IO()O número e o tipo de parâmetros para oexchange.IO()Funções são indeterminadas.
arg
verdade
string, number, bool, object, array, null e quaisquer outros tipos suportados pelo sistema
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);
}
Utilizando oexchange.IO("api", httpMethod, resource, params, raw)Convocatóriaexchange.IO()Para que você possa usar a função, é necessário entender a interface API da troca e verificar a documentação relevante primeiro.POSTsolicitação não requer que você se preocupe com a criptografia, assinatura ou verificação dos parâmetros, que já são tratados pela FMZ na parte inferior, desde que você preencha os parâmetros correspondentes.Intercâmbio OKXcontratos futuros, e utilizar o parâmetrorawPara passar os parâmetros de ordem:
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);
}
Se o valor chave noparamsparameter (ou seja, Http requisit parameter) é uma cadeia, ele precisa ser escrito em aspas simples (ou seja, o símbolo ') em torno do valor do parâmetro para envolver o valor do parâmetro.
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);
}
Ele suporta passar em parâmetros de url completos, que podem omitir a operação de alternar o endereço de base (chamando oexchange.SetBase()função).
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);
}
Exemplo de chamada sem o parâmetroraw:
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());
}
Mudar o par de negociação da troca atual, de modo que ele irá mudar o par de negociação configurado por códigona criação de negociação ao vivoouem backtest.
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");
}
Para exchanges com diferentes endereços de base para a interface do ticker e a interface de negociação, por exemplo, o Bitfinex Futures tem dois endereços, um para a interface do ticker e o outro para a interface de negociação.exchange.SetBase("xxx")Os futuros da Bitfinex mudam de endereço de base de interface pública usandoexchange.IO("mbase", "xxx").
I. Para as trocas centradas em criptomoedas, outras chamadas de interface de API que não sejam uniformemente encapsuladas, com parâmetrokdefinido em"api":
exchange.IO("api", httpMethod, resource, params, raw)
POST, GET, etc.URL.Oexchange.IO("api", httpMethod, resource, params, raw)a chamada de função acessará a interface de troca e retornará null se a chamada falhar e ocorrer um erro.
Só o mercado real suporta a chamadaexchange.IO("api", httpMethod, resource, params, raw) function.
II. Para trocas de pares de negociação, o parâmetrokestá definido em"currency":
exchange.IO("currency", currency)
moeda: O parâmetro é um tipo de cadeia de caracteres com um formato de maiúscula uniforme, utilizando um sublinhado para separarbaseCurrencydequoteCurrency, tais comoBTC_USDT.
ETH_BTCsó pode mudar paraLTC_BTC, não paraLTC_USDT.exchange.IO("currency", currency)para trocar pares de negociação.III. Utilizado para alternar o modo de conta alavancada do objecto de câmbio spot de criptomoedas:
kestá definido em"trade_margin"Para colocar ordens e obter ativos da conta, será acessada a interface de alavancagem spot da bolsa.
Se a bolsa distinguir entre margem total e margem isolada na alavancagem spot, utilizar:exchange.IO("trade_super_margin")A transição para a margem total para a conta alavancada, eexchange.IO("trade_margin")Para a transferência para a margem isolada para a conta alavancada.kestá definido em"trade_normal"para voltar ao modo normal de conta à vista.Bolsas à vista que suportam a troca entre modelos de contas alavancadas:
| Intercâmbio | Observações especiais |
|---|---|
| OKX | Os pares de negociação no modo de conta alavancada são diferentes dos normais, alguns pares de negociação podem não tê-los.exchange.IO("trade_super_margin")para mudar para a posição completa para as contas alavancadas e utilizarexchange.IO("trade_margin")para mudar de posição em posição.trade_normalpara mudar para o modo normal de localização.exchange.IO("tdMode", "cross")Para especificar directamente o modo de alavancagem. |
| Huobi | Os pares de negociação no modo de conta alavancada são diferentes dos normais, alguns pares de negociação podem não tê-los.trade_marginpara mudar para posição de conta de alavancagem por posição, utilizartrade_super_marginpara mudar para a posição total da conta de alavancagem.trade_normalpara mudar para o modo normal moeda-moeda. |
| Binance | O modo de conta alavancada é dividido em posição por posição e posição total, utilizaçãotrade_marginpara mudar para posição por posição, usartrade_super_marginpara mudar para a posição completa, utilizartrade_normalpara mudar para o modo normal moeda-moeda. |
| Portão | O modo de conta alavancada é dividido em posição por posição e posição total, utilizaçãotrade_marginpara mudar para posição por posição, usartrade_super_marginpara mudar para a posição completa, utilizartrade_normalpara mudar para o modo normal moeda-moeda. |
| AscendEx | Utilizaçãoexchange.IO("trade_margin")para mudar para o modo de conta de alavancagem eexchange.IO("trade_normal")para voltar ao modo de conta normal. |
| O quê? | Utilizaçãoexchange.IO("trade_margin")para mudar para o modo de conta de alavancagem eexchange.IO("trade_normal")para voltar ao modo de conta normal. |
| CoinEx | Utilizaçãoexchange.IO("trade_margin")para mudar para o modo de conta alavancada eexchange.IO("trade_normal")para voltar ao modo de conta normal. |
Outras funções de comutação:Veja oexchange.IO()função paraOutras funções de comutaçãono Guia do Utilizador.
{@fun/NetSettings/exchange.SetBase exchange.SetBase}, {@fun/Account/exchange.SetCurrency exchange.SetCurrency}, {@var EXCHANGE_OP_IO_CONTROL}
Oexchange.Log()A função é usada para extrair o log de colocação e retirada de ordens na área da coluna de log. Quando chamada, nenhuma ordem é colocada, apenas o log de transações é extraído e registrado.
troca.Log ((ordem) Tipo, preço, montante) troca.Log ((ordem) Tipo, preço, montante,... args)
OorderTypeO parâmetro é utilizado para definir o tipo de log de saída, os valores opcionais são {@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}.
ordem Tipo
verdade
Número
OpriceO parâmetro é utilizado para definir o preço exibido no log de saída.
Preço
verdade
Número
OamountO parâmetro é utilizado para definir a quantidade de encomendas realizadas exibidas no diário de saída.
quantidade
verdade
Número
Parâmetros estendidos que podem fornecer informações de acompanhamento a este registo,argOs parâmetros podem ser transmitidos para mais de um.
arg
Falso
string, number, bool, object, array, null e qualquer outro tipo suportado pelo sistema
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);
}
Utilizaçãoexchange.Log(orderType, price, amount)Um dos cenários mais comuns é usar o {@fun/Trade/exchange.IOexchange.IO} função para aceder à interface do exchange para criar ordens condicionais, mas utilizando oexchange.IO()A função não produz as informações do registro de transacções no registro de negociação ao vivo.exchange.Log()A função pode ser utilizada para complementar o diário de saída, a fim de registar as informações sobre a colocação de ordens, e o mesmo se aplica às operações de retirada de ordens.
Quando oorderTypeParâmetro éLOG_TYPE_CANCEL, opriceParâmetro é a ordem Id da ordem retirada, que é utilizada para imprimir o diário de retirada quando a ordem é retirada diretamente usando oexchange.IO()Aexchange.Log()função é uma função membro do objeto de troca {@var/EXCHANGE exchange}, em contraste com a função global {@fun/Log Log}.
O número de pessoas que participam no processo de aquisição é o número de pessoas que participam no processo de aquisição.
Oexchange.Encode()A função é utilizada para cálculos de encriptação de assinatura.
Oexchange.Encode()Função que retorna a codificação do valor hash calculado.
cordel
exchange.Encode ((algo, inputFormat, outputFormat, dados) exchange.Encode ((algo, inputFormat, outputFormat, dados, chaveFormat, chave)
O parâmetroalgoé o algoritmo usado para o cálculo de codificação. As configurações suportadas são: algotambém suporta: algotambém suporta: algopode ser escrito como ed25519.seedCalculo.
algo
verdade
cordel
Utilizado para especificar o formato de dados dodataParâmetro.inputFormatParâmetro pode ser definido para um dos seguintes: hexcodificado, base64codificado, e outputFormatO parâmetro suporta as seguintes configurações: hexcodificado, base64codificado, e datasão os dados a processar.
dados
verdade
cordel
Utilizado para especificar o formato de dados dokeyParâmetro.keyParâmetro pode ser definido para um dos seguintes: hexcodificado, base64codificado, e keyParâmetro é usado para especificar a chave usada no cálculo da assinatura, e pode ser usado como uma cadeia de texto simples."{{accesskey}}", "{{secretkey}}"referir-se aoaccessKeyesecretKeyConfigurado no objeto de troca {@var/EXCHANGE exchange}.
Chave
Falso
cordel
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"];
}
}
}
Exemplo de push de mudança de posição do BitMEX (protocolo wss):
Só o mercado real suporta chamadasexchange.Encode()A"{{accesskey}}", "{{secretkey}}"As referências só são válidas quando oexchange.Encode()função é utilizada.
{@var/EXCHANGE exchange}, {@fun/Global/Encode Encode}
As funções de suporte assíncrono multi-threaded podem transformar as operações de todas as funções suportadas em execução simultânea assíncrona.
Oexchange.Go()função retorna um objeto simultâneo imediatamente, e você pode usar owait()método desse objeto concorrente para obter o resultado da solicitação concorrente.
Objeto
Método de troca. troca.Go (método,...args)
OmethodO parâmetro é usado para especificar o nome da função concorrente.
Método
verdade
cordel
Parâmetros paraFunções executadas simultaneamente, pode haver mais de um parâmetroargTipo e número de parâmetrosargDepende dos parâmetros dofunção de execução simultânea- Não.
arg
Falso
string, number, bool, object, array, function, null e todos os outros tipos suportados pelo sistema
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()exemplo de utilização de funções, para determinarundefinedpara utilizartypeof(xx) === "undefined", porquenull == undefinedé válido em JavaScript.
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);
}
Chamando owait()método em um objeto simultâneo que foi liberado irá relatar um erro:
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);
}
}
Acesso simultâneo a múltiplos tickers de câmbio:
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");
}
Convocatórias paraexchange.IO("api", ...)Função:
Esta função só cria tarefas de execução multi-threaded quando executadas em negociação real, o backtesting não suporta a execução de tarefas simultâneas multi-threaded (o backtesting está disponível, mas ainda é executado sequencialmente).
Após oexchange.Go()função retorna um objeto, seuwait()A função é chamada através desse objeto para obter os dados retornados pelo thread.wait()A função deve ser chamada para obter os dados antes que o thread seja liberado automaticamente.wait()O resultado do thread deve ser obtido antes que ele seja liberado automaticamente (independentemente do sucesso ou fracasso da chamada de interface para acesso simultâneo).wait()função independentemente de a execução ser bem sucedida ou fracassada, e o recurso do thread solicitado peloexchange.Go()A função deve ser liberada automaticamente pelo docker.
Owait()O método suporta um parâmetro de timeout:
Sem um parâmetro de timeout, isto é,wait(), ou com um parâmetro de timeout de 0, ou seja,wait(0). Owait()blocos de função e espera até que o thread concorrente tenha terminado de executar, devolvendo o resultado da execução do thread concorrente.
Defina o parâmetro de timeout -1, ou seja,wait(-1). Owait()função retorna imediatamente, com diferentes valores de retorno para diferentes linguagens de programação, ver esta subseção para um exemplo de chamada.
Configure o parâmetro de tempo limite específico,wait(300), e owait()A função irá esperar no máximo 300 milissegundos antes de retornar.
Se o resultado de retorno do finalwait()Função não é obtida, os recursos do thread não serão liberados automaticamente, o que levará ao acúmulo de threads solicitados e mais de 2000 irá relatar um erro:"too many routine wait, max is 2000"- Não.
Funções suportadas:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Todas estas funções são executadas com base no objeto de troca {@var/EXCHANGE exchange} atual quando chamados simultaneamente.
A diferença entre a linguagem Python e a linguagem JavaScript é que owait()função de objetos concorrentes na linguagem Python retorna dois parâmetros. O primeiro parâmetro é o resultado retornado por uma chamada de API assíncrona, e o segundo parâmetro indica se a chamada assíncrona foi concluída.
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)
Não, não, não, não, não, não.
Mercado Conta