Discusión sobre la recepción de señales externas de la plataforma FMZ: una solución completa para recibir señales con servicio HTTP incorporado en la estrategia
El autor:FMZ~Lydia, Creado: 2024-12-18 09:22:33, Actualizado: 2024-12-18 09:24:49Prefacio
En el artículo anteriorDiscusión sobre la recepción de señales externas de la plataforma FMZ: API extendida frente a la estrategia de servicio HTTP incorporado, comparamos dos formas diferentes de recibir señales externas para el comercio programático y analizamos los detalles. La solución de usar la API extendida de la plataforma FMZ para recibir señales externas tiene una estrategia completa en la biblioteca de estrategias de la plataforma.
Aplicación de la estrategia
Siguiendo la estrategia anterior de usar la extensión de FMZ API para acceder a las señales de Trading View, utilizamos el formato de mensaje anterior, el método de procesamiento de mensajes, etc. y hacemos modificaciones simples a la estrategia.
Debido a que los servicios incorporados en la estrategia pueden utilizar Http o HTTPS, para una demostración simple, utilizamos el protocolo Http, añadimos la verificación de la lista blanca IP y añadimos la verificación de contraseñas.
//Signal structure
var Template = {
Flag: "45M103Buy", // Logo, can be specified at will
Exchange: 1, // Designated exchange trading pairs
Currency: "BTC_USDT", // Trading pairs
ContractType: "spot", // Contract type, swap, quarter, next_quarter, spot fill in spot
Price: "{{close}}", // Opening or closing price, -1 is the market price
Action: "buy", // Transaction type [buy: spot buy, sell: spot sell, long: futures long, short: futures short, closesell: futures buy to close short, closebuy: futures sell to close long]
Amount: "1", // Trading volume
}
var Success = "#5cb85c" // Success color
var Danger = "#ff0000" // Danger color
var Warning = "#f0ad4e" // Warning color
var buffSignal = []
// Http service
function serverFunc(ctx, ipWhiteList, passPhrase) {
var path = ctx.path()
if (path == "/CommandRobot") {
// Verify IP address
var fromIP = ctx.remoteAddr().split(":")[0]
if (ipWhiteList && ipWhiteList.length > 0) {
var ipList = ipWhiteList.split(",")
if (!ipList.includes(fromIP)) {
ctx.setStatus(500)
ctx.write("IP address not in white list")
Log("500 Error: IP address not in white list", "#FF0000")
return
}
}
// Verify password
var pass = ctx.rawQuery().length > 0 ? ctx.query("passPhrase") : ""
if (passPhrase && passPhrase.length > 0) {
if (pass != passPhrase) {
ctx.setStatus(500)
ctx.write("Authentication failed")
Log("500 Error: Authentication failed", "#FF0000")
return
}
}
var body = JSON.parse(ctx.body())
threading.mainThread().postMessage(JSON.stringify(body))
ctx.write("OK")
// 200
} else {
ctx.setStatus(404)
}
}
// Check signal message format
function DiffObject(object1, object2) {
const keys1 = Object.keys(object1)
const keys2 = Object.keys(object2)
if (keys1.length !== keys2.length) {
return false
}
for (let i = 0; i < keys1.length; i++) {
if (keys1[i] !== keys2[i]) {
return false
}
}
return true
}
function CheckSignal(Signal) {
Signal.Price = parseFloat(Signal.Price)
Signal.Amount = parseFloat(Signal.Amount)
if (Signal.Exchange <= 0 || !Number.isInteger(Signal.Exchange)) {
Log("The minimum exchange number is 1 and is an integer.", Danger)
return
}
if (Signal.Amount <= 0 || typeof(Signal.Amount) != "number") {
Log("The trading volume cannot be less than 0 and must be a numeric type.", typeof(Signal.Amount), Danger)
return
}
if (typeof(Signal.Price) != "number") {
Log("Price must be a numeric value", Danger)
return
}
if (Signal.ContractType == "spot" && Signal.Action != "buy" && Signal.Action != "sell") {
Log("The instruction is to operate spot goods, and the Action is wrong, Action：", Signal.Action, Danger)
return
}
if (Signal.ContractType != "spot" && Signal.Action != "long" && Signal.Action != "short" && Signal.Action != "closesell" && Signal.Action != "closebuy") {
Log("The instruction is to operate futures, and the Action is wrong, Action：", Signal.Action, Danger)
return
}
return true
}
// Signal processing object
function createManager() {
var self = {}
self.tasks = []
self.process = function() {
var processed = 0
if (self.tasks.length > 0) {
_.each(self.tasks, function(task) {
if (!task.finished) {
processed++
self.pollTask(task)
}
})
if (processed == 0) {
self.tasks = []
}
}
}
self.newTask = function(signal) {
// {"Flag":"45M103Buy","Exchange":1,"Currency":"BTC_USDT","ContractType":"swap","Price":"10000","Action":"buy","Amount":"0"}
var task = {}
task.Flag = signal["Flag"]
task.Exchange = signal["Exchange"]
task.Currency = signal["Currency"]
task.ContractType = signal["ContractType"]
task.Price = signal["Price"]
task.Action = signal["Action"]
task.Amount = signal["Amount"]
task.exchangeIdx = signal["Exchange"] - 1
task.pricePrecision = null
task.amountPrecision = null
task.error = null
task.exchangeLabel = exchanges[task.exchangeIdx].GetLabel()
task.finished = false
Log("Create a task:", task)
self.tasks.push(task)
}
self.getPrecision = function(n) {
var precision = null
var arr = n.toString().split(".")
if (arr.length == 1) {
precision = 0
} else if (arr.length == 2) {
precision = arr[1].length
}
return precision
}
self.pollTask = function(task) {
var e = exchanges[task.exchangeIdx]
var name = e.GetName()
var isFutures = true
e.SetCurrency(task.Currency)
if (task.ContractType != "spot" && name.indexOf("Futures_") != -1) {
// If it is not spot, set up a contract
e.SetContractType(task.ContractType)
} else if (task.ContractType == "spot" && name.indexOf("Futures_") == -1) {
isFutures = false
} else {
task.error = "The ContractType in the instruction does not match the configured exchange object type"
return
}
var depth = e.GetDepth()
if (!depth || !depth.Bids || !depth.Asks) {
task.error = "Abnormal order book data"
return
}
if (depth.Bids.length == 0 && depth.Asks.length == 0) {
task.error = "No orders on the market"
return
}
_.each([depth.Bids, depth.Asks], function(arr) {
_.each(arr, function(order) {
var pricePrecision = self.getPrecision(order.Price)
var amountPrecision = self.getPrecision(order.Amount)
if (Number.isInteger(pricePrecision) && !Number.isInteger(self.pricePrecision)) {
self.pricePrecision = pricePrecision
} else if (Number.isInteger(self.pricePrecision) && Number.isInteger(pricePrecision) && pricePrecision > self.pricePrecision) {
self.pricePrecision = pricePrecision
}
if (Number.isInteger(amountPrecision) && !Number.isInteger(self.amountPrecision)) {
self.amountPrecision = amountPrecision
} else if (Number.isInteger(self.amountPrecision) && Number.isInteger(amountPrecision) && amountPrecision > self.amountPrecision) {
self.amountPrecision = amountPrecision
}
})
})
if (!Number.isInteger(self.pricePrecision) || !Number.isInteger(self.amountPrecision)) {
task.err = "Failed to get precision"
return
}
e.SetPrecision(self.pricePrecision, self.amountPrecision)
// buy: spot purchase, sell: spot sell, long: futures long, short: futures short, closesell: futures buy to close short, closebuy: futures sell to close long
var direction = null
var tradeFunc = null
if (isFutures) {
switch (task.Action) {
case "long":
direction = "buy"
tradeFunc = e.Buy
break
case "short":
direction = "sell"
tradeFunc = e.Sell
break
case "closesell":
direction = "closesell"
tradeFunc = e.Buy
break
case "closebuy":
direction = "closebuy"
tradeFunc = e.Sell
break
}
if (!direction || !tradeFunc) {
task.error = "Wrong transaction direction:" + task.Action
return
}
e.SetDirection(direction)
} else {
if (task.Action == "buy") {
tradeFunc = e.Buy
} else if (task.Action == "sell") {
tradeFunc = e.Sell
} else {
task.error = "Wrong transaction direction:" + task.Action
return
}
}
var id = tradeFunc(task.Price, task.Amount)
if (!id) {
task.error = "Order failed"
}
task.finished = true
}
return self
}
function main() {
// Reset log information
if (isResetLog) {
LogReset(1)
}
Log("Transaction type [buy: spot buy, sell: spot sell, long: futures long, short: futures short, closesell: futures buy to close short, closebuy: futures sell to close long]", Danger)
Log("Instruction templates:", JSON.stringify(Template), Danger)
if (!passPhrase || passPhrase.length == 0) {
Log("webhook url:", `http://${serverIP}:${port}/CommandRobot`)
} else {
Log("webhook url:", `http://${serverIP}:${port}/CommandRobot?passPhrase=${passPhrase}`)
}
// Creating an Http built-in service
__Serve("http://0.0.0.0:" + port, serverFunc, ipWhiteList, passPhrase)
// Initialize the code to execute
if (initCode && initCode.length > 0) {
try {
Log("Execute the initialization code:", initCode)
eval(initCode)
} catch(error) {
Log("e.name:", error.name, "e.stack:", error.stack, "e.message:", error.message)
}
}
// Create a signal management object
var manager = createManager()
while (true) {
try {
// Detect interactive controls for testing
var cmd = GetCommand()
if (cmd) {
// Send Http request, simulate test
var arrCmd = cmd.split(":", 2)
if (arrCmd[0] == "TestSignal") {
// {"Flag":"TestSignal","Exchange":1,"Currency":"BTC_USDT","ContractType":"swap","Price":"10000","Action":"long","Amount":"1"}
var signal = cmd.replace("TestSignal:", "")
if (!passPhrase || passPhrase.length == 0) {
var ret = HttpQuery(`http://${serverIP}:${port}/CommandRobot`, {"method": "POST", "body": JSON.stringify(signal)})
Log("Test request response:", ret)
} else {
var ret = HttpQuery(`http://${serverIP}:${port}/CommandRobot?passPhrase=${passPhrase}`, {"method": "POST", "body": JSON.stringify(signal)})
Log("Test request response:", ret)
}
}
}
// Detect the message that the built-in Http service notifies the main thread after receiving the request, and writes it to the task queue of the manager object
var msg = threading.mainThread().peekMessage(-1)
if (msg) {
Log("Receive message msg:", msg)
var objSignal = JSON.parse(msg)
if (DiffObject(Template, objSignal)) {
Log("Receive trading signal instructions:", objSignal)
buffSignal.push(objSignal)
// Check trading volume, exchange ID
if (!CheckSignal(objSignal)) {
continue
}
// Create a task
if (objSignal["Flag"] == "TestSignal") {
Log("Received test message:", JSON.stringify(objSignal))
} else {
manager.newTask(objSignal)
}
} else {
Log("Command not recognized", signal)
}
} else {
Sleep(1000 * SleepInterval)
}
// Processing tasks
manager.process()
// Status bar displays signal
if (buffSignal.length > maxBuffSignalRowDisplay) {
buffSignal.shift()
}
var buffSignalTbl = {
"type" : "table",
"title" : "Signal recording",
"cols" : ["Flag", "Exchange", "Currency", "ContractType", "Price", "Action", "Amount"],
"rows" : []
}
for (var i = buffSignal.length - 1 ; i >= 0 ; i--) {
buffSignalTbl.rows.push([buffSignal[i].Flag, buffSignal[i].Exchange, buffSignal[i].Currency, buffSignal[i].ContractType, buffSignal[i].Price, buffSignal[i].Action, buffSignal[i].Amount])
}
LogStatus(_D(), "\n", "`" + JSON.stringify(buffSignalTbl) + "`")
} catch (error) {
Log("e.name:", error.name, "e.stack:", error.stack, "e.message:", error.message)
}
}
}
- Parámetro de puerto: Si utiliza el protocolo HTTP, sólo puede configurar el puerto 80 en Trading View.
- Parámetro serverIP: Ingrese la dirección IP pública del servidor.
- Parámetro initCode: puede utilizarse para cambiar la dirección de base para pruebas en el entorno de prueba de intercambio.
En comparación con la estrategia de utilizar la API extendida para acceder a señales externas, la estrategia no cambia mucho.serverFuncFunción de procesamiento del servicio HTTP y utiliza el método de transmisión de mensajes multi-threaded recientemente añadido por la plataforma FMZ:postMessage / peekMessageLos otros códigos están casi sin cambios.
Lista blanca de IP
Dado que las solicitudes del webhook de Trading View
52.89.214.238
34.212.75.30
54.218.53.128
52.32.178.7
Por lo tanto, añadimos un parámetroipWhiteListTodas las solicitudes que no estén en la lista blanca de direcciones IP serán ignoradas.
// Verify IP address
var fromIP = ctx.remoteAddr().split(":")[0]
if (ipWhiteList && ipWhiteList.length > 0) {
var ipList = ipWhiteList.split(",")
if (!ipList.includes(fromIP)) {
ctx.setStatus(500)
ctx.write("IP address not in white list")
Log("500 Error: IP address not in white list", "#FF0000")
return
}
}
Verifique la contraseña
Añadir un parámetropassPhrasela estrategia para configurar la contraseña de verificación. Esta contraseña está configurada en la configuración de la url de Webhook en la vista de negociación. Las solicitudes que no coincidan con la contraseña de verificación serán ignoradas.
Por ejemplo, ponemos:test123456.
// Verify password
var pass = ctx.rawQuery().length > 0 ? ctx.query("passPhrase") : ""
if (passPhrase && passPhrase.length > 0) {
if (pass != passPhrase) {
ctx.setStatus(500)
ctx.write("Authentication failed")
Log("500 Error: Authentication failed", "#FF0000")
return
}
}
Señales externas
Utilice el script PINE de la plataforma Trading View como fuente de activación de señales externas y seleccione uno de los scripts PINE lanzados al azar por Trading View oficialmente:
//@version=6
strategy("MovingAvg Cross", overlay=true)
length = input(9)
confirmBars = input(1)
price = close
ma = ta.sma(price, length)
bcond = price > ma
bcount = 0
bcount := bcond ? nz(bcount[1]) + 1 : 0
if (bcount == confirmBars)
strategy.entry("MACrossLE", strategy.long, comment="long")
scond = price < ma
scount = 0
scount := scond ? nz(scount[1]) + 1 : 0
if (scount == confirmBars)
strategy.entry("MACrossSE", strategy.short, comment="short")
Por supuesto, también puede ejecutar scripts PINE directamente en la plataforma FMZ para ejecutar operaciones en vivo, pero si desea que la plataforma Trading View ejecute scripts PINE para enviar señales, solo puede usar las soluciones que discutimos.
Para adaptar este script PINE al mensaje en nuestra solicitud webhook, necesitamos modificar la función de negociacióncomment, que mencionaremos más adelante en el artículo.
Configuración del cuerpo de WebhookUrl y solicitud
Las configuraciones de WebhookUrl y el cuerpo de la solicitud son básicamente las mismas que el método de API extendido anterior para acceder a señales externas.
URL de la conexión web
Después de agregar este script PINE a un gráfico de un mercado (elegimos el mercado de contratos perpetuos ETH_USDT de Binance para probar) en Trading View, podemos ver que el script ha comenzado a funcionar. Luego agregamos una alerta al script como se muestra en la captura de pantalla.
Configuración de la URL del Webhook: El código de estrategia ha sido diseñado para generar la URL del webhook automáticamente. Sólo necesitamos copiarlo del registro al comienzo de la operación de estrategia.
http://xxx.xxx.xxx.xxx:80/CommandRobot?passPhrase=test123456
Trading View estipula que la URL Webhook sólo puede utilizar el puerto 80 para las solicitudes HTTP, por lo que también fijamos el parámetro de puerto a 80 en la estrategia, por lo que podemos ver que el puerto de enlace de la URL Webhook generado por la estrategia es también 80.
Mensaje del cuerpo
Luego fijamos el mensaje del cuerpo de la solicitud en la pestaña
{
"Flag":"{{strategy.order.id}}",
"Exchange":1,
"Currency":"ETH_USDT",
"ContractType":"swap",
"Price":"-1",
"Action":"{{strategy.order.comment}}",
"Amount":"{{strategy.order.contracts}}"
}
¿Recuerdas el código de orden de colocación en el guión PINE que acabamos de hablar?
strategy.entry("MACrossLE", strategy.long, comment="long")
Así que los ajustes deben ser consistentes. Aquí ponemos
El script PINE no especifica la cantidad de orden para cada orden, por lo que cuando Trading View envía un mensaje de alerta, utiliza la cantidad de orden predeterminada para llenar la parte
Prueba de negociación en vivo
Cuando el script PINE que se ejecuta en Trading View ejecuta la función de negociación, porque hemos configurado la alerta de URL Webhook, la plataforma Trading View enviará una solicitud POST al servicio HTTP incorporado de nuestra estrategia.passPhraseEl organismo solicitante recibido es similar al siguiente:
Luego nuestra estrategia ejecuta las operaciones comerciales correspondientes basadas en el mensaje en este cuerpo.
Se puede ver que la estrategia realiza operaciones de señales sincronizadas en el entorno de simulación OKX de acuerdo con el script PINE en Trading View.
Dirección de la estrategia
Gracias por su atención a FMZ Quant, y gracias por leer.
- ¿Se produce este error si el volumen mínimo de transacción en Ma es 0.01?
- Por favor, muéstrame el problema de los reportes de errores en el mercado de divisas.
- Por favor, enseñen el código de JS
- La ley de Metcalfe en Bitcoin
- Reexaminar las estrategias de seguimiento de tendencias y retorno al valor medio de Bitcoin
- ¿Cuántos bitcoins deberíamos asignar a nuestra cartera?
- ¿Cómo ganar dinero con Bitcoin durante la noche?
- ¿Por qué las páginas siempre se caen?
- Construcción e implementación de portafolios para optimizar el volumen de operaciones
- ¿Cómo se actualizan los parámetros en el disco real en ejecución?