En la carga de los recursos... Cargando...

Comercio

exchange.Buy

Elexchange.Buy()La función se utiliza para realizar órdenes de compra.Buy()La función es una función miembro del objeto de intercambio {@var/EXCHANGE exchange}.Buy()La función opera en la cuenta de cambio vinculada al objeto de cambioexchangeEl objetivo de las funciones (métodos) de los miembros de laexchangeobjeto sólo está relacionado conexchange, y no se repetirá después de la documentación.

Una orden exitosa devuelve el ID de orden, una orden fallida devuelve un valor nulo. El atributoIdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato del par de negociación al contadoETH_USDTel orden del intercambio OKX es:ETH-USDT,1547130415509278720- ¿ Por qué? Cuando se llama a laexchange.Buy()función para realizar una orden, la orden de valor de retornoIdes coherente con laIdatributo de la estructura de orden {@struct/Order Order}.

cadena, valor cero

intercambio.Comprar ((precio, cantidad) intercambio.Comprar ((precio, cantidad,...argumentos)

ElpriceEl parámetro se utiliza para establecer el precio de la orden. precio verdadero Número ElamountEl parámetro se utiliza para establecer el importe del pedido. cantidad verdadero Número Parámetros ampliados que pueden producir información de acompañamiento en este registro de pedidos,argLos parámetros pueden ser pasados más de uno. el falsos cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo compatible con el 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);
}

El número de orden devuelto porexchange.Buy()puede utilizarse para consultar la información del pedido y cancelar el pedido.

// 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);
}

Cuando se realiza una orden para un contrato de futuros de criptomonedas, se debe tener cuidado de garantizar que la dirección del comercio se establezca correctamente, ya que un desajuste entre la dirección del comercio y la función del comercio dará lugar a un error:

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);
}

Orden del mercado al contado.

Al realizar una orden para un contrato de futuros, debe prestar atención a si la dirección del comercio está establecida correctamente, ya que se reportará un error si la dirección del comercio y la función del comercio no coinciden. El parámetropriceestá configurado para:-1para la colocación de órdenes de mercado, lo que requiere que la interfaz de colocación de órdenes de la bolsa soporte las órdenes de mercado.amountes la cantidad de dinero en la moneda de la orden. al colocar órdenes de mercado para contratos de futuros de criptomonedas, el parámetro de cantidadamountes el número de contratos. Hay algunos intercambios de criptomonedas que no admiten la interfaz de orden de mercado durante la negociación en vivo. La cantidad de orden para las órdenes de compra de mercado en algunos intercambios al contado es el número de monedas comerciales.Instrucciones especiales para los intercambiosEn la Guía de usuario se encuentran los detalles. Si está utilizando una versión anterior del docker, el valor de retorno de la ordenIdde lasexchange.Buy()La función puede ser diferente del valor de retorno de la ordenIdse describe en el documento actual.

El valor de las operaciones de cambio se calcula en función de las condiciones de cambio de las operaciones de cambio.

exchange.Sell

Elexchange.Sell()La función se utiliza para colocar órdenes de venta.

Una orden exitosa devuelve el orden Id, una orden fallida devuelve un valor nulo.IdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato del par de negociación al contadoETH_USDTel orden del intercambio OKX es:ETH-USDT,1547130415509278720Cuando llamas a laexchange.Sell()función para realizar una orden, la orden de valor de retornoIdes coherente con laIdatributo de la estructura de orden {@struct/Order Order}. cadena, valor cero

intercambio.Venta (precio, cantidad) intercambio.Venta ((precio, cantidad,...argumentos)

ElpriceEl parámetro se utiliza para establecer el precio de la orden. precio verdadero Número ElamountEl parámetro se utiliza para establecer el importe del pedido. cantidad verdadero Número Parámetros ampliados que pueden producir información de acompañamiento en este registro de pedidos,argLos parámetros pueden ser pasados más de uno. el falsos cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo compatible con el 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);
}

El número de orden devuelto porexchange.Sell()puede utilizarse para consultar información de pedidos y cancelar pedidos.

// 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);
}

Cuando se realiza una orden para un contrato de futuros de criptomonedas, se debe tener cuidado de garantizar que la dirección del comercio se establezca correctamente, ya que un desajuste entre la dirección del comercio y la función del comercio dará lugar a un error:

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);
}

Orden del mercado al contado.

Al realizar una orden para un contrato de futuros, debe prestar atención a si la dirección de negociación está establecida correctamente, ya que se reportará un error si la dirección de negociación y la función de negociación no coinciden. El parámetropriceestá configurado para:-1para la colocación de órdenes de mercado, lo que requiere que la interfaz de colocación de órdenes de la bolsa soporte las órdenes de mercado.amountCuando se colocan órdenes de mercado para contratos de futuros de criptomonedas, el parámetro de cantidadamountHay algunos intercambios de criptomonedas que no admiten la interfaz de orden de mercado durante el comercio en vivo. Si está utilizando una versión anterior del docker, el valor de retorno de la ordenIdde lasexchange.Sell()La función puede ser diferente del valor de retorno de la ordenIdse describe en el documento actual.

El valor de las operaciones de cambio se calcula a partir de la suma de las operaciones de cambio.

exchange.CreateOrder

Elexchange.CreateOrder()La función se utiliza para hacer un pedido.

Si el pedido se realiza con éxito, se devuelve el ID del pedido; si el pedido falla, se devuelve un valor nulo.IdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato de la orden del par de negociación al contadoETH_USDTde la bolsa OKX es:ETH-USDT,1547130415509278720Cuando llamas a laexchange.CreateOrder(symbol, side, price, amount)función para realizar una orden, el valor devuelto de la ordenIdes coherente con laIdpropiedad de la estructura del orden {@struct/Order Order}. cadena, valor cero

intercambio.CreateOrder ((símbolo, lado, precio, cantidad) intercambio.CreateOrder ((símbolo, lado, precio, cantidad,...args)

El parámetrosymbolSe utiliza para especificar el par de operaciones específico y el código del contrato de la orden.exchange.CreateOrder(symbol, side, price, amount)función para realizar un pedido,exchangeSi la moneda denominada de la orden es USDT y la moneda de transacción es BTC, el parámetrosymboles:"BTC_USDT", en el formato del par de operaciones definido por la plataforma FMZ.exchange.CreateOrder(symbol, side, price, amount)función para realizar un pedido,exchangeSi la orden es una orden de contrato perpetuo estándar BTCs U, el parámetrosymboles:"BTC_USDT.swap", y el formato es una combinación dePares de negociaciónycódigo del contratodefinido por la plataforma FMZ, separado por el carácter ..exchange.CreateOrder(symbol, side, price, amount)función para realizar un pedido,exchangeSi la orden es una orden de contrato de opción estándar U de BTC, el parámetrosymboles:"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como ejemplo), y el formato es una combinación dePares de negociacióndefinido por la plataforma FMZ y el código del contrato de opción específico definido por la bolsa, separado por el carácter .. el símbolo verdadero la cuerda Elsideel parámetro se utiliza para especificar la dirección de negociación de la orden. Para los objetos de intercambio al contado, los valores opcionales de lasidelos parámetros son:buy, sell. buysignifica comprar, ysellsignifica vender. En el caso de los objetos de cambio de futuros, los valores opcionales de lasidelos parámetros son:buy, closebuy, sell, closesell. buysignifica la apertura de una posición larga,closebuysignifica el cierre de una posición larga,sellsignifica abrir una posición corta, yclosesellsignifica cerrar una posición corta.

el lado verdadero la cuerda El parámetropriceSe utiliza para establecer el precio de la orden. Un precio de -1 indica que la orden es una orden de mercado. precio verdadero Número El parámetroamountSe utiliza para establecer la cantidad de orden. Tenga en cuenta que cuando la orden es una orden de compra de mercado, la cantidad de orden es el importe de compra; la cantidad de orden de la orden de compra de mercado de algunos intercambios al contado es el número de monedas de negociación.Instrucciones especiales para los intercambiosen la Guía del usuario. cantidad verdadero Número Los parámetros extendidos pueden producir información adicional a este registro de pedidos.arglos parámetros pueden ser pasados. el falsos Cualquier tipo compatible con el sistema, como cadena, 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);
}

Los objetos de intercambio al contado y los objetos de intercambio de futuros se denominanexchange.CreateOrder()Función para hacer un pedido.

En el caso de las empresas de servicios de la Unión Europea, el número de empresas de servicios de servicios de la Unión Europea es el siguiente:

exchange.CancelOrder

Elexchange.CancelOrder()La función se utiliza para cancelar el pedido. El atributoIdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato de la orden del par de negociación al contadoETH_USDTde la bolsa OKX es:ETH-USDT,1547130415509278720- ¿ Por qué? El parámetroorderIdEn el momento de llamar a laexchange.CancelOrder()La función para cancelar una orden es consistente con laIdpropiedad de la estructura del orden {@struct/Order Order}.

Elexchange.CancelOrder()función devuelve un valor verdadero, por ejemplotruesignifica que la solicitud de orden de cancelación fue enviada con éxito. Si devuelve un valor falso, comofalseEl valor devuelto sólo representa el éxito o fracaso de la solicitud enviada para determinar si el intercambio cancela el pedido.exchange.GetOrders()para determinar si la orden se cancela. - ¿ Qué?

Intercambio.Cancelar Pedido (Identificación del pedido) Intercambio.Cancelar Orden ((ordenId,...args)

ElorderIdEl parámetro se utiliza para especificar la orden a cancelar. ordenado verdadero número, cadena Parámetros extendidos, puede enviar la información adjunta a este registro de retiro,argLos parámetros pueden ser pasados más de uno. el falsos cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo compatible con el 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);
}

Cancela la orden.

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);
    }
}

Funciones de la API FMZ que pueden producir funciones de salida de registro tales como:Log(), exchange.Buy(), exchange.CancelOrder()puede ser seguido por algunos parámetros de salida de acompañamiento después de los parámetros necesarios, por ejemplo:exchange.CancelOrder(orders[i].Id, orders[i]), de modo que al cancelar el pedido cuyo ID esorders[i].Id, la información de la orden se emite con ella. Es decir, la estructura de {@struct/Order Order} deorders[i].

Si está utilizando una versión anterior del docker, el parámetro orderId de la función exchange.CancelOrder() puede ser diferente del orderId descrito en el documento actual.

Se trata de una lista de las acciones que se han emitido en el mercado de valores.

exchange.GetOrder

Elexchange.GetOrder()La función se utiliza para obtener la información del pedido.

Consultar los detalles del orden de acuerdo con el número de orden, y devolver la estructura {@struct/Order Order} si la consulta tiene éxito, o devolver nulo si la consulta falla. {@struct/Order Order}, valor nulo

En el caso de las operaciones de intercambio.GetOrder ((orderId))

ElorderIdEl parámetro se utiliza para especificar el orden a consultar. El atributoIdLa estructura de orden {@struct/Order Order} de la plataforma FMZ consiste en el código de producto de intercambio y el ID de pedido original de intercambio, separados por comas en inglés.Idformato de la orden del par de negociación al contadoETH_USDTde la bolsa OKX es:ETH-USDT,1547130415509278720- ¿ Por qué? El parámetroorderIdEn el momento de llamar a laexchange.GetOrder()Función para consultar una orden es consistente con elIdpropiedad de la estructura del orden {@struct/Order Order}.

ordenado verdadero la cuerda

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);
}

Elexchange.GetOrder()La función no es soportada por algunos intercambios.AvgPriceAlgunos intercambios no admiten este campo, y si no lo hacen, se establece en 0. Si está utilizando una versión anterior del docker, elorderIdParámetro delexchange.GetOrder()La función de laorderIddescrito en la documentación actual. Los intercambios que no apoyan laexchange.GetOrder()Función:

Nombre de la función Intercambios al contado sin soporte Exchanges de futuros no respaldados
Obtener orden Zaif / Coincheck / Bitstamp. ¿ Qué es esto? –

{@struct/Order Order}, {@fun/Trade/exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@struct/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetHistoryOrders exchange.GetHistoryOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Exchange.GetOrders exchange.GetOrders exchange.GetOrders exchange.GetOrders}, {@fun/Trade/Trade/Exchange

exchange.GetOrders

Elexchange.GetOrders()La función se utiliza para obtener pedidos pendientes.

Elexchange.GetOrders()La función devuelve una matriz de estructuras {@struct/Order Order} si la solicitud de datos tiene éxito, y devuelve valores nulos si la solicitud de datos falla. {@struct/Order Order} matriz, valor nulo

El cambio.GetOrders ((( intercambio.GetOrders (símbolo)

El parámetrosymbolse utiliza para establecer elsímbolo de la transaccióno bienrango de símbolos de transacciónpara ser interrogado. Para los objetos de intercambio al contado, si elsymbolSi no se pasa el parámetro, se solicitarán los datos de pedido incompletos de todos los productos al contado. Para los objetos de cambio de futuros, si elsymbolSi el parámetro no se pasa, el valor predeterminado es solicitar los datos de orden incompletos de todas las variedades en el rango de dimensiones del par de negociación actual y el código del contrato.

el símbolo falsos la cuerda

/*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;
}

Utilice el objeto de intercambio al contado para realizar órdenes de compra para varios pares de operaciones diferentes a la mitad del precio actual y, a continuación, consultar la información de la orden pendiente.

/*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;
}

Utilizar objetos de intercambio de futuros para colocar órdenes para múltiples pares de operaciones diferentes y códigos de contrato.

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);
}

Cuando se llama a laexchange.GetOrders()Función, pasar en elSymbolParámetro para solicitar datos de orden para un par de operaciones específico y código de contrato.

En elGetOrdersFunción, los escenarios de uso del parámetro símbolo se resumen de la siguiente manera:

Clasificación de objetos de intercambio símbolo Parámetros Alcance de la consulta No obstante,
Punto No pase el parámetro de símbolo Consulta todos los pares de operaciones al contado Para todos los escenarios de llamada, si la interfaz de intercambio no lo admite, se informará un error y se devolverá un valor nulo.
Punto Especificar el tipo de negociación, el parámetro del símbolo es: BTC_USDT Consultar el par de operaciones BTC_USDT especificado Para los objetos de intercambio al contado, el formato del parámetro del símbolo es: BTC_USDT
Los futuros No pase el parámetro de símbolo Consultar todos los productos de negociación dentro del rango de dimensiones del par de negociación actual y del código del contrato Si el par de negociación actual es BTC_USDT y el código del contrato es swap, todos los contratos perpetuos con margen en USDT serán consultados.GetOrders("USDT.swap")
Los futuros Especifique el tipo de negociación, el parámetro del símbolo es: BTC_USDT.swap Consultar el contrato perpetuo basado en USDT para un BTC especificado Para los objetos de intercambio de futuros, el formato del símbolo del parámetro es:Pares de negociaciónycódigo del contratodefinidas por la plataforma FMZ, separadas por los caracteres"..
Los futuros Especifique el rango de productos de negociación, el parámetro del símbolo es: USDT.swap Consultar todos los contratos perpetuos basados en USDT -
Bolsas de futuros que admiten opciones No pase el parámetro de símbolo Consultar todos los contratos de opción dentro del rango de dimensiones del par de operaciones actual Si el par de operaciones actual es BTC_USDT, el contrato se establece en un contrato de opción, por ejemplo, contrato de opción de Binance: BTC-240108-40000-C
Bolsas de futuros que admiten opciones Especificar los productos comerciales específicos Consultar el contrato de opción especificado Por ejemplo, para Binance Futures Exchange, el parámetro del símbolo es: BTC_USDT.BTC-240108-40000-C
Bolsas de futuros que admiten opciones Especifique la gama de productos de negociación, el parámetro del símbolo es: USDT.option Consultar todos los contratos de opciones basados en USDT -

En elGetOrdersfunción, la consulta del objeto de intercambio de futuros el rango de dimensiones se resume de la siguiente manera:

símbolo Parámetros Definición del rango de solicitud No obstante,
USDT.swap Los tipos de interés de las entidades de crédito incluidas en el anexo I se determinarán de acuerdo con el método de cálculo de la rentabilidad. Para

dimensiones que no sean compatibles con la interfaz de intercambio API, se informará de un error y se devolverá un valor nulo cuando llamando. Un contrato de entrega basado en USDT. USD.swap. Rango de cambio perpetuo basado en moneda Los contratos. USD.futures Rango de entrega basado en moneda Los contratos. Un contrato de opciones basado en USDT. Un contrato de opciones basado en divisas. Conjunto USDT.futures_combo. Rango de combinaciones de CFD. Futures_Deribit Intercambio Un rango de contratos de entrega de margen mixto. Futures_Kraken Intercambio Un conjunto de contratos perpetuos de margen mixto. El futuro es el intercambio Kraken

Cuando la cuenta representada por el objeto de intercambioexchangeno tiene órdenes pendientes dentro de larango de búsquedao bieninstrumentos de negociación específicos(órdenes activas en un estado no cumplido), llamando a esta función devuelve una matriz vacía, es decir:[]¿ Qué pasa? Los siguientes intercambios requieren que el instrumento pase en el parámetro del instrumento al consultar las órdenes actualmente incompletas. Cuando se llama a la función GetOrders con estos intercambios, si no se pasa el parámetro del instrumento, solo se solicitan las órdenes incompletas del instrumento actual, no las órdenes incompletas de todos los instrumentos (porque la interfaz de intercambio no admite esto). Zaif, MEXC, LBank, Korbit, Coinw, BitMart, Bithumb, BitFlyer, BigONE. Es el único que tiene el nombre de la compañía.

Los intercambios que no apoyan laexchange.GetOrders()Función:

Nombre de la función Intercambios al contado sin soporte Exchanges de futuros no respaldados
Obtener órdenes – El valor de la inversión se calcula a partir del valor de la inversión

Los datos de las operaciones de compra y venta de los productos de los Estados miembros que se encuentran en el ámbito de aplicación de la presente Directiva son los siguientes: {@struct/Order Order}, {@fun/Trade/exchange.GetOrder exchange.GetOrder}

exchange.GetHistoryOrders

Elexchange.GetHistoryOrders()Esta función se utiliza para obtener el par de operaciones actual, las órdenes históricas de los contratos; admite la especificación de variedades de operaciones específicas.

Elexchange.GetHistoryOrders()La función devuelve una matriz de estructuras {@struct/Order Order} si la solicitud de datos tiene éxito, y nula si la solicitud falla. Las matrices de {@struct/Order Order}, valores nulos

intercambio.GetHistoryOrders (() intercambio.GetHistoryOrders (símbolo) intercambio.GetHistoryOrders (símbolo, desde) intercambio.GetHistoryOrders (símbolo, desde, límite) intercambio.GetHistoryOrders (Desde entonces) intercambio.GetHistoryOrders (desde el límite)

ElsymbolEn el caso de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valoresBTC_USDTEn la actualidad, el mercado de la moneda única se ha convertido en un mercado de valores.exchangees un objeto de intercambio al contado, el formato de parámetro parasymbolesBTC_USDTEn el caso de un objeto de intercambio de futuros, tomando como ejemplo el contrato perpetuo, el formato de parámetro parasymboles:BTC_USDT.swap¿ Qué pasa? Si usted está consultando los datos de orden de los contratos de opción, establecer el parámetrosymbolEn el"BTC_USDT.BTC-240108-40000-C"(tomando Binance Option BTC-240108-40000-C como ejemplo).Pares de negociacióndefinido por la plataforma FMZ y el código del contrato de opción específico definido por la bolsa, separado por el carácter .. Si no se pasa este parámetro, se solicitarán por defecto los datos de orden del par de operaciones y el código del contrato actualmente establecidos.

el símbolo falsos la cuerda ElsinceParámetro utilizado para especificar la marca de tiempo de inicio de la consulta en milisegundos. Desde entonces falsos Número EllimitEl parámetro se utiliza para especificar el número de órdenes a consultar. el límite falsos 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);
}
  • ¿Cuándo?symbol, since, limitSi no se especifican los parámetros, la consulta predeterminada es el par de operaciones actual, las órdenes históricas del contrato.
  • Cuando elsymbolSi se especifica el parámetro, consultar el historial de órdenes para el tipo de operación establecido.
  • Cuando elsinceParámetro se especifica, consulta en la dirección de la hora actual utilizando elsinceel sello de tiempo como la hora de inicio.
  • Si ellimitCuando se especifica un parámetro, la consulta se devuelve después de un número suficiente de entradas.
  • Esta función solo es compatible con los intercambios que proporcionan una interfaz de consulta de pedidos históricos.

Los intercambios que no apoyan laexchange.GetHistoryOrders()Función:

Nombre de la función Intercambios al contado sin soporte Exchanges de futuros no respaldados
Obtener órdenes de historial Zaif / Upbit / Coincheck / Bitstamp / Bithumb / BitFlyer / BigONE Los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores de los valores

Los datos de las operaciones de compra y de venta de los productos de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros incluidos en la lista de productos de venta de los Estados miembros.

exchange.SetPrecision

exchange.SetPrecision()Función utilizada para establecer la precisión delexchangeobjeto de intercambioprecioyimporte de la orden, después de la configuración, el sistema ignorará el exceso de datos automáticamente.

cambio.ConfiguraciónPrecisión ((precioPrecisión, cantidadPrecisión)

ElpricePrecisionEl parámetro se utiliza para controlar la precisión de los datos de precios. Precio Precisión verdadero Número ElamountPrecisionEl parámetro se utiliza para controlar la precisión de la cantidad de datos a ordenar. cantidadPrecisión verdadero 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);
}

El sistema de backtesting no admite esta función, y la precisión numérica del sistema de backtesting se maneja automáticamente.

En el caso de las empresas de servicios de la Unión Europea, el número de empresas de servicios de servicios de la Unión Europea es el siguiente:

exchange.SetRate

Establecer el tipo de cambio actual del objeto de intercambio.

cambio.Tasa establecida (Tasa)

Elrateel parámetro se utiliza para especificar el tipo de cambio de conversión. el tipo verdadero 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);
}

Si se ha fijado un valor de tipo de cambio utilizando elexchange.SetRate()En este caso, la información de precios, como tickers, profundidades, precios de pedido, etc. para el intercambio representado por el actualexchangeel objeto de cambio se convertirá multiplicándolo por el tipo de cambio establecido de 7.exchangees un intercambio con el dólar estadounidense como moneda nominal.exchange.SetRate(7), todos los precios en el mercado en vivo se convertirán a precios cercanos a los precios de los precios de los precios en el mercado en vivo.En el caso de las empresas de servicios de telecomunicaciones:La denominación se multiplica por 7.

¿Por qué no lo haces?

exchange.IO

Elexchange.IO()La función se utiliza para otras llamadas de interfaz relacionadas con el objeto de intercambio.

Elexchange.IO()La función llama a otras interfaces relacionadas con el objeto de intercambio, devolviendo los datos de respuesta solicitados en una llamada exitosa y devuelve nulo en una llamada fallida. cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo soportado por el sistema

exchange.IO(k,...args)

ElkParámetro utilizado para establecer el tipo de llamada, con valores opcionales"api", "currency", "base", "trade_margin", "trade_normal", "public_base", "mbase", selfTradePreventionMode, simulate, cross, dual, unifiedy así sucesivamente. el verdadero la cuerda Parámetros ampliados, aprobados de acuerdo con el escenario de llamada específico,argLos parámetros pueden ser pasados a más de uno.exchange.IO()El número y el tipo de parámetros para elexchange.IO()Las funciones son indeterminadas. el verdadero string, number, bool, object, array, null y cualquier otro tipo soportado por el 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 elexchange.IO("api", httpMethod, resource, params, raw)el formulario de convocatoria de laexchange.IO()En este caso, es necesario entender la interfaz API del intercambio y comprobar primero la documentación pertinente. Esto le permitirá ampliar la funcionalidad que no se agrega a la plataforma FMZ.POSTLa solicitud no requiere que se preocupe por cifrar, firmar o verificar los parámetros, que ya son manejados por FMZ en la parte inferior, siempre y cuando complete los parámetros correspondientes.Intercambio OKXlos contratos de futuros, y utilizar el parámetrorawpara pasar los parámetros de orden:

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);
}

Si el valor clave en elparamsParámetro (es decir, parámetro de solicitud HTTP) es una cadena, que necesita ser escrito en comillas (es decir, el símbolo ') alrededor del valor del parámetro para envolver el valor del 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);
}

Apoya el paso de parámetros de url completos que pueden omitir la operación de cambiar la dirección base (llamando elexchange.SetBase()función).

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);
}

Ejemplo de llamada sin el 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());
}

Cambiar el par de negociación del intercambio actual, de modo que cambiará el par de negociación configurado por códigoen la creación de operaciones en vivoo bienen el 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 los intercambios con diferentes direcciones de base para la interfaz de ticker y la interfaz de negociación, por ejemplo, Bitfinex Futures tiene dos direcciones, una para la interfaz de ticker y la otra para la interfaz de negociación.exchange.SetBase("xxx")Los futuros de Bitfinex cambian la dirección de base de la interfaz pública usandoexchange.IO("mbase", "xxx").

I. Para los intercambios centrados en las criptomonedas, otras llamadas de interfaz de API que no estén encapsuladas de manera uniforme, con parámetrokSe establece en"api":

exchange.IO("api", httpMethod, resource, params, raw)
  • httpMethod : El parámetro es un tipo de cadena, complete el tipo de solicitudPOST, GET, etc.
  • resource : El parámetro es de tipo cadena y llena la ruta de solicitud; admite el uso de rutas de solicitud completas, véase el ejemplo de referencia para más detalles.
  • Parámetros: El parámetro es un tipo de cadena, lleno de parámetros de solicitud, codificado conURL.
  • raw: el parámetro es el parámetro de la cadena raw y se puede omitir.

Elexchange.IO("api", httpMethod, resource, params, raw)La llamada de la función accederá a la interfaz de intercambio y devolverá null si la llamada falla y se produce un error. Sólo el comercio real apoya la llamadaexchange.IO("api", httpMethod, resource, params, raw) function.

II. Para el cambio de pares de operaciones, el parámetrokestá configurado para:"currency":

exchange.IO("currency", currency)

  • moneda: El parámetro es un tipo de cadena con un formato de mayúscula uniforme, utilizando un trazo para separarbaseCurrencydesdequoteCurrency, como por ejemploBTC_USDT.

    1. El sistema de backtesting ahora admite el cambio de pares comerciales (sólo para objetos de intercambio spot de moneda digital), al hacer backtesting, debe prestar atención a que solo puede cambiar a pares comerciales con la misma moneda denominada, por ejemplo, el par comercial actual esETH_BTCsólo puede cambiar aLTC_BTC, no paraLTC_USDT.
    2. Para los contratos de futuros de criptomonedas, el objeto de intercambio cambia de par de operaciones y el código del contrato debe volver a establecerse para determinar qué contrato se negociará.
    3. Usar la función {@fun/Account/exchange.SetCurrency exchange.SetCurrency} para cambiar pares de operaciones es exactamente lo mismo que usarexchange.IO("currency", currency)para cambiar de par de operaciones.

III. Se utiliza para cambiar el modo de cuenta apalancada del objeto de intercambio spot de criptomonedas:

  • El parámetrokestá configurado para:"trade_margin"Para realizar órdenes y obtener activos de la cuenta, se accederá a la interfaz de apalancamiento al contado de la bolsa. Si la bolsa distingue entre el margen total y el margen aislado en el apalancamiento al contado, utilizar:exchange.IO("trade_super_margin")cambiar al margen completo para la cuenta apalancada, yexchange.IO("trade_margin")el cambio a margen aislado para la cuenta apalancada.
  • Parámetrokestá configurado para:"trade_normal"para volver al modo normal de cuenta al contado.

Bolsas al contado que admiten el cambio entre modelos de cuentas apalancadas:

Los intercambios Observaciones especiales
No hay problema. Los pares de operaciones en el modo de cuenta apalancada son diferentes de los normales, algunos pares de operaciones pueden no tenerlos.exchange.IO("trade_super_margin")cambiar a posición completa para las cuentas apalancadas y utilizarexchange.IO("trade_margin")para cambiar a posición por posición.trade_normalpara cambiar al modo spot normal.exchange.IO("tdMode", "cross")para especificar directamente el modo de apalancamiento.
- ¿ Qué? Los pares de operaciones de modo de cuenta apalancada son diferentes de los normales, algunos pares de operaciones pueden no tenerlos.trade_marginpara cambiar a la posición de la cuenta de apalancamiento por posición, utilizartrade_super_marginPara cambiar a la posición completa de la cuenta de apalancamiento.trade_normalpara cambiar al modo normal de divisas.
Binance El modo de cuenta apalancada se divide en posición por posición y posición completa, usotrade_marginpara cambiar a posición por posición, utilizartrade_super_marginpara cambiar a posición completa, utilizartrade_normalpara cambiar al modo normal de divisas.
Puerta de entrada El modo de cuenta apalancada se divide en posición por posición y posición completa, usotrade_marginpara cambiar a posición por posición, utilizartrade_super_marginpara cambiar a posición completa, utilizartrade_normalpara cambiar al modo normal de divisas.
AscendEx es el nombre de la aplicación. Utilizaciónexchange.IO("trade_margin")cambiar al modo de cuenta de apalancamiento yexchange.IO("trade_normal")para volver al modo de cuenta normal.
¿ Qué pasa? Utilizaciónexchange.IO("trade_margin")cambiar al modo de cuenta de apalancamiento yexchange.IO("trade_normal")para volver al modo de cuenta normal.
CoinEx también Utilizaciónexchange.IO("trade_margin")cambiar al modo de cuenta apalancada yexchange.IO("trade_normal")para volver al modo de cuenta normal.

Otras funciones de conmutación:Mira elexchange.IO()Función paraOtras funciones de conmutaciónen la Guía del usuario.

En el caso de los sistemas operativos, el valor de los valores de los valores de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos de los sistemas operativos.

exchange.Log

Elexchange.Log()Cuando se llama, no se colocan órdenes, solo se sacan y registran los registros de transacciones.

cambio.Log ((ordenTipo, precio, importe) cambio.Log ((ordenTipo, precio, importe,...argumentos)

ElorderTypeSe utiliza el parámetro para establecer el tipo de registro de salida, los valores opcionales son {@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}. ordenTipo verdadero Número ElpriceEl parámetro se utiliza para establecer el precio que se muestra en el registro de salida. precio verdadero Número ElamountEl parámetro se utiliza para establecer la cantidad de pedidos realizados que se muestran en el registro de salida. cantidad verdadero Número Parámetros ampliados que pueden producir información de acompañamiento a este registro,argLos parámetros pueden ser pasados más de uno. el falsos cadena, número, bool, objeto, matriz, nulo y cualquier otro tipo compatible con el 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);
}

Utilizandoexchange.Log(orderType, price, amount)Uno de los escenarios más comunes es el uso de {@fun/Trade/exchange.IOexchange.IO} para acceder a la interfaz de intercambio para crear órdenes condicionales, pero utilizando elexchange.IO()la función no produce la información del registro de transacciones en el registro de operaciones en vivo.exchange.Log()La función puede utilizarse para complementar el registro de salida con el fin de registrar la información sobre la colocación de pedidos, y lo mismo ocurre con las operaciones de retirada de pedidos.

Cuando elorderTypeel parámetro esLOG_TYPE_CANCEL, elpriceParámetro es el orden Id de la orden retirada, que se utiliza para imprimir el registro de retirada cuando la orden se retira directamente utilizando elexchange.IO()La funciónexchange.Log()La función es una función miembro del objeto de intercambio {@var/EXCHANGE exchange}, a diferencia de la función global {@fun/Log Log}.

Los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos de los datos.

exchange.Encode

Elexchange.Encode()La función se utiliza para los cálculos de cifrado de firmas.

Elexchange.Encode()La función devuelve el valor de codificación de hash calculado. la cuerda

exchange.Encode ((algo, inputFormat, outputFormat, datos) exchange.Encode ((algo, inputFormat, outputFormat, datos, claveFormat, clave)

El parámetroalgoes el algoritmo utilizado para el cálculo de codificación. Los ajustes compatibles son: raw (sin algoritmo utilizado), sign, signTx, md4, md5, sha256, sha512, sha1, keccak256, sha3.224, sha3.256, sha3.384, sha3.512, sha3.keccak256, sha3.keccak512, sha512.384, sha512.256, sha512.224, emd160, ripke2b.256, blake2b.512, blake2b.512, blake2s.128, blake2s.256.algoTambién admite: text.encoder.utf8, text.decoder.utf8, text.encoder.gbk, text.decoder.gbk, para codificar y decodificar cadenas.algotambién admite: ed25519 algoritmo. admite el uso de diferentes algoritmos de hash, por ejemplo, el parámetroalgopuede escribirse como ed25519.md5, ed25519.sha512, etc.ed25519.seedel cálculo. algo verdadero la cuerda Se utiliza para especificar el formato de datos deldatael parámetro.inputFormatraw significa que los datos son datos en bruto, hex significa que los datos sonhexcodificado, base64 significa que los datos estánbase64codificado, y string significa que los datos son una cadena. EntradaFormato verdadero la cuerda Se utiliza para especificar el formato de datos de salida.outputFormatParámetro admite los siguientes ajustes: raw, hex, base64, string. raw significa que los datos son datos en bruto, hex significa que los datos sonhexcodificado, base64 significa que los datos estánbase64codificado, y string significa que los datos son una cadena. ProducciónFormato verdadero la cuerda El parámetrodataes los datos a tratar. datos verdadero la cuerda Se utiliza para especificar el formato de datos delkeyel parámetro.keyraw significa que los datos son datos en bruto, hex significa que los datos sonhexcodificado, base64 significa que los datos estánbase64codificado, y string significa que los datos son una cadena. claveFormato falsos la cuerda ElkeyParámetro se utiliza para especificar la clave utilizada en el cálculo de la firma, y se puede utilizar como una cadena de texto plano."{{accesskey}}", "{{secretkey}}"para referirse a laaccessKeyysecretKeyconfigurado en el objeto de intercambio {@var/EXCHANGE exchange}. llave falsos la cuerda

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"];
        }
    }
}

Ejemplo de empuje de cambio de posición de BitMEX (protocolo wss):

Sólo el comercio real apoya la llamadaexchange.Encode()La función"{{accesskey}}", "{{secretkey}}"Las referencias sólo son válidas cuando elexchange.Encode()La función se utiliza.

¿Qué es lo que está pasando?

exchange.Go

Las funciones de soporte asíncrono de múltiples hilos pueden convertir las operaciones de todas las funciones soportadas en una ejecución simultánea asíncrona.

Elexchange.Go()función devuelve un objeto concurrente inmediatamente, y se puede utilizar elwait()método de ese objeto concurrente para obtener el resultado de la solicitud concurrente. objeto

el método de intercambio. el intercambio.Método Go,...args

ElmethodParámetro se utiliza para especificar el nombre de la función concurrente. Tenga en cuenta que el parámetro es una cadena de nombres de función, no una referencia de función. Método verdadero la cuerda Parámetros paraEjecutar funciones simultáneamente, puede haber más de un parámetroargTipo y número de parámetrosargdependerá de los parámetros de laFunción de ejecución simultánea¿ Qué pasa? el falsos cadena, número, bool, objeto, matriz, función, nulo y todos los demás tipos compatibles con el 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()ejemplo de uso de la función, para determinarundefinedpara usartypeof(xx) === "undefined", porquenull == undefinedes válido en 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);
}

Llamando alwait()El método en un objeto concurrente que ha sido liberado reportará un error:

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);
    }
}

Acceso simultáneo a varios tickers de cambio:

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");
}

Convocatorias simultáneas paraexchange.IO("api", ...)Función:

Esta función solo crea tareas de ejecución de múltiples hilos cuando se ejecutan en el comercio real, la prueba posterior no admite la ejecución simultánea de tareas de múltiples hilos (la prueba posterior está disponible, pero aún se ejecuta secuencialmente). Después de laexchange.Go()función devuelve un objeto, suwait()La función se llama a través de ese objeto para obtener los datos devueltos por el hilo.wait()La función debe ser llamada para obtener los datos antes de que el hilo será liberado automáticamente.wait()El resultado del hilo debe ser obtenido antes de que sea liberado automáticamente (independientemente del éxito o fracaso de la llamada de la interfaz para el acceso concurrente).wait()función independientemente de si la ejecución tiene éxito o no, y el recurso del hilo solicitado por elexchange.Go()La función debe ser liberada automáticamente por el docker. Elwait()El método admite un parámetro de tiempo de espera: Sin un parámetro de tiempo de espera, es decir,wait(), o con un parámetro de tiempo de espera de 0, es decir,wait(0)El.wait()Bloques de función y espera hasta que el hilo concurrente haya terminado de ejecutarse, devolviendo el resultado de la ejecución del hilo concurrente. Establecer el parámetro de tiempo de espera -1, es decirwait(-1)El.wait()función devuelve inmediatamente, con diferentes valores de retorno para diferentes lenguajes de programación, ver esta subsección para un ejemplo de llamada. Establezca el parámetro de tiempo de espera específico,wait(300), y elwait()La función esperará un máximo de 300 milisegundos antes de regresar.

Si el resultado de vuelta de la finalwait()Si no se obtiene la función, los recursos de hilo no se liberarán automáticamente, lo que dará lugar a la acumulación de hilos solicitados, y más de 2000 reportará un error:"too many routine wait, max is 2000"- ¿ Por qué? Funciones soportadas:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Todas estas funciones se ejecutan basándose en el objeto de intercambio actual {@var/EXCHANGE exchange} cuando se llama simultáneamente. La diferencia entre el lenguaje Python y el lenguaje JavaScript es quewait()La función de objetos concurrentes en Python devuelve dos parámetros. El primer parámetro es el resultado devuelto por una llamada de API asíncrona, y el segundo parámetro indica si la llamada asíncrona se ha completado.


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)

¿Qué es lo que está pasando? ¿Qué está pasando?

Mercado Cuenta

2019 FMZ - Todos los derechos reservados