ক্রিপ্টোকারেন্সি বাজার একটি অনন্য ট্রেডিং পরিবেশ প্রদান করে, যা গ্রিড ট্রেডিং কৌশলগুলির জন্য একটি আদর্শ প্রয়োগের দৃশ্যপট তৈরি করে। ঐতিহ্যবাহী আর্থিক বাজারের তুলনায়, ক্রিপ্টোকারেন্সি সেক্টর ²⁴⁄₇ কাজ করে, ক্রমাগত এবং ঘন ঘন মূল্যের ওঠানামা সহ, গ্রিড কৌশলগুলির জন্য প্রচুর সালিসি সুযোগ তৈরি করে। তদুপরি, স্পট এবং চিরস্থায়ী চুক্তির মতো প্রধান ট্রেডিং উপকরণগুলিতে কোনও মেয়াদোত্তীর্ণ বিধিনিষেধ নেই, যা ব্যবসায়ীদের চুক্তির মেয়াদ শেষ হওয়ার ঝুঁকি সম্পর্কে চিন্তা না করে দীর্ঘমেয়াদী অবস্থান ধরে রাখতে দেয়। তদুপরি, ক্রিপ্টোকারেন্সি বাজারের উচ্চ অস্থিরতা এবং তুলনামূলকভাবে উচ্চ তরলতা গ্রিড কৌশল বাস্তবায়নের জন্য অনুকূল পরিস্থিতি প্রদান করে।

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

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

গ্রিড কৌশল নীতিমালা

ঐতিহ্যবাহী গ্রিড ট্রেডিংয়ের মূল উপাদানগুলি

• গ্রিড নোড:পূর্বনির্ধারিত মূল্য বিন্দু যেখানে ক্রয় বা বিক্রয় অর্ডার দেওয়া হয়।
• গ্রিড ব্যবধান:সংলগ্ন গ্রিড নোডের মধ্যে দামের দূরত্ব নির্ধারণ করে যে কোনও লেনদেন শুরু করার জন্য দাম কতটা ওঠানামা করতে হবে।
• গ্রিডের আকার:গ্রিড নোডের মোট সংখ্যা কৌশল দ্বারা আচ্ছাদিত মূল্য পরিসীমা নিয়ন্ত্রণ করে।

গ্রিড ট্রেডিং কৌশলগুলি কীভাবে কাজ করে

• যখন দাম নিম্ন স্তর থেকে বেড়ে সেট গ্রিড নোড ভেঙে যায়, তখন একটি বিক্রয় আদেশ ট্রিগার হয়।
• যখন দাম উচ্চ স্তর থেকে নেমে আসে এবং সেট গ্রিড নোড ভেঙে যায়, তখন একটি ক্রয় আদেশ শুরু হয়।
• বিভিন্ন রেঞ্জে ক্রমাগত “কম দামে কেনা এবং বেশি দামে বিক্রি” করে, এমনকি যদি দাম সীমার মধ্যে ওঠানামা করে, তবুও আপনি প্রতিটি ওঠানামা থেকে লাভ করতে পারেন।

উদাহরণ

ধরুন, একটি গ্রিড কৌশল \(8,000 থেকে \)9,000 এর গ্রিড ব্যবধানের সাথে সেট করা হয়েছে, যার গ্রিড ব্যবধান \(500। যখন দাম \)8,000 থেকে \(8,500 এ বৃদ্ধি পায়, তখন কৌশলটি \)8,000 এ কিনবে এবং \(8,500 এ বিক্রি করবে। যদি দাম আরও \)9,000 এ বৃদ্ধি পায়, তবে এটি তার কিছু হোল্ডিং আবার বিক্রি করবে। যখন দাম \(9,000 থেকে \)8,500 এ ফিরে আসে, তখন এটি আবার কিনবে। এই প্রক্রিয়াটি পুনরাবৃত্তি করে, কৌশলটি বাজারের ওঠানামার মধ্যেও ক্রমাগত লাভ সংগ্রহ করতে পারে।

গ্রিড ট্রেডিং কৌশল এবং ব্যালেন্সড ট্রেডিং কৌশলের মধ্যে তুলনা

একটি সুষম কৌশলের মূল বিষয় হল সম্পদের একটি নির্দিষ্ট অনুপাত বজায় রাখা, যেমন ৫০% ডিজিটাল মুদ্রা এবং ৫০% ফিয়াট মুদ্রা। যখন একটি ক্রিপ্টোকারেন্সির দাম বেড়ে যায় এবং হোল্ডেড ক্রিপ্টোকারেন্সির অনুপাত ৫০% ছাড়িয়ে যায়, তখন এটি বিক্রি করা হয়; যখন দাম কমে যায়, তখন এটি কেনা হয়। এটি নিশ্চিত করে যে হোল্ডেড সম্পদের মূল্য স্থির অনুপাতের কাছাকাছি থাকে। বাজারের ওঠানামা নির্বিশেষে, একটি সুষম কৌশল একটি নির্দিষ্ট পরিমাণ ক্রিপ্টোকারেন্সি বজায় রাখে।

গ্রিড কৌশল এবং ভারসাম্য কৌশলের মধ্যে মিল এবং পার্থক্য

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

চুক্তি: গাণিতিক গ্রিড কৌশল

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

কোর লজিক

মূল ধারণা:

1. সমদূরবর্তী ব্যবধান
   গাণিতিক গ্রিড কৌশলে, ক্রয় এবং বিক্রয় মূল্যের মধ্যে একটি ব্যবধান থাকে।স্থির মূল্যের ব্যবধান, যা কোডে আছেgridউদাহরণস্বরূপ, যখন দাম 300 ইউনিট ওঠানামা করে (যেমন কোডে আছে)grid=300), একটি ক্রয় বা বিক্রয় অর্ডার ট্রিগার করা হয়।

2. গ্রিড আরম্ভকরণ
   এই কৌশলটি বর্তমান মূল্যের উপর ভিত্তি করে প্রাথমিক ক্রয় এবং বিক্রয় মূল্য তৈরি করে, যা হলbuyp এবংsellpদুটি মূল্য ব্যবধান গ্রিড ব্যবধানের উপর ভিত্তি করে তৈরিgridবর্তমান মূল্যের উপরে এবং নীচে যথাক্রমে সেট করতেgridইউনিট।

3. লাভ নিন এবং বিপরীত করুন
   যখন দাম একটি নির্দিষ্ট পরিসরে বৃদ্ধি পায়, তখন কৌশলটি দীর্ঘ অবস্থানের এলাকায় ক্রয় করবে এবং মুনাফা নেওয়ার জন্য একটি বিক্রয় আদেশ সেট করবে। যদি দাম বিপরীত অবস্থানের এলাকায় বৃদ্ধি পেতে থাকে (upper), লং পজিশন লাভ করবে এবং স্বল্প মূল্যে যাবে, এবং বিপরীতভাবে।

4. গ্রিডের মধ্যে অবস্থান ব্যবস্থাপনা
   গ্রিডের মধ্যে প্রতিটি ক্রয় বা বিক্রয় ক্রিয়া তখনই শুরু হবে যখন দাম প্রিসেটের উপরে পৌঁছাবে।buypঅথবাsellpপ্রতিটি লেনদেনের পরে, সিস্টেমটি একটি নির্দিষ্ট গ্রিড ব্যবধান বজায় রাখার জন্য স্বয়ংক্রিয়ভাবে পরবর্তী ক্রয় এবং বিক্রয় মূল্যের গ্রুপ সামঞ্জস্য করে।

5. অবস্থান যোগ করা এবং হ্রাস করা
   গ্রিড মূল্যের উপর ভিত্তি করে কৌশলটি ক্রমাগত তার অবস্থান সামঞ্জস্য করে। যখন দাম ক্রয় বিন্দুতে পৌঁছায়, তখন এটি তার অবস্থান বৃদ্ধি করে (তার অবস্থান বৃদ্ধি করে); যখন দাম বিক্রয় বিন্দুতে পৌঁছায়, তখন এটি ধীরে ধীরে তার অবস্থান হ্রাস করে (তার অবস্থান হ্রাস করে)। বারবার ক্রয় এবং বিক্রয়ের মাধ্যমে, এটি প্রতিটি ছোট বাজারের ওঠানামা ক্যাপচার করে।

নীতি কোড

'''backtest
start: 2024-08-26 00:00:00
end: 2024-09-25 00:00:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":2500}]
args: [["H",30],["n1",0.001],["grid",300],["bottom",50000]]
'''

# 交易参数配置（设为策略参数）
M = 20          # 杠杆大小
H = 50          # 初始底仓份数
n1 = 1          # 单个网格交易数量
grid = 200      # 单个网格交易间距
bottom = 35000  # 开多点位
upper = 60000   # 开空点位

def CancelPendingOrders():
    orders = _C(exchanges[0].GetOrders)
    if len(orders)>0:
        for j in range(len(orders)):
            exchanges[0].CancelOrder(orders[j].Id, orders[j])
            j=j+1

def main():
    exchange.SetContractType('swap')
    exchange.SetMarginLevel(M)
    currency=exchange.GetCurrency()
    if _G('buyp') and _G('sellp'):
        buyp=_G('buyp')
        sellp=_G('sellp')
        Log('读取网格价格')
    else:
        ticker=exchange.GetTicker()
        buyp=ticker["Last"]-grid
        sellp=ticker["Last"]+grid
        _G('buyp',buyp)
        _G('sellp',sellp)
        Log('网格数据初始化')
    while True:
        account=exchange.GetAccount()
        ticker=exchange.GetTicker()
        position=exchange.GetPosition()
        orders=exchange.GetOrders()
        if len(position)==0:
            if ticker["Last"]>upper:
                exchange.SetDirection('sell')
                exchange.Sell(-1,n1*H)
                Log(currency,'到达开空区域,买入空头底仓')
                
            else:
                exchange.SetDirection('buy')
                exchange.Buy(-1,n1*H)
                Log(currency,'到达开多区域,买入多头底仓')
        if len(position)==1:
            if position[0]["Type"]==1: #持有空头仓位
                if ticker["Last"]<bottom:
                    Log(currency,'空单全部止盈反手')
                    exchange.SetDirection('closesell')
                    exchange.Buy(-1,position[0].Amount)
                else: 
                    orders=exchange.GetOrders()
                    if len(orders)==0: 
                        exchange.SetDirection('sell')
                        exchange.Sell(sellp,n1)
                        exchange.SetDirection('closesell')
                        exchange.Buy(buyp,n1)
                    if len(orders)==1:
                        if orders[0]["Type"]==1: #止盈成交
                            Log(currency,'网格减仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp-grid
                            sellp=sellp-grid
                            LogProfit(account["Balance"])
                        if orders[0]["Type"]==0:
                            Log(currency,'网格加仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp+grid
                            sellp=sellp+grid
                            LogProfit(account["Balance"])
        
            if position[0]["Type"]==0:
                if ticker["Last"]>float(upper):
                    Log(currency,'多单全部止盈反手')
                    exchange.SetDirection('closebuy')
                    exchange.Sell(-1,position[0].Amount)
                else:
                    orders=exchange.GetOrders()
                    if len(orders)==0:
                        exchange.SetDirection('buy')
                        exchange.Buy(buyp,n1)
                        exchange.SetDirection('closebuy')
                        exchange.Sell(sellp,n1)
                    if len(orders)==1:
                        if orders[0]["Type"]==0: #止盈成交
                            Log(currency,'网格减仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp+grid
                            sellp=sellp+grid
                            LogProfit(account["Balance"])
                        if orders[0]["Type"]==1:
                            Log(currency,'网格加仓,当前份数:',position[0].Amount)
                            CancelPendingOrders()
                            buyp=buyp-grid
                            sellp=sellp-grid
                            LogProfit(account["Balance"])

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

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

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

স্পট: ডায়নামিক গ্রিড কৌশল

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

মূল বৈশিষ্ট্য

1. গতিশীল মেশ নোড জেনারেশন：

   • বাজার মূল্য পূর্ববর্তী গ্রিড নোড অতিক্রম করে এবং ওঠানামার পরিসর পূর্বনির্ধারিত পরিসর অতিক্রম করে (দ্বারা_GridPointDisনিয়ন্ত্রণ), কৌশলটি নতুন গ্রিড নোড তৈরি করে।
   • প্রতিটি গ্রিড নোড বর্তমান মূল্য এবং অবস্থানের তথ্য রেকর্ড করে এবং সমাপনী শর্ত নির্ধারণ করে (দ্বারা_GridCovDisনিয়ন্ত্রিত ক্লোজিং স্প্রেড)।

2. ক্রয়-বিক্রয় কার্যক্রম：

   • দীর্ঘ দিকনির্দেশনা（direction = 1): যখন দাম বেড়ে যায় এবং গ্রিড নোড ভেঙে যায়, তখন আপনার কাছে থাকা সম্পদগুলি বিক্রি করুন; যখন এটি আবার পড়ে যায়, তখন আবার কিনুন।
   • সংক্ষিপ্ত দিকনির্দেশনা（direction = -1): যখন দাম পড়ে এবং গ্রিড নোড ভেঙে যায়, তখন সম্পদটি কিনুন; যখন এটি পুনরুজ্জীবিত হয়, তখন রাখা সম্পদটি বিক্রি করুন।

3. বন্ধের কাজ：

   • যখন দাম নির্ধারিত সমাপনী মূল্যে পৌঁছায় (_GridCovDisসেট করুন), পজিশন ক্লোজিং সম্পূর্ণ করার জন্য বর্তমান দিক অনুসারে বাইব্যাক (যখন দীর্ঘ সময় ধরে চলছে) অথবা বিক্রয় (যখন সংক্ষিপ্ত সময় চলছে) অপারেশন সম্পাদন করুন।

4. জালের পরিমাণ নিয়ন্ত্রণ：

   • যদি গ্রিড নোডের সংখ্যা সর্বোচ্চ সেটিং মান অতিক্রম করে (_GridNum), কৌশলটি স্বয়ংক্রিয়ভাবে প্রথম দিকের গ্রিড নোডটি মুছে ফেলবে, যার ফলে অতিরিক্ত অবস্থান রোধ হবে এবং ঝুঁকি হ্রাস পাবে।

কোর লজিক

1. আরম্ভের পরামিতি：

   • _GridNum: গ্রিড নোডের সর্বাধিক সংখ্যা, নিয়ন্ত্রণ কৌশল একই সময়ে ধরে রাখার জন্য সর্বোচ্চ সংখ্যক গ্রিড নোড।
   • _GridPointAmount: প্রতিটি গ্রিড নোডের অর্ডার পরিমাণ।
   • _GridPointDis: গ্রিড নোডের মধ্যে মূল্য ব্যবধান।
   • _GridCovDis: একটি পজিশন বন্ধ করার সময় মূল্যের পার্থক্য। যখন বাজার মূল্য এবং গ্রিড মূল্যের মধ্যে ওঠানামা এই মূল্যের পার্থক্যকে ছাড়িয়ে যায়, তখন পজিশনটি বন্ধ হয়ে যাবে।

2. আপডেটগ্রিড ফাংশন：

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

3. প্রধান লুপ：

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

কৌশল কোড (পাইথন স্পট এবং অঙ্কন টেমপ্লেটের রেফারেন্স প্রয়োজন)

'''backtest
start: 2024-04-01 00:00:00
end: 2024-09-23 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Binance","currency":"ETH_USDT"}]
'''

direction = 1  # 网格方向：1表示向上，-1表示向下
_GridNum = 10  # 网格节点数量
_GridPointAmount = 0.1  # 每个网格节点的下单量
_GridPointDis = 100  # 网格节点之间的价格间距
_GridCovDis = 150  # 平仓价与网格节点的差距
_Grid = []  # 网格数据列表

def UpdateGrid(nowBidsPrice, nowAsksPrice, direction):  # up 1, down -1
    global _Grid

    # 检查是否需要创建新的网格节点
    if len(_Grid) == 0 or (direction == 1 and nowBidsPrice - _Grid[-1]['price'] > _GridPointDis) or \
            (direction == -1 and _Grid[-1]['price'] - nowAsksPrice > _GridPointDis):
        
        if len(_Grid) == 0:
            Log('策略起始')
        if len(_Grid) != 0 and direction == 1 and nowBidsPrice - _Grid[-1]['price'] > _GridPointDis:
            Log('向上突破，突破阈值：', nowBidsPrice - _Grid[-1]['price'])
        if len(_Grid) != 0 and direction == -1 and _Grid[-1]['price'] - nowAsksPrice > _GridPointDis:
            Log('向下突破，突破阈值：', _Grid[-1]['price'] - nowAsksPrice)

        # 根据方向决定当前网格节点的价格
        nowPrice = nowBidsPrice if direction == 1 else nowAsksPrice
        _Grid.append({
            'price': nowPrice if len(_Grid) == 0 else _Grid[-1]['price'] + _GridPointDis * direction,
            'hold': {'price': 0, 'amount': 0},
            'coverPrice': (nowPrice - direction * _GridCovDis) if len(_Grid) == 0 else _Grid[-1]['price'] + _GridPointDis * direction - direction * _GridCovDis
        })

        Log('网格更新数量：', len(_Grid), '网格最新增添：', _Grid[-1])

        # 下单操作，向上突破时卖出，向下突破时买入
        tradeInfo = ext.Sell(_GridPointAmount) if direction == 1 else ext.Buy(_GridPointAmount)
        _Grid[-1]['hold']['price'] = tradeInfo['price']
        _Grid[-1]['hold']['amount'] = tradeInfo['amount']

        Log('网格操作：', '向上卖出' if direction == 1 else '向下买入')

    # 检查是否需要平仓
    if len(_Grid) > 0 and (
            (direction == 1 and nowAsksPrice < _Grid[-1]['coverPrice']) or 
            (direction == -1 and nowBidsPrice > _Grid[-1]['coverPrice'])):

        coverInfo = ext.Buy(_Grid[-1]['hold']['amount']) if direction == 1 else ext.Sell(_Grid[-1]['hold']['amount'])
        Log('价格跌破平仓价格，买入，去除最后添加网格' if direction == 1 else '价格突破平仓价格，卖出，去除最后添加网格')

        _Grid.pop()  # 移除已平仓的网格节点
    
    # 如果网格数量超出设定值，则平掉最早的网格节点
    elif len(_Grid) > _GridNum:
        coverFirstInfo = ext.Buy(_Grid[0]['hold']['amount']) if direction == 1 else ext.Sell(_Grid[0]['hold']['amount'])
        Log('网格数量过多，买入操作，去除初始网格' if direction == 1 else '网格数量过多，卖出操作，去除初始网格')
        _Grid.pop(0)

def main():
    global _Grid
    while True:
        ticker = _C(exchange.GetTicker)
        records = _C(exchange.GetRecords)
        ext.PlotRecords(records, "kline")
        UpdateGrid(ticker['Buy'], ticker['Sell'], direction)

        # 记录当前网格状态
        msg = ""
        for grid in _Grid:
            msg += str(grid) + "\n"
        
        LogStatus(_D(), _C(exchange.GetAccount), "\n", "_Grid.length:", len(_Grid), "_GridNum:", _GridNum, "\n", msg)
        Sleep(500)

নোটঃ

1. গ্রিড জেনারেশন প্রক্রিয়াটি সকলকে বুঝতে সাহায্য করার জন্য, কোডটিতে অনেক মন্তব্য যোগ করা হয়, যা প্রকৃত প্রয়োগে মুছে ফেলা যেতে পারে।
2. ট্রেডিং সহজতর করার জন্য, স্পট কৌশলটি স্পট টেমপ্লেট ট্রেডিং লাইব্রেরি ব্যবহার করে। এটি সম্পর্কে জানতে আপনি সোর্স কোডটি পর্যবেক্ষণ করতে পারেন।
3. বাস্তব ট্রেডিংয়ের ক্ষেত্রে প্রয়োগ করলে, বিভিন্ন এক্সচেঞ্জের বৈশিষ্ট্য অনুসারে এটি উন্নত করা প্রয়োজন।

ফিউচার: দীর্ঘ-সংক্ষিপ্ত দ্বিমুখী গ্রিড কৌশল

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

মূল বৈশিষ্ট্য

1. দীর্ঘ এবং সংক্ষিপ্ত মোড: দাম বাড়ুক বা কমুক না কেন, কৌশলটি সংশ্লিষ্ট দিকে কাজ করে লাভ অর্জন করতে পারে।
2. ডায়নামিক পজিশনের পরিবর্তন：প্রাথমিক মূল্য থেকে মূল্য বিচ্যুতির অনুপাতের উপর ভিত্তি করে লক্ষ্য অবস্থান গণনা করুন
3. দ্বিমুখী গ্রিড ক্রম: উভয় দিকের দামের ওঠানামা ক্যাপচার করার জন্য একই সময়ে ক্রয় এবং বিক্রয় অর্ডার সেট করুন।
4. ঝুঁকি নিয়ন্ত্রণ： যুক্তিসঙ্গত অবস্থান ব্যবস্থাপনা এবং শৃঙ্খলা নিয়ন্ত্রণের মাধ্যমে একতরফা ঝুঁকি হ্রাস করুন

কৌশল যুক্তি

কৌশলটির মূল যুক্তি হল মূল্য এবং প্রাথমিক মূল্যের মধ্যে বিচ্যুতির মাত্রার উপর ভিত্তি করে লক্ষ্য অবস্থান নির্ধারণ করা:

• যখন দাম বাড়ে, তখন লক্ষ্য অবস্থান নেতিবাচক (সংক্ষিপ্ত) হয়, এবং দাম যত বাড়ে, শর্ট অবস্থান তত বড় হয়।
• যখন দাম পড়ে, তখন লক্ষ্য অবস্থানটি ইতিবাচক (দীর্ঘ) থাকে। দাম যত বেশি পড়ে, লং পজিশন তত বড় হয়।
• গ্রিড অর্ডার কার্যকর করার মাধ্যমে ধীরে ধীরে প্রকৃত অবস্থানকে লক্ষ্য অবস্থানের সাথে সামঞ্জস্য করুন।

নীতি কোড

”`python import time import math

全局变量初始化

InitPrice = 800 Funding = 50000

策略参数（需要在策略页面设置）

pct = 5.0 # 网格间距百分比 value = 5000 # 每个网格的投入金额 Interval = 3 # 策略执行间隔（秒）

账户资产信息

assets = { ‘USDT’: { ‘total_balance’: 0, ‘margin_balance’: 0, ‘margin’: 0, ‘unrealised_profit’: 0 } }

def init(): “”“初始化策略”“” global symbol, Funding, base_currency

Log('交易模式：多空都做')

# 设置合约类型
exchange.SetContractType('swap')

# 获取交易币种
currency = exchange.GetCurrency()
symbol = currency  # 保持原格式，如 "BTC_USDT"
base_currency = symbol.split('_')[0]  # 获取基础币种，如 "BTC"
Log('交易币种：', symbol)
Log('基础币种：', base_currency)

swapcode = symbol + '.swap'
ticker = exchange.GetTicker(swapcode)  # 回测系统需要
exchange_info = exchange.GetMarkets()
data = exchange_info.get(swapcode)

# 初始化资产信息
assets[base_currency] = {
    'amount': 0,
    'price': 0,
    'hold_price': 0,
    'price': 0,
    'unrealised_profit': 0,
    'leverage': 20,
    'liquidation_price': 0,
    'AmountPrecision': data['AmountPrecision'],
    'PricePrecision': data['PricePrecision'],
    'MinQty': data['MinQty']
}

# 撤销所有挂单
cancel_all_orders()

# 获取初始资金
account = exchange.GetAccount()
if account:
    Funding = account.Balance + account.FrozenBalance
    Log('初始资金：', Funding)

def calculate_grid_orders(): “”“计算网格订单”“” if InitPrice == 0 or assets[base_currency][‘price’] == 0: return None

current_price = assets[base_currency]['price']
current_amount = assets[base_currency]['amount']

# 多空都做模式：根据价格变化计算目标持仓
price_change_ratio = (current_price - InitPrice) / InitPrice
target_amount = -price_change_ratio * (value / pct) / current_price

# 计算买卖价格
grid_spacing = current_price * (pct / 100)  # 网格间距
buy_price = current_price - grid_spacing
sell_price = current_price + grid_spacing

# 计算订单数量
order_amount = value / current_price

return {
    'buy_price': round(buy_price, assets[base_currency]['PricePrecision']),
    'sell_price': round(sell_price, assets[base_currency]['PricePrecision']),
    'buy_amount': round(order_amount, assets[base_currency]['AmountPrecision']),
    'sell_amount': round(order_amount, assets[base_currency]['AmountPrecision']),
    'target_amount': target_amount
}

def execute_strategy(): “”“执行交易策略”“” # 计算网格订单 grid_info = calculate_grid_orders() if not grid_info: return

current_amount = assets[base_currency]['amount']
target_amount = grid_info['target_amount']
amount_diff = target_amount - current_amount

# 如果持仓偏离较大，先调整持仓
if abs(amount_diff) > assets[base_currency]['MinQty']:
    cancel_all_orders()
    Sleep(500)

    # 判断需要的操作
    if amount_diff > 0:
        # 需要增加多头持仓或减少空头持仓
        if current_amount >= 0:
            # 当前是多头或空仓，直接开多
            Log(f'当前持仓：{current_amount}，需要开多：{abs(amount_diff):.6f}')
            open_position('LONG', assets[base_currency]['price'], abs(amount_diff))
        else:
            # 当前是空头，需要先平空再开多
            if abs(amount_diff) <= abs(current_amount):
                # 只需要平掉部分空仓
                Log(f'当前空仓：{current_amount}，需要平仓：{abs(amount_diff):.6f}')
                safe_close_position(abs(amount_diff), assets[base_currency]['price'])
            else:
                # 需要平掉所有空仓，然后开多
                Log(f'平掉所有空仓：{abs(current_amount):.6f}')
                if safe_close_position(abs(current_amount), assets[base_currency]['price']):
                    Sleep(1000)  # 等待平仓完成

                    # 更新持仓信息
                    update_account()
                    remaining_amount = abs(amount_diff) - abs(current_amount)
                    if remaining_amount > assets[base_currency]['MinQty']:
                        Log(f'开多剩余数量：{remaining_amount:.6f}')
                        open_position('LONG', assets[base_currency]['price'], remaining_amount)

    elif amount_diff < 0:
        # 需要增加空头持仓或减少多头持仓
        if current_amount <= 0:
            # 当前是空头或空仓，直接开空
            Log(f'当前持仓：{current_amount}，需要开空：{abs(amount_diff):.6f}')
            open_position('SHORT', assets[base_currency]['price'], abs(amount_diff))
        else:
            # 当前是多头，需要先平多再开空
            if abs(amount_diff) <= current_amount:
                # 只需要平掉部分多仓
                Log(f'当前多仓：{current_amount}，需要平仓：{abs(amount_diff):.6f}')
                safe_close_position(abs(amount_diff), assets[base_currency]['price'])
            else:
                # 需要平掉所有多仓，然后开空
                Log(f'平掉所有多仓：{current_amount:.6f}')
                if safe_close_position(current_amount, assets[base_currency]['price']):
                    Sleep(1000)  # 等待平仓完成

                    # 更新持仓信息
                    update_account()
                    remaining_amount = abs(amount_diff) - current_amount
                    if remaining_amount > assets[base_currency]['MinQty']:
                        Log(f'开空剩余数量：{remaining_amount:.6f}')
                        open_position('SHORT', assets[base_currency]['price'], remaining_amount)

# 检查是否需要重新挂网格单
orders = exchange.GetOrders()
if not orders or len(orders) < 2:  # 多空都做模式需要2个订单
    cancel_all_orders()
    Sleep(500)

    # 重新获取最新持仓信息
    update_account()
    current_amount = assets[base_currency]['amount']

    # 挂买单和卖单（网格订单）
    buy_amount = grid_info['buy_amount']
    sell_amount = grid_info['sell_amount']

    # 多空都做模式：无论当前持仓如何，都要挂多空双向网格单
    place_grid_orders(current_amount, grid_info, buy_amount, sell_amount)

def place_grid_orders(current_amount, grid_info, buy_amount, sell_amount): “”“放置网格订单 - 多空都做模式”“” Log(f’放置网格订单 - 当前持仓：{current_amount}‘)

# 多空都做模式：无论当前持仓如何，都要挂多空双向网格单
Log(f'多空都做模式 - 挂开多单：数量={buy_amount:.6f}，价格={grid_info["buy_price"]}')
open_position('LONG', grid_info['buy_price'], buy_amount)
Sleep(200)
Log(f'多空都做模式 - 挂开空单：数量={sell_amount:.6f}，价格={grid_info["sell_price"]}')
open_position('SHORT', grid_info['sell_price'], sell_amount)

def cancel_all_orders(): “”“撤销所有未成交订单”“” try: orders = exchange.GetOrders() if orders: for order in orders: exchange.CancelOrder(order[‘Id’]) Sleep(100) # 避免频繁操作 return True except Exception as e: Log(‘撤单异常：’, str(e)) return False

def get_real_position(): “”“获取真实持仓信息”“” try: positions = exchange.GetPosition() if positions: for pos in positions: if pos[‘ContractType’] == ‘swap’ and pos[‘Amount’] > 0: position_amount = pos[‘Amount’] * (1 if pos[‘Type’] == 0 else -1) return position_amount, pos[‘Price’], pos[‘Profit’]

    return 0, 0, 0
except Exception as e:
    Log('获取持仓异常：', str(e))
    return 0, 0, 0

def update_account(): “”“更新账户信息”“” try: account = exchange.GetAccount() if not account: Log(‘获取账户信息失败’) return False

    # 更新USDT资产信息
    assets['USDT']['total_balance'] = account.Balance + account.FrozenBalance
    assets['USDT']['margin_balance'] = account.Balance

    # 获取真实持仓信息
    position_amount, hold_price, profit = get_real_position()
    assets[base_currency]['amount'] = position_amount
    assets[base_currency]['hold_price'] = hold_price
    assets[base_currency]['unrealised_profit'] = profit

    return True
except Exception as e:
    Log('更新账户异常：', str(e))
    return False

def update_price(): “”“更新行情价格”“” global InitPrice

ticker = exchange.GetTicker()
if not ticker:
    Log('获取行情失败')
    return False

# 设置初始价格
if InitPrice == 0:
    InitPrice = ticker.Last
    Log('设置初始价格：', InitPrice)

assets[base_currency]['price'] = ticker.Last
return True

def create_order(side, price, amount, order_type=“开仓”): “”“使用CreateOrder下单函数”“” try: if amount <= 0: Log(f’订单数量无效：{amount}‘) return False

    # 构造期货合约symbol
    contract_symbol = f"{symbol}.swap"

    # 下单
    order_id = exchange.CreateOrder(contract_symbol, side, price, amount)

    if order_id:
        Log(f'{order_type} {side} 下单成功：价格={price}, 数量={amount}, 订单ID={order_id}')
        return order_id
    else:
        Log(f'{order_type} {side} 下单失败：价格={price}, 数量={amount}')
        return False

except Exception as e:
    Log('下单异常：', str(e))
    return False

def safe_close_position(close_amount, price=-1): “”“安全平仓函数”“” try: if close_amount <= 0: Log(f’平仓数量无效：{close_amount}‘) return False

    # 实时获取持仓信息
    current_position, _, _ = get_real_position()

    # 检查是否真的有持仓
    if current_position == 0:
        Log('当前无持仓，跳过平仓操作')
        return False

    # 检查平仓数量是否超过持仓
    if abs(close_amount) > abs(current_position):
        Log(f'平仓数量超过持仓：持仓{current_position}，平仓{close_amount}，调整为持仓数量')
        close_amount = abs(current_position)

    # 根据当前持仓方向确定平仓操作
    if current_position > 0:  # 当前是多仓
        side = "closebuy"  # 平多仓
        Log(f'平多仓：数量={close_amount}，价格={price}')
    else:  # 当前是空仓
        side = "closesell"  # 平空仓
        Log(f'平空仓：数量={close_amount}，价格={price}')

    return create_order(side, price, close_amount, "平仓")

except Exception as e:
    Log('平仓异常：', str(e))
    return False

def open_position(direction, price, amount): “”“开仓函数”“” try: if amount <= 0: Log(f’开仓数量无效：{amount}‘) return False

    # 确定开仓方向
    if direction == 'LONG':
        side = "buy"  # 开多仓
        Log(f'开多仓：数量={amount}，价格={price}')
    else:  # SHORT
        side = "sell"  # 开空仓
        Log(f'开空仓：数量={amount}，价格={price}')

    return create_order(side, price, amount, "开仓")

except Exception as e:
    Log('开仓异常：', str(e))
    return False

def update_status(): “”“更新状态显示”“” try: if Funding > 0: current_balance = assets[‘USDT’][‘total_balance’] profit = current_balance - Funding profit_rate = (profit / Funding) * 100

        status_info = f"""

策略状态 - {symbol} 交易模式: 多空都做 当前价格: {assets[base_currency][‘price’]} 初始价格: {InitPrice} 持仓数量: {assets[base_currency][‘amount’]} 持仓价格: {assets[base_currency][‘hold_price’]} 账户余额: {current_balance:.4f} USDT 总收益: {profit:.4f} USDT ({profit_rate:.2f}%) 未实现盈亏: {assets[base_currency][‘unrealised_profit’]:.4f} USDT “”” LogStatus(status_info)

except Exception as e:
    Log('状态更新异常：', str(e))

def main(): “”“主函数”“” # 设置错误过滤 SetErrorFilter(“502: