[TOC]

তথ্যচিত্র ব্যবস্থার চাহিদার পরিস্থিতি

FMZ প্ল্যাটফর্ম কমিউনিটিতে এবং ব্যবহারকারীদের সাথে ব্যক্তিগত যোগাযোগের ক্ষেত্রে, আমাকে প্রায়শই এই প্রশ্নটি জিজ্ঞাসা করা হয়:

“কেন মাই বা পাইন স্ক্রিপ্টে লেখা কৌশলগুলি কেবল একটি অ্যাকাউন্ট এবং একটি পণ্য নিয়ন্ত্রণ করতে পারে?”

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

যখন একজন ব্যবহারকারী রিয়েল টাইমে একাধিক অ্যাকাউন্ট চালাতে চান, তখন এটি শুধুমাত্র একাধিক Pine অথবা My রিয়েল ইনস্ট্যান্স চালানোর মাধ্যমেই অর্জন করা যেতে পারে। অ্যাকাউন্টের সংখ্যা কম হলে এই পদ্ধতি গ্রহণযোগ্য, কিন্তু একই হোস্টে একাধিক ইনস্ট্যান্স স্থাপন করা হলে, প্রচুর সংখ্যক API অনুরোধ তৈরি হবে এবং অতিরিক্ত অনুরোধের ফ্রিকোয়েন্সির কারণে এক্সচেঞ্জ অ্যাক্সেস সীমিত করতে পারে, যা অপ্রয়োজনীয় রিয়েল-টাইম ঝুঁকি নিয়ে আসে।

তাহলে, Pine অথবা My language স্ক্রিপ্ট চালানোর জন্য কি আরও মার্জিত কোন উপায় আছে যাতে অন্যান্য অ্যাকাউন্টগুলি স্বয়ংক্রিয়ভাবে এর ট্রেডিং আচরণ অনুলিপি করতে পারে?

উত্তর হল: হ্যাঁ।

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

কৌশল নকশা

প্রোগ্রামটি জাভাস্ক্রিপ্টে লেখা এবং ডিজাইন করা হয়েছে, এবং প্রোগ্রাম আর্কিটেকচারটি লিডার-সাবস্ক্রাইবার মডেল ব্যবহার করে।

কৌশল সোর্স কোড:

/*backtest
start: 2024-05-21 00:00:00
end: 2025-05-20 00:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"},{"eid":"Futures_Binance","currency":"ETH_USDT"},{"eid":"Futures_Binance","currency":"ETH_USDT","balance":10000}]
args: [["isBacktest",true]]
*/

class Leader {
    constructor(leaderCfg = { type: "exchange", apiClient: exchanges[0] }) {
        // 带单账户配置
        this.leaderCfg = leaderCfg
        // 缓存上次持仓信息，用于对比
        this.lastPos = null
        // 记录当前持仓信息
        this.currentPos = null
        // 记录订阅者
        this.subscribers = []

        // 根据 leaderCfg 配置，确定使用哪种监控方案：1、直接监控带单账户。2、通过FMZ 扩展API监控带单策略实盘的数据。3、消息推送机制跟单。默认使用方案1。

        // 初始化
        let ex = this.leaderCfg.apiClient
        let currency = ex.GetCurrency()
        let arrCurrency = currency.split("_")
        if (arrCurrency.length !== 2) {
            throw new Error("带单账户配置错误，必须是两种币对")
        }
        this.baseCurrency = arrCurrency[0]
        this.quoteCurrency = arrCurrency[1]
        // 获取初始化时，带单账户的总权益
        this.initEquity = _C(ex.GetAccount).Equity
        this.currentPos = _C(ex.GetPositions)
    }

    // 监控leader的逻辑
    poll() {
        // 获取交易所对象
        let ex = this.leaderCfg.apiClient

        // 获取leader的持仓、账户资产数据
        let pos = ex.GetPositions()
        if (!pos) {
            return
        }
        this.currentPos = pos

        // 调用判断方法，判断持仓变化
        let { hasChanged, diff } = this._hasChanged(pos)
        if (hasChanged) {
            Log("Leader持仓变化，当前持仓：", pos)
            Log("持仓变动：", diff)
            // 通知订阅者
            this.subscribers.forEach(subscriber => {
                subscriber.applyPosChanges(diff)
            })
        }

        // 同步持仓
        this.subscribers.forEach(subscriber => {
            subscriber.syncPositions(pos)
        })
    }

    // 判断持仓是否变化
    _hasChanged(pos) {
        if (this.lastPos) {
            // 用于存储持仓差异的结果
            let diff = {
                added: [],    // 新增的持仓
                removed: [],  // 移除的持仓
                updated: []   // 更新的持仓（数量或价格变化）
            }

            // 将上次持仓和当前持仓转换为 Map，键为 `symbol + direction`，值为持仓对象
            let lastPosMap = new Map(this.lastPos.map(p => [`${p.Symbol}|${p.Type}`, p]))
            let currentPosMap = new Map(pos.map(p => [`${p.Symbol}|${p.Type}`, p]))

            // 遍历当前持仓，找出新增和更新的持仓
            for (let [key, current] of currentPosMap) {
                if (!lastPosMap.has(key)) {
                    // 如果上次持仓中没有该 key，则为新增持仓
                    diff.added.push({ symbol: current.Symbol, type: current.Type, deltaAmount: current.Amount })
                } else {
                    // 如果存在，则检查数量或价格是否变化
                    let last = lastPosMap.get(key)
                    if (current.Amount !== last.Amount) {
                        diff.updated.push({ symbol: current.Symbol, type: current.Type, deltaAmount: current.Amount - last.Amount })
                    }
                    // 从 lastPosMap 中移除，剩下的就是被移除的持仓
                    lastPosMap.delete(key)
                }
            }

            // 剩余在 lastPosMap 中的 key 是被移除的持仓
            for (let [key, last] of lastPosMap) {
                diff.removed.push({ symbol: last.Symbol, type: last.Type, deltaAmount: -last.Amount })
            }

            // 判断是否有变化
            let hasChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.updated.length > 0

            // 如果有变化，更新 lastPos
            if (hasChanged) {
                this.lastPos = pos
            }

            return { hasChanged: hasChanged, diff: diff }
        } else {
            // 如果没有上次持仓记录，更新记录，不做持仓同步
            this.lastPos = pos
            return { hasChanged: false, diff: { added: [], removed: [], updated: [] } }

            /* 另一种方案：同步仓位
            if (pos.length > 0) {
                let diff = {
                    added: pos.map(p => ({symbol: p.Symbol, type: p.Type, deltaAmount: p.Amount})),
                    removed: [],
                    updated: []
                }
                return {hasChanged: true, diff: diff}
            } else {
                return {hasChanged: false, diff: {added: [], removed: [], updated: []}}
            }
            */
        }
    }

    // 订阅者注册
    subscribe(subscriber) {
        if (this.subscribers.indexOf(subscriber) === -1) {
            if (this.quoteCurrency !== subscriber.quoteCurrency) {
                throw new Error("订阅者币对不匹配，当前leader币对：" + this.quoteCurrency + "，订阅者币对：" + subscriber.quoteCurrency)
            }
            if (subscriber.followStrategy.followMode === "equity_ratio") {
                // 设置跟单比例
                let ex = this.leaderCfg.apiClient
                let equity = _C(ex.GetAccount).Equity
                subscriber.setEquityRatio(equity)
            }
            this.subscribers.push(subscriber)
            Log("订阅者注册成功，订阅配置：", subscriber.getApiClientInfo())
        }
    }

    // 取消订阅
    unsubscribe(subscriber) {
        const index = this.subscribers.indexOf(subscriber)
        if (index !== -1) {
            this.subscribers.splice(index, 1)
            Log("订阅者取消注册成功，订阅配置：", subscriber.getApiClientInfo())
        } else {
            Log("订阅者取消注册失败，订阅配置：", subscriber.getApiClientInfo())
        }
    }

    // 获取UI信息
    fetchLeaderUI() {
        // 带单者信息
        let tblLeaderInfo = { "type": "table", "title": "Leader Info", "cols": ["带单方案", "计价币种", "跟单者数量", "初始总权益"], "rows": [] }
        tblLeaderInfo.rows.push([this.leaderCfg.type, this.quoteCurrency, this.subscribers.length, this.initEquity])

        // 构造带单者的显示信息：持仓信息
        let tblLeaderPos = { "type": "table", "title": "Leader pos", "cols": ["交易品种", "方向", "数量", "价格"], "rows": [] }
        this.currentPos.forEach(pos => {
            let row = [pos.Symbol, pos.Type == PD_LONG ? "多" : "空", pos.Amount, pos.Price]
            tblLeaderPos.rows.push(row)
        })

        // 构造订阅者的显示信息
        let strFollowerMsg = ""
        this.subscribers.forEach(subscriber => {
            let arrTbl = subscriber.fetchFollowerUI()
            strFollowerMsg += "`" + JSON.stringify(arrTbl) + "`\n"
        })

        return "`" + JSON.stringify([tblLeaderInfo, tblLeaderPos]) + "`\n" + strFollowerMsg
    }

    // 扩展暂停跟单、移除订阅等功能
}

class Subscriber {
    constructor(subscriberCfg, followStrategy = { followMode: "position_ratio", ratio: 1, maxReTries: 3 }) {
        this.subscriberCfg = subscriberCfg
        this.followStrategy = followStrategy

        // 初始化
        let ex = this.subscriberCfg.apiClient
        let currency = ex.GetCurrency()
        let arrCurrency = currency.split("_")
        if (arrCurrency.length !== 2) {
            throw new Error("订阅者配置错误，必须是两种币对")
        }
        this.baseCurrency = arrCurrency[0]
        this.quoteCurrency = arrCurrency[1]

        // 初始获取持仓数据
        this.currentPos = _C(ex.GetPositions)
    }

    setEquityRatio(leaderEquity) {
        // {followMode: "equity_ratio"} 自动根据账户权益比例跟单
        if (this.followStrategy.followMode === "equity_ratio") {
            let ex = this.subscriberCfg.apiClient
            let equity = _C(ex.GetAccount).Equity
            let ratio = equity / leaderEquity
            this.followStrategy.ratio = ratio
            Log("带单者权益:", leaderEquity, "订阅者权益：", equity)
            Log("自动设置，订阅者权益比例：", ratio)
        }
    }

    // 获取订阅者绑定的API客户端信息
    getApiClientInfo() {
        let ex = this.subscriberCfg.apiClient
        let idx = this.subscriberCfg.clientIdx
        if (ex) {
            return { exName: ex.GetName(), exLabel: ex.GetLabel(), exIdx: idx, followStrategy: this.followStrategy }
        } else {
            throw new Error("订阅者没有绑定API客户端")
        }
    }

    // 根据持仓类型、仓位变化，返回交易方向参数
    getTradeSide(type, deltaAmount) {
        if (type == PD_LONG && deltaAmount > 0) {
            return "buy"
        } else if (type == PD_LONG && deltaAmount < 0) {
            return "closebuy"
        } else if (type == PD_SHORT && deltaAmount > 0) {
            return "sell"
        } else if (type == PD_SHORT && deltaAmount < 0) {
            return "closesell"
        }

        return null
    }

    getSymbolPosAmount(symbol, type) {
        let ex = this.subscriberCfg.apiClient
        if (ex) {
            let pos = _C(ex.GetPositions, symbol)
            if (pos.length > 0) {
                // 遍历持仓，查找对应的symbol和type
                for (let i = 0; i < pos.length; i++) {
                    if (pos[i].Symbol === symbol && pos[i].Type === type) {
                        return pos[i].Amount
                    }
                }
            }
            return 0
        } else {
            throw new Error("订阅者没有绑定API客户端")
        }
    }

    // 下单重试
    tryCreateOrder(ex, symbol, side, price, amount, label, maxReTries) {
        for (let i = 0; i < Math.max(maxReTries, 1); i++) {
            let orderId = ex.CreateOrder(symbol, side, price, amount, label)
            if (orderId) {
                return orderId
            }
            Sleep(1000)
        }
        return null
    }

    // 同步持仓变化
    applyPosChanges(diff) {
        let ex = this.subscriberCfg.apiClient
        if (ex) {
            ["added", "removed", "updated"].forEach(key => {
                diff[key].forEach(item => {
                    let side = this.getTradeSide(item.type, item.deltaAmount)
                    if (side) {
                        // 计算跟单比例
                        let ratio = this.followStrategy.ratio
                        let tradeAmount = Math.abs(item.deltaAmount) * ratio
                        if (side == "closebuy" || side == "closesell") {
                            // 获取持仓数量检查
                            let posAmount = this.getSymbolPosAmount(item.symbol, item.type)
                            tradeAmount = Math.min(posAmount, tradeAmount)
                        }
                        // 订单Id
                        // let orderId = ex.CreateOrder(item.symbol, side, -1, tradeAmount, ex.GetLabel())
                        let orderId = this.tryCreateOrder(ex, item.symbol, side, -1, tradeAmount, ex.GetLabel(), this.followStrategy.maxReTries)
                        // 检测订单Id
                        if (orderId) {
                            Log("订阅者下单成功，订单Id：", orderId, "，下单方向：", side, "，下单数量：", Math.abs(item.deltaAmount), "，跟单比例（倍）：", ratio)
                        } else {
                            Log("订阅者下单失败，订单Id：", orderId, "，下单方向：", side, "，下单数量：", Math.abs(item.deltaAmount), "，跟单比例（倍）：", ratio)
                        }
                    }
                })
            })

            // 更新当前持仓
            this.currentPos = _C(ex.GetPositions)
        } else {
            throw new Error("订阅者没有绑定API客户端")
        }
    }

    // 同步持仓
    syncPositions(leaderPos) {
        let ex = this.subscriberCfg.apiClient
        this.currentPos = _C(ex.GetPositions)

        // 用于存储持仓差异的结果
        let diff = {
            added: [],    // 新增的持仓
            removed: [],  // 移除的持仓
            updated: []   // 更新的持仓（数量或价格变化）
        }
        let leaderPosMap = new Map(leaderPos.map(p => [`${p.Symbol}|${p.Type}`, p]))
        let currentPosMap = new Map(this.currentPos.map(p => [`${p.Symbol}|${p.Type}`, p]))
        // 遍历当前持仓，找出新增和更新的持仓
        for (let [key, leader] of leaderPosMap) {
            if (!currentPosMap.has(key)) {
                diff.added.push({ symbol: leader.Symbol, type: leader.Type, deltaAmount: leader.Amount })
            } else {
                let current = currentPosMap.get(key)
                if (leader.Amount !== current.Amount) {
                    diff.updated.push({ symbol: leader.Symbol, type: leader.Type, deltaAmount: leader.Amount - current.Amount * this.followStrategy.ratio })
                }
                currentPosMap.delete(key)
            }
        }
        for (let [key, current] of currentPosMap) {
            diff.removed.push({ symbol: current.Symbol, type: current.Type, deltaAmount: -current.Amount * this.followStrategy.ratio })
        }
        // 判断是否有变化
        let hasChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.updated.length > 0
        if (hasChanged) {
            // 同步
            this.applyPosChanges(diff)
        }
    }

    // 获取订阅者UI信息
    fetchFollowerUI() {
        // 订阅者信息
        let ex = this.subscriberCfg.apiClient
        let equity = _C(ex.GetAccount).Equity
        let exLabel = ex.GetLabel()
        let tblFollowerInfo = { "type": "table", "title": "Follower Info", "cols": ["交易所对象索引", "交易所对象标签", "计价币种", "跟单模式", "跟单比例（倍）", "最大重试次数", "总权益"], "rows": [] }
        tblFollowerInfo.rows.push([this.subscriberCfg.clientIdx, exLabel, this.quoteCurrency, this.followStrategy.followMode, this.followStrategy.ratio, this.followStrategy.maxReTries, equity])

        // 订阅者持仓信息
        let tblFollowerPos = { "type": "table", "title": "Follower pos", "cols": ["交易品种", "方向", "数量", "价格"], "rows": [] }
        let pos = this.currentPos
        pos.forEach(p => {
            let row = [p.Symbol, p.Type == PD_LONG ? "多" : "空", p.Amount, p.Price]
            tblFollowerPos.rows.push(row)
        })

        return [tblFollowerInfo, tblFollowerPos]
    }
}

// 测试函数，模拟随机开仓，模拟leader仓位变动
function randomTrade(symbol, amount) {
    let randomNum = Math.random()
    if (randomNum < 0.0001) {
        Log("模拟带单交易", "#FF0000")
        let ex = exchanges[0]
        let pos = _C(ex.GetPositions)

        if (pos.length > 0) {
            // 随机平仓
            let randomPos = pos[Math.floor(Math.random() * pos.length)]
            let tradeAmount = Math.random() > 0.7 ? Math.abs(randomPos.Amount * 0.5) : Math.abs(randomPos.Amount)
            ex.CreateOrder(randomPos.Symbol, randomPos.Type === PD_LONG ? "closebuy" : "closesell", -1, tradeAmount, ex.GetLabel())
        } else {
            let tradeAmount = Math.random() * amount
            let side = Math.random() > 0.5 ? "buy" : "sell"
            if (side === "buy") {
                ex.CreateOrder(symbol, side, -1, tradeAmount, ex.GetLabel())
            } else {
                ex.CreateOrder(symbol, side, -1, tradeAmount, ex.GetLabel())
            }
        }
    }
}

// 策略主循环
function main() {
    let leader = new Leader()

    let followStrategyArr = JSON.parse(strFollowStrategyArr)
    if (followStrategyArr.length > 0 && followStrategyArr.length !== exchanges.length - 1) {
        throw new Error("跟单策略配置错误，跟单策略数量和交易所数量不匹配")
    }

    for (let i = 1; i < exchanges.length; i++) {
        let subscriber = null
        if (followStrategyArr.length == 0) {
            subscriber = new Subscriber({ apiClient: exchanges[i], clientIdx: i })
        } else {
            let followStrategy = followStrategyArr[i - 1]
            subscriber = new Subscriber({ apiClient: exchanges[i], clientIdx: i }, followStrategy)
        }
        leader.subscribe(subscriber)
    }

    // 启动监控
    while (true) {
        leader.poll()
        Sleep(1000 * pollInterval)

        // 模拟随机交易
        if (IsVirtual() && isBacktest) {
            randomTrade("BTC_USDT.swap", 0.001)
            randomTrade("ETH_USDT.swap", 0.02)
            randomTrade("SOL_USDT.swap", 0.1)
        }

        LogStatus(_D(), "\n", leader.fetchLeaderUI())
    }
}

• ডিজাইন প্যাটার্নস আমরা পূর্বে প্ল্যাটফর্মে একাধিক কপি ট্রেডিং কৌশল তৈরি করেছি, একটি প্রক্রিয়া-ভিত্তিক নকশা ব্যবহার করে। এই নিবন্ধটি একটি নতুন নকশা প্রচেষ্টা, একটি বস্তু-ভিত্তিক শৈলী এবং পর্যবেক্ষক নকশা প্যাটার্ন ব্যবহার করে।

• পর্যবেক্ষণ সমাধান তথাকথিত কপি ট্রেডিংয়ের সারমর্ম হল এক ধরণের পর্যবেক্ষণ আচরণ, লক্ষ্যবস্তুর ক্রিয়াকলাপ পর্যবেক্ষণ করা এবং নতুন ক্রিয়াকলাপ পাওয়া গেলে সেগুলি প্রতিলিপি করা।

এই নিবন্ধটি শুধুমাত্র একটি সমাধান বাস্তবায়ন করে: এক্সচেঞ্জ অবজেক্ট কনফিগার করতে এবং লক্ষ্য অ্যাকাউন্টের অবস্থান পর্যবেক্ষণ করতে API KEY ব্যবহার করা। আসলে, আরও দুটি সমাধান রয়েছে যা নকশায় আরও জটিল হতে পারে:

• FMZ এর বর্ধিত API এর মাধ্যমে লক্ষ্যবস্তু রিয়েল অ্যাকাউন্টের লগ এবং স্ট্যাটাস বারের তথ্য পর্যবেক্ষণ করুন এবং পরিবর্তনের উপর ভিত্তি করে ক্রিয়াকলাপ সম্পাদন করুন এবং আদেশ অনুসরণ করুন। এই সমাধানটি ব্যবহারের সুবিধা হল এটি কার্যকরভাবে API অনুরোধ কমাতে পারে।

• লক্ষ্যবস্তু রিয়েল ডিস্ক বার্তা পুশের উপর নির্ভর করে আপনি FMZ-এ টার্গেট রিয়েল অ্যাকাউন্টের মেসেজ পুশ চালু করতে পারেন, এবং টার্গেট রিয়েল অ্যাকাউন্টের অর্ডার পেলে একটি মেসেজ পুশ করা হবে। কপি ট্রেডিং কৌশল এই বার্তাগুলি গ্রহণ করতে পারে এবং পদক্ষেপ নিতে পারে। এই সমাধান ব্যবহারের সুবিধাগুলির মধ্যে রয়েছে: API অনুরোধ হ্রাস করা এবং একটি অনুরোধ পোলিং প্রক্রিয়া থেকে একটি ইভেন্ট-চালিত প্রক্রিয়ায় পরিবর্তন করা।

• কপি ট্রেডিং কৌশল

কপি ট্রেডিং কৌশলের জন্য একাধিক প্রয়োজনীয়তা থাকতে পারে এবং কৌশল কাঠামোটি এমনভাবে ডিজাইন করা হয়েছে যাতে এটি সহজেই সম্প্রসারিত হয়।

• অবস্থানের প্রতিলিপি: পজিশনগুলি ১:১ অনুপাতে প্রতিলিপি করা যেতে পারে, অথবা নির্দিষ্ট স্কেলিং পরামিতি অনুসারে স্কেল করা যেতে পারে।

• ইকুইটি অনুপাত অর্ডার সহ অ্যাকাউন্ট এবং নিম্নলিখিত অর্ডারগুলির মধ্যে ইকুইটি অনুপাত স্বয়ংক্রিয়ভাবে নিম্নলিখিত অর্ডারগুলির জন্য স্কেলিং প্যারামিটার হিসাবে ব্যবহার করা যেতে পারে।

• অবস্থান সিঙ্ক্রোনাইজেশন প্রকৃত ব্যবহারে, অর্ডার গ্রহণকারী এবং অর্ডার অনুসরণকারীর অবস্থান ভিন্ন হওয়ার বিভিন্ন কারণ থাকতে পারে। অর্ডার অনুসরণ করার সময় কপি করা অ্যাকাউন্ট এবং অর্ডার বহনকারী অ্যাকাউন্টের মধ্যে পার্থক্য সনাক্ত করার জন্য এবং স্বয়ংক্রিয়ভাবে অবস্থানগুলি সিঙ্ক্রোনাইজ করার জন্য সিস্টেমটি ডিজাইন করা যেতে পারে।

• অর্ডার পুনরায় চেষ্টা করুন কপি ট্রেডিং কৌশলে ব্যর্থ অর্ডারের জন্য পুনঃপ্রচেষ্টার নির্দিষ্ট সংখ্যা আপনি নির্দিষ্ট করতে পারেন।

• ব্যাকটেস্টিং র‍্যান্ডম টেস্টিং কোডেfunction randomTrade(symbol, amount)কপি ট্রেডিং প্রভাব সনাক্ত করার জন্য ব্যাকটেস্টিংয়ের সময় র্যান্ডম ওপেনিং পরীক্ষার জন্য ফাংশনটি ব্যবহার করা হয়।

কৌশল ব্যাকটেস্টিং এবং যাচাইকরণ

প্রথম যোগ করা বিনিময় বস্তু (অর্ডার গ্রহণকারী) অনুসারে, পরবর্তীকালে যোগ করা বিনিময় বস্তুগুলি আদেশগুলি (অনুসারী) অনুসরণ করে।

পরীক্ষায়, বহু-বৈচিত্র্যপূর্ণ কপি ট্রেডিংয়ের চাহিদা যাচাই করার জন্য এলোমেলোভাবে তিন ধরণের অর্ডার দেওয়া হয়েছিল:

randomTrade("BTC_USDT.swap", 0.001)
randomTrade("ETH_USDT.swap", 0.02)
randomTrade("SOL_USDT.swap", 0.1)

কৌশল ভাগাভাগি

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

এক্সটেনশন এবং অপ্টিমাইজেশন

• অবস্থান এবং অ্যাকাউন্ট তথ্যের মতো ডেটার জন্য পর্যবেক্ষণ সমাধানগুলি প্রসারিত করুন।
• গ্রাহকদের উপর নিয়ন্ত্রণ বাড়ানোর জন্য, আপনি অ্যাকাউন্টগুলি কপি করা এবং সাবস্ক্রাইব করা বন্ধ করার মতো ফাংশন যোগ করতে পারেন।
• কপি ট্রেডিং কৌশলের পরামিতিগুলি গতিশীলভাবে আপডেট করুন।
• আরও সমৃদ্ধ ডকুমেন্টারি ডেটা এবং তথ্য প্রদর্শন যোগ এবং প্রসারিত করুন।

END

ইনভেনটর কোয়ান্টিটেটিভ (FMZ.COM) লাইব্রেরি এবং কমিউনিটিতে বার্তা রেখে আলোচনা করতে পারেন। আপনি বিভিন্ন দাবি এবং ধারণা পেশ করতে পারেন। সম্পাদক বার্তাগুলির উপর ভিত্তি করে আরও মূল্যবান বিষয়বস্তু, উৎপাদন পরিকল্পনার নকশা, ব্যাখ্যা এবং শিক্ষণ উপকরণগুলি পরীক্ষা করবেন।

এই প্রবন্ধটি কেবল একটি সূচনা বিন্দু। এটি একটি প্রাথমিক কপি ট্রেডিং কৌশল কাঠামো ডিজাইন করতে অবজেক্ট-ওরিয়েন্টেড স্টাইল এবং পর্যবেক্ষক মোড ব্যবহার করে। আমি আশা করি এটি পাঠকদের জন্য রেফারেন্স এবং অনুপ্রেরণা প্রদান করতে পারবে। আপনার পড়া এবং সমর্থনের জন্য ধন্যবাদ।