[TOC]

序文

前の記事「FMZ プラットフォームでの外部信号受信に関する議論: 拡張 API と戦略組み込み HTTP サービス」ディスカッションでは、プログラマティック取引のための外部シグナルを受信する 2 つの異なる方法を比較し、詳細を分析しました。 FMZ プラットフォーム拡張 API を使用して外部シグナルを受信するソリューションには、プラットフォーム戦略ライブラリにすでに完全な戦略があります。この記事では、戦略に組み込まれた Http サービスを使用してシグナルを受信する完全なソリューションを実装します。

戦略の実施

FMZ 拡張 API を使用して Trading View シグナルにアクセスするという以前の戦略に従い、以前のメッセージ形式、メッセージ処理方法などを使用し、戦略に簡単な変更を加えます。

ポリシーの組み込みサービスは HTTP または HTTPS を使用できるため、簡単なデモンストレーションでは HTTP プロトコルを使用し、IP ホワイトリスト検証を追加し、パスワード検証を追加します。セキュリティをさらに強化する必要がある場合は、ポリシー組み込みサービスを Https サービスとして設計できます。

//信号结构
var Template = {
    Flag: "45M103Buy",     // 标识,可随意指定
    Exchange: 1,           // 指定交易所交易对
    Currency: "BTC_USDT",  // 交易对
    ContractType: "spot",  // 合约类型,swap,quarter,next_quarter,现货填写spot
    Price: "{{close}}",    // 开仓或者平仓价格,-1为市价
    Action: "buy",         // 交易类型[ buy:现货买入 , sell:现货卖出 , long:期货做多 , short:期货做空 , closesell:期货买入平空 , closebuy:期货卖出平多]
    Amount: "1",           // 交易量
}

var Success = "#5cb85c"    // 成功颜色
var Danger = "#ff0000"     // 危险颜色
var Warning = "#f0ad4e"    // 警告颜色
var buffSignal = []

// Http服务
function serverFunc(ctx, ipWhiteList, passPhrase) {
    var path = ctx.path()
    if (path == "/CommandRobot") {
        // 校验IP地址
        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 
            }
        }

        // 校验口令
        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)
    }
}

// 校验信号消息格式
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("交易所最小编号为1，并且为整数", Danger)
        return
    }
    if (Signal.Amount <= 0 || typeof(Signal.Amount) != "number") {
        Log("交易量不能小于0，并且为数值类型", typeof(Signal.Amount), Danger)
        return
    }
    if (typeof(Signal.Price) != "number") {
        Log("价格必须是数值", Danger)
        return
    }
    if (Signal.ContractType == "spot" && Signal.Action != "buy" && Signal.Action != "sell") {
        Log("指令为操作现货，Action错误，Action：", Signal.Action, Danger)
        return 
    }
    if (Signal.ContractType != "spot" && Signal.Action != "long" && Signal.Action != "short" && Signal.Action != "closesell" && Signal.Action != "closebuy") {
        Log("指令为操作期货，Action错误，Action：", Signal.Action, Danger)
        return 
    }
    return true
}

// 信号处理对象
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("创建任务：", 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) {
            // 非现货，则设置合约
            e.SetContractType(task.ContractType)
        } else if (task.ContractType == "spot" && name.indexOf("Futures_") == -1) {
            isFutures = false 
        } else {
            task.error = "指令中的ContractType与配置的交易所对象类型不匹配"
            return 
        }
        
        var depth = e.GetDepth()
        if (!depth || !depth.Bids || !depth.Asks) {
            task.error = "订单薄数据异常"
            return 
        }
        
        if (depth.Bids.length == 0 && depth.Asks.length == 0) {
            task.error = "盘口无订单"
            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 = "获取精度失败"
            return 
        }
        
        e.SetPrecision(self.pricePrecision, self.amountPrecision)
        
        // buy:现货买入 , sell:现货卖出 , long:期货做多 , short:期货做空 , closesell:期货买入平空 , closebuy:期货卖出平多
        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 = "交易方向错误：" + 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 = "交易方向错误：" + task.Action
                return 
            }
        }
        var id = tradeFunc(task.Price, task.Amount)
        if (!id) {
            task.error = "下单失败"
        }
        
        task.finished = true
    }
    
    return self
}

function main() {
    // 重置日志信息
    if (isResetLog) {
        LogReset(1)
    }

    Log("交易类型[ buy:现货买入 , sell:现货卖出 , long:期货做多 , short:期货做空 , closesell:期货买入平空 , closebuy:期货卖出平多]", Danger)
    Log("指令模板:", 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}`)
    }

    // 创建Http内置服务
    __Serve("http://0.0.0.0:" + port, serverFunc, ipWhiteList, passPhrase)

    // 初始化执行的代码
    if (initCode && initCode.length > 0) {
        try {
            Log("执行初始化代码：", initCode)
            eval(initCode)
        } catch(error) {
            Log("e.name:", error.name, "e.stack:", error.stack, "e.message:", error.message)
        }
    }    

    // 创建信号管理对象
    var manager = createManager()
    
    while (true) {
        try {
            // 检测交互控件，用于测试
            var cmd = GetCommand()
            if (cmd) {
                // 发送Http请求，模拟测试
                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": signal})
                        Log("测试请求的应答:", ret)
                    } else {
                        var ret = HttpQuery(`http://${serverIP}:${port}/CommandRobot?passPhrase=${passPhrase}`, {"method": "POST", "body": signal})
                        Log("测试请求的应答:", ret)
                    }                    
                }
            }

            // 检测内置Http服务收到请求之后通知主线程的消息，写入manager对象的任务队列
            var msg = threading.mainThread().peekMessage(-1)
            if (msg) {
                Log("收到消息 msg:", msg)
                var objSignal = JSON.parse(msg)
                if (DiffObject(Template, objSignal)) {
                    Log("接收到交易信号指令：", objSignal)
                    buffSignal.push(objSignal)
                    
                    // 检查交易量、交易所编号
                    if (!CheckSignal(objSignal)) {
                        continue
                    }
                    
                    // 创建任务
                    if (objSignal["Flag"] == "TestSignal") {
                        Log("收到测试消息：", JSON.stringify(objSignal))
                    } else {
                        manager.newTask(objSignal)
                    }                    
                } else {
                    Log("指令无法识别", signal)
                }
            } else {
                Sleep(1000 * SleepInterval)
            }

            // 处理任务
            manager.process()
            
            // 状态栏显示信号
            if (buffSignal.length > maxBuffSignalRowDisplay) {
                buffSignal.shift()
            }
            var buffSignalTbl = {
                "type" : "table",
                "title" : "信号记录",
                "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)
        }        
    }
}

• ポートパラメータ: HTTP プロトコルを使用する場合、Trading View ではポート 80 のみを設定できます。
• serverIP パラメータ: サーバーのパブリック IP アドレスを入力します。
• initCode パラメータ: 交換テスト環境でテストするためのベース アドレスを切り替えるために使用できます。

拡張APIを使用して外部信号にアクセスする戦略と比較すると、戦略の変更は大きくなく、serverFuncHttp サービス処理機能は、FMZ プラットフォームによって新しく追加されたマルチスレッド メッセージ パッシング方式を使用します。postMessage/peekMessageその他のコードはほとんど変更されていません。

IP ホワイトリスト

Trading View の Webhook からのリクエストは、次の IP アドレスからのみ送信されます。

52.89.214.238
34.212.75.30
54.218.53.128
52.32.178.7

そこで戦略にパラメータを追加しますipWhiteListIP ホワイトリストを設定するために使用されます。この IP アドレス ホワイトリストに含まれていないすべてのリクエストは無視されます。

        // 校验IP地址
        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 
            }
        }

パスワードの確認

戦略にパラメータを追加するpassPhrase、確認パスワードを設定するために使用されます。このパスワードは、Trading View の Webhook URL 設定で設定されます。確認パスワードと一致しないリクエストは無視されます。

たとえば、次のように設定します。test123456。

        // 校验口令
        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 
            }
        }

外部信号

外部シグナルトリガーソースとしてTrading ViewプラットフォームのPINEスクリプトを使用し、Trading Viewによって公式にリリースされたPINEスクリプトの1つをランダムに選択します。

//@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")

もちろん、FMZ プラットフォームで直接 PINE スクリプトを実行して実際のトランザクションを実行することもできますが、Trading View プラットフォームで PINE スクリプトを実行してシグナルを送信する場合は、ここで説明したソリューションのみを使用できます。

このスクリプトの order 関数に注目する必要があります。この PINE スクリプトを Webhook リクエストのメッセージに適合させるには、トランザクション関数の order 関数を変更する必要があります。commentこれについてはこの記事の後半で触れます。

WebhookUrlとリクエスト本文の設定

WebhookUrl とリクエストボディの設定は、基本的に以前の外部シグナルにアクセスするための拡張 API メソッドと同じです。この記事では同じ部分は繰り返しません。前回の記事を参照してください。

Webhook Url

この PINE スクリプトを Trading View の市場のチャートに追加すると (テストでは Binance の ETH_USDT 永久契約市場を選択しました)、スクリプトが動作し始めていることがわかります。次に、スクリーンショットに示すように、スクリプトにアラームを追加します。

Webhook URL設定: ポリシー コードは、Webhook URL を自動的に生成するように設計されています。ポリシー実行の開始時にログからそれをコピーするだけで済みます。

http://xxx.xxx.xxx.xxx:80/CommandRobot?passPhrase=test123456

Trading View では、Webhook URL は HTTP リクエストにポート 80 のみを使用できると規定されているため、戦略でもポート パラメータを 80 に設定しています。そのため、戦略によって生成された Webhook URL のリンク ポートも 80 であることがわかります。

本文メッセージ

次に、スクリーンショットに示すように、「設定」タブでリクエスト本文メッセージを設定します。

{
    "Flag":"{{strategy.order.id}}",
    "Exchange":1,
    "Currency":"ETH_USDT",
    "ContractType":"swap",
    "Price":"-1",
    "Action":"{{strategy.order.comment}}",
    "Amount":"{{strategy.order.contracts}}"
}

先ほど述べた PINE スクリプトの注文コードを覚えていますか?コード内でロングポジションを開く例を見てみましょう。

strategy.entry("MACrossLE", strategy.long, comment="long")

「MACrossLE」は、将来アラームがトリガーされたときに「{{strategy.order.id}}」に入力される内容です。

「long」は、将来アラームがトリガーされたときに「{{strategy.order.comment}}」に入力されるコンテンツです。戦略で特定されたシグナルは次のとおりです (下のスクリーンショット)。

したがって、設定は一貫している必要があります。ここでは、注文関数に「ロング」と「ショート」を設定し、ロングまたはショートポジションを開くためのシグナルを示します。

PINE スクリプトは各注文の注文数量を指定しないため、Trading View がアラート メッセージを送信するときに、デフォルトの注文数量を使用して「{{strategy.order.contracts}}」の部分を埋めます。

実際のテスト

Trading Viewで実行されているPINEスクリプトが取引機能を実行すると、Webhook URLアラームを設定しているため、Trading Viewプラットフォームは戦略に組み込まれているHTTPサービスにPOSTリクエストを送信します。このリクエストクエリには、認証用のパスワードパラメータが含まれています。passPhrase。実際に受信されるリクエスト本文は次のようになります。

次に、この本文のメッセージに基づいて、対応するトランザクション操作が戦略によって実行されます。

この戦略は、Trading View の PINE スクリプトに従って OKX シミュレーション環境で同期シグナル取引を実行していることがわかります。

ポリシーアドレス

https://www.fmz.com/strategy/475235

FMZ Quantitativeにご注目いただき、またお読みいただきありがとうございました。