Verwenden Sie die erweiterte API auf FMZ Quant, um den Warnsignalhandel "TradingView" zu realisieren

Verwenden Sie die erweiterte API auf FMZ, um TradingView Alert Signal Trading zu realisieren

Video-Link auf Bilibili

Die erweiterte API der FMZ Quant Trading Plattform wurde kürzlich aktualisiert, und das Upgrade unterstützt den direkten Zugriffsmodus, so dass das TradingView-Alarmsignal leicht an die Bots auf FMZ für den automatischen Handel gesendet werden kann.

Erweiterte API der FMZ Quant-Plattform

Verknüpfung des zugehörigen Teils in der FMZ-API-Dokumentation

Die Hauptfunktion der erweiterten API besteht darin, Schnittstellen für verschiedene Funktionen auf der FMZ Quant-Handelsplattform bereitzustellen, für die programmatischen Operationen, wie z. B. Batchstart-Bots gleichzeitig, Timing-Bot-Start und -Stop, Lesen von Bot-Informationsdetails usw. Wir verwenden die erweiterte API von FMZ, um den TradingView-Alarmsignalhandel zu implementieren.CommandRobot(RobotId, Cmd)Diese Schnittstelle kann interaktiven Befehle an den Bot mit der angegebenen ID senden, und der Bot kann die entsprechenden Operationen ausführen (z. B. eine Bestellung zum Kaufen oder Verkaufen etc.)

Um die erweiterte API zu verwenden, müssen Sie zuerst Ihr eigenes Konto erstellenAPI KEYauf FMZ:

### Direct Access Mode of Extended API 

The direct access mode indicates directly writing ```API KEY``` in the Query of URL; for example, the URL accessing the extended API of FMZ Quant platform can be written as: 

https://www.fmz.com/api/v1?access_key=xxx&secret_key=yyyy&method=CommandRobot&args=[186515,“ok12345”]

Among them, ```https://www.fmz.com/api/v1``` is the interface address; ```?``` is followed by ```Query```; the parameter ```access_key``` is, for example, represented by xxx (when using, fill in the access_key of your own FMZ account); the parameter ```secret_key``` is represented by yyyy (when using, fill in your own account secret_key); the parameter ```method``` is the specific name of the extended API interface to be accessed, and ```args``` is the parameter of the ```method``` interface to be called.

We use TradingView as a signal source to send trading commands to the FMZ bots. In fact, we only use the ```CommandRobot``` interface.

### TradingView

First of all, you need to have a TradingView Pro account. The Basic level cannot use the WebHood function in the alert. We enter the Chart of TradingView.

![Use the extended API on FMZ Quant to realize "TradingView" alert signal trading](/upload/asset/269159723a8d53f907d86.png)  

Add an indicator to the chart, and other script algorithms can also be used. Here, for the convenience of demonstration, we use the most commonly used ```MACD``` indicator, and then set the K-line period to 1 minute (in order to make the signal trigger faster and facilitate the demonstration).

![Use the extended API on FMZ Quant to realize "TradingView" alert signal trading](/upload/asset/26980a2ff4858e1ed81e6.png) 

Right-click on the chart and select "Add Alert" from the pop-up menu.

 ![Use the extended API on FMZ Quant to realize "TradingView" alert signal trading](/upload/asset/2689e1efab8e133c43188.png) 

Set ```WebHook``` in the "Alert" pop-up window. At this point, you don't have to worry about setting it. Let's first run the bot that monitors the signals on FMZ Quant trading platform.

### Ordering Bot of Monitoring Signal 

Strategy source code:
```js
// global variable 
var BUY = "buy"     // Note: the command used for spot
var SELL = "sell"   //       the command used for futures 
var LONG = "long"   //       the command used for futures
var SHORT = "short" //       the command used for futures
var COVER_LONG = "cover_long"   // the command used for futures
var COVER_SHORT = "cover_short" // the command used for futures

function main() {
    // Empty the logs; delete, if not needed 
    LogReset(1)

    // Set the precision 
    exchange.SetPrecision(QuotePrecision, BasePrecision)

    // Judge whether it is spot or futures 
    var eType = 0
    var eName = exchange.GetName()
    var patt = /Futures_/
    if (patt.test(eName)) {
        Log("The added platform is a futures platform:", eName, "#FF0000")
        eType = 1
        if (Ct == "") {
            throw "Ct contract set to null"
        } else {
            Log(exchange.SetContractType(Ct), "Set contract:", Ct, "#FF0000")
        }
    } else {
        Log("The added platform is a spot platform:", eName, "#32CD32")
    }
    
    var lastMsg = ""
    var acc = _C(exchange.GetAccount)
    while(true) {
        var cmd = GetCommand()
        if (cmd) {
            // Detect the interactive command 
            lastMsg = "Command:" + cmd + "Time:" + _D()
            var arr = cmd.split(":")
            if (arr.length != 2) {
                Log("Wrong cmd information:", cmd, "#FF0000")
                continue
            }

            var action = arr[0]
            var amount = parseFloat(arr[1])

            if (eType == 0) {
                if (action == BUY) {               
                    var buyInfo = IsMarketOrder ? exchange.Buy(-1, amount) : $.Buy(amount)
                    Log("buyInfo:", buyInfo)
                } else if (action == SELL) {        
                    var sellInfo = IsMarketOrder ? exchange.Sell(-1, amount) : $.Sell(amount)
                    Log("sellInfo:", sellInfo)
                } else {
                    Log("Spot trading platforms are not supported!", "#FF0000")
                }
            } else if (eType == 1) {
                var tradeInfo = null
                var ticker = _C(exchange.GetTicker)
                if (action == LONG) {
                    exchange.SetDirection("buy")
                    tradeInfo = IsMarketOrder ? exchange.Buy(-1, amount) : exchange.Buy(ticker.Sell, amount)
                } else if (action == SHORT) {        
                    exchange.SetDirection("sell")
                    tradeInfo = IsMarketOrder ? exchange.Sell(-1, amount) : exchange.Sell(ticker.Buy, amount)
                } else if (action == COVER_LONG) {        
                    exchange.SetDirection("closebuy")
                    tradeInfo = IsMarketOrder ? exchange.Sell(-1, amount) : exchange.Sell(ticker.Buy, amount)
                } else if (action == COVER_SHORT) {        
                    exchange.SetDirection("closesell")
                    tradeInfo = IsMarketOrder ? exchange.Buy(-1, amount) : exchange.Buy(ticker.Sell, amount)
                } else {
                    Log("Futures trading platforms are not supported!", "#FF0000")
                }
                if (tradeInfo) {
                    Log("tradeInfo:", tradeInfo)
                }
            } else {
                throw "eType error, eType:" + eType
            }
            acc = _C(exchange.GetAccount)
        }
        var tbl = {
            type : "table", 
            title : "Status information", 
            cols : ["Data"], 
            rows : []
        }
        // tbl.rows.push([JSON.stringify(acc)])   // Used during testing 
        LogStatus(_D(), eName, "The command received last time:", lastMsg, "\n", "`" + JSON.stringify(tbl) + "`")
        Sleep(1000)
    }
}

Strategie-Quellcode

Der Code ist sehr einfach. Es erkennt den Rückgabewert derGetCommandWenn eine interaktive Nachricht an das Strategieprogramm gesendet wird,GetCommandDie Strategie wird von einem Bot ausgestattet, der eine entsprechende Handelsoperation basierend auf dem Inhalt der Nachricht durchführt.WexAppder FMZ Quant Handelsplattform.

Klicken Sie auf die Interaktionsschaltfläche, um die Bot-Kapazität zu testen, um einen Kaufbefehl zu erhalten.

Wir können sehen, dass die vom Bot empfangene Befehlszeile lautet:buy:0.01.

Wir müssen nur die getragenen Parameter seinbuy:0.01während des Zugriffs aufCommandRobotdie Schnittstelle der erweiterten API von FMZ Quant in der WebHook-Anfrage-URL, wenn die TradingView-Warnung ausgelöst wird.

WebHook-Konfiguration von TradingView

Zurück zu TradingView, füllen wir die URL des WebHook.API KEYin deraccess_keyundsecret_keyfür diemethodWir müssen nur auf die erweiterte API zugreifen.CommandRobot- dieargsParameter ist in Form von[robot ID, command string], können wir die Roboter-ID direkt über die Bot-Seite erhalten, wie in der Abbildung gezeigt:

Dieses Mal, wenn wir das Signal auslösen, kaufen Sie 0,02 Münze, und die Befehlszeile lautet:"buy:0.02"Das ist die WebHook-URL.

https://www.fmz.com/api/v1?access_key=e3809e173e23004821a9bfb6a468e308&secret_key=45a811e0009d91ad21154e79d4074bc6&method=CommandRobot&args=[443999,"buy:0.02"]

Auf TradingView eingestellt:

Warten Sie, bis das Signal ausgelöst wird. Wenn der Bot das Signal empfängt, sehen Sie die Warnsignale oben rechts auf der Seite und die Triggerprotokolle unten rechts.

Der Bot hat das Signal empfangen:

Auf diese Weise können Sie die reichen Chartfunktionen und Indikator-Algorithmen auf TradingView verwenden, um mit dem Strategie-Bot von FMZ Quant zusammenzuarbeiten, um den von Ihnen gewünschten automatisierten Handel zu realisieren.

Der Strategie-Code von Ordering Bot of Monitoring Signal ist nur für Studium und Forschung bestimmt. Er muss für den Einsatz von echten Bots optimiert und angepasst werden. Er unterstützt auch Futures. Wir empfehlen, ihn auf Market Order-Modus einzustellen. Weitere Informationen finden Sie in den Strategie-Code-Parametern. Wenn Sie Fragen oder Anregungen haben, hinterlassen Sie bitte eine Nachricht.