[TOC]

ভূমিকা

এই প্রবন্ধটি পেপারট্রেডারের নকশা এবং বাস্তবায়নের সাথে পরিচয় করিয়ে দেয়, যা FMZ পরিমাণগত প্ল্যাটফর্মের উপর ভিত্তি করে এবং বাস্তব বাজার পরিস্থিতি দ্বারা চালিত একটি সিমুলেশন ট্রেডিং সিস্টেম। এই সিস্টেমটি রিয়েল-টাইম ইন ডেপথ মার্কেট কন্ডিশনের মাধ্যমে অর্ডারের সাথে মেলে, স্ট্র্যাটেজি অর্ডার প্লেসমেন্ট, লেনদেন, অ্যাসেট পরিবর্তন এবং ফি প্রসেসিংয়ের মতো ট্রেডিং প্রক্রিয়াগুলিকে সম্পূর্ণরূপে অনুকরণ করে, মার্কেট/লিমিট অর্ডার, অ্যাসেট ফ্রিজিং এবং ক্যান্সেলেশন আর্কাইভিং সমর্থন করে এবং রিয়েল ট্রেডিংয়ের আগে স্ট্র্যাটেজি টেস্টিং এবং রিয়েল আচরণ যাচাইয়ের জন্য উপযুক্ত। এই প্রবন্ধে সিস্টেম আর্কিটেকচার, ম্যাচিং মেকানিজম, ইন্টারফেস সামঞ্জস্যতা ইত্যাদির দৃষ্টিকোণ থেকে এর নকশা ধারণা এবং মূল বাস্তবায়ন সম্পর্কে বিস্তারিতভাবে ব্যাখ্যা করা হবে এবং অনলাইনে যাওয়ার আগে পরিমাণগত কৌশলগুলিকে একটি নিরাপদ এবং নির্ভরযোগ্য “ইন্টারমিডিয়েট স্যান্ডবক্স” তৈরি করতে সহায়তা করার জন্য সম্পূর্ণ ব্যবহারিক প্রদর্শনী ব্যবহারের কেস প্রদান করা হবে।

পেপারট্রেডারের প্রয়োজনীয়তা বিশ্লেষণ এবং নকশা

চাহিদার ব্যথার পয়েন্ট:

• এক্সচেঞ্জ সিমুলেশন ট্রেডিং বিশৃঙ্খল এবং অবাস্তব।
• এক্সচেঞ্জে সিমুলেটেড অ্যাকাউন্টের জন্য আবেদন করা কষ্টকর, এবং পরীক্ষার তহবিল সংগ্রহ করাও কষ্টকর।
• অনেক এক্সচেঞ্জ পরীক্ষার পরিবেশ প্রদান করে না।

ব্যাকটেস্টিং এবং রিয়েল ট্রেডিংয়ের মধ্যে “ধূসর অঞ্চল” সমস্যা

কেন আপনার একটি সিমুলেটেড ট্রেডিং সিস্টেমের প্রয়োজন?

পরিমাণগত কৌশল বিকাশের পুরো প্রক্রিয়ায়, আমরা সাধারণত “ঐতিহাসিক ব্যাকটেস্টিং → পরিবেশগত পরীক্ষা → বাস্তব ট্রেডিং” এর ধাপগুলি অতিক্রম করি। তবে, ঐতিহাসিক ব্যাকটেস্টিং পরিসংখ্যানগত তথ্য ব্যবহার করে এবং প্রকৃত বাজার পরিস্থিতিতে কৌশলগুলির কার্যকারিতা প্রক্রিয়া করতে পারে না। তবে, প্রকৃত ট্রেডিং মানে তহবিলের পলায়ন, এবং একটি মধ্যবর্তী পরীক্ষার পরিবেশের অভাব আমাদের অনুসন্ধানের ক্ষেত্রে একটি যন্ত্রণাদায়ক বিষয় হয়ে দাঁড়িয়েছে। এই সমস্যা সমাধানের জন্য, আমাদের একটি হালকা সিমুলেশন ট্রেডিং সিস্টেম - পেপারট্রেডার ডিজাইন করতে হবে, যা রিয়েল-টাইম বাজার পরিস্থিতি (গভীরতা, বাজার মূল্য) ব্যবহার করে অর্ডার দেওয়া, মুলতুবি অর্ডার, লেনদেন, অর্ডার উত্তোলন, সম্পদ পরিবর্তন এবং কমিশন কর্তন সহ সমগ্র ট্রেডিং প্রক্রিয়া অনুকরণ করতে পারে এবং শেষ পর্যন্ত বাস্তব ট্রেডিং স্তরের কাছাকাছি কৌশল যাচাইকরণ সম্পূর্ণ করতে পারে।

নকশা লক্ষ্য এবং মূল বৈশিষ্ট্য

• 1. রিয়েল-টাইম মার্কেট ড্রাইভ GetTicker() এবং GetDepth() এর মতো কয়েক ডজন ইন্টারফেস সহ আসল বিনিময় কোট অ্যাক্সেস করতে FMZ ব্যবহার করুন।
• 1. সিমুলেশন অর্ডার প্লেসমেন্ট এবং ডিডাকশন সীমা/বাজার অর্ডার, প্রস্তুতকারক/গ্রহীতার ফি পৃথকভাবে কর্তন সমর্থন করে এবং বাজার ক্রয় অর্ডারের জন্য প্রকৃত গণনা করা ইনপুট পরিমাণ ব্যবহার করে।
• 1. সম্পদ/পজিশন/অর্ডার ব্যবস্থাপনা এটি অর্ডার দেওয়ার সময় সম্পদ জব্দ করা এবং অর্ডার বাতিল করার সময় ফেরত দেওয়া সমর্থন করে এবং প্রতীক স্তরের উপর ভিত্তি করে একাধিক সম্পদ/পজিশন/অর্ডার রক্ষণাবেক্ষণ সমর্থন করে।
• 1. সম্পূর্ণ অর্ডার চক্র অর্ডার তৈরি, অপেক্ষা, কার্যকরকরণ থেকে বাতিলকরণ পর্যন্ত স্পষ্টভাবে পরিচালিত হয়। কার্যকর করার পরে, ভবিষ্যতের প্রশ্ন এবং বিশ্লেষণ সমর্থন করার জন্য এগুলি স্বয়ংক্রিয়ভাবে স্থানীয় ডাটাবেসে সংরক্ষণাগারভুক্ত হয়।
• 1. ব্যবহারকারীর অভিজ্ঞতা এই কৌশলটির জন্য কোনও অর্ডার কল পরিবর্তন করার প্রয়োজন নেই, এবং কেবল এক্সচেঞ্জ অবজেক্টকে পেপারট্রেডার দিয়ে প্রতিস্থাপন করে সিমুলেটেড ট্রেডিং বাস্তবায়ন করা যেতে পারে।

লাইব্রেরি ডিজাইনের ওভারভিউ

এই সিস্টেমটি প্রধানত তিনটি অংশ নিয়ে গঠিত:

• পেপারট্রেডার ক্লাস মূল সিমুলেশন অ্যাকাউন্টে সম্পদ, অর্ডার, অবস্থান, বাজারের অবস্থা এবং কনফিগারেশনের মতো ডেটা রক্ষণাবেক্ষণ অন্তর্ভুক্ত থাকে।

• [সিমইঞ্জিন ম্যাচিং ইঞ্জিন]: ব্যাকগ্রাউন্ড থ্রেড, বাজারের গভীরতা অনুসারে বর্তমান ক্রম স্ক্যান করে এবং ক্রিয়াকলাপ সম্পাদন করে

• 【ডাটাবেস আর্কাইভ】: পরবর্তী বিশ্লেষণ এবং পর্যালোচনার জন্য স্থানীয় ডাটাবেসে সম্পূর্ণ/বাতিলকৃত অর্ডারগুলি লিখুন।

মিলিত ইঞ্জিন ডিজাইন：

simEngine(data, lock) হল সমগ্র সিমুলেশন সিস্টেমের মূল। লেনদেনের জন্য সঠিক সিমুলেশন ফলাফল প্রদানের জন্য এটি প্রকৃত বাজার গভীরতার তথ্য অনুসারে একটি লুপে বর্তমান মুলতুবি অর্ডারগুলির সাথে মিলিত হয়।

প্রধান প্রক্রিয়ার মধ্যে রয়েছে:

• বর্তমান পেন্ডিং অর্ডার, পজিশন, সম্পদ এবং বাজারের অবস্থা জানুন;
• ব্যবহৃত সকল প্রতীকের গভীরতা বের করুন GetDepth;
• মুলতুবি থাকা অর্ডারগুলি অতিক্রম করুন এবং নির্দেশ (ক্রয়/বিক্রয়) অনুসারে অপারেশনের গভীরতা (জিজ্ঞাসা/বিড) নির্বাচন করুন;
• মূল্য অপারেটিং শর্ত পূরণ করে কিনা তার উপর ভিত্তি করে লেনদেন সম্পন্ন হয়েছে কিনা তা নির্ধারণ করুন;
• লেনদেন সম্পন্ন হলে, অর্ডারের তথ্য আপডেট করুন এবং গণনা করুন যেমন AvgPrice / DealAmount;
• প্রস্তুতকারক/গ্রহীতার উপর ভিত্তি করে হ্যান্ডলিং ফি কেটে নিন।
• যদি সমস্ত অর্ডার কার্যকর করা হয়ে থাকে, তাহলে অর্ডারটি সংরক্ষণাগারভুক্ত করা হবে; অন্যথায়, এটি বিচারাধীন থাকবে।

ইন্টারফেস তথ্য সামঞ্জস্য：

পেপারট্রেডারকে FMZ প্ল্যাটফর্মের আসল ট্রেডিং ইন্টারফেসের সাথে যথাসম্ভব সামঞ্জস্যপূর্ণ করার জন্য ডিজাইন করা হয়েছে, যার মধ্যে রয়েছে কিন্তু সীমাবদ্ধ নয়:

এই নকশাটি কৌশলগত যুক্তিকে কোনও পরিবর্তন ছাড়াই সরাসরি একটি সিমুলেটেড ট্রেডিং পরিবেশে চালানোর অনুমতি দেয়। এক ক্লিকেই পেপারট্রেডারের সাথে এক্সচেঞ্জ প্রতিস্থাপন করে, আপনি কৌশলটিকে ব্যাকটেস্টিং এবং রিয়েল ট্রেডিংয়ের মধ্যে “মাঝারি স্তরে” স্থানান্তর করতে পারেন।

পেপারট্রেডার ডিজাইন সোর্স কোড

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 চালায়, বাস্তব লেনদেনের বিবরণ যেমন মুলতুবি অর্ডার, আংশিক লেনদেন, ম্যাচিং স্লিপেজ এবং ফি কাঠামো উপেক্ষা করে। সিমুলেশন সিস্টেম:

• রিয়েল-টাইম উদ্ধৃতি ব্যবহার করুন (স্থির ঐতিহাসিক তথ্য নয়)
• আসল অর্ডার জীবনচক্র অনুকরণ করুন (তৈরি করুন → অর্ডার দিন → মিল করুন → কার্যকর করুন → বাতিল করুন)
• ফি, স্লিপেজ এবং গড় লেনদেন মূল্য সঠিকভাবে গণনা করুন
• “কৌশলগত মডেল” পরীক্ষা করার চেয়ে “কৌশলগত আচরণ” পরীক্ষা করা ভালো।
• রিয়েল-টাইম স্থাপনার মধ্যে সেতুবন্ধন হিসেবে কাজ করা

পেপারট্রেডার সম্পর্কিত নোটস উপরের পেপারট্রেডারটি কেবল একটি প্রাথমিক নকশা (শুধুমাত্র প্রাথমিক কোড পর্যালোচনা এবং পরীক্ষা করা হয়েছে), এবং লক্ষ্য হল একটি নকশা ধারণা এবং সমাধানের রেফারেন্স প্রদান করা। ম্যাচিং লজিক, অর্ডার সিস্টেম, পজিশন সিস্টেম, ক্যাপিটাল সিস্টেম এবং অন্যান্য ডিজাইন যুক্তিসঙ্গত কিনা তা পরীক্ষা করার জন্য পেপারট্রেডারকেও পরীক্ষা করা প্রয়োজন। সময়ের সীমাবদ্ধতার কারণে, শুধুমাত্র স্পট ট্রেডিং তুলনামূলকভাবে সম্পূর্ণরূপে বাস্তবায়িত হয়েছে, এবং ফিউচার চুক্তির কিছু ফাংশন এখনও করণীয় অবস্থায় রয়েছে।

সম্ভাব্য সম্ভাব্য সমস্যা:

• ভাসমান বিন্দু গণনার ত্রুটি।
• যৌক্তিক প্রক্রিয়াকরণের সীমানা।
• ডেলিভারি চুক্তির জন্য সহায়তা আরও জটিল
• লিকুইডেশন মেকানিজমের নকশা আরও জটিল

পরবর্তী বিবর্তনের দিকনির্দেশনা

পেপারট্রেডারের অ্যাপ্লিকেশন মূল্য আরও বৃদ্ধি করার জন্য, পরবর্তী পর্যায়ে সম্প্রসারণের জন্য নিম্নলিখিত নির্দেশাবলী বিবেচনা করা যেতে পারে:

• চুক্তি সিমুলেশনের জন্য সমর্থন উন্নত করুন (কোডে অংশ নেওয়ার জন্য অসম্পূর্ণ)।
• চুক্তির অবস্থান এবং লিভারেজ তহবিল ব্যবস্থাপনা (পজিশন অনুসারে, সম্পূর্ণ অবস্থান) সমর্থন করে।
• ভাসমান লাভ-ক্ষতির হিসাব এবং জোরপূর্বক অবসান প্রক্রিয়া চালু করুন।

পেপারট্রেডারের মাধ্যমে, আমরা কেবল কৌশলগুলির জন্য একটি নিরাপদ পরীক্ষার পরিবেশ প্রদান করতে পারি না, বরং “গবেষণা মডেল” থেকে “প্রকৃত উৎপাদনশীলতা” পর্যন্ত কৌশলগুলির ম�