ប្រែក្លាយ FunC ទៅជា FunCtional ជាមួយ Haskell: របៀបដែល Serokell បានឈ្នះការប្រកួត Telegram Blockchain

អ្នកប្រហែលជាធ្លាប់លឺថា Telegram ហៀបនឹងបើកដំណើរការវេទិកា Ton blockchain. ប៉ុន្តែ​អ្នក​ប្រហែល​ជា​បាន​ខក​ខាន​ព័ត៌មាន​ដែល​មិន​បាន​យូរ​មក​ហើយ​ក្នុង​កម្មវិធី Telegram បានប្រកាសការប្រកួតប្រជែង សម្រាប់ការអនុវត្តកិច្ចសន្យាឆ្លាតវៃមួយ ឬច្រើនសម្រាប់វេទិកានេះ។

ក្រុម Serokell ដែលមានបទពិសោធន៍យ៉ាងទូលំទូលាយក្នុងការអភិវឌ្ឍន៍គម្រោង blockchain ធំមិនអាចឈរនៅម្ខាងបានទេ។ យើងបានចាត់តាំងបុគ្គលិកប្រាំនាក់ឱ្យចូលរួមក្នុងការប្រកួត ហើយពីរសប្តាហ៍ក្រោយមកពួកគេបានជាប់ចំណាត់ថ្នាក់លេខ 1 នៅក្នុងវាក្រោមឈ្មោះហៅក្រៅចៃដន្យតិចតួច (ក្នុង) Sexy Chameleon ។ នៅក្នុងអត្ថបទនេះខ្ញុំនឹងនិយាយអំពីរបៀបដែលពួកគេបានធ្វើវា។ យើងសង្ឃឹមថាក្នុងរយៈពេលដប់នាទីបន្ទាប់ យ៉ាងហោចណាស់អ្នកនឹងបានអានរឿងដ៏គួរឱ្យចាប់អារម្មណ៍មួយ ហើយភាគច្រើនអ្នកនឹងរកឃើញអ្វីដែលមានប្រយោជន៍នៅក្នុងវា ដែលអ្នកអាចអនុវត្តក្នុងការងាររបស់អ្នក។

ប៉ុន្តែសូមចាប់ផ្តើមជាមួយនឹងបរិបទតូចមួយ។

ការប្រកួតប្រជែងនិងលក្ខខណ្ឌរបស់វា។

ដូច្នេះ ភារកិច្ចចម្បងរបស់អ្នកចូលរួមគឺការអនុវត្តកិច្ចសន្យាឆ្លាតវៃដែលបានស្នើឡើងមួយ ឬច្រើន ក៏ដូចជាការធ្វើសំណើដើម្បីកែលម្អប្រព័ន្ធអេកូឡូស៊ី TON ។ ការប្រកួតបានដំណើរការចាប់ពីថ្ងៃទី 24 ខែកញ្ញាដល់ថ្ងៃទី 15 ខែតុលា ហើយលទ្ធផលត្រូវបានប្រកាសត្រឹមថ្ងៃទី 15 ខែវិច្ឆិកាប៉ុណ្ណោះ។ យូរណាស់មកហើយ ដោយពិចារណាថា ក្នុងអំឡុងពេលនេះ Telegram បានគ្រប់គ្រង និងប្រកាសលទ្ធផលនៃការប្រកួតប្រជែងលើការរចនា និងការអភិវឌ្ឍន៍កម្មវិធីនៅក្នុង C++ សម្រាប់សាកល្បង និងវាយតម្លៃគុណភាពនៃការហៅ VoIP នៅក្នុង Telegram។

យើងបានជ្រើសរើសកិច្ចសន្យាឆ្លាតវៃចំនួនពីរពីបញ្ជីដែលបានស្នើឡើងដោយអ្នករៀបចំ។ សម្រាប់មួយក្នុងចំណោមពួកគេ យើងបានប្រើឧបករណ៍ដែលចែកចាយជាមួយ TON ហើយទីពីរត្រូវបានអនុវត្តជាភាសាថ្មីដែលត្រូវបានបង្កើតឡើងដោយវិស្វកររបស់យើងជាពិសេសសម្រាប់ TON ហើយបានបង្កើតឡើងនៅក្នុង Haskell ។

ជម្រើសនៃភាសាសរសេរកម្មវិធីដែលមានមុខងារគឺមិនចៃដន្យទេ។ នៅក្នុងរបស់យើង។ ប្លុកសាជីវកម្ម យើងច្រើនតែនិយាយអំពីមូលហេតុដែលយើងគិតថាភាពស្មុគស្មាញនៃភាសាមុខងារគឺជាការបំផ្លើសដ៏ធំ ហើយហេតុអ្វីបានជាយើងចូលចិត្តពួកវាចំពោះភាសាដែលតម្រង់ទិស។ ដោយវិធីនេះវាក៏មានផងដែរ។ ដើមនៃអត្ថបទនេះ។.

ហេតុអ្វីបានជាយើងសម្រេចចិត្តចូលរួម?

សរុបមក ដោយសារឯកទេសរបស់យើងគឺជាគម្រោងមិនស្តង់ដារ និងស្មុគស្មាញដែលទាមទារជំនាញពិសេស ហើយជារឿយៗមានតម្លៃខាងវិទ្យាសាស្ត្រសម្រាប់សហគមន៍ IT ។ យើងគាំទ្រយ៉ាងខ្លាំងចំពោះការអភិវឌ្ឍន៍ប្រភពបើកចំហ ហើយបានចូលរួមក្នុងការពេញនិយមរបស់វា ហើយក៏សហការជាមួយសាកលវិទ្យាល័យឈានមុខគេរបស់រុស្ស៊ីក្នុងវិស័យវិទ្យាសាស្ត្រកុំព្យូទ័រ និងគណិតវិទ្យាផងដែរ។

ភារកិច្ចគួរឱ្យចាប់អារម្មណ៍នៃការប្រកួតប្រជែង និងការចូលរួមក្នុងគម្រោង Telegram ជាទីស្រឡាញ់របស់យើងគឺនៅក្នុងខ្លួនពួកគេផ្ទាល់ជាការលើកទឹកចិត្តដ៏ល្អ ប៉ុន្តែមូលនិធិរង្វាន់បានក្លាយជាការលើកទឹកចិត្តបន្ថែម។ 🙂

ការស្រាវជ្រាវ blockchain TON

យើងតាមដានយ៉ាងដិតដល់នូវការអភិវឌ្ឍន៍ថ្មីៗនៅក្នុង blockchain បញ្ញាសិប្បនិម្មិត និងការរៀនម៉ាស៊ីន ហើយព្យាយាមមិនឱ្យខកខានការចេញផ្សាយដ៏សំខាន់មួយនៅក្នុងផ្នែកនីមួយៗដែលយើងធ្វើការ។ ដូច្នេះ​ហើយ នៅ​ពេល​ដែល​ការ​ប្រកួត​បាន​ចាប់​ផ្តើម ក្រុម​របស់​យើង​បាន​ស្គាល់​រួច​ហើយ​នូវ​គំនិត​ពី​ ក្រដាសស TON. ទោះជាយ៉ាងណាក៏ដោយមុនពេលចាប់ផ្តើមការងារជាមួយ TON យើងមិនបានវិភាគឯកសារបច្ចេកទេសនិងកូដប្រភពពិតប្រាកដនៃវេទិកានោះទេដូច្នេះជំហានដំបូងគឺជាក់ស្តែង - ការសិក្សាហ្មត់ចត់នៃឯកសារផ្លូវការនៅលើ តំបន់បណ្តាញ និងនៅក្នុង ឃ្លាំងគម្រោង.

នៅពេលការប្រកួតប្រជែងចាប់ផ្តើម កូដត្រូវបានបោះពុម្ពរួចហើយ ដូច្នេះដើម្បីសន្សំពេលវេលា យើងបានសម្រេចចិត្តស្វែងរកការណែនាំ ឬសេចក្តីសង្ខេបដែលសរសេរដោយ ដោយអ្នកប្រើប្រាស់. ជាអកុសល វាមិនបានផ្តល់លទ្ធផលអ្វីទេ - ក្រៅពីការណែនាំសម្រាប់ការផ្គុំវេទិកានៅលើអ៊ូប៊ុនទូ យើងមិនបានរកឃើញសម្ភារៈផ្សេងទៀតទេ។

ឯកសារខ្លួនឯងត្រូវបានស្រាវជ្រាវយ៉ាងល្អ ប៉ុន្តែពិបាកអានក្នុងផ្នែកខ្លះ។ ជាញឹកញយ យើងត្រូវតែត្រលប់ទៅចំណុចជាក់លាក់មួយវិញ ហើយប្តូរពីការពិពណ៌នាកម្រិតខ្ពស់នៃគំនិតអរូបី ទៅជាព័ត៌មានលម្អិតនៃការអនុវត្តកម្រិតទាប។

វានឹងកាន់តែងាយស្រួល ប្រសិនបើការបញ្ជាក់មិនរួមបញ្ចូលការពិពណ៌នាលម្អិតនៃការអនុវត្តទាល់តែសោះ។ ព័ត៌មានអំពីរបៀបដែលម៉ាស៊ីននិម្មិតតំណាងឱ្យជង់របស់វាទំនងជារំខានអ្នកអភិវឌ្ឍន៍ក្នុងការបង្កើតកិច្ចសន្យាឆ្លាតវៃសម្រាប់វេទិកា TON ជាជាងជួយពួកគេ។

Nix: ដាក់គម្រោងជាមួយគ្នា

នៅ Serokell យើងជាអ្នកគាំទ្រដ៏ធំ និច. យើងប្រមូលគម្រោងរបស់យើងជាមួយវា ហើយដាក់ឱ្យពួកគេប្រើប្រាស់ NixOpsនិងបានដំឡើងនៅលើម៉ាស៊ីនមេរបស់យើងទាំងអស់។ នីស៊ីអេស. សូមអរគុណចំពោះបញ្ហានេះ រាល់ការស្ថាបនារបស់យើងគឺអាចផលិតឡើងវិញបាន ហើយដំណើរការលើប្រព័ន្ធប្រតិបត្តិការណាមួយដែល 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

ចំណាំថាអ្នកមិនចាំបាច់ដំឡើងភាពអាស្រ័យណាមួយទេ។ Nix នឹងធ្វើអ្វីៗគ្រប់យ៉ាងយ៉ាងអស្ចារ្យសម្រាប់អ្នក មិនថាអ្នកកំពុងប្រើ NixOS, Ubuntu ឬ macOS ទេ។

កម្មវិធីសម្រាប់ TON

លេខកូដកិច្ចសន្យាឆ្លាតវៃនៅក្នុងបណ្តាញ TON ដំណើរការលើម៉ាស៊ីននិម្មិត TON (TVM) ។ TVM មានភាពស្មុគ្រស្មាញជាងម៉ាស៊ីននិម្មិតដទៃទៀត ហើយមានមុខងារគួរឱ្យចាប់អារម្មណ៍ជាឧទាហរណ៍ វាអាចធ្វើការជាមួយបាន។ ការបន្ត и តំណភ្ជាប់ទៅទិន្នន័យ.

លើសពីនេះទៅទៀត បុរសមកពី TON បានបង្កើតភាសាសរសេរកម្មវិធីថ្មីចំនួនបី៖

ហ្វីហ្វ គឺជាភាសាកម្មវិធីជង់ជាសកលដែលស្រដៀងនឹង ទីបួន. សមត្ថភាពដ៏អស្ចារ្យរបស់គាត់គឺសមត្ថភាពក្នុងការប្រាស្រ័យទាក់ទងជាមួយ TVM ។

FunC គឺជាភាសាសរសេរកម្មវិធីកិច្ចសន្យាឆ្លាតវៃដែលស្រដៀងនឹង C ហើយត្រូវបានចងក្រងជាភាសាមួយផ្សេងទៀត - Fift Assembler ។

ក្រុមទីប្រាំ - បណ្ណាល័យចំនួនប្រាំសម្រាប់បង្កើតកូដដែលអាចប្រតិបត្តិបានប្រព័ន្ធគោលពីរសម្រាប់ TVM ។ Fifth Assembler មិនមានអ្នកចងក្រងទេ។ នេះ។ ភាសាជាក់លាក់ដែនដែលបានបង្កប់ (eDSL).

ការប្រកួតប្រជែងរបស់យើងដំណើរការ

ទីបំផុត ដល់ពេលត្រូវមើលលទ្ធផលនៃកិច្ចខិតខំប្រឹងប្រែងរបស់យើង។

ឆានែលទូទាត់អសមកាល

ឆានែលទូទាត់គឺជាកិច្ចសន្យាឆ្លាតវៃដែលអនុញ្ញាតឱ្យអ្នកប្រើពីរនាក់ផ្ញើការទូទាត់នៅខាងក្រៅ blockchain ។ ជាលទ្ធផល អ្នកសន្សំមិនត្រឹមតែប្រាក់ទេ (មិនមានកម្រៃជើងសារ) ប៉ុន្តែក៏មានពេលវេលាផងដែរ (អ្នកមិនចាំបាច់រង់ចាំដំណើរការប្លុកបន្ទាប់ទៀត)។ ការទូទាត់អាចមានទំហំតូចតាមការចង់បាន និងញឹកញាប់តាមតម្រូវការ។ ក្នុងករណីនេះភាគីមិនត្រូវទុកចិត្តគ្នាទៅវិញទៅមកទេព្រោះថាភាពយុត្តិធម៌នៃដំណោះស្រាយចុងក្រោយត្រូវបានធានាដោយកិច្ចសន្យាឆ្លាតវៃ។

យើងបានរកឃើញដំណោះស្រាយដ៏សាមញ្ញមួយចំពោះបញ្ហា។ ភាគីទាំងពីរអាចផ្លាស់ប្តូរសារដែលមានហត្ថលេខា ដែលនីមួយៗមានលេខពីរ ដែលជាចំនួនពេញដែលបានបង់ដោយភាគីនីមួយៗ។ លេខទាំងពីរនេះដំណើរការដូច នាឡិកាវ៉ិចទ័រ នៅក្នុងប្រព័ន្ធចែកចាយប្រពៃណី និងកំណត់ការបញ្ជាទិញ "បានកើតឡើងមុន" លើប្រតិបត្តិការ។ ដោយប្រើទិន្នន័យនេះ កិច្ចសន្យានឹងអាចដោះស្រាយជម្លោះដែលអាចកើតមាន។

តាមពិត លេខមួយគឺគ្រប់គ្រាន់ដើម្បីអនុវត្តគំនិតនេះ ប៉ុន្តែយើងបានចាកចេញទាំងពីរ ដោយសារវិធីនេះយើងអាចបង្កើតចំណុចប្រទាក់អ្នកប្រើកាន់តែងាយស្រួល។ លើសពីនេះ យើងបានសម្រេចចិត្តបញ្ចូលចំនួនទឹកប្រាក់នៃការបង់ប្រាក់នៅក្នុងសារនីមួយៗ។ បើគ្មានវាទេ ប្រសិនបើសារត្រូវបានបាត់បង់ដោយហេតុផលមួយចំនួន នោះទោះបីជាបរិមាណទាំងអស់ និងការគណនាចុងក្រោយនឹងត្រឹមត្រូវក៏ដោយ អ្នកប្រើប្រាស់ប្រហែលជាមិនកត់សំគាល់ការបាត់បង់នោះទេ។

ដើម្បីសាកល្បងគំនិតរបស់យើង យើងបានស្វែងរកឧទាហរណ៍នៃការប្រើប្រាស់ពិធីការឆានែលទូទាត់សាមញ្ញ និងសង្ខេបបែបនេះ។ គួរឱ្យភ្ញាក់ផ្អើល យើងរកឃើញតែពីរប៉ុណ្ណោះ៖

1. បរិយាយ វិធីសាស្រ្តស្រដៀងគ្នានេះសម្រាប់តែករណីនៃឆានែល unidirectional មួយ។
2. ការបង្រៀនដែលពិពណ៌នាអំពីគំនិតដូចគ្នានឹងគំនិតរបស់យើងដែរ ប៉ុន្តែដោយមិនពន្យល់លម្អិតសំខាន់ៗជាច្រើន ដូចជាភាពត្រឹមត្រូវទូទៅ និងនីតិវិធីដោះស្រាយជម្លោះ។

វាច្បាស់ណាស់ថាវាសមហេតុផលក្នុងការពិពណ៌នាពិធីការរបស់យើងយ៉ាងលម្អិត ដោយយកចិត្តទុកដាក់ជាពិសេសចំពោះភាពត្រឹមត្រូវរបស់វា។ បន្ទាប់ពីការធ្វើម្តងទៀតជាច្រើន ការបញ្ជាក់បានត្រៀមរួចរាល់ ហើយឥឡូវនេះអ្នកក៏អាចធ្វើបានដែរ។ មើលនាង.

យើងបានអនុវត្តកិច្ចសន្យានៅក្នុង FunC ហើយយើងបានសរសេរឧបករណ៍ប្រើប្រាស់បន្ទាត់ពាក្យបញ្ជាសម្រាប់អន្តរកម្មជាមួយកិច្ចសន្យារបស់យើងទាំងស្រុងនៅក្នុង Fift ដូចដែលបានណែនាំដោយអ្នករៀបចំ។ យើងអាចជ្រើសរើសភាសាផ្សេងទៀតសម្រាប់ CLI របស់យើង ប៉ុន្តែយើងចាប់អារម្មណ៍ក្នុងការព្យាយាម Fit ដើម្បីមើលពីរបៀបដែលវាដំណើរការនៅក្នុងការអនុវត្ត។

និយាយឱ្យត្រង់ទៅ បន្ទាប់ពីធ្វើការជាមួយ Fift យើងមិនឃើញហេតុផលគួរឱ្យទាក់ទាញណាមួយក្នុងការចូលចិត្តភាសានេះទៅជាភាសាពេញនិយម និងប្រើប្រាស់យ៉ាងសកម្មជាមួយនឹងឧបករណ៍ និងបណ្ណាល័យដែលបានអភិវឌ្ឍនោះទេ។ ការសរសេរកម្មវិធីជាភាសាដែលមានមូលដ្ឋានលើជង់គឺពិតជាមិនល្អទេ ព្រោះអ្នកត្រូវតែរក្សាអ្វីដែលមាននៅលើជង់ជានិច្ច ហើយអ្នកចងក្រងមិនជួយក្នុងរឿងនេះទេ។

ដូច្នេះតាមគំនិតរបស់យើង យុត្តិកម្មតែមួយគត់សម្រាប់អត្ថិភាពនៃ Fift គឺតួនាទីរបស់វាជាភាសាម៉ាស៊ីនសម្រាប់ Fift Assembler ។ ប៉ុន្តែតើវាប្រសើរជាងក្នុងការបង្កប់ឧបករណ៍ដំឡើង TVM ទៅជាភាសាដែលមានស្រាប់ ជាជាងបង្កើតកម្មវិធីថ្មីសម្រាប់គោលបំណងតែមួយគត់នេះទេ?

TVM Haskell eDSL

ឥឡូវនេះវាដល់ពេលហើយដើម្បីនិយាយអំពីកិច្ចសន្យាឆ្លាតវៃទីពីររបស់យើង។ យើងបានសម្រេចចិត្តបង្កើតកាបូបដែលមានហត្ថលេខាច្រើន ប៉ុន្តែការសរសេរកិច្ចសន្យាឆ្លាតវៃមួយផ្សេងទៀតនៅក្នុង FunC នឹងគួរឱ្យធុញពេក។ យើង​ចង់​បន្ថែម​រសជាតិ​ខ្លះ ហើយ​នោះ​ជា​ភាសា​ដំឡើង​របស់​យើង​ផ្ទាល់​សម្រាប់ TVM។

ដូចជា Fift Assembler ភាសាថ្មីរបស់យើងត្រូវបានបង្កប់ ប៉ុន្តែយើងបានជ្រើសរើស Haskell ជាម៉ាស៊ីនជំនួសឱ្យ Fift ដែលអនុញ្ញាតឱ្យយើងទាញយកអត្ថប្រយោជន៍ពេញលេញពីប្រព័ន្ធប្រភេទកម្រិតខ្ពស់របស់វា។ នៅពេលធ្វើការជាមួយកិច្ចសន្យាឆ្លាតវៃ ដែលតម្លៃនៃសូម្បីតែកំហុសតូចមួយអាចខ្ពស់ណាស់ ការវាយអក្សរឋិតិវន្តតាមគំនិតរបស់យើងគឺជាអត្ថប្រយោជន៍ដ៏ធំមួយ។

ដើម្បីបង្ហាញពីអ្វីដែលឧបករណ៍ដំឡើង TVM មើលទៅដូចបានបង្កប់នៅក្នុង Haskell យើងបានអនុវត្តកាបូបស្តង់ដារនៅលើវា។ នេះជារឿងមួយចំនួនដែលត្រូវយកចិត្តទុកដាក់៖

• កិច្ចសន្យានេះមានមុខងារមួយ ប៉ុន្តែអ្នកអាចប្រើបានច្រើនតាមដែលអ្នកចូលចិត្ត។ នៅពេលអ្នកកំណត់មុខងារថ្មីជាភាសាម៉ាស៊ីន (ឧ. Haskell) eDSL របស់យើងអនុញ្ញាតឱ្យអ្នកជ្រើសរើសថាតើអ្នកចង់ឱ្យវាក្លាយជាទម្លាប់ដាច់ដោយឡែកនៅក្នុង TVM ឬគ្រាន់តែដាក់បញ្ចូលនៅចំណុចនៃការហៅទូរសព្ទ។
• ដូច Haskell មុខងារមានប្រភេទដែលត្រូវបានពិនិត្យនៅពេលចងក្រង។ នៅក្នុង 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 និងហត្ថលេខាច្រើនរបស់យើងអាចរកបាននៅ ឃ្លាំងនេះ។ និង​ច្រើន​ទៀត បានប្រាប់លម្អិត អំពីភាសាដែលភ្ជាប់មកជាមួយ សហសេវិករបស់យើង Georgy Agapov ។

សេចក្តីសន្និដ្ឋានអំពីការប្រកួតប្រជែងនិង TON

សរុបមក ការងាររបស់យើងបានចំណាយពេល 380 ម៉ោង (រួមទាំងការយល់ដឹងអំពីឯកសារ ការប្រជុំ និងការអភិវឌ្ឍន៍ជាក់ស្តែង)។ អ្នកអភិវឌ្ឍន៍ XNUMX នាក់បានចូលរួមក្នុងគម្រោងប្រកួតប្រជែង: CTO, អ្នកដឹកនាំក្រុម, អ្នកឯកទេសវេទិកា blockchain និងអ្នកបង្កើតកម្មវិធី Haskell ។

យើងបានរកឃើញធនធានដើម្បីចូលរួមក្នុងការប្រកួតដោយគ្មានការលំបាក ចាប់តាំងពីស្មារតីនៃការ hackathon ការងារជាក្រុមយ៉ាងជិតស្និទ្ធ និងតម្រូវការក្នុងការបញ្ចូលខ្លួនយើងយ៉ាងឆាប់រហ័សនៅក្នុងទិដ្ឋភាពនៃបច្ចេកវិទ្យាថ្មីៗគឺតែងតែគួរឱ្យរំភើប។ ការគេងមិនលក់ជាច្រើនយប់ដើម្បីទទួលបានលទ្ធផលអតិបរមានៅក្នុងលក្ខខណ្ឌនៃធនធានមានកំណត់ត្រូវបានទូទាត់ដោយបទពិសោធន៍ដែលមិនអាចកាត់ថ្លៃបាន និងការចងចាំដ៏ល្អ។ លើសពីនេះ ការធ្វើការលើកិច្ចការបែបនេះគឺតែងតែជាការសាកល្បងដ៏ល្អនៃដំណើរការរបស់ក្រុមហ៊ុន ព្រោះវាពិបាកខ្លាំងណាស់ក្នុងការសម្រេចបាននូវលទ្ធផលសមរម្យពិតប្រាកដ ដោយគ្មានអន្តរកម្មផ្ទៃក្នុងដែលដំណើរការបានល្អ។

អត្ថបទចម្រៀងមួយឡែក៖ យើងចាប់អារម្មណ៍នឹងចំនួនការងារដែលដាក់ដោយក្រុម TON ។ ពួកគេបានគ្រប់គ្រងដើម្បីសាងសង់ប្រព័ន្ធការងារដ៏ស្មុគស្មាញ ស្រស់ស្អាត ហើយសំខាន់បំផុត។ TON បានបង្ហាញខ្លួនឯងថាជាវេទិកាមួយដែលមានសក្តានុពលដ៏អស្ចារ្យ។ ទោះជាយ៉ាងណាក៏ដោយ ដើម្បីឱ្យប្រព័ន្ធអេកូឡូស៊ីនេះអភិវឌ្ឍបាន ចាំបាច់ត្រូវធ្វើច្រើនទៀត ទាំងការប្រើប្រាស់របស់វានៅក្នុងគម្រោង blockchain និងក្នុងលក្ខខណ្ឌនៃការកែលម្អឧបករណ៍អភិវឌ្ឍន៍។ យើង​មាន​មោទនភាព​ដែល​បាន​ក្លាយ​ជា​ផ្នែក​មួយ​នៃ​ដំណើរការ​នេះ។

ប្រសិនបើបន្ទាប់ពីអានអត្ថបទនេះ អ្នកនៅតែមានចម្ងល់ ឬមានគំនិតអំពីរបៀបប្រើ TON ដើម្បីដោះស្រាយបញ្ហារបស់អ្នក។ សរសេរមកយើង - យើងនឹងរីករាយក្នុងការចែករំលែកបទពិសោធន៍របស់យើង។

ប្រភព: www.habr.com