FunC-ის ფუნქციონირებად გადაქცევა Haskell-თან ერთად: როგორ მოიგო Serokell-მა Telegram Blockchain-ის კონკურსი

თქვენ ალბათ გსმენიათ ეს Telegram აპირებს Ton blockchain პლატფორმის გაშვებას. მაგრამ თქვენ შეიძლება გამოგრჩეთ ახალი ამბები, რომ არც ისე დიდი ხნის წინ Telegram გამოაცხადა კონკურსი ამ პლატფორმისთვის ერთი ან მეტი ჭკვიანი კონტრაქტის განსახორციელებლად.

Serokell-ის გუნდი, რომელსაც დიდი გამოცდილება აქვს მსხვილი ბლოკჩეინის პროექტების შემუშავებაში, განზე ვერ გაჩერდა. კონკურსზე ხუთი თანამშრომელი გავანაწილეთ და ორი კვირის შემდეგ მათ პირველი ადგილი დაიკავეს (არა)მოკრძალებული შემთხვევითი მეტსახელით სექსუალური ქამელეონი. ამ სტატიაში ვისაუბრებ იმაზე, თუ როგორ გააკეთეს ეს. ვიმედოვნებთ, რომ უახლოეს ათ წუთში მაინც წაიკითხავთ საინტერესო ამბავს და მაქსიმუმ იპოვით მასში რაიმე სასარგებლოს, რომელიც შეგიძლიათ გამოიყენოთ თქვენს საქმიანობაში.

მაგრამ დავიწყოთ მცირე კონტექსტით.

კონკურსი და მისი პირობები

ასე რომ, მონაწილეთა ძირითადი ამოცანები იყო ერთი ან მეტი შემოთავაზებული ჭკვიანი კონტრაქტის განხორციელება, ასევე TON ეკოსისტემის გაუმჯობესების წინადადებების გაკეთება. კონკურსი 24 სექტემბრიდან 15 ოქტომბრის ჩათვლით გაგრძელდა, შედეგები კი მხოლოდ 15 ნოემბერს გამოცხადდა. საკმაოდ დიდი ხნის განმავლობაში, იმის გათვალისწინებით, რომ ამ ხნის განმავლობაში Telegram-მა მოახერხა კონკურსების გამართვა და გამოცხადება C++-ში აპლიკაციების დიზაინისა და შემუშავების შესახებ, Telegram-ში VoIP ზარების ტესტირებისა და ხარისხის შესაფასებლად.

ორგანიზატორების მიერ შემოთავაზებული სიიდან ორი ჭკვიანი კონტრაქტი შევარჩიეთ. ერთ-ერთი მათგანისთვის ჩვენ გამოვიყენეთ TON-ით განაწილებული ხელსაწყოები, ხოლო მეორე განხორციელდა ახალ ენაზე, რომელიც შემუშავდა ჩვენი ინჟინრების მიერ სპეციალურად TON-ისთვის და ჩაშენებული იყო Haskell-ში.

ფუნქციური პროგრამირების ენის არჩევანი შემთხვევითი არ არის. ჩვენს კორპორატიული ბლოგი ჩვენ ხშირად ვსაუბრობთ იმაზე, თუ რატომ გვგონია ფუნქციური ენების სირთულე უზარმაზარი გაზვიადება და რატომ ვანიჭებთ უპირატესობას მათ ობიექტზე ორიენტირებულ ენებს. სხვათა შორის, ის ასევე შეიცავს ამ სტატიის ორიგინალი.

რატომ გადავწყვიტეთ მონაწილეობა?

მოკლედ, იმიტომ, რომ ჩვენი სპეციალიზაცია არის არასტანდარტული და კომპლექსური პროექტები, რომლებიც განსაკუთრებულ უნარებს მოითხოვს და ხშირად მეცნიერული ღირებულების მქონეა IT საზოგადოებისთვის. ჩვენ მტკიცედ ვუჭერთ მხარს ღია კოდის განვითარებას და ჩართული ვართ მის პოპულარიზაციაში, ასევე ვთანამშრომლობთ წამყვან რუსულ უნივერსიტეტებთან კომპიუტერული მეცნიერებისა და მათემატიკის სფეროში.

კონკურსის საინტერესო ამოცანები და ჩვენს საყვარელ ტელეგრამის პროექტში ჩართვა თავისთავად შესანიშნავი მოტივაცია იყო, მაგრამ საპრიზო ფონდი გახდა დამატებითი სტიმული. 🙂

TON-ის ბლოკჩეინის კვლევა

ჩვენ ყურადღებით ვადევნებთ თვალყურს ბლოკჩეინის, ხელოვნური ინტელექტისა და მანქანათმცოდნეობის ახალ განვითარებას და ვცდილობთ არ გამოვტოვოთ არც ერთი მნიშვნელოვანი გამოცემა თითოეულ სფეროში, სადაც ჩვენ ვმუშაობთ. ამიტომ, კონკურსის დაწყების დროისთვის ჩვენი გუნდი უკვე იცნობდა იდეებს TON თეთრი ქაღალდი. თუმცა, TON-თან მუშაობის დაწყებამდე ჩვენ არ გავაანალიზეთ ტექნიკური დოკუმენტაცია და პლატფორმის ფაქტობრივი კოდი, ამიტომ პირველი ნაბიჯი საკმაოდ აშკარა იყო - ოფიციალური დოკუმენტაციის საფუძვლიანი შესწავლა. ონლაინი და პროექტის საცავი.

კონკურსის დაწყებისას კოდი უკვე გამოქვეყნებული იყო, ამიტომ დროის დაზოგვის მიზნით გადავწყვიტეთ მოძებნოთ სახელმძღვანელო ან რეზიუმე, რომელიც დაწერილი იყო მომხმარებლების მიერ. სამწუხაროდ, ამან შედეგი არ მოიტანა - გარდა Ubuntu-ზე პლატფორმის აწყობის ინსტრუქციისა, ჩვენ ვერ ვიპოვნეთ სხვა მასალები.

თავად დოკუმენტაცია კარგად იყო გამოკვლეული, მაგრამ ზოგიერთ სფეროში ძნელი წასაკითხი იყო. ხშირად გვიწევდა გარკვეულ პუნქტებზე დაბრუნება და აბსტრაქტული იდეების მაღალი დონის აღწერილობიდან დაბალ დონეზე განხორციელების დეტალებზე გადასვლა.

უფრო ადვილი იქნებოდა, თუ სპეციფიკაცია საერთოდ არ მოიცავდა განხორციელების დეტალურ აღწერას. ინფორმაცია იმის შესახებ, თუ როგორ წარმოადგენს ვირტუალური მანქანა თავის დასტას, უფრო მეტად გადაიტანს დეველოპერებს, რომლებიც ქმნიან გონიერ კონტრაქტებს TON პლატფორმისთვის, ვიდრე დაეხმარება მათ.

ნიქსი: პროექტის შედგენა

Serokელში ჩვენ დიდი გულშემატკივრები ვართ Nix. ჩვენ მასში ვაგროვებთ ჩვენს პროექტებს და ვაყენებთ მათ გამოყენებით NixOpsდა დაინსტალირებულია ყველა ჩვენს სერვერზე Nix OS. ამის წყალობით, ყველა ჩვენი კონსტრუქცია რეპროდუცირებადია და მუშაობს ნებისმიერ ოპერაციულ სისტემაზე, რომელზედაც შესაძლებელია Nix-ის დაყენება.

ამიტომ დავიწყეთ შემოქმედებით Nix-ის გადაფარვა TON-ის შეკრების გამოხატვით. მისი დახმარებით TON-ის შედგენა რაც შეიძლება მარტივია:

$ cd ~/.config/nixpkgs/overlays && git clone https://github.com/serokell/ton.nix
$ cd /path/to/ton/repo && nix-shell
[nix-shell]$ cmakeConfigurePhase && make

გაითვალისწინეთ, რომ თქვენ არ გჭირდებათ რაიმე დამოკიდებულების დაყენება. ნიქსი ჯადოსნურად გააკეთებს ყველაფერს თქვენთვის, მიუხედავად იმისა, იყენებთ NixOS-ს, Ubuntu-ს თუ macOS-ს.

პროგრამირება TON-ისთვის

ჭკვიანი კონტრაქტის კოდი TON ქსელში მუშაობს TON ვირტუალურ მანქანაზე (TVM). TVM უფრო რთულია, ვიდრე სხვა ვირტუალური მანქანების უმეტესობა და აქვს ძალიან საინტერესო ფუნქციონირება, მაგალითად, მას შეუძლია მუშაობა გაგრძელება и ბმულები მონაცემებთან.

უფრო მეტიც, TON-ის ბიჭებმა შექმნეს სამი ახალი პროგრამირების ენა:

მეხუთე არის უნივერსალური სტეკის პროგრამირების ენა, რომელიც წააგავს მეოთხე. მისი სუპერ უნარი არის TVM-თან ურთიერთობის უნარი.

FunC არის ჭკვიანი კონტრაქტის პროგრამირების ენა, რომელიც მსგავსია C და შედგენილია სხვა ენაზე - Fift Assembler.

მეხუთე ასამბლეერი — მეხუთე ბიბლიოთეკა TVM-სთვის ბინარული შესრულებადი კოდის გენერირებისთვის. მეხუთე ასამბლერს არ აქვს კომპილერი. ეს ჩაშენებული დომენის სპეციფიკური ენა (eDSL).

ჩვენი კონკურსი მუშაობს

დაბოლოს, დროა გადავხედოთ ჩვენი ძალისხმევის შედეგებს.

ასინქრონული გადახდის არხი

გადახდის არხი არის ჭკვიანი კონტრაქტი, რომელიც საშუალებას აძლევს ორ მომხმარებელს გააგზავნოს გადახდები ბლოკჩეინის გარეთ. შედეგად, თქვენ დაზოგავთ არა მხოლოდ ფულს (არ არის საკომისიო), არამედ დროსაც (თქვენ არ უნდა დაელოდოთ შემდეგი ბლოკის დამუშავებას). გადახდები შეიძლება იყოს როგორც მცირე, ისე ხშირად, როგორც საჭიროა. ამ შემთხვევაში მხარეებს არ უწევთ ერთმანეთის ნდობა, ვინაიდან საბოლოო ანგარიშსწორების სამართლიანობა გარანტირებულია ჭკვიანი კონტრაქტით.

ჩვენ აღმოვაჩინეთ პრობლემის საკმაოდ მარტივი გამოსავალი. ორ მხარეს შეუძლია გაცვალოს ხელმოწერილი შეტყობინებები, თითოეული შეიცავს ორ ნომერს - თითოეული მხარის მიერ გადახდილი სრული თანხა. ეს ორი ციფრი მუშაობს ასე ვექტორული საათი ტრადიციულ განაწილებულ სისტემებში და დააწესეთ ტრანზაქციების ბრძანება „დასწრებული ადრე“. ამ მონაცემების გამოყენებით კონტრაქტი შეძლებს ნებისმიერი შესაძლო კონფლიქტის მოგვარებას.

ფაქტობრივად, ამ იდეის განსახორციელებლად ერთი რიცხვიც საკმარისია, მაგრამ ორივე დავტოვეთ, რადგან ამ გზით შეგვეძლო უფრო მოსახერხებელი მომხმარებლის ინტერფეისის შექმნა. გარდა ამისა, გადავწყვიტეთ თითოეულ შეტყობინებაში შეგვეტანა გადახდის თანხა. ამის გარეშე, თუ შეტყობინება რაიმე მიზეზით დაიკარგება, მაშინ, მიუხედავად იმისა, რომ ყველა თანხა და საბოლოო გაანგარიშება სწორი იქნება, მომხმარებელმა შეიძლება ვერ შეამჩნიოს ზარალი.

ჩვენი იდეის შესამოწმებლად, ჩვენ მოვძებნეთ ასეთი მარტივი და ლაკონური გადახდის არხის პროტოკოლის გამოყენების მაგალითები. გასაკვირია, რომ ჩვენ აღმოვაჩინეთ მხოლოდ ორი:

1. აღწერა მსგავსი მიდგომა, მხოლოდ ცალმხრივი არხის შემთხვევაში.
2. სახელმძღვანელო, რომელიც აღწერს იგივე იდეას, რაც ჩვენსას, მაგრამ ბევრი მნიშვნელოვანი დეტალის ახსნის გარეშე, როგორიცაა ზოგადი სისწორე და კონფლიქტის მოგვარების პროცედურები.

გაირკვა, რომ აზრი აქვს ჩვენი პროტოკოლის დეტალურად აღწერას, განსაკუთრებული ყურადღების მიქცევით მის სისწორეს. რამდენიმე გამეორების შემდეგ, სპეციფიკაცია მზად იყო და ახლა თქვენც შეგიძლიათ. შეხედე მას.

ჩვენ განვახორციელეთ კონტრაქტი FunC-ში და დავწერეთ ბრძანების ხაზი ჩვენს კონტრაქტთან ინტერაქციისთვის მთლიანად Fift-ში, როგორც ამას ორგანიზატორები გვირჩევენ. ჩვენ შეგვეძლო აერჩია ნებისმიერი სხვა ენა ჩვენი CLI-სთვის, მაგრამ გვაინტერესებდა Fit-ის პრაქტიკაში შესრულება.

მართალი გითხრათ, Fift-თან მუშაობის შემდეგ, ჩვენ ვერ დავინახეთ რაიმე დამაჯერებელი მიზეზი, რომ ამ ენას ვამჯობინოთ პოპულარულ და აქტიურად გამოყენებულ ენებზე, განვითარებული ხელსაწყოებითა და ბიბლიოთეკებით. სტეკზე დაფუძნებულ ენაზე პროგრამირება საკმაოდ უსიამოვნოა, რადგან თქვენ მუდმივად უნდა შეინახოთ თქვენს თავში ის, რაც დასტაზეა, და კომპილერი ამაში არ გეხმარებათ.

ამიტომ, ჩვენი აზრით, Fift-ის არსებობის ერთადერთი დასაბუთება არის Fift Assembler-ის მასპინძელი ენის როლი. მაგრამ არ იქნება უკეთესი TVM ასამბლერის ჩასმა რომელიმე არსებულ ენაზე, ვიდრე ახლის გამოგონება ამ არსებითად ერთადერთი მიზნისთვის?

TVM Haskell eDSL

ახლა დროა ვისაუბროთ ჩვენს მეორე ჭკვიან კონტრაქტზე. ჩვენ გადავწყვიტეთ შეგვექმნა მრავალხელმოწერიანი საფულე, მაგრამ FunC-ში კიდევ ერთი ჭკვიანი კონტრაქტის დაწერა ძალიან მოსაწყენი იქნებოდა. გვინდოდა შეგვემატებინა გარკვეული არომატი და ეს იყო ჩვენი საკუთარი ასამბლეის ენა TVM-ისთვის.

Fift Assembler-ის მსგავსად, ჩვენი ახალი ენაც ჩაშენებულია, მაგრამ ჩვენ ავირჩიეთ Haskell, როგორც მასპინძელი Fift-ის ნაცვლად, რაც საშუალებას გვაძლევს სრულად ვისარგებლოთ მისი მოწინავე ტიპის სისტემით. სმარტ კონტრაქტებთან მუშაობისას, სადაც თუნდაც მცირე შეცდომის ღირებულება შეიძლება იყოს ძალიან მაღალი, სტატიკური აკრეფა, ჩვენი აზრით, დიდი უპირატესობაა.

იმის დემონსტრირებისთვის, თუ როგორ გამოიყურება TVM ასამბლეერი, რომელიც ჩაშენებულია Haskell-ში, ჩვენ მასზე დავაყენეთ სტანდარტული საფულე. აქ არის რამდენიმე რამ, რასაც ყურადღება უნდა მიაქციოთ:

• ეს კონტრაქტი შედგება ერთი ფუნქციისგან, მაგრამ შეგიძლიათ გამოიყენოთ რამდენიც გსურთ. როდესაც თქვენ განსაზღვრავთ ახალ ფუნქციას მასპინძელ ენაზე (მაგ. Haskell), ჩვენი eDSL საშუალებას გაძლევთ აირჩიოთ, გსურთ ის გახდეს ცალკე რუტინა TVM-ში თუ უბრალოდ ჩართული იყოს გამოძახების ადგილზე.
• ჰასკელის მსგავსად, ფუნქციებს აქვთ ტიპები, რომლებიც შემოწმებულია კომპილაციის დროს. ჩვენს eDSL-ში, ფუნქციის შეყვანის ტიპი არის დატის ტიპი, რომელსაც ფუნქცია მოელის, ხოლო შედეგის ტიპი არის დატის ტიპი, რომელიც წარმოიქმნება გამოძახების შემდეგ.
• კოდს აქვს ანოტაციები stacktype, აღწერს მოსალოდნელ სტეკის ტიპს გამოძახების წერტილში. საფულის თავდაპირველ კონტრაქტში ეს მხოლოდ კომენტარები იყო, მაგრამ ჩვენს eDSL-ში ისინი რეალურად კოდის ნაწილია და შემოწმებულია კომპილაციის დროს. ისინი შეიძლება იყოს დოკუმენტაცია ან განცხადებები, რომლებიც ეხმარება დეველოპერს პრობლემის პოვნაში, თუ კოდი შეიცვლება და შეიცვლება სტეკის ტიპი. რა თქმა უნდა, ასეთი ანოტაციები გავლენას არ მოახდენს გაშვების დროზე, რადგან მათთვის TVM კოდი არ არის გენერირებული.
• ეს ჯერ კიდევ ორ კვირაში დაწერილი პროტოტიპია, ამიტომ პროექტზე ჯერ კიდევ ბევრია სამუშაო. მაგალითად, კლასების ყველა მაგალითი, რომელსაც ხედავთ ქვემოთ მოცემულ კოდში, ავტომატურად უნდა გენერირდეს.

ასე გამოიყურება multisig საფულის დანერგვა ჩვენს eDSL-ზე:

main :: IO ()
main = putText $ pretty $ declProgram procedures methods
  where
    procedures =
      [ ("recv_external", decl recvExternal)
      , ("recv_internal", decl recvInternal)
      ]
    methods =
      [ ("seqno", declMethod getSeqno)
      ]

data Storage = Storage
  { sCnt :: Word32
  , sPubKey :: PublicKey
  }

instance DecodeSlice Storage where
  type DecodeSliceFields Storage = [PublicKey, Word32]
  decodeFromSliceImpl = do
    decodeFromSliceImpl @Word32
    decodeFromSliceImpl @PublicKey

instance EncodeBuilder Storage where
  encodeToBuilder = do
    encodeToBuilder @Word32
    encodeToBuilder @PublicKey

data WalletError
  = SeqNoMismatch
  | SignatureMismatch
  deriving (Eq, Ord, Show, Generic)

instance Exception WalletError

instance Enum WalletError where
  toEnum 33 = SeqNoMismatch
  toEnum 34 = SignatureMismatch
  toEnum _ = error "Uknown MultiSigError id"

  fromEnum SeqNoMismatch = 33
  fromEnum SignatureMismatch = 34

recvInternal :: '[Slice] :-> '[]
recvInternal = drop

recvExternal :: '[Slice] :-> '[]
recvExternal = do
  decodeFromSlice @Signature
  dup
  preloadFromSlice @Word32
  stacktype @[Word32, Slice, Signature]
  -- cnt cs sign

  pushRoot
  decodeFromCell @Storage
  stacktype @[PublicKey, Word32, Word32, Slice, Signature]
  -- pk cnt' cnt cs sign

  xcpu @1 @2
  stacktype @[Word32, Word32, PublicKey, Word32, Slice, Signature]
  -- cnt cnt' pk cnt cs sign

  equalInt >> throwIfNot SeqNoMismatch

  push @2
  sliceHash
  stacktype @[Hash Slice, PublicKey, Word32, Slice, Signature]
  -- hash pk cnt cs sign

  xc2pu @0 @4 @4
  stacktype @[PublicKey, Signature, Hash Slice, Word32, Slice, PublicKey]
  -- pubk sign hash cnt cs pubk

  chkSignU
  stacktype @[Bool, Word32, Slice, PublicKey]
  -- ? cnt cs pubk

  throwIfNot SignatureMismatch
  accept

  swap
  decodeFromSlice @Word32
  nip

  dup
  srefs @Word8

  pushInt 0
  if IsEq
  then ignore
  else do
    decodeFromSlice @Word8
    decodeFromSlice @(Cell MessageObject)
    stacktype @[Slice, Cell MessageObject, Word8, Word32, PublicKey]
    xchg @2
    sendRawMsg
    stacktype @[Slice, Word32, PublicKey]

  endS
  inc

  encodeToCell @Storage
  popRoot

getSeqno :: '[] :-> '[Word32]
getSeqno = do
  pushRoot
  cToS
  preloadFromSlice @Word32

ჩვენი eDSL და მრავალხელმოწერიანი საფულის კონტრაქტის სრული წყაროს კოდი შეგიძლიათ იხილოთ აქ ეს საცავი. Და მეტი დეტალურად განუცხადა ჩაშენებული ენების შესახებ, ჩვენი კოლეგა გეორგი აგაპოვი.

დასკვნები კონკურსისა და TON-ის შესახებ

საერთო ჯამში, ჩვენს მუშაობას 380 საათი დასჭირდა (მათ შორის, დოკუმენტაციის გაცნობა, შეხვედრები და ფაქტობრივი განვითარება). კონკურსის პროექტში მონაწილეობა მიიღო ხუთმა დეველოპერმა: CTO, გუნდის ლიდერი, ბლოკჩეინის პლატფორმის სპეციალისტები და Haskell პროგრამული უზრუნველყოფის დეველოპერები.

ჩვენ ვიპოვნეთ რესურსები კონკურსში მონაწილეობისთვის უპრობლემოდ, რადგან ჰაკათონის სული, მჭიდრო გუნდური მუშაობა და ახალი ტექნოლოგიების ასპექტებში სწრაფად ჩაძირვის აუცილებლობა ყოველთვის საინტერესოა. რამდენიმე უძილო ღამე შეზღუდული რესურსების პირობებში მაქსიმალური შედეგის მისაღწევად ანაზღაურდება ფასდაუდებელი გამოცდილებით და შესანიშნავი მოგონებებით. გარდა ამისა, ასეთ ამოცანებზე მუშაობა ყოველთვის არის კომპანიის პროცესების კარგი გამოცდა, რადგან ძალიან რთულია ჭეშმარიტად ღირსეული შედეგების მიღწევა კარგად ფუნქციონირების შიდა ურთიერთქმედების გარეშე.

ტექსტი განზე: ჩვენ შთაბეჭდილება მოახდინა TON-ის გუნდის მიერ გაწეული სამუშაოს მოცულობით. მათ მოახერხეს რთული, ლამაზი და რაც მთავარია მუშა სისტემის აგება. TON-მა დაამტკიცა, რომ არის პლატფორმა დიდი პოტენციალით. თუმცა, იმისათვის, რომ ეს ეკოსისტემა განვითარდეს, კიდევ ბევრი რამ არის გასაკეთებელი, როგორც ბლოკჩეინის პროექტებში მისი გამოყენების, ასევე განვითარების ინსტრუმენტების გაუმჯობესების თვალსაზრისით. ჩვენ ვამაყობთ, რომ ახლა ვართ ამ პროცესის ნაწილი.

თუ ამ სტატიის წაკითხვის შემდეგ კვლავ გაქვთ რაიმე შეკითხვა ან გაქვთ იდეები, თუ როგორ გამოიყენოთ TON თქვენი პრობლემების გადასაჭრელად, მოგვწერეთ — სიამოვნებით გაგიზიარებთ გამოცდილებას.

წყარო: www.habr.com