თუ კრიპტო სიახლეებს ადევნებ თვალს, ალბათ გინახავს სათაურები იმის შესახებ, რომ ბლოკჩეინი (blockchain) „იფორკება“, უცებ ჩნდება ახალი coin-ები, ან ბირჟები დროებით აჩერებენ დეპოზიტებს. ბევრი მომხმარებლისთვის ეს ასე გამოიყურება: წესები ერთ ღამეში იცვლება და გაურკვეველია, უსაფრთხოა თუ არა მათი არსებული coin-ები. ამ გაიდში გაიგებ, სინამდვილეში რა არის ბლოკჩეინის fork და როგორ უკავშირდება ის საერთო ისტორიას, जिस पर ყველა node თანხმდება. განვიხილავთ soft fork-ებს და hard fork-ებს, რატომ ხდება ისინი და რა ტიპიური გავლენა აქვთ ბალანსებზე, wallet-ებზე და ტრეიდინგზე. ბოლოს კი უკვე გეცოდინება, როდის შეგიძლია fork-ი თითქმის არ შეიმჩნიო, როდის უნდა მიაქციო განსაკუთრებული ყურადღება და რა მარტივი ნაბიჯები დაგეხმარება, რომ უსაფრთხოდ დარჩე და თავიდან აიცილო ზედმეტი სტრესი ასეთ მოვლენების დროს.
სწრაფი შეჯამება: Fork-ები ერთი შეხედვით
შეჯამება
- Fork ხდება მაშინ, როცა ზოგი node ერთ წესებს მიჰყვება, სხვები – სხვას, რის შედეგადაც ჩნდება ჯაჭვის კონკურენტული ვერსიები.
- Soft fork ამკაცრებს წესებს, მაგრამ ინარჩუნებს თავსებადობას, ამიტომ ძველი node-ებიც იღებენ ახალ block-ებს და ჯაჭვი, როგორც წესი, მუდმივად არ იყოფა.
- Hard fork ცვლის წესებს ისე, რომ ისინი აღარ არის თავსებადი, რის გამოც ქსელი შეიძლება ორ ცალკე ჯაჭვად და ორ coin-ად გაიყოს.
- Soft fork-ის დროს მომხმარებლებს იშვიათად სჭირდებათ რაიმე ქმედება, გარდა wallet-ების განახლებისა და პროექტის ოფიციალური განცხადებების თვალყურის დევნებისა.
- Hard fork-ის დროს მომხმარებლებმა უნდა გადაამოწმონ, რომელი ჯაჭვის მხარდაჭერას აპირებენ მათი ბირჟები და wallet-ები და დააკრედიტებენ თუ არა ახალ coin-ებს.
- Fork-ები ხშირად იწვევს მოკლევადიან დაბნეულობას და ვოლატილობას (volatility), მაგრამ ასევე შეიძლება მოიტანოს მნიშვნელოვანი განახლებები ან ახალი მიმართულებები პროექტისთვის.
ძირითადი კონცეფცია: რა არის Fork ბლოკჩეინში (blockchain)?
ზოგად დონეზე, ბლოკჩეინი (blockchain) არის გაზიარებული ტრანზაქციების ჟურნალი, जिस पर ბევრი კომპიუტერი თანხმდება. Fork ხდება მაშინ, როცა ეს გაზიარებული ჟურნალი დროებით ან მუდმივად იყოფა ორ სხვადასხვა ვერსიად, რადგან ყველა ერთსა და იმავე წესებს ან ისტორიას აღარ მიჰყვება.
შეგიძლია წარმოიდგინო გზა, რომელიც უცებ ორ ბილიკად იყოფა: მანქანები, რომლებიც მარცხენა ბილიკს ირჩევენ, ერთ მარშრუტს მიჰყვებიან, ხოლო მარჯვენას – სხვას. ბლოკჩეინში ზოგი node ერთ კონსენსუსის წესებს მიჰყვება, სხვები – სხვას, ამიტომ ისინი სხვადასხვა block-ჯაჭვებს აგებენ.
ზოგჯერ fork-ები შემთხვევითია და ხანმოკლე – მაგალითად, როცა ორი miner თითქმის ერთდროულად პოულობს ვალიდურ block-ს. ქსელი სწრაფად ირჩევს ერთ block-ს მთავარ გზად და მეორეს უგულებელყოფს. სხვა დროს fork-ები განზრახ rule change-ებია: დეველოპერები და კომუნა აახლებენ software-ს, ამატებენ ფუნქციებს, ასწორებენ bug-ებს ან ცვლიან პოლიტიკას, და უთანხმოებამ შეიძლება გამოიწვიოს გრძელვადიანი გაყოფა.
- ქსელის დაგვიანებამ ან ლატენტურობამ შეიძლება გამოიწვიოს ის, რომ ორი miner ან validator თითქმის ერთდროულად აწარმოებს ვალიდურ block-ს, რაც დროებით ქმნის კონკურენტულ ტოტებს.
- დაგეგმილი პროტოკოლის განახლებები ამატებს ახალ ფუნქციებს ან აუმჯობესებს წარმადობას, რაც node-ების მიერ გამოყენებული წესების შეცვლას მოითხოვს.
- Bug-ების ან უსაფრთხოების ხარვეზების გასწორება ამკაცრებს იმას, თუ რა ითვლება ვალიდურ ტრანზაქციად ან block-ად, რათა ქსელი ცნობილ პრობლემებისგან დაიცვას.
- კომუნის უთანხმოება fee-ებზე, block-ის ზომაზე ან მონეტარულ პოლიტიკაზე იწვევს იმას, რომ სხვადასხვა ჯგუფი სხვადასხვა წესების ნაკრებს უჭერს მხარს.
- გადაუდებელმა რეაგირებამ hack-ებზე ან კრიტიკულ ექსპლოიტებზე შეიძლება გამოიწვიოს fork-ები, რომლებიც ცდილობენ ბოროტი ტრანზაქციების დაბრუნებას ან იზოლაციას.
- ექსპერიმენტული პროექტები ზოგჯერ არსებულ ჯაჭვს fork-ავენ, რათა გამოსცადონ ახალი ეკონომიკური მოდელები ან მმართველობის სისტემები ნულიდან დაწყების გარეშე.
როგორ ხდება Fork-ები ქსელის დონეზე
საჯარო ბლოკჩეინს (blockchain) ათასობით დამოუკიდებელი node მართავს, თითოეული ერთსა და იმავე კონსენსუსის წესებს ამუშავებს software-ის საშუალებით. სანამ ყველა ამ წესებზე თანხმდება, ისინი ერთსა და იმავე block-ებს იღებენ და ერთსა და იმავე ჯაჭვს ხედავენ.
როცა დეველოპერები უშვებენ ახალ software-ს შეცვლილი წესებით, თითოეული node-ის ოპერატორი თავად წყვეტს, როდის და განაახლოს თუ არა. თუ ზოგი node ახალ წესებს ამოქმედებს, სხვები კი ძველს ტოვებენ, შეიძლება უთანხმოება გაჩნდეს, რომელი block-ებია ვალიდური.
როგორც კი იქმნება block-ები, რომლებიც ერთ წესების ნაკრებში ვალიდურია, მეორეში – არა, ქსელი ფაქტობრივად იყოფა. ახალი software-ით მომუშავე node-ები ერთ ტოტს მიჰყვებიან, ძველი software-ით – მეორეს, და სწორედ ამ განსხვავებას ვუწოდებთ fork-ს.
- დეველოპერები ან კომუნის წევრები სთავაზობენ rule change-ს – მაგალითად, ახალ ფუნქციას, bug fix-ს ან პოლიტიკის კორექტირებას – და საჯაროდ განიხილავენ მას.
- შეთანხმების შემდეგ ისინი უშვებენ განახლებულ node software-ს, რომელიც ახალ კონსენსუსის წესებს კოდავს და ხშირად შეიცავს აქტივაციის block-ის სიმაღლეს ან დროს.
- Node-ების ოპერატორები, miner-ები და validator-ები წყვეტენ, დააყენონ თუ არა ახალი software, რის შედეგადაც ქსელში ჩნდება განახლებული და არაგანახლებული node-ების ნაზავი.
- როცა დგება აქტივაციის მომენტი, განახლებული node-ები იწყებენ ახალი წესების დაცვას, ხოლო ძველი node-ები კვლავ ძველ წესებს ამუშავებენ.
- თუ იქმნება block-ები, რომლებიც აკმაყოფილებენ ახალ წესებს, მაგრამ არღვევენ ძველს, ორი node-ჯგუფი ვერ თანხმდება და იწყებს სხვადასხვა ჯაჭვის მიყოლას.
- დროთა განმავლობაში ქსელი ან ისევ ერთ ჯაჭვზე იყრის თავს, როგორც ბევრ soft fork-ის შემთხვევაში, ან რჩება ორ ცალკე ჯაჭვად, როგორც დაპირისპირებულ hard fork-ებში.
Soft Fork-ები: უკუ-თავსებადი ცვლილებები წესებში
Soft fork არის წესების ცვლილება, რომელიც ვალიდური block-ებისა და ტრანზაქციების ნაკრებს უფრო შეზღუდულს ხდის, მაგრამ არ არღვევს თავსებადობას ძველ node-ებთან. ახალი block-ები უფრო მკაცრ წესებს ემორჩილება, მაგრამ მაინც ისეთ ფორმატშია, რომ ძველი software მათ ვალიდურად აღიქვამს.
ამ უკუ-თავსებადობის გამო, ქსელი ჩვეულებრივ ერთ მთავარ ჯაჭვს ინარჩუნებს და განახლების გარეშე დარჩენილი node-ებიც აგრძელებენ მის მიყოლას, თუნდაც ყველა ახალ ფუნქციას ვერ იგებდნენ. მთავარი ის არის, რომ miner-ების ან validator-ების უმრავლესობა ახალ, უფრო მკაცრ წესებს ამტკიცებს.
რიგითი მომხმარებლებისთვის soft fork-ები ხშირად ჩვეულებრივ განახლებებად იგრძნობა. შეიძლება დაგჭირდეს wallet-ის განახლება, რომ გამოიყენო ახალი ფუნქციები ან აირიდო იშვიათი პრობლემები, მაგრამ, როგორც წესი, არ ჩნდება ახალი coin-ი და არც ორ ჯაჭვს შორის არჩევა გიწევს.
- Soft fork-ები, როგორც წესი, ზღუდავს იმაზე, რა არის დაშვებული – მაგალითად, ამკაცრებს script-ის წესებს ან ზღუდავენ block-ის შიგთავსს – ისე, რომ ყველა ახალი block მაინც ვალიდურად გამოიყურებოდეს ძველი node-ებისთვის.
- რადგან ძველი node-ები იღებენ განახლებული miner-ების მიერ შექმნილ block-ებს, ჯაჭვი ჩვეულებრივ არ იყოფა ორ გრძელვადიან ვერსიად.
- Bitcoin-ის SegWit განახლება 2017 წელს იყო soft fork, რომელმაც შეცვალა ხელმოწერების შენახვის ფორმა, გაზარდა გამტარუნარიანობა და გამოასწორა ტრანზაქციების მუტაბელურობა, თან ძველი node-ების თავსებადობა შეინარჩუნა.
- მომხმარებელთა უმეტესობამ SegWit უბრალოდ როგორც უფრო სწრაფი და იაფი ტრანზაქციები იგრძნო, მას შემდეგ რაც მათი wallet-ები და ბირჟები ახალ ფორმატზე გადავიდნენ, ახალი coin-ების მოთხოვნის გარეშე.
- Soft fork-ები ხშირად გამოიყენება ეტაპობრივი გაუმჯობესებებისთვის, როცა კომუნა ძირითადად თანხმდება მიმართულებაზე და სურს disruptive გაყოფის თავიდან აცილება.
Pro Tip:Soft fork-ები იშვიათად ქმნის „უფასო coin-ებს“ ან გაძალებენ, რომ მხარე აირჩიო. თუ შენი თანხები უსაფრთხო, კარგად მოვლილ wallet-შია, ჩვეულებრივ საკმარისია software-ის განახლება და პროექტის ოფიციალური განცხადებების მიყოლა.
Hard Fork-ები: არათავსებადი გაყოფები და ახალი ჯაჭვები
Hard fork არის წესების ცვლილება, რომელიც უკუ-თავსებადი აღარ არის – ანუ block-ები, რომლებიც ახალ წესებს ემორჩილება, უარყოფილია იმ node-ების მიერ, რომლებიც ძველ software-ს იყენებენ. ორი node-ჯგუფი ვეღარ თანხმდება, რა ითვლება ვალიდურ block-ად.
თუ ყველა განახლდება, ქსელი უბრალოდ ახალ წესებზე გადადის და გრძელვადიანი გაყოფა არ ხდება. მაგრამ თუ მნიშვნელოვანი ნაწილი უარს ამბობს განახლებაზე, ბლოკჩეინი (blockchain) შეიძლება ორ ცალკე ჯაჭვად გაიყოს, თითოეული საკუთარი წესებითა და ისტორიით fork-ის წერტილიდან მოყოლებული.
ამ ჯაჭვებს ხშირად სხვადასხვა სახელები და ტიკერები ეძლევა – მაგალითად, Bitcoin (BTC) და Bitcoin Cash (BCH) ან Ethereum (ETH) და Ethereum Classic (ETC). მომხმარებლებისთვის ეს შეიძლება ნიშნავდეს გაორებულ ბალანსებს fork-ის block-ზე, ახალ coin-ებს და დაბნეულობას, რომელი ჯაჭვი უჭირავთ მხარს ბირჟებსა და wallet-ებს.
- დაპირისპირებულ hard fork-ს შეუძლია შექმნას ორი გრძელვადიანი ჯაჭვი, თითოეული საკუთარი კომუნით, განვითარების roadmap-ით და ბრენდინგით.
- Fork-ის block-ზე ბალანსები ხშირად ორმაგდება, ამიტომ holder-ებს შეიძლება ორივე ჯაჭვზე ჰქონდეთ coin-ები, იმ პირობით, რომ მათი wallet-ები და ბირჟები მათ მხარს უჭერენ.
- პროექტები, როგორც წესი, ერთ ან ორივე ჯაჭვს ახალ სახელებსა და ტიკერებს არქმევენ, რათა ისინი ბაზრებზე და ბირჟებზე ერთმანეთისგან განასხვავონ.
- ბირჟებმა შეიძლება დროებით შეაჩერონ დეპოზიტები და გამოტანები fork-ის დროს, შემდეგ კი გადაწყვიტონ, რომელი ჯაჭვი ჩამოითვალონ, ან ორივე ჩამოთვალონ ცალკე ტიკერებით.
- Wallet-ების პროვაიდერებმა უნდა აირჩიონ, რომელი ჯაჭვის მხარდაჭერა იყოს ნაგულისხმევი და შესაძლოა სპეციალური ინსტრუმენტებიც დაამატონ, რომ მომხმარებლებმა მეორე ჯაჭვზე coin-ებსაც მიაღწიონ.
- სიახლეები, სოციალური მედია და ფასების ვოლატილობა (volatility) ღონისძიების გარშემო ქმნის მოკლევადიან დაბნეულობას და შესაძლებლობებს როგორც მოგებისთვის, ისე scam-ებისთვის.
Pro Tip:არ იფიქრო, რომ ყოველი hard fork ავტომატურად ნიშნავს უფასო ფულს. ახალ ჯაჭვს გრძელვადიანი ღირებულება მხოლოდ მაშინ უჩნდება, თუ ის რეალურ მომხმარებლებს, დეველოპერებს და ბირჟების მხარდაჭერას იზიდავს, ამიტომ ბევრი fork-ით მიღებული coin-ი არალიკვიდური რჩება ან საერთოდ ქრება საწყისი აჟიოტაჟის მიუხედავად.
Soft Fork vs Hard Fork: მთავარი განსხვავებები მომხმარებლებისთვის
როგორც soft fork, ისე hard fork არის ბლოკჩეინის (blockchain) წესების შეცვლის გზა, მაგრამ ისინი სრულიად განსხვავებულად იქცევიან, როცა ცოცხალ ქსელში ამოქმედდებიან. საკვანძო კითხვა ასეთია: შეძლებენ თუ არა ძველი node-ები ჯაჭვის მიყოლას ცვლილების შემდეგ.
Soft fork-ები ერთ მთავარ ჯაჭვს ინარჩუნებენ და უკუ-თავსებადობაზეა ორიენტირებული, ამიტომ მომხმარებელთა უმეტესობა ამას ჩვეულებრივ განახლებად აღიქვამს. Hard fork-ებმა შეიძლება დაარღვიოს თავსებადობა, დატოვოს ორი ჯაჭვი, ორი coin-ი და არჩევანის მთელი ნაკრები wallet-ებისთვის, ბირჟებისთვის და holder-ებისთვის.
Key facts
თავსებადობა ძველ node-ებთან
Soft fork: ახალი block-ები მაინც ვალიდურად გამოიყურება ძველი node-ებისთვის. Hard fork: ძველი node-ები უარყოფენ ახალ block-ებს, რაც უთანხმოებას იწვევს.
ჯაჭვის უწყვეტობა
Soft fork: ჩვეულებრივ ინარჩუნებს ერთ მთავარ ჯაჭვს, დროებითი fork-ები სწრაფად წყდება. Hard fork: შეიძლება ორ მუდმივ ჯაჭვად დასრულდეს, თუ ჯგუფები ვერ თანხმდებიან.
მომხმარებლის გამოცდილება
Soft fork: გრძნობა ჰგავს სტანდარტულ განახლებას, ხილული ცვლილებები ძირითადად ახალ ფუნქციებს ეხება. Hard fork: მომხმარებლებმა შეიძლება ნახონ ტრეიდინგის შეჩერება, ახალი ტიკერები და გაორებული ბალანსები.
განახლების საჭიროება
Soft fork: miner-ებმა და validator-ებმა უნდა შეათანხმონ ქმედებები; მომხმარებლებმა დროთა განმავლობაში უნდა განაახლონ wallet-ები. Hard fork: ყველა მონაწილემ უნდა აირჩიოს, რომელი წესების მიყოლა სურს და შესაბამისად განაახლოს software.
coin-ების გაყოფა და ახალი აქტივები
Soft fork: ჩვეულებრივ არ ჩნდება ახალი coin-ი, მხოლოდ გაუმჯობესებული წესები. Hard fork: შეიძლება შექმნას ახალი coin-ი ახალ ჯაჭვზე, ბაზრისა და კომუნის მხარდაჭერაზე დამოკიდებულებით.
ხშირი მაგალითები
Soft fork: Bitcoin SegWit, Taproot. Hard fork: Bitcoin Cash – Bitcoin-იდან, Ethereum Classic – Ethereum-იდან DAO-ის hack-ის შემდეგ.
SegWit-ის დროს Bitcoin-ის მომხმარებელთა უმეტესობამ უბრალოდ wallet-ები განაახლა და ტრანზაქციებს ჩვეულებრივ აგრძელებდა. Bitcoin Cash-ის hard fork-ის დროს ბირჟებმა დროებით შეაჩერეს სერვისები, გაჩნდა ახალი BCH ბალანსები და holder-ებს უნდა გადაეწყვიტათ, დაეტოვებინათ, გაეყიდათ თუ დაეიგნორებინათ ახალი coin-ი.
ისტორიული მომენტები: ცნობილი ბლოკჩეინის (blockchain) Fork-ები
Fork-ები იშვიათი ხარვეზები არ არის; ისინი მთავარი შემობრუნების წერტილებია დიდი ბლოკჩეინების (blockchain) ისტორიაში. როცა კომუნები უთანხმოებას ან კრიზისს აწყდებიან, ჯაჭვის fork-ვა შეიძლება გახდეს გზა, რომლითაც მიმართულებას ირჩევენ. ზოგი fork, მაგალითად Bitcoin-ის SegWit განახლება, ჩუმად აუმჯობესებს სისტემას ზედმეტი დრამის გარეშე. სხვები, მაგალითად Ethereum-სა და Ethereum Classic-ს შორის გაყოფა, ასახავს ღრმა ფილოსოფიურ განსხვავებებსimmutability-ზე, მმართველობაზე და hack-ებზე რეაგირების გზებზე.
მთავარი პუნქტები
- 2013–2016: ადრეული Bitcoin soft fork-ები ეტაპობრივად ამკაცრებს წესებს და ამატებს ფუნქციებს, რაც აჩვენებს, რომ უკუ-თავსებადი განახლებები ჯაჭვის გაყოფის გარეშეა შესაძლებელი.
- 2016: DAO-ის hack-ის შემდეგ Ethereum-ზე, სადავო hard fork აბრუნებს hack-ს მთავარ ჯაჭვზე (ETH), ხოლო ოპონენტები ინარჩუნებენ ორიგინალ ჯაჭვს, როგორც Ethereum Classic (ETC).
- 2017: Bitcoin-ის კომუნა სკალირებაზე კამათობს; ერთი გზა SegWit soft fork-ს ამოქმედებს, ხოლო მეორე ჯგუფი უშვებს hard fork-ს, რომელიც ხდება Bitcoin Cash (BCH) უფრო დიდი block-ებით.
- 2017–2018: რამდენიმე Bitcoin Cash hard fork ხდება, მათ შორის BCH და BSV-ის გაყოფა, რაც აჩვენებს, როგორ შეუძლია განმეორებით უთანხმოებებს კომუნისა და ლიკვიდობის ფრაგმენტაცია.
- 2021: Bitcoin-ის Taproot soft fork აქტიურდება, აუმჯობესებს კონფიდენციალურობას და scripting-ის შესაძლებლობებს ფართო კონსენსუსით და მინიმალური მომხმარებლის შეწუხებით.
- გაგრძელებადია: ბევრი მცირე პროექტი იყენებს დაგეგმილ hard fork-ებს, როგორც განახლების განსაზღვრულ ეტაპებს, რათა მთელი კომუნა კოორდინირებულად გადავიდეს ახალ ვერსიაზე კონკურენტული ჯაჭვის დატოვების გარეშე.
ქეის სტადი / ისტორია
ამირი დისტანციური software ინჟინერია, რომელიც რეგულარულად ყიდულობს რამდენიმე ძირითად coin-ს dollar-cost averaging სტრატეგიით. ერთ დილას ის ხსნის სიახლეების feed-ს და ხედავს სათაურებს მოახლოებული hard fork-ის შესახებ იმ ქსელზე, რომლის coin-ებიც აქვს. ზოგი სტატია „უფასო coin-ებს“ ჰპირდება, სხვები ქაოსზე აფრთხილებენ და ამირი აცნობიერებს, რომ სინამდვილეში არ იცის, რა არის fork.
პანიკის ნაცვლად, ამირი ამას debugging-ის ამოცანასავით უდგება. კითხულობს პროექტის ოფიციალურ ბლოგს, ეცნობა ნეიტრალურ განმარტებას soft და hard fork-ებზე და შემდეგ შედის თავის მთავარ ბირჟაზე, რომ მათი fork-ის პოლიტიკა ნახოს. ბირჟა ხსნის, რომელი ჯაჭვის მხარდაჭერას გეგმავს და დააკრედიტებს თუ არა fork-ით მიღებულ coin-ებს.
ამირი თავისი ჰოლდინგების ნაწილს ბირჟიდან იმ wallet-ში გადაჰყავს, სადაც private key-ებს თავად აკონტროლებს, ყურადღებით ინახავს seed phrase-ს და შემდეგ აჩერებს ყველა ტრანსფერს fork-ის შემდეგამდე. როცა fork ხდება, მისი ბირჟა დროებით აჩერებს გამოტანებს, შემდეგ კი ხელახლა ხსნის სერვისს ახალი ტიკერით fork-ილი coin-ისთვის.
საბოლოოდ, ამირის თავდაპირველი ჰოლდინგები უსაფრთხოდ რჩება და ის იღებს ახალი coin-ის მცირე რაოდენობას. უფრო მნიშვნელოვანია ის, რომ ის სწავლობს: თუ გაიგებ, როგორ მუშაობს fork-ები, მაშინ საშიში სათაურები გადაიქცევა მარტივ checklist-ად – გადაამოწმე მხარდაჭერა, უზრუნველყავი wallet-ების უსაფრთხოება, მოერიდე ნაჩქარევ ტრეიდებს და ახალი coin-ები მხოლოდ სანდო ინსტრუმენტებით მოითხოვე.
რატომ არის Fork-ები მნიშვნელოვანი: რეალური მიზნები და შედეგები
გარედან Fork-ები შეიძლება მხოლოდ დრამად გამოიყურებოდეს, მაგრამ ისინი ასევე ძლიერი ინსტრუმენტებია ბლოკჩეინის (blockchain) მომავლის ფორმირებისთვის. ღია კოდის სისტემებში ნებისმიერს შეუძლია დააკოპიროს კოდი ან შესთავაზოს ახალი წესები, ხოლო fork-ები არის გზა, როგორ მოწმდება ეს იდეები რეალურ სამყაროში. დეველოპერები fork-ებს იყენებენ განახლებების გამოსაშვებად, bug-ების გასასწორებლად ან გადაუდებელ სიტუაციებზე რეაგირებისთვის. კომუნები მათ იყენებენ განსხვავებული ხედვების გამოსახატავად fee-ებზე, კონფიდენციალურობაზე ან მონეტარულ პოლიტიკაზე. ინვესტორები და მომხმარებლები ამ ყველაფერს გრძნობენ ახალი ფუნქციების, შეცვლილი სტიმულების ან სრულიად ახალი coin-ების სახით, რომლებიც ყურადღებისთვის იბრძვიან.
გამოყენების შემთხვევები
- სკალირების განახლებების დანერგვა, რომლებიც ცვლიან, როგორ ინახება ან ვალიდირდება მონაცემები, რათა ერთ block-ში მეტი ტრანზაქცია ჩაეტიოს ან fee-ები შემცირდეს.
- ახალი ფუნქციების დამატება – მაგალითად, გაუმჯობესებული scripting, smart contract-ის შესაძლებლობები ან კონფიდენციალურობის გაუმჯობესება – რომლებიც კონსენსუსის წესების ცვლილებას მოითხოვს.
- Hack-ებზე ან კრიტიკულ bug-ებზე რეაგირება – გადაწყვეტილება, დაბრუნდეს თუ არა კონკრეტული ტრანზაქციები თუ ჯაჭვი ხელუხლებელი დარჩეს, რაც ზოგჯერ კომუნის გაყოფას იწვევს.
- მმართველობის დავების გადაწყვეტა block-ის ზომაზე, fee-ს ბაზრებზე ან მონეტარულ პოლიტიკაზე – სხვადასხვა ფრაქციებს შეუძლიათ თავიანთი სასურველი წესები ცალკე ჯაჭვებზე განახორციელონ.
- პროტოკოლის ქცევის კორექტირება რეგულაციურ მოლოდინებთან ან შესაბამისობის მოთხოვნებთან უკეთესი შესაბამისობისთვის – მაგალითად, გარკვეული მისამართების შავ სიაში შეყვანა ან KYC-თან დაკავშირებული წესების გამკაცრება პროტოკოლის საზღვრებზე.
- ექსპერიმენტული ეკონომიკური მოდელების გაშვება – მაგალითად, განსხვავებული ინფლაციის გრაფიკები, staking-ის ჯილდოები ან საგანძურის (treasury) სისტემები – არსებული მომხმარებლის ბაზის სრულად მიტოვების გარეშე.
- გათვლილი, არადამოუკიდებელი hard fork-ების დაგეგმვა, როგორც განახლების ეტაპები, რათა მთელი კომუნა კოორდინირებულად გადავიდეს დიდ ვერსიის ცვლილებებზე.
პრაქტიკული გზამკვლევი: რა უნდა ქნა, როცა Fork მოდის?
Fork-ების უსაფრთხოდ გასავლელად არ არის საჭირო პროტოკოლის ინჟინერი იყო. ძირითადი სამუშაოს უმეტესობას დეველოპერები, miner-ები, validator-ები, ბირჟები და wallet-ების პროვაიდერები ასრულებენ.
მაინც, რამდენიმე მარტივ ჩვევას შეუძლია მნიშვნელოვნად შეამციროს შენი რისკი და სტრესი, როცა fork-ის შესახებ განცხადება ჩნდება. მოექეცი მას, როგორც დაგეგმილ სისტემურ ცვლილებას: შეაგროვე ინფორმაცია, უზრუნველყავი წვდომა და მოერიდე ზედმეტ მოძრაობებს, სანამ სიტუაცია არ გაირკვევა.
- წაიკითხე პროექტის ოფიციალური განცხადებები და ორი ნეიტრალური განმარტება, რომ გაიგო, fork არის soft თუ hard და რა მიზნები აქვს.
- შეამოწმე შენი ძირითადი ბირჟებისა და wallet-ების განცხადებები – რომელი ჯაჭვის მხარდაჭერას აპირებენ და დააკრედიტებენ თუ არა fork-ით მიღებულ coin-ებს.
- განაახლე შენი wallet-ის software ან აპლიკაცია უახლეს ვერსიამდე, რომ სწორად გაუმკლავდეს ახალ წესებს და აირიდოს ცნობილი bug-ები fork-ის გარშემო.
- იფიქრე იმაზე, რომ დროებით შეაჩერო დიდი ან არაგადაუდებელი ტრანსფერები fork-მდე და fork-ის დროს, როცა კონფირმაციები შეიძლება შენელდეს და support-გუნდები უფრო დაკავებული იყვნენ.
- ფრთხილად იყავი scam-ების მიმართ, რომლებიც გთხოვენ, რომ fork-ილი coin-ების „მოსათხოვნელად“ შეიყვანო შენი seed phrase ან private key – გამოიყენე მხოლოდ ის ინსტრუმენტები, რომლებსაც სანდო wallet-ების პროვაიდერები გირჩევენ.
- თუ გეგმავ coin-ების მოთხოვნას ორივე ჯაჭვზე, ჩაინიშნე snapshot block-ის სიმაღლე ან დრო და დარწმუნდი, რომ ამ მომენტში შენი თანხები იმ wallet-შია, სადაც key-ებს შენ აკონტროლებ.
- Fork-ის შემდეგ გადაამოწმე, რომ შენი ბალანსები სწორად ჩანს არჩეულ ჯაჭვზე, სანამ თანხებს გადაადგილებ ან აგრესიულ ტრეიდინგს დაიწყებ ახალ ბაზარზე.
Pro Tip:თუ არ ხარ დარწმუნებული, რა ქნა fork-ის დროს, ხშირად უფრო უსაფრთხოა არაფერი გააკეთო, ვიდრე სწრაფ ტრეიდებს დაედევნო. შეინახე თანხები უსაფრთხო wallet-ში, დაელოდე მკაფიო ინფორმაციას და იმოქმედე მხოლოდ სანდო პლატფორმების მეშვეობით.
რისკები და უსაფრთხოების საკითხები Fork-ების გარშემო
ძირითადი რისკ-ფაქტორები
Fork-ები ქმნის მოკლე პერიოდებს, როცა ბლოკჩეინის (blockchain) ჩვეულებრივი ვარაუდები შეიძლება დაირღვეს. ორი ჯაჭვი შეიძლება ერთსა და იმავე ისტორიას იზიარებდეს გარკვეულ წერტილამდე, ინსტრუმენტები შეიძლება სრულად არ უჭერდეს მხარს ორივეს, ხოლო scam-ერები კარგად იციან, რომ მომხმარებლები დაბნეულები არიან. ამ ფანჯრებში ტექნიკური პრობლემები, როგორიცაა replay attack-ები ან ჯაჭვის რეორგანიზაციები, შეიძლება გადაიკვეთოს ადამიანურ შეცდომებთან – მაგალითად, coin-ების გაგზავნასთან არამხარდაჭერილ ჯაჭვზე ან ყალბ claim-ინსტრუმენტებზე ნდობასთან. ძირითადი რისკების გაგება გეხმარება, იცნო მომენტები, როცა უნდა შეანელო ტემპი და ორჯერ გადაამოწმო შენი ქმედებები.
Primary Risk Factors
Replay attack-ები
თუ ორივე ჯაჭვი ერთსა და იმავე ტრანზაქციის ფორმატსა და ხელმოწერებს იღებს, ერთ ჯაჭვზე გაშვებული ტრანზაქცია შეიძლება დაკოპირდეს და „გაიმეოროს“ მეორეზე, რაც მოულოდნელად გადაადგილებს თანხებს, თუ replay protection არ არის დამატებული.
ჯაჭვის რეორგანიზაციები
Fork-ის გარშემო დროებითი კონკურენტული ტოტები და hash rate-ის გადანაცვლება შეიძლება გამოიწვიოს ჩვეულებრივზე უფრო ღრმა reorg-ები, როცა ახლახან დადასტურებული ტრანზაქციები სხვა ისტორიით იცვლება.
Scam-token-ები და ყალბი wallet-ები
თავდამსხმელები შეიძლება გაუშვან ძალიან მსგავსი coin-ები, wallet-ები ან claim-ინსტრუმენტები, რომლებიც fork-ილ coin-ებს ჰპირდებიან, მაგრამ სინამდვილეში იპარავენ private key-ებს, seed phrase-ებს ან არსებულ ბალანსებს.
ბირჟების გაყინვები და პოლიტიკის ცვლილებები
ბირჟები ხშირად აჩერებენ დეპოზიტებსა და გამოტანებს fork-ების დროს და მოგვიანებით შეიძლება გადაწყვიტონ, რომ ერთ ჯაჭვს საერთოდ არ დაუჭირონ მხარი, რის შედეგადაც მომხმარებლებს ამ პლატფორმიდან გარკვეულ fork-ილ აქტივებზე წვდომა აღარ ექნებათ.
შეცდომით ტრანსფერები არამხარდაჭერილ ჯაჭვებზე
მომხმარებლები ზოგჯერ აგზავნიან coin-ებს იმ ჯაჭვის მისამართზე, რომელსაც მათი wallet ან ბირჟა არ უჭერს მხარს, რის გამოც აღდგენა რთული ან შეუძლებელი ხდება რთული პროცედურების გარეშე.
ლიკვიდობა და ფასების ვოლატილობა (volatility)
ახლად fork-ილ coin-ებს შეიძლება ჰქონდეთ თხელი order book-ები და უკიდურესი ვოლატილობა (volatility), ამიტომ დიდი ტრეიდები ძლიერ ამოძრავებს ბაზარს ან ცუდ შესრულებას იღებს.
მოძველებული software
ძველი node-ის ან wallet-ის software-ის გამოყენებამ fork-ის დროს და შემდეგ შეიძლება გამოგაჩინოს bug-ების, არასწორი ბალანსების ან არასწორ ჯაჭვთან დაკავშირების რისკის ქვეშ. განახლებული software ამ რისკს ამცირებს.
უსაფრთხოების საუკეთესო პრაქტიკები
Fork-ების პლიუსები და მინუსები ბლოკჩეინში (blockchain)
პლიუსები
Fork-ები ხელს უწყობს სწრაფ ინოვაციას – დეველოპერებს შეუძლიათ ახალი ფუნქციების, წარმადობის გაუმჯობესებისა და უსაფრთხოების ფიქსების გამოშვება ერთხმოვანი თანხმობის მოლოდინის გარეშე.
ისინი აძლევს კომუნებს საშუალებას, სხვადასხვა ხედვა გამოხატონ – უმცირეს ჯგუფებს შეუძლიათ ალტერნატიულ ჯაჭვზე გააგრძელონ, ნაცვლად იმისა, რომ იძულებით დაემორჩილონ უმრავლესობას.
Hard fork-ებმა შეიძლება თავიდან ააწყონ ან შეაკეთონ დაზიანებული სისტემები დიდი hack-ების ან bug-ების შემდეგ, შეინარჩუნონ მომხმარებელთა თანხები და ნდობა მთავარ ჯაჭვში.
Fork-ილ ჯაჭვებს შორის კონკურენციამ შეიძლება გამოიწვიოს უკეთესი ინსტრუმენტები, დაბალი fee-ები და უფრო მოქნილი მმართველობა, რადგან პროექტები მომხმარებლების მოზიდვას ცდილობენ.
Fork-ის შესაძლებლობა მოქმედებს როგორც კონტროლი ცენტრალიზებულ ძალაზე – მომხმარებლებსა და დეველოპერებს ყოველთვის შეუძლიათ „გაეცალონ“, თუ გადაწყვეტილებებთან კატეგორიულად არ ეთანხმებიან.
მინუსები
Fork-ებმა შეიძლება დააფრაგმენტოს ლიკვიდობა და დეველოპერების ყურადღება, რის შედეგადაც ჩნდება რამდენიმე სუსტი ჯაჭვი ერთი ძლიერი ეკოსისტემის ნაცვლად.
ისინი ქმნის მომხმარებლის დაბნეულობას – რომელი ჯაჭვი არის „ნამდვილი“, რომელი ტიკერებია სანდო და როგორ უნდა მოექცნენ გაორებულ ბალანსებს.
მოკლევადიანმა ვოლატილობამ (volatility) და სპეკულაციამ fork-ების გარშემო შეიძლება გამოიწვიოს რისკიანი ტრეიდინგი და მოულოდნელი დანაკარგები გამოუცდელი მომხმარებლებისთვის.
ბრენდის განზავება ხდება, როცა რამდენიმე ჯაჭვი მსგავს სახელებს ან ტიკერებს იყენებს, რაც ახალბედებისთვის ართულებს იმის გაგებას, რას ყიდულობენ.
დაპირისპირებულ fork-ებს შეუძლია დააზიანოს კომუნის ნდობა და შექმნას ხანგრძლივი სოციალური განხეთქილებები, რომელთა შეხორცებაც რთულია.