प्रस्तावना

यह आलेख पेपरट्रेडर के डिजाइन और कार्यान्वयन का परिचय देता है, जो FMZ मात्रात्मक प्लेटफॉर्म पर आधारित और वास्तविक बाजार स्थितियों द्वारा संचालित एक सिमुलेशन ट्रेडिंग सिस्टम है। यह प्रणाली वास्तविक समय में गहन बाजार स्थितियों के माध्यम से आदेशों का मिलान करती है, रणनीति आदेश प्लेसमेंट, लेनदेन, परिसंपत्ति परिवर्तन और शुल्क प्रसंस्करण जैसी व्यापारिक प्रक्रियाओं का पूरी तरह से अनुकरण करती है, बाजार/सीमा आदेशों, परिसंपत्ति फ्रीजिंग और रद्दीकरण संग्रह का समर्थन करती है, और वास्तविक व्यापार से पहले रणनीति परीक्षण और वास्तविक व्यवहार सत्यापन के लिए उपयुक्त है। यह आलेख सिस्टम आर्किटेक्चर, मिलान तंत्र, इंटरफ़ेस संगतता आदि के दृष्टिकोण से इसकी डिजाइन अवधारणा और प्रमुख कार्यान्वयन को विस्तार से समझाएगा, और मात्रात्मक रणनीतियों को ऑनलाइन जाने से पहले एक सुरक्षित और विश्वसनीय "मध्यवर्ती सैंडबॉक्स" बनाने में मदद करने के लिए पूर्ण व्यावहारिक प्रदर्शन उपयोग के मामले प्रदान करेगा।

पेपरट्रेडर आवश्यकता विश्लेषण और डिजाइन

मांग संबंधी समस्याएँ:

• एक्सचेंज सिमुलेशन ट्रेडिंग अव्यवस्थित और अवास्तविक है।
• किसी एक्सचेंज पर सिम्युलेटेड खाते के लिए आवेदन करना बोझिल है, और परीक्षण निधि प्राप्त करना भी बोझिल है।
• कई एक्सचेंज परीक्षण वातावरण उपलब्ध नहीं कराते हैं।

बैकटेस्टिंग और वास्तविक ट्रेडिंग के बीच “ग्रे एरिया” समस्या

आपको सिम्युलेटेड ट्रेडिंग सिस्टम की आवश्यकता क्यों है?

मात्रात्मक रणनीति विकास की पूरी प्रक्रिया में, हम आमतौर पर "ऐतिहासिक बैकटेस्टिंग → पर्यावरण परीक्षण → वास्तविक ट्रेडिंग" के चरणों से गुजरते हैं। हालाँकि, ऐतिहासिक बैकटेस्टिंग सांख्यिकीय डेटा का उपयोग करती है और वास्तविक बाजार स्थितियों में रणनीतियों की प्रभावशीलता को संसाधित नहीं कर सकती है। हालांकि, वास्तविक ट्रेडिंग का मतलब है फंड का पलायन, और मध्यवर्ती परीक्षण वातावरण का अभाव हमारे अन्वेषण में एक समस्या बन गया है।
इस समस्या को हल करने के लिए, हमें एक हल्के सिमुलेशन ट्रेडिंग सिस्टम - पेपरट्रेडर को डिजाइन करने की आवश्यकता है, जो वास्तविक समय की बाजार स्थितियों (गहराई, बाजार मूल्य) का उपयोग करके ऑर्डर देने, लंबित ऑर्डर, लेनदेन, ऑर्डर निकासी, परिसंपत्ति परिवर्तन और कमीशन कटौती सहित संपूर्ण ट्रेडिंग प्रक्रिया का अनुकरण कर सकता है, और अंततः वास्तविक ट्रेडिंग स्तर के करीब रणनीति सत्यापन पूरा कर सकता है।

डिज़ाइन लक्ष्य और मुख्य विशेषताएं

• 1. वास्तविक समय बाजार ड्राइव
     वास्तविक एक्सचेंज कोट्स तक पहुंचने के लिए FMZ का उपयोग करें, जिसमें GetTicker(), GetDepth() और दर्जनों अन्य इंटरफेस शामिल हैं।
• 2. सिमुलेशन ऑर्डर प्लेसमेंट और कटौती
     सीमा/बाजार आदेशों का समर्थन करता है, निर्माता/लेने वाले शुल्क की अलग कटौती करता है, तथा बाजार खरीद आदेशों के लिए वास्तविक गणना की गई इनपुट राशि का उपयोग करता है।
• 3. परिसंपत्ति/स्थिति/आदेश प्रबंधन
     यह ऑर्डर देते समय परिसंपत्तियों को फ्रीज करने और ऑर्डर रद्द करते समय उन्हें वापस करने का समर्थन करता है, और प्रतीक स्तर के आधार पर कई परिसंपत्तियों/स्थितियों/ऑर्डरों के रखरखाव का समर्थन करता है।
• 4. ऑर्डर चक्र पूरा करें
     आदेशों का निर्माण, प्रतीक्षा, निष्पादन से लेकर निरस्तीकरण तक का प्रबंधन स्पष्ट रूप से किया जाता है। निष्पादन के बाद, भविष्य में पूछताछ और विश्लेषण के लिए उन्हें स्वचालित रूप से स्थानीय डाटाबेस में संग्रहीत कर दिया जाता है।
• 5. प्रयोगकर्ता का अनुभव
     इस रणनीति में किसी भी ऑर्डर कॉल को बदलने की आवश्यकता नहीं होती है, तथा यह एक्सचेंज ऑब्जेक्ट को पेपरट्रेडर से प्रतिस्थापित करके सिम्युलेटेड ट्रेडिंग को क्रियान्वित कर सकती है।

लाइब्रेरी डिज़ाइन अवलोकन

इस प्रणाली में मुख्यतः तीन भाग होते हैं:

• पेपरट्रेडर क्लास
  कोर सिमुलेशन खाते में परिसंपत्तियां, ऑर्डर, स्थिति, बाजार स्थितियां और कॉन्फ़िगरेशन जैसे डेटा रखरखाव शामिल हैं।

• [simEngine मिलान इंजन]:
  बैकग्राउंड थ्रेड, बाजार की गहराई के अनुसार वर्तमान ऑर्डर को स्कैन करता है और संचालन करता है

• 【डेटाबेस संग्रह】:
  बाद में विश्लेषण और समीक्षा के लिए पूर्ण/रद्द किए गए ऑर्डर को स्थानीय डेटाबेस में लिखें

मिलान इंजन डिजाइन：

simEngine(data, lock) संपूर्ण सिमुलेशन प्रणाली का मूल है। यह लेनदेन के लिए सटीक सिमुलेशन परिणाम प्रदान करने के लिए वास्तविक बाजार गहराई डेटा के अनुसार एक लूप में वर्तमान लंबित ऑर्डर का मिलान करता है।

मुख्य प्रक्रिया में शामिल हैं:

• वर्तमान लंबित आदेश, स्थिति, परिसंपत्तियां और बाजार की स्थिति प्राप्त करें;
• सभी प्रयुक्त प्रतीकों की गहराई प्राप्त करें GetDepth;
• लंबित ऑर्डरों को पार करें और दिशा (खरीद/बिक्री) के अनुसार ऑपरेशन गहराई (पूछ/बोली) का चयन करें;
• यह निर्धारित करना कि क्या लेनदेन इस आधार पर पूरा हुआ है कि क्या कीमत परिचालन शर्तों को पूरा करती है;
• यदि लेनदेन पूरा हो गया है, तो ऑर्डर की जानकारी जैसे औसत मूल्य / डील राशि को अपडेट करें और गिनें;
• निर्माता/लेने वाले के आधार पर हैंडलिंग शुल्क काटें।
• यदि सभी आदेश निष्पादित हो गए हैं, तो आदेश संग्रहीत कर दिया जाएगा; अन्यथा, यह लंबित रहेगा.

इंटरफ़ेस जानकारी संगतता：

पेपरट्रेडर को यथासंभव एफएमजेड प्लेटफॉर्म के वास्तविक ट्रेडिंग इंटरफेस के साथ संरेखित करने के लिए डिज़ाइन किया गया है, जिसमें निम्नलिखित शामिल हैं, लेकिन इन्हीं तक सीमित नहीं हैं:

यह डिज़ाइन रणनीति तर्क को बिना किसी संशोधन के सीधे सिम्युलेटेड ट्रेडिंग वातावरण में चलाने की अनुमति देता है। एक क्लिक से एक्सचेंज को पेपरट्रेडर से प्रतिस्थापित करके, आप रणनीति को बैकटेस्टिंग और वास्तविक ट्रेडिंग के बीच "मध्य परत" में स्थानांतरित कर सकते हैं।

पेपरट्रेडर डिज़ाइन स्रोत कोड

            javascript
            
            
class PaperTrader {
    constructor(exIdx, realExchange, assets, fee) {
        this.exIdx = exIdx
        this.e = realExchange
        this.name = realExchange.GetName() + "_PaperTrader"
        this.currency = realExchange.GetCurrency()
        this.baseCurrency = this.currency.split("_")[0]
        this.quoteCurrency = this.currency.split("_")[1]        
        this.period = realExchange.GetPeriod()
        this.fee = fee
        
        // 数据同步锁
        this.data = threading.Dict()
        this.dataLock = threading.Lock()
        // 初始化this.data
        this.data.set("assets", assets)
        this.data.set("orders", [])
        this.data.set("positions", [])

        // exchangeData
        let exchangeData = {
            "exIdx": this.exIdx,
            "fee": this.fee
        }

        // exchange Type
        if (this.name.includes("Futures_")) {
            this.exchangeType = "Futures"
            this.direction = "buy"
            this.marginLevel = 10
            this.contractType = "swap"
            this.e.SetContractType(this.contractType)

            // set exchangeData
            exchangeData["exchangeType"] = this.exchangeType
            exchangeData["marginLevel"] = this.marginLevel
        } else {            
            this.exchangeType = "Spot"
            
            // set exchangeData
            exchangeData["exchangeType"] = this.exchangeType
        }

        // 记录交易所相关信息，用于传入撮合引擎
        this.data.set("exchangeData", exchangeData)

        // database
        this.historyOrdersTblName = "HISTORY_ORDER"
        this.data.set("historyOrdersTblName", this.historyOrdersTblName)

        // init
        this.init()
    }
    
    // export
    SetCurrency(currency) {        
        let arrCurrency = currency.split("_")
        if (arrCurrency.length != 2) {
            this.e.Log(3, null, null, `invalid currency: ${currency}`)
            return 
        }

        this.currency = currency
        this.baseCurrency = arrCurrency[0]
        this.quoteCurrency = arrCurrency[1]

        return this.e.SetCurrency(currency)
    }

    SetContractType(contractType) {
        if (this.exchangeType == "Spot") {
            this.e.Log(3, null, null, `not support`)
            return 
        }

        if (!this.isValidContractType(contractType)) {
            this.e.Log(3, null, null, `invalid contractType: ${contractType}`)
            return 
        }

        this.contractType = contractType
        return this.e.SetContractType(contractType)
    }

    SetDirection(direction) {
        if (this.exchangeType == "Spot") {
            this.e.Log(3, null, null, `not support`)
            return 
        }

        if (direction != "buy" && direction != "sell" && direction != "closebuy" && direction != "closesell") {
            this.e.Log(3, null, null, `invalid direction: ${direction}`)
            return 
        }

        this.direction = direction
        return this.e.SetDirection(direction)
    }

    GetTicker(...args) {
        return this.e.GetTicker(...args)
    }

    GetDepth(...args) {
        return this.e.GetDepth(...args)
    }

    GetTrades(...args) {
        return this.e.GetTrades(...args)
    }

    GetRecords(...args) {
        return this.e.GetRecords(...args)
    }

    GetMarkets() {
        return this.e.GetMarkets()
    }

    GetTickers() {
        return this.e.GetTickers()
    }

    GetFundings(...args) {
        if (this.exchangeType == "Spot") {
            this.e.Log(3, null, null, `not support`)
            return 
        }

        return this.e.GetFundings(...args)
    }

    GetAccount() {
        let assets = this.data.get("assets")
        let acc = {"Balance": 0, "FrozenBalance": 0, "Stocks": 0, "FrozenStocks": 0}
        for (let asset of assets) {
            if (this.exchangeType == "Futures") {
                if (this.quoteCurrency == "USDT" || this.quoteCurrency == "USDC") {
                    if (asset["Currency"] == this.quoteCurrency) {
                        return {"Balance": asset["Amount"], "FrozenBalance": asset["FrozenAmount"], "Stocks": 0, "FrozenStocks": 0}
                    }
                } else if (this.quoteCurrency == "USD") {
                    if (asset["Currency"] == this.baseCurrency) {
                        return {"Balance": 0, "FrozenBalance": 0, "Stocks": asset["Amount"], "FrozenStocks": asset["FrozenAmount"]}
                    }                
                }
            } else if (this.exchangeType == "Spot") {
                if (asset["Currency"] == this.baseCurrency) {
                    // Stocks
                    acc["Stocks"] = asset["Amount"]
                    acc["FrozenStocks"] = asset["FrozenAmount"]
                } else if (asset["Currency"] == this.quoteCurrency) {
                    // Balance
                    acc["Balance"] = asset["Amount"]
                    acc["FrozenBalance"] = asset["FrozenAmount"]
                }
            }
        }

        return acc
    }

    GetAssets() {
        let assets = this.data.get("assets")
        return assets
    }

    GetOrders(symbol) {
        let ret = []
        let orders = this.data.get("orders")
        if (this.exchangeType == "Spot") {
            if (typeof(symbol) == "undefined") {
                return orders
            } else {
                let arrCurrency = symbol.split("_")
                if (arrCurrency.length != 2) {
                    this.e.Log(3, null, null, `invalid symbol: ${symbol}`)
                    return null 
                }

                for (let o of orders) {
                    if (o.Symbol == symbol) {
                        ret.push(o)
                    }
                }
                return ret 
            }
        } else if (this.exchangeType == "Futures") {
            if (typeof(symbol) == "undefined") {
                for (let o of orders) {
                    if (o.Symbol.includes(`${this.quoteCurrency}.${this.contractType}`)) {
                        ret.push(o)
                    }
                }
                return ret 
            } else {
                let arr = symbol.split(".")
                if (arr.length != 2) {
                    this.e.Log(3, null, null, `invalid symbol: ${symbol}`)
                    return null 
                }

                let currency = arr[0]
                let contractType = arr[1]
                let arrCurrency = currency.split("_")
                if (arrCurrency.length != 2) {
                    for (let o of orders) {
                        if (o.Symbol.includes(`${arrCurrency[0]}.${contractType}`)) {
                            ret.push(o)
                        }
                    }
                } else {
                    for (let o of orders) {
                        if (o.Symbol == symbol) {
                            ret.push(o)
                        }
                    }
                }
                return ret 
            }            
        } else {
            this.e.Log(3, null, null, `invalid exchangeType: ${this.exchangeType}`)
            return null 
        }
    }

    GetOrder(orderId) {
        let data = DBExec(`SELECT ORDERDATA FROM ${this.historyOrdersTblName} WHERE ID = ?`, orderId)
        // {"columns":["ORDERDATA"],"values":[]}
        if (!data) {
            this.e.Log(3, null, null, `Order not found: ${orderId}`)
            return null 
        }

        if (data && Array.isArray(data["values"]) && data["values"].length <= 0) {
            this.e.Log(3, null, null, `Order not found: ${orderId}`)
            return null 
        } else if (data["values"].length != 1) {
            this.e.Log(3, null, null, `invalid data: ${data["values"]}`)
            return null 
        } else {
            let ret = this.parseJSON(data["values"][0])
            if (!ret) {
                this.e.Log(3, null, null, `invalid data: ${data["values"]}`)
                return null 
            }

            return ret 
        }
    }

    Buy(price, amount) {
        return this.trade("Buy", price, amount)
    }

    Sell(price, amount) {
        return this.trade("Sell", price, amount)
    }

    trade(tradeType, price, amount) {
        if (this.exchangeType == "Spot") {
            let side = ""
            if (tradeType == "Buy") {
                side = "buy"
            } else if (tradeType == "Sell") {
                side = "sell"
            } else {
                this.e.Log(3, null, null, `invalid tradeType: ${tradeType}`)
                return null 
            }
            let symbol = this.currency
            return this.createOrder(symbol, side, price, amount)
        } else if (this.exchangeType == "Futures") {
            let compose = `${tradeType}_${this.direction}`
            if (compose != "Sell_closebuy" && compose != "Sell_sell" && compose != "Buy_buy" && compose != "Buy_closesell") {
                this.e.Log(3, null, null, `${tradeType}, invalid direction: ${this.direction}`)
                return null 
            }

            let side = this.direction
            let symbol = `${this.currency}.${this.contractType}`
            return this.createOrder(symbol, side, price, amount)
        } else {
            this.e.Log(3, null, null, `invalid exchangeType: ${this.exchangeType}`)
            return 
        }
    }

    CreateOrder(symbol, side, price, amount) {
        if (side != "buy" && side != "sell" && side != "closebuy" && side != "closesell") {
            this.e.Log(3, null, null, `invalid direction: ${side}`)
            return null 
        }
        if (this.exchangeType == "Spot") {
            if (side == "closebuy") {
                side = "sell"
            } else if (side == "closesell") {
                side = "buy"
            }
        }
        return this.createOrder(symbol, side, price, amount)
    }

    createOrder(symbol, side, price, amount) {
        this.dataLock.acquire()
        let isError = false 
        let orders = this.data.get("orders")
        let positions = this.data.get("positions")
        let assets = this.data.get("assets")

        // 检查amount
        if (amount <= 0) {
            this.e.Log(3, null, null, `invalid amount: ${amount}`)
            return null 
        }

        // 构造订单
        let order = {
            "Info": null,
            "Symbol": symbol,
            "Price": price,
            "Amount": amount,
            "DealAmount": 0,
            "AvgPrice": 0,
            "Status": ORDER_STATE_PENDING,
            "ContractType": symbol.split(".").length == 2 ? symbol.split(".")[1] : ""
        }

        let logType = null 
        switch (side) {
            case "buy":
                order["Type"] = ORDER_TYPE_BUY
                order["Offset"] = ORDER_OFFSET_OPEN
                logType = LOG_TYPE_BUY
                break
            case "sell":
                order["Type"] = ORDER_TYPE_SELL
                order["Offset"] = ORDER_OFFSET_OPEN
                logType = LOG_TYPE_SELL
                break
            case "closebuy":
                order["Type"] = ORDER_TYPE_SELL
                order["Offset"] = ORDER_OFFSET_CLOSE
                logType = LOG_TYPE_SELL
                break
            case "closesell":
                order["Type"] = ORDER_TYPE_BUY
                order["Offset"] = ORDER_OFFSET_CLOSE
                logType = LOG_TYPE_BUY
                break
            default:
                this.e.Log(3, null, null, `invalid direction: ${side}`)
                isError = true 
        }
        if (isError) {
            return null 
        }

        // 检查资产/持仓，资产/持仓不足报错
        let needAssetName = ""
        let needAsset = 0
        if (this.exchangeType == "Futures") {
            // 检查资产、持仓
            // to do 
        } else if (this.exchangeType == "Spot") {
            // 检查资产
            let arr = symbol.split(".")
            if (arr.length == 2) {
                this.e.Log(3, null, null, `invalid symbol: ${symbol}`)
                return null 
            }
            let currency = arr[0]

            let arrCurrency = currency.split("_")
            if (arrCurrency.length != 2) {
                this.e.Log(3, null, null, `invalid symbol: ${symbol}`)
                return null 
            }
            let baseCurrency = arrCurrency[0]
            let quoteCurrency = arrCurrency[1]
            needAssetName = side == "buy" ? quoteCurrency : baseCurrency            
            if (side == "buy" && price <= 0) {
                // market order of buy, amount is quantity by quoteCurrency
                needAsset = amount
            } else {
                // limit order, amount is quantity by baseCurrency
                needAsset = side == "buy" ? price * amount : amount
            }

            let canPostOrder = false 
            for (let asset of assets) {
                if (asset["Currency"] == needAssetName && asset["Amount"] >= needAsset) {
                    canPostOrder = true 
                }
            }
            if (!canPostOrder) {
                this.e.Log(3, null, null, `insufficient balance for ${needAssetName}, need: ${needAsset}, Account: ${JSON.stringify(assets)}`)
                return null 
            }
        } else {
            this.e.Log(3, null, null, `invalid exchangeType: ${this.exchangeType}`)
            return null 
        }

        // 生成订单ID, UnixNano() 使用纳秒时间戳
        let orderId = this.generateOrderId(symbol, UnixNano())
        order["Id"] = orderId

        // 更新pending中的订单记录
        orders.push(order)
        this.data.set("orders", orders)
        
        // 输出日志记录
        if (this.exchangeType == "Futures") {
            this.e.SetDirection(side)
        }   
        this.e.Log(logType, price, amount, `orderId: ${orderId}`)

        // 更新资产
        for (let asset of assets) {
            if (asset["Currency"] == needAssetName) {
                asset["Amount"] -= needAsset
                asset["FrozenAmount"] += needAsset
            }
        }
        this.data.set("assets", assets)

        this.dataLock.release()
        return orderId
    }

    CancelOrder(orderId) {
        this.dataLock.acquire()
        let orders = this.data.get("orders")
        let assets = this.data.get("assets")
        let positions = this.data.get("positions")

        let targetIdx = orders.findIndex(item => item.Id == orderId)
        if (targetIdx != -1) {
            // 目标订单
            let targetOrder = orders[targetIdx]

            // 更新资产
            if (this.exchangeType == "Futures") {
                // 合约交易所资产更新
                // to do
            } else if (this.exchangeType == "Spot") {
                let arrCurrency = targetOrder.Symbol.split("_")
                let baseCurrency = arrCurrency[0]
                let quoteCurrency = arrCurrency[1]

                let needAsset = 0
                let needAssetName = ""
                if (targetOrder.Type == ORDER_TYPE_BUY && targetOrder.Price <= 0) {
                    needAssetName = quoteCurrency
                    needAsset = targetOrder.Amount - targetOrder.DealAmount                    
                } else {
                    needAssetName = targetOrder.Type == ORDER_TYPE_BUY ? quoteCurrency : baseCurrency
                    needAsset = targetOrder.Type == ORDER_TYPE_BUY ? targetOrder.Price * (targetOrder.Amount - targetOrder.DealAmount) : (targetOrder.Amount - targetOrder.DealAmount)
                }

                for (let asset of assets) {
                    if (asset["Currency"] == needAssetName) {
                        asset["FrozenAmount"] -= needAsset
                        asset["Amount"] += needAsset
                    }
                }

                // 更新 assets
                this.data.set("assets", assets)
            } else {
                this.e.Log(3, null, null, `invalid exchangeType: ${this.exchangeType}`)
                return false 
            }

            // 更新撤销状态
            orders.splice(targetIdx, 1)
            targetOrder.Status = ORDER_STATE_CANCELED
            
            // 归档，写入数据库
            let strSql = [
                `INSERT INTO ${this.historyOrdersTblName} (ID, ORDERDATA)`,
                `VALUES ('${targetOrder.Id}', '${JSON.stringify(targetOrder)}');`
            ].join("")
            let ret = DBExec(strSql)
            if (!ret) {
                e.Log(3, null, null, `Order matched successfully, but failed to archive to database: ${JSON.stringify(o)}`)
            }
        } else {
            // 撤单失败
            this.e.Log(3, null, null, `Order not found: ${orderId}`)
            this.dataLock.release()
            return false 
        }
        this.data.set("orders", orders)
        this.e.Log(LOG_TYPE_CANCEL, orderId)

        this.dataLock.release()
        return true 
    }

    GetHistoryOrders(symbol, since, limit) {
        // 查询历史订单
        // to do
    }

    SetMarginLevel(symbol) {
        // 设置杠杆值
        // 同步 this.marginLevel 和 this.data 中的 exchangeData["marginLevel"]
        // to do    
    }

    GetPositions(symbol) {
        // 查询持仓
        // to do
        
        /*
        if (this.exchangeType == "Spot") {
            this.e.Log(3, null, null, `not support`)
            return 
        }

        let pos = this.data.get("positions")
        */
    }


    // engine
    simEngine(data, lock) {
        while (true) {
            lock.acquire()

            // get orders / positions / assets / exchangeData 
            let orders = data.get("orders")
            let positions = data.get("positions")
            let assets = data.get("assets")
            let exchangeData = data.get("exchangeData")
            let historyOrdersTblName = data.get("historyOrdersTblName")
            

            // get exchange idx and fee
            let exIdx = exchangeData["exIdx"]
            let fee = exchangeData["fee"]
            let e = exchanges[exIdx]

            // get exchangeType 
            let exchangeType = exchangeData["exchangeType"]
            let marginLevel = 0
            if (exchangeType == "Futures") {
                marginLevel = exchangeData["marginLevel"]
            }


            // get Depth 
            let dictTick = {}
            for (let order of orders) {
                dictTick[order.Symbol] = {}
            }
            for (let position of positions) {
                dictTick[position.Symbol] = {}
            }
            // 更新行情
            for (let symbol in dictTick) {
                dictTick[symbol] = e.GetDepth(symbol)
            }

            // 撮合
            let newPendingOrders = []
            for (let o of orders) {

                // 只处理pending订单
                if (o.Status != ORDER_STATE_PENDING) {
                    continue 
                }

                // 盘口无数据 
                let depth = dictTick[o.Symbol]
                if (!depth) {
                    e.Log(3, null, null, `Order canceled due to invalid order book data: ${JSON.stringify(o)}`)
                    continue 
                }

                // 根据订单方向，确定订单薄撮合方向
                let matchSide = o.Type == ORDER_TYPE_BUY ? depth.Asks : depth.Bids
                if (!matchSide || matchSide.length == 0) {
                    e.Log(3, null, null, `Order canceled due to invalid order book data: ${JSON.stringify(o)}`)
                    continue 
                }

                let remain = o.Amount - o.DealAmount
                let filledValue = 0
                let filledAmount = 0
                for (let level of matchSide) {
                    let levelAmount = level.Amount 
                    let levelPrice = level.Price
                    if ((o.Price > 0 && ((o.Type == ORDER_TYPE_BUY && o.Price >= levelPrice) || (o.Type == ORDER_TYPE_SELL && o.Price <= levelPrice))) || o.Price <= 0) {
                        if (exchangeType == "Spot" && o.Type == ORDER_TYPE_BUY && o.Price <= 0) {
                            // 现货市价单买单
                            let currentFilledQty = Math.min(levelAmount * levelPrice, remain)
                            remain -= currentFilledQty
                            filledValue += currentFilledQty
                            filledAmount += currentFilledQty / levelPrice
                        } else {
                            // 限价单，价格符合撮合；市价单，直接盘口撮合
                            let currentFilledAmount = Math.min(levelAmount, remain)
                            remain -= currentFilledAmount
                            filledValue += currentFilledAmount * levelPrice
                            filledAmount += currentFilledAmount
                        }
                        
                        // 初次判断，如果直接撮合，判定为 taker
                        if (typeof(o.isMaker) == "undefined") {
                            o.isMaker = false 
                        }
                    } else {
                        // 价格不符合撮合，初次判断，判定为 maker
                        if (typeof(o.isMaker) == "undefined") {
                            o.isMaker = true 
                        }
                        break
                    }

                    if (remain <= 0) {
                        // 订单成交完成
                        break 
                    }
                }

                // 订单有变动
                if (filledAmount > 0) {
                    // 更新订单变动
                    if (exchangeType == "Spot" && o.Type == ORDER_TYPE_BUY && o.Price <= 0) {
                        if (o.AvgPrice == 0) {
                            o.AvgPrice = filledValue / filledAmount
                            o.DealAmount += filledValue
                        } else {
                            o.AvgPrice = (o.DealAmount + filledValue) / (filledAmount + o.DealAmount / o.AvgPrice)
                            o.DealAmount += filledValue
                        }
                    } else {
                        o.AvgPrice = (o.DealAmount * o.AvgPrice + filledValue) / (filledAmount + o.DealAmount)
                        o.DealAmount += filledAmount
                    }

                    // 处理持仓更新
                    if (exchangeType == "Futures") {
                        // 期货，查找对应订单方向上的持仓，更新
                        // to do 

                        /*
                        if () {
                            // 查到对应持仓，更新
                        } else {
                            // 没有对应持仓，新建
                            let pos = {
                                "Info": null,
                                "Symbol": o.Symbol,
                                "MarginLevel": marginLevel,
                                "Amount": o.Amount,
                                "FrozenAmount": 0,
                                "Price": o.Price,
                                "Profit": 0,
                                "Type": o.Type == ORDER_TYPE_BUY ? PD_LONG : PD_SHORT,
                                "ContractType": o.Symbol.split(".")[1],
                                "Margin": o.Amount * o.Price / marginLevel  // to do USDT/USD contract Multiplier
                            }

                            positions.push(pos)
                        }
                        */ 
                    }

                    // 处理资产更新
                    if (exchangeType == "Futures") {
                        // 处理期货资产更新
                        // to do 
                    } else if (exchangeType == "Spot") {
                        // 处理现货资产更新
                        
                        let arrCurrency = o.Symbol.split("_")
                        let baseCurrency = arrCurrency[0]
                        let quoteCurrency = arrCurrency[1]
                        let minusAssetName = o.Type == ORDER_TYPE_BUY ? quoteCurrency : baseCurrency
                        let minusAsset = o.Type == ORDER_TYPE_BUY ? filledValue : filledAmount
                        let plusAssetName = o.Type == ORDER_TYPE_BUY ? baseCurrency : quoteCurrency
                        let plusAsset = o.Type == ORDER_TYPE_BUY ? filledAmount : filledValue
                        
                        // 手续费扣除
                        if (o.isMaker) {
                            plusAsset = (1 - fee["maker"]) * plusAsset
                        } else {
                            plusAsset = (1 - fee["taker"]) * plusAsset
                        }

                        for (let asset of assets) {
                            if (asset["Currency"] == minusAssetName) {
                                // asset["FrozenAmount"] -= minusAsset
                                asset["FrozenAmount"] = Math.max(0, asset["FrozenAmount"] - minusAsset)                                
                            } else if (asset["Currency"] == plusAssetName) {
                                asset["Amount"] += plusAsset
                            }
                        }
                    }
                }

                // 检测remain更新订单状态
                if (remain <= 0) {
                    // 订单完成，更新订单状态，更新均价，更新完成量
                    o.Status = ORDER_STATE_CLOSED
                    
                    // 完成的订单归档，记录到数据库
                    let strSql = [
                        `INSERT INTO ${historyOrdersTblName} (ID, ORDERDATA)`,
                        `VALUES ('${o.Id}', '${JSON.stringify(o)}');`
                    ].join("")
                    let ret = DBExec(strSql)
                    if (!ret) {
                        e.Log(3, null, null, `Order matched successfully, but failed to archive to database: ${JSON.stringify(o)}`)
                    }
                } else {
                    newPendingOrders.push(o)
                }
            }

            // 更新当前挂单数据
            data.set("orders", newPendingOrders)
            data.set("assets", assets)
            lock.release()
            Sleep(1000)
        }
    }

    // other
    isValidContractType(contractType) {
        // only support swap 
        let contractTypes = ["swap"]
        if (contractTypes.includes(contractType)) {
            return true 
        } else {
            return false 
        }
    }

    generateOrderId(symbol, ts) {
        let uuid = '', i, random
        for (i = 0; i < 36; i++) {
            if (i === 8 || i === 13 || i === 18 || i === 23) {
                uuid += '-'
            } else if (i === 14) {
                // 固定为4
                uuid += '4'
            } else if (i === 19) {
                // 高2位固定为10
                random = (Math.random() * 16) | 0
                uuid += ((random & 0x3) | 0x8).toString(16)
            } else {
                random = (Math.random() * 16) | 0
                uuid += random.toString(16)
            }
        }
        return `${symbol},${uuid}-${ts}`
    }

    parseJSON(strData) {
        let ret = null 
        try {
            ret = JSON.parse(strData)
        } catch (err) {
            Log("err.name:", err.name, ", err.stack:", err.stack, ", err.message:", err.message, ", strData:", strData)
        }
        return ret 
    }

    init() {
        threading.Thread(this.simEngine, this.data, this.dataLock)
        
        // 删除数据库 历史订单表
        DBExec(`DROP TABLE IF EXISTS ${this.historyOrdersTblName};`)
        
        // 重建 历史订单表
        let strSql = [
            `CREATE TABLE IF NOT EXISTS ${this.historyOrdersTblName} (`,
            "ID VARCHAR(255) NOT NULL PRIMARY KEY,",
            "ORDERDATA TEXT NOT NULL",
            ")"
        ].join("");
        DBExec(strSql)
    }
}

// extport
$.CreatePaperTrader = function(exIdx, realExchange, assets, fee) {
    return new PaperTrader(exIdx, realExchange, assets, fee)
}

// 用真实行情打造高效 Paper Trader
function main() {
    // create PaperTrader
    let simulateAssets = [{"Currency": "USDT", "Amount": 10000, "FrozenAmount": 0}]
    let fee = {"taker": 0.001, "maker": 0.0005}
    paperTraderEx = $.CreatePaperTrader(0, exchange, simulateAssets, fee)
    Log(paperTraderEx)

    // test GetTicker
    Log("GetTicker:", paperTraderEx.GetTicker())

    // test GetOrders
    Log("GetOrders:", paperTraderEx.GetOrders())

    // test Buy/Sell
    let orderId = paperTraderEx.Buy(-1, 0.1)
    Log("orderId:", orderId)

    // test GetOrder
    Sleep(1000)
    Log(paperTraderEx.GetOrder(orderId))

    Sleep(6000)
}

व्यावहारिक प्रदर्शन और परीक्षण मामले

पक्का प्रस्ताव

उपरोक्त कोड को FMZ प्लेटफॉर्म की "टेम्पलेट लाइब्रेरी" के रूप में सहेजा जा सकता है।mainयह फ़ंक्शन परीक्षण फ़ंक्शन है:

इस तरह, जब आप वास्तव में ट्रेडिंग कर रहे हों, तो आप एक्सचेंज ऑब्जेक्ट को कॉन्फ़िगर करते समय API KEY स्ट्रिंग लिख सकते हैं। इस समय, ऑर्डर देने जैसे संचालन वास्तव में एक्सचेंज इंटरफ़ेस तक नहीं पहुंचेंगे, बल्कि सिमुलेशन के लिए सिमुलेशन सिस्टम की परिसंपत्तियों, ऑर्डर, स्थिति और अन्य डेटा का उपयोग करेंगे। लेकिन बाजार की स्थितियां ही एक्सचेंज की वास्तविक बाजार स्थितियां होती हैं।

विस्तार और अनुकूलन दिशा

रणनीति विकास में सिमुलेशन सिस्टम का महत्व
पेपरट्रेडर एक परीक्षण वातावरण प्रदान करता है जो वास्तविक बाजार के बहुत करीब है, जिससे डेवलपर्स को बिना किसी जोखिम के रणनीति के निष्पादन व्यवहार, ऑर्डर तर्क, मिलान प्रदर्शन और पूंजी परिवर्तनों को सत्यापित करने की अनुमति मिलती है। यह निम्नलिखित परिदृश्यों के लिए विशेष रूप से उपयुक्त है:

• बहु-रणनीति डिबगिंग समवर्ती परीक्षण
• विभिन्न बाजार स्थितियों के तहत रणनीतियों के प्रदर्शन को शीघ्रता से सत्यापित करें
• नुकसान से बचने के लिए डिबगिंग के दौरान प्रत्यक्ष वास्तविक समय के आदेशों से बचें
• कुछ पारंपरिक ऐतिहासिक बैकटेस्टिंग सत्यापन विधियों को बदलें

शुद्ध बैकटेस्टिंग से अंतर

पारंपरिक बैकटेस्टिंग ऐतिहासिक डेटा पर आधारित है और K दर K चलती है, तथा वास्तविक लेनदेन विवरण जैसे लंबित ऑर्डर, आंशिक लेनदेन, मिलान स्लिपेज और शुल्क संरचना को नजरअंदाज करती है। सिमुलेशन प्रणाली:

• वास्तविक समय उद्धरण का उपयोग करें (स्थिर ऐतिहासिक डेटा नहीं)
• वास्तविक ऑर्डर जीवन चक्र का अनुकरण करें (बनाएँ → ऑर्डर दें → मिलान करें → निष्पादित करें → रद्द करें)
• शुल्क, स्लिपेज और औसत लेनदेन मूल्य की सटीक गणना करें
• केवल "रणनीति मॉडल" के बजाय "रणनीति व्यवहार" का परीक्षण करना बेहतर है
• वास्तविक समय तैनाती के बीच एक सेतु के रूप में कार्य करना

पेपरट्रेडर पर नोट्स
उपरोक्त पेपरट्रेडर केवल एक प्रारंभिक डिज़ाइन है (केवल प्रारंभिक कोड समीक्षा और परीक्षण किया गया है), और इसका लक्ष्य एक डिज़ाइन विचार और समाधान संदर्भ प्रदान करना है। पेपरट्रेडर का भी परीक्षण किया जाना चाहिए ताकि यह पता लगाया जा सके कि मिलान तर्क, आदेश प्रणाली, स्थिति प्रणाली, पूंजी प्रणाली और अन्य डिजाइन उचित हैं या नहीं। समय की कमी के कारण, केवल स्पॉट ट्रेडिंग ही अपेक्षाकृत पूरी तरह से क्रियान्वित हो पाई है, तथा वायदा अनुबंधों के कुछ कार्य अभी भी अधूरे पड़े हैं।

संभावित समस्याएं:

• फ़्लोटिंग पॉइंट गणना त्रुटि.
• तार्किक प्रसंस्करण सीमाएँ.
• डिलीवरी अनुबंधों के लिए समर्थन अधिक जटिल है
• परिसमापन तंत्र का डिज़ाइन अधिक जटिल है

विकास की अगली दिशा

पेपरट्रेडर के अनुप्रयोग मूल्य को और अधिक बढ़ाने के लिए, अगले चरण में विस्तार के लिए निम्नलिखित दिशाओं पर विचार किया जा सकता है:

• अनुबंध सिमुलेशन के लिए समर्थन में सुधार (कोड में भाग पूरा करना अधूरा है)।
• अनुबंध स्थिति और उत्तोलक निधि प्रबंधन (स्थिति दर स्थिति, पूर्ण स्थिति) का समर्थन करता है।
• अस्थायी लाभ और हानि गणना और जबरन परिसमापन तंत्र लागू करना।

पेपरट्रेडर के माध्यम से, हम न केवल रणनीतियों के लिए एक सुरक्षित परीक्षण वातावरण प्रदान कर सकते हैं, बल्कि "शोध मॉडल" से "वास्तविक उत्पादकता" तक रणनीतियों की प्रमुख कड़ी को भी बढ़ावा दे सकते हैं।

पाठकों को संदेश छोड़ने के लिए स्वागत है, पढ़ने के लिए धन्यवाद।