អំពីរបៀបសរសេរ និងបោះពុម្ពកិច្ចសន្យាឆ្លាតវៃនៅក្នុង TON

តើអត្ថបទនេះនិយាយអំពីអ្វី?

នៅក្នុងអត្ថបទខ្ញុំនឹងនិយាយអំពីរបៀបដែលខ្ញុំបានចូលរួមក្នុងការប្រកួតប្រជែង Telegram blockchain ដំបូង (ពីរ) មិនបានយករង្វាន់ទេហើយបានសម្រេចចិត្តកត់ត្រាបទពិសោធន៍របស់ខ្ញុំនៅក្នុងអត្ថបទមួយដើម្បីកុំឱ្យវាធ្លាក់ចូលទៅក្នុងការភ្លេចភ្លាំងហើយប្រហែលជាជួយ។ អ្នកណាម្នាក់។

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

អត្ថបទនឹងមានប្រយោជន៍សម្រាប់អ្នកដែលចង់ធ្វើកិច្ចសន្យាឆ្លាតវៃដំបូងរបស់ពួកគេនៅក្នុង TON ប៉ុន្តែមិនដឹងថាត្រូវចាប់ផ្តើមពីណា។

ដោយប្រើឆ្នោតជាឧទាហរណ៍ ខ្ញុំនឹងទៅពីការដំឡើងបរិស្ថានទៅការបោះពុម្ពកិច្ចសន្យាឆ្លាតវៃ ធ្វើអន្តរកម្មជាមួយវា និងសរសេរគេហទំព័រសម្រាប់ទទួល និងបោះពុម្ពទិន្នន័យ។

អំពីការចូលរួមក្នុងការប្រកួតប្រជែង

កាលពីខែតុលាឆ្នាំមុន Telegram បានប្រកាសការប្រកួតប្រជែង blockchain ជាមួយនឹងភាសាថ្មី។ Fift и FunC. វាចាំបាច់ក្នុងការជ្រើសរើសពីការសរសេរកិច្ចសន្យាឆ្លាតវៃណាមួយដែលបានស្នើឡើងទាំងប្រាំ។ ខ្ញុំ​គិត​ថា​វា​ជា​ការ​ល្អ​ក្នុង​ការ​ធ្វើ​អ្វី​ដែល​ប្លែក​ពី​គេ រៀន​ភាសា និង​ធ្វើ​អ្វី​មួយ ទោះ​បី​ជា​ខ្ញុំ​មិន​ត្រូវ​សរសេរ​អ្វី​ផ្សេង​ទៀត​នៅ​ពេល​អនាគត។ លើសពីនេះប្រធានបទគឺជាប់ជានិច្ចនៅលើបបូរមាត់។

វាសមនឹងនិយាយថាខ្ញុំមិនមានបទពិសោធន៍ក្នុងការអភិវឌ្ឍន៍កិច្ចសន្យាឆ្លាតវៃទេ។

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

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

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

ពេលវេលាជាច្រើនត្រូវបានចំណាយលើការយល់ដឹង ដូច្នេះវាត្រូវបានគេសម្រេចចិត្តសរសេរអត្ថបទមួយ។ ដោយសារមិនទាន់មានព័ត៌មានច្រើន អត្ថបទនេះនឹងជួយសន្សំសំចៃពេលវេលាសម្រាប់អ្នកចាប់អារម្មណ៍គ្រប់គ្នា។

គំនិតនៃកិច្ចសន្យាឆ្លាតវៃនៅក្នុង TON

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

យើងនឹងផ្តោតលើការសរសេរកិច្ចសន្យាឆ្លាតវៃ និងធ្វើការជាមួយ TON Virtual Machine (TVM), Fift и FunCដូច្នេះអត្ថបទគឺដូចជាការពិពណ៌នាអំពីការអភិវឌ្ឍន៍កម្មវិធីធម្មតា។ យើងនឹងមិនពឹងផ្អែកលើរបៀបដែលវេទិកាខ្លួនវាដំណើរការនៅទីនេះទេ។

ជាទូទៅអំពីរបៀបដែលវាដំណើរការ TVM និងភាសា Fift មានឯកសារផ្លូវការល្អ។ ពេល​ចូល​រួម​ក្នុង​ការ​ប្រកួត​ប្រជែង ហើយ​ឥឡូវ​ពេល​កំពុង​សរសេរ​កិច្ច​សន្យា​បច្ចុប្បន្ន ខ្ញុំ​តែង​ងាក​ទៅ​រក​នាង។

ភាសាសំខាន់ដែលកិច្ចសន្យាឆ្លាតវៃត្រូវបានសរសេរ FunC. មិនមានឯកសារនៅលើវានៅពេលនេះទេ ដូច្នេះដើម្បីសរសេរអ្វីមួយ អ្នកត្រូវសិក្សាឧទាហរណ៍នៃកិច្ចសន្យាឆ្លាតវៃពីឃ្លាំងផ្លូវការ និងការអនុវត្តភាសាខ្លួនឯងនៅទីនោះ បូកអ្នកអាចមើលឧទាហរណ៍នៃកិច្ចសន្យាឆ្លាតវៃពីអតីតកាលពីរ។ ការប្រកួតប្រជែង។ តំណភ្ជាប់នៅចុងបញ្ចប់នៃអត្ថបទ។

ចូរនិយាយថាយើងបានសរសេរកិច្ចសន្យាឆ្លាតវៃរួចហើយសម្រាប់ FunCបន្ទាប់ពីនោះយើងចងក្រងកូដទៅជា Fift assembler។

កិច្ចសន្យាឆ្លាតវៃដែលបានចងក្រងនៅតែត្រូវបោះពុម្ព។ ដើម្បីធ្វើដូច្នេះអ្នកត្រូវសរសេរមុខងារនៅក្នុង Fiftដែលនឹងយកលេខកូដកិច្ចសន្យាឆ្លាតវៃ និងប៉ារ៉ាម៉ែត្រផ្សេងទៀតមួយចំនួនជាការបញ្ចូល ហើយលទ្ធផលនឹងជាឯកសារដែលមានផ្នែកបន្ថែម .boc (ដែលមានន័យថា "ថង់ក្រឡា") ហើយអាស្រ័យលើរបៀបដែលយើងសរសេរវា សោឯកជន និងអាសយដ្ឋាន ដែលត្រូវបានបង្កើតដោយផ្អែកលើលេខកូដកិច្ចសន្យាឆ្លាតវៃ។ អ្នកអាចផ្ញើក្រាមទៅអាសយដ្ឋាននៃកិច្ចសន្យាឆ្លាតវៃដែលមិនទាន់ត្រូវបានបោះពុម្ពផ្សាយរួចហើយ។

ដើម្បីបោះពុម្ពកិច្ចសន្យាឆ្លាតវៃនៅក្នុង TON បានទទួល .boc ឯកសារនឹងត្រូវបញ្ជូនទៅ blockchain ដោយប្រើម៉ាស៊ីនភ្ញៀវពន្លឺ (បន្ថែមលើវាខាងក្រោម) ។ ប៉ុន្តែមុនពេលបោះពុម្ព អ្នកត្រូវផ្ទេរក្រាមទៅអាសយដ្ឋានដែលបានបង្កើត បើមិនដូច្នេះទេកិច្ចសន្យាឆ្លាតវៃនឹងមិនត្រូវបានបោះពុម្ពទេ។ បន្ទាប់ពីការបោះពុម្ពផ្សាយ អ្នកអាចធ្វើអន្តរកម្មជាមួយកិច្ចសន្យាឆ្លាតវៃដោយផ្ញើសារពីខាងក្រៅ (ឧទាហរណ៍ ការប្រើប្រាស់ម៉ាស៊ីនភ្ញៀវពន្លឺ) ឬពីខាងក្នុង (ឧទាហរណ៍ កិច្ចសន្យាឆ្លាតវៃមួយផ្ញើសារផ្សេងទៀតនៅក្នុង TON) ។

នៅពេលដែលយើងយល់ពីរបៀបដែលកូដត្រូវបានបោះពុម្ព វាកាន់តែងាយស្រួល។ យើង​ប្រហែល​ជា​ដឹង​ពី​អ្វី​ដែល​យើង​ចង់​សរសេរ និង​របៀប​ដែល​កម្មវិធី​របស់​យើង​នឹង​ដំណើរការ។ ហើយខណៈពេលកំពុងសរសេរ យើងរកមើលពីរបៀបដែលវាត្រូវបានអនុវត្តនៅក្នុងកិច្ចសន្យាឆ្លាតវៃដែលមានស្រាប់ ឬយើងពិនិត្យមើលកូដការអនុវត្ត Fift и FunC នៅក្នុងឃ្លាំងផ្លូវការ ឬរកមើលនៅក្នុងឯកសារផ្លូវការ។

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

វាដល់ពេលដែលត្រូវផ្លាស់ប្តូរពីទ្រឹស្តីទៅការអនុវត្ត។

ការរៀបចំបរិស្ថានសម្រាប់ធ្វើការជាមួយ TON

ខ្ញុំបានធ្វើអ្វីគ្រប់យ៉ាងដែលនឹងត្រូវបានពិពណ៌នានៅក្នុងអត្ថបទនៅលើ MacOS ហើយបានពិនិត្យវាពីរដងក្នុង Ubuntu 18.04 LTS ស្អាតនៅលើ Docker ។

រឿងដំបូងដែលអ្នកត្រូវធ្វើគឺទាញយកនិងដំឡើង lite-client ដែលអ្នកអាចផ្ញើសំណើទៅ TON ។

ការណែនាំនៅលើគេហទំព័រផ្លូវការពណ៌នាអំពីដំណើរការដំឡើងយ៉ាងលម្អិត និងច្បាស់លាស់ ហើយលុបចោលព័ត៌មានលម្អិតមួយចំនួន។ នៅទីនេះយើងធ្វើតាមការណែនាំដោយដំឡើងភាពអាស្រ័យដែលបាត់នៅតាមផ្លូវ។ ខ្ញុំ​មិន​បាន​ចងក្រង​គម្រោង​នីមួយៗ​ដោយ​ខ្លួន​ឯង​ទេ ហើយ​បាន​ដំឡើង​ពី​ឃ្លាំង Ubuntu ផ្លូវការ (នៅ​លើ MacOS ដែល​ខ្ញុំ​បាន​ប្រើ brew).

apt -y install git 
apt -y install wget 
apt -y install cmake 
apt -y install g++ 
apt -y install zlib1g-dev 
apt -y install libssl-dev 

នៅពេលដំឡើងភាពអាស្រ័យទាំងអស់ អ្នកអាចដំឡើងបាន។ lite-client, Fift, FunC.

ដំបូង យើងក្លូនឃ្លាំង TON រួមជាមួយនឹងភាពអាស្រ័យរបស់វា។ ដើម្បីភាពងាយស្រួល យើងនឹងធ្វើអ្វីគ្រប់យ៉ាងនៅក្នុងថតមួយ។ ~/TON.

cd ~/TON
git clone https://github.com/ton-blockchain/ton.git
cd ./ton
git submodule update --init --recursive

ឃ្លាំងផ្ទុកនូវការអនុវត្តផងដែរ។ Fift и FunC.

ឥឡូវនេះយើងត្រៀមខ្លួនរួចរាល់ហើយដើម្បីប្រមូលផ្តុំគម្រោង។ លេខកូដឃ្លាំងត្រូវបានក្លូនទៅក្នុងថតឯកសារ ~/TON/ton។ នេះ ~/TON បង្កើតថតឯកសារ build ហើយប្រមូលគម្រោងនៅក្នុងនោះ។

mkdir ~/TON/build 
cd ~/TON/build
cmake ../ton

ដោយសារ​យើង​នឹង​សរសេរ​កិច្ចសន្យា​ឆ្លាត​វៃ យើង​ត្រូវ​ការ​មិន​ត្រឹម​តែ​ប៉ុណ្ណោះ។ lite-clientប៉ុន្តែ Fift с FunCដូច្នេះ ចូរយើងចងក្រងគ្រប់យ៉ាង។ វាមិនមែនជាដំណើរការរហ័សទេ ដូច្នេះយើងកំពុងរង់ចាំ។

cmake --build . --target lite-client
cmake --build . --target fift
cmake --build . --target func

បន្ទាប់មក ទាញយកឯកសារកំណត់រចនាសម្ព័ន្ធដែលមានទិន្នន័យអំពីថ្នាំងណា lite-client នឹងភ្ជាប់។

wget https://test.ton.org/ton-lite-client-test1.config.json

ធ្វើសំណើដំបូងទៅ TON

ឥឡូវនេះសូមចាប់ផ្តើម lite-client.

cd ~/TON/build
./lite-client/lite-client -C ton-lite-client-test1.config.json

ប្រសិនបើការស្ថាបនាបានជោគជ័យ នោះបន្ទាប់ពីការបើកដំណើរការ អ្នកនឹងឃើញកំណត់ហេតុនៃការភ្ជាប់ម៉ាស៊ីនភ្ញៀវពន្លឺទៅកាន់ថ្នាំង។

[ 1][t 2][1582054822.963129282][lite-client.h:201][!testnode]   conn ready
[ 2][t 2][1582054823.085654020][lite-client.cpp:277][!testnode] server version is 1.1, capabilities 7
[ 3][t 2][1582054823.085725069][lite-client.cpp:286][!testnode] server time is 1582054823 (delta 0)
...

អ្នកអាចដំណើរការពាក្យបញ្ជា help ហើយមើលពាក្យបញ្ជាណាដែលអាចប្រើបាន។

help

ចូររាយបញ្ជីពាក្យបញ្ជាដែលយើងនឹងប្រើក្នុងអត្ថបទនេះ។

list of available commands:
last    Get last block and state info from server
sendfile <filename> Load a serialized message from <filename> and send it to server
getaccount <addr> [<block-id-ext>]  Loads the most recent state of specified account; <addr> is in [<workchain>:]<hex-or-base64-addr> format
runmethod <addr> [<block-id-ext>] <method-id> <params>...   Runs GET method <method-id> of account <addr> with specified parameters

last получает последний созданный блок с сервера. 

sendfile <filename> отправляет в TON файл с сообщением, именно с помощью этой команды публикуется смарт-контракт и запрсосы к нему. 

getaccount <addr> загружает текущее состояние смарт-контракта с указанным адресом. 

runmethod <addr> [<block-id-ext>] <method-id> <params>  запускает get-методы смартконтракта. 

ឥឡូវនេះយើងត្រៀមខ្លួនរួចរាល់ហើយដើម្បីសរសេរកិច្ចសន្យាដោយខ្លួនឯង។

Реализация

គំនិត

ដូចដែលខ្ញុំបានសរសេរខាងលើកិច្ចសន្យាឆ្លាតដែលយើងកំពុងសរសេរគឺជាឆ្នោត។

ជាងនេះទៅទៀត នេះមិនមែនជាឆ្នោតដែលអ្នកត្រូវការទិញសំបុត្រ ហើយរង់ចាំមួយម៉ោង ថ្ងៃ ឬខែនោះទេ ប៉ុន្តែជាភ្លាមៗដែលអ្នកប្រើប្រាស់ផ្ទេរទៅអាសយដ្ឋានកិច្ចសន្យា។ N ក្រាម ហើយយកវាមកវិញភ្លាមៗ 2 * N ក្រាមឬចាញ់។ យើងនឹងធ្វើឱ្យប្រូបាប៊ីលីតេនៃការឈ្នះប្រហែល 40% ។ ប្រសិនបើមិនមានក្រាមគ្រប់គ្រាន់សម្រាប់ការទូទាត់ទេ នោះយើងនឹងពិចារណាប្រតិបត្តិការជាការបញ្ចូលទឹកប្រាក់។

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

ការសរសេរកិច្ចសន្យាឆ្លាតវៃ

ដើម្បីភាពងាយស្រួល ខ្ញុំបានរំលេចកូដសម្រាប់ FunC ហើយកម្មវិធីជំនួយអាចត្រូវបានរកឃើញ និងដំឡើងនៅក្នុងការស្វែងរក Visual Studio Code ប្រសិនបើអ្នកភ្លាមៗចង់បន្ថែមអ្វីមួយ ខ្ញុំបានធ្វើឱ្យកម្មវិធីជំនួយនេះអាចប្រើបានជាសាធារណៈ។ ដូចគ្នានេះផងដែរ នរណាម្នាក់ពីមុនបានបង្កើតកម្មវិធីជំនួយសម្រាប់ធ្វើការជាមួយ Fift អ្នកក៏អាចដំឡើងវា និងស្វែងរកវានៅក្នុង VSC ផងដែរ។

តោះបង្កើតឃ្លាំងមួយភ្លាមៗ ដែលយើងនឹងសម្រេចលទ្ធផលកម្រិតមធ្យម។

ដើម្បីធ្វើឱ្យជីវិតរបស់យើងកាន់តែងាយស្រួល យើងនឹងសរសេរកិច្ចសន្យាឆ្លាតវៃ ហើយសាកល្បងវានៅក្នុងមូលដ្ឋានរហូតដល់វារួចរាល់។ មានតែបន្ទាប់ពីនោះយើងនឹងបោះពុម្ពវានៅក្នុង TON ។

កិច្ចសន្យាឆ្លាតវៃមានវិធីសាស្រ្តខាងក្រៅពីរដែលអាចចូលបាន។ ទីមួយ recv_external() មុខងារនេះត្រូវបានប្រតិបត្តិនៅពេលដែលសំណើទៅកិច្ចសន្យាមកពីពិភពខាងក្រៅ ពោលគឺមិនមែនមកពី TON ឧទាហរណ៍ នៅពេលដែលយើងបង្កើតសារមួយ ហើយផ្ញើវាតាមរយៈអតិថិជនតិចតួច។ ទីពីរ recv_internal() នេះគឺជាពេលដែលនៅក្នុង TON ខ្លួនវា កិច្ចសន្យាណាមួយសំដៅទៅលើរបស់យើង។ ក្នុងករណីទាំងពីរអ្នកអាចឆ្លងប៉ារ៉ាម៉ែត្រទៅមុខងារ។

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

() recv_internal(slice in_msg) impure {
    ;; TODO: implementation 
}

() recv_external(slice in_msg) impure {
    ;; TODO: implementation  
}

នៅទីនេះយើងត្រូវពន្យល់ថាវាជាអ្វី slice. ទិន្នន័យទាំងអស់ដែលបានរក្សាទុកនៅក្នុង TON Blockchain គឺជាបណ្តុំមួយ។ TVM cell ឬធម្មតា cellនៅក្នុងក្រឡាបែបនេះ អ្នកអាចផ្ទុកទិន្នន័យរហូតដល់ 1023 ប៊ីត និងរហូតដល់ 4 តំណភ្ជាប់ទៅកាន់កោសិកាផ្សេងទៀត។

TVM cell slice ឬ slice នេះគឺជាផ្នែកមួយនៃការដែលមានស្រាប់ cell ត្រូវបានប្រើដើម្បីញែកវា វានឹងកាន់តែច្បាស់នៅពេលក្រោយ។ រឿងសំខាន់សម្រាប់យើងគឺថាយើងអាចផ្ទេរបាន។ slice ហើយអាស្រ័យលើប្រភេទនៃសារ ដំណើរការទិន្នន័យនៅក្នុង recv_external() ឬ recv_internal().

impure - ពាក្យគន្លឹះដែលបង្ហាញថាមុខងារកែប្រែទិន្នន័យកិច្ចសន្យាឆ្លាតវៃ។

តោះរក្សាទុកលេខកូដកិច្ចសន្យា lottery-code.fc និងចងក្រង។

~/TON/build/crypto/func -APSR -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc 

អត្ថន័យនៃទង់អាចត្រូវបានមើលដោយប្រើពាក្យបញ្ជា

~/TON/build/crypto/func -help

យើងបានចងក្រង Fift assembler code នៅក្នុង lottery-compiled.fif:

// lottery-compiled.fif

"Asm.fif" include
// automatically generated from `/Users/rajymbekkapisev/TON/ton/crypto/smartcont/stdlib.fc` `./lottery-code.fc` 
PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>c

វាអាចត្រូវបានដាក់ឱ្យដំណើរការក្នុងស្រុកសម្រាប់ការនេះយើងនឹងរៀបចំបរិស្ថាន។

ចំណាំថាខ្សែទីមួយតភ្ជាប់ Asm.fifនេះគឺជាកូដដែលសរសេរក្នុង Fift for the Fift assembler។

ដោយសារយើងចង់ដំណើរការ និងសាកល្បងកិច្ចសន្យាឆ្លាតវៃក្នុងមូលដ្ឋាន យើងនឹងបង្កើតឯកសារមួយ។ lottery-test-suite.fif ហើយចម្លងកូដដែលបានចងក្រងនៅទីនោះ ដោយជំនួសបន្ទាត់ចុងក្រោយនៅក្នុងវា ដែលសរសេរកូដកិច្ចសន្យាឆ្លាតវៃទៅជាថេរ។ codeដើម្បីផ្ទេរវាទៅម៉ាស៊ីននិម្មិត៖

"TonUtil.fif" include
"Asm.fif" include

PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>s constant code

រហូតមកដល់ពេលនេះ វាហាក់ដូចជាច្បាស់ហើយ ឥឡូវនេះ សូមបន្ថែមទៅឯកសារដូចគ្នានូវកូដដែលយើងនឹងប្រើដើម្បីបើកដំណើរការ TVM ។

0 tuple 0x076ef1ea , // magic
0 , 0 , // actions msg_sents
1570998536 , // unix_time
1 , 1 , 3 , // block_lt, trans_lt, rand_seed
0 tuple 100000000000000 , dictnew , , // remaining balance
0 , dictnew , // contract_address, global_config
1 tuple // wrap to another tuple
constant c7

0 constant recv_internal // to run recv_internal() 
-1 constant recv_external // to invoke recv_external()

В c7 យើងកត់ត្រាបរិបទ នោះគឺជាទិន្នន័យដែល TVM (ឬស្ថានភាពបណ្តាញ) នឹងត្រូវបានដាក់ឱ្យដំណើរការ។ សូម្បីតែក្នុងអំឡុងពេលប្រកួតប្រជែងអ្នកអភិវឌ្ឍន៍ម្នាក់បានបង្ហាញពីរបៀបបង្កើត c7 ហើយខ្ញុំបានចម្លង។ នៅក្នុងអត្ថបទនេះ យើងប្រហែលជាត្រូវផ្លាស់ប្តូរ rand_seed ចាប់តាំងពីជំនាន់នៃលេខចៃដន្យអាស្រ័យលើវា ហើយប្រសិនបើមិនផ្លាស់ប្តូរទេ លេខដូចគ្នានឹងត្រូវបានត្រឡប់មកវិញរាល់ពេល។

recv_internal и recv_external ថេរដែលមានតម្លៃ 0 និង -1 នឹងទទួលខុសត្រូវចំពោះការហៅមុខងារដែលត្រូវគ្នានៅក្នុងកិច្ចសន្យាឆ្លាតវៃ។

ឥឡូវនេះយើងត្រៀមខ្លួនជាស្រេចដើម្បីបង្កើតការសាកល្បងដំបូងសម្រាប់កិច្ចសន្យាឆ្លាតវៃទទេរបស់យើង។ សម្រាប់ភាពច្បាស់លាស់សម្រាប់ពេលនេះយើងនឹងបន្ថែមការធ្វើតេស្តទាំងអស់ទៅក្នុងឯកសារដូចគ្នា។ lottery-test-suite.fif.

តោះបង្កើតអថេរ storage ហើយសរសេរទទេទៅក្នុងនោះ។ cellនេះនឹងជាកន្លែងផ្ទុកកិច្ចសន្យាឆ្លាតវៃ។

message នេះគឺជាសារដែលយើងនឹងបញ្ជូនទៅកាន់ទំនាក់ទំនងឆ្លាតវៃពីខាងក្រៅ។ យើងក៏នឹងធ្វើឱ្យវាទទេសម្រាប់ពេលនេះដែរ។

variable storage 
<b b> storage ! 

variable message 
<b b> message ! 

បន្ទាប់ពីយើងរៀបចំថេរ និងអថេរ យើងបើក TVM ដោយប្រើពាក្យបញ្ជា runvmctx និងបញ្ជូនប៉ារ៉ាម៉ែត្រដែលបានបង្កើតទៅធាតុបញ្ចូល។

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx 

នៅទីបញ្ចប់យើងនឹងទទួលបានជោគជ័យ ដូចនេះ កូដកម្រិតមធ្យមសម្រាប់ Fift.

ឥឡូវនេះយើងអាចដំណើរការកូដលទ្ធផល។

export FIFTPATH=~/TON/ton/crypto/fift/lib // выполняем один раз для удобства 
~/TON/build/crypto/fift -s lottery-test-suite.fif 

កម្មវិធីគួរតែដំណើរការដោយគ្មានកំហុស ហើយនៅក្នុងលទ្ធផលយើងនឹងឃើញកំណត់ហេតុប្រតិបត្តិ៖

execute SETCP 0
execute DICTPUSHCONST 19 (xC_,1)
execute DICTIGETJMPZ
execute DROP
execute implicit RET
[ 3][t 0][1582281699.325381279][vm.cpp:479]     steps: 5 gas: used=304, max=9223372036854775807, limit=9223372036854775807, credit=0

ល្អណាស់ យើងបានសរសេរកំណែការងារដំបូងនៃកិច្ចសន្យាឆ្លាតវៃ។

ឥឡូវនេះយើងត្រូវបន្ថែមមុខងារ។ ជាដំបូង ចូរយើងដោះស្រាយជាមួយនឹងសារដែលមកពីពិភពខាងក្រៅទៅ recv_external()

អ្នកអភិវឌ្ឍន៍ខ្លួនឯងជ្រើសរើសទម្រង់សារដែលកិច្ចសន្យាអាចទទួលយកបាន។

ប៉ុន្តែជាធម្មតា

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

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

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

មានវិធីផ្សេងគ្នាដើម្បីដោះស្រាយបញ្ហាជាមួយសារស្ទួន។ នេះជារបៀបដែលយើងនឹងធ្វើវា។ នៅក្នុងកិច្ចសន្យាឆ្លាតវៃ យើងចាប់ផ្តើមរាប់សារដែលទទួលបានដោយតម្លៃដំបូង 0។ ក្នុងសារនីមួយៗទៅកាន់កិច្ចសន្យាឆ្លាតវៃ យើងនឹងបន្ថែមតម្លៃបញ្ជរបច្ចុប្បន្ន។ ប្រសិនបើតម្លៃរាប់ក្នុងសារមិនត្រូវគ្នានឹងតម្លៃនៅក្នុងកិច្ចសន្យាឆ្លាតវៃនោះ យើងមិនដំណើរការវាទេ ប្រសិនបើវាកើតឡើង យើងដំណើរការវា ហើយបង្កើនចំនួនរាប់ក្នុងកិច្ចសន្យាឆ្លាតវៃដោយ 1 ។

តោះត្រឡប់ទៅ lottery-test-suite.fif ហើយបន្ថែមការធ្វើតេស្តទីពីរទៅវា។ ប្រសិនបើយើងផ្ញើលេខមិនត្រឹមត្រូវ លេខកូដគួរតែលើកលែង។ ឧទាហរណ៍ អនុញ្ញាតឱ្យទិន្នន័យកិច្ចសន្យារក្សាទុក 166 ហើយយើងនឹងផ្ញើ 165 ។

<b 166 32 u, b> storage !
<b 165 32 u, b> message !

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

drop 
exit_code ! 
."Exit code " exit_code @ . cr 
exit_code @ 33 - abort"Test #2 Not passed"

តោះចាប់ផ្តើម។

 ~/TON/build/crypto/fift -s lottery-test-suite.fif 

ហើយយើងនឹងឃើញថាការធ្វើតេស្តដំណើរការដោយមានកំហុស។

[ 1][t 0][1582283084.210902214][words.cpp:3046] lottery-test-suite.fif:67: abort": Test #2 Not passed
[ 1][t 0][1582283084.210941076][fift-main.cpp:196]      Error interpreting file `lottery-test-suite.fif`: error interpreting included file `lottery-test-suite.fif` : lottery-test-suite.fif:67: abort": Test #2 Not passed

នៅ​ដំណាក់កាល​នេះ lottery-test-suite.fif គួរតែមើលទៅដូច តំណភ្ជាប់.

ឥឡូវនេះ ចូរយើងបន្ថែមតក្កវិជ្ជាប្រឆាំងទៅនឹងកិច្ចសន្យាឆ្លាតវៃ lottery-code.fc.

() recv_internal(slice in_msg) impure {
    ;; TODO: implementation 
}

() recv_external(slice in_msg) impure {
    if (slice_empty?(in_msg)) {
        return (); 
    }
    int msg_seqno = in_msg~load_uint(32);
    var ds = begin_parse(get_data());
    int stored_seqno = ds~load_uint(32);
    throw_unless(33, msg_seqno == stored_seqno);
}

В slice in_msg កុហកសារដែលយើងផ្ញើ។

រឿងដំបូងដែលយើងធ្វើគឺពិនិត្យមើលថាតើសារមានទិន្នន័យឬអត់ នោះយើងគ្រាន់តែចេញ។

បន្ទាប់យើងញែកសារ។ in_msg~load_uint(32) ផ្ទុកលេខ 165, 32 ប៊ីត unsigned int ពីសារដែលបានបញ្ជូន។

បន្ទាប់យើងផ្ទុក 32 ប៊ីតពីឧបករណ៍ផ្ទុកកិច្ចសន្យាឆ្លាតវៃ។ យើងពិនិត្យមើលថាលេខដែលផ្ទុកត្រូវគ្នានឹងលេខដែលបានឆ្លងកាត់ បើមិនអញ្ចឹងទេ យើងលើកករណីលើកលែងមួយ។ ក្នុងករណីរបស់យើង ដោយសារយើងកំពុងឆ្លងកាត់ការមិនប្រកួត ការលើកលែងមួយគួរតែត្រូវបានបដិសេធ។

ឥឡូវនេះ ចូរយើងចងក្រង។

~/TON/build/crypto/func -APSR -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc 

ចម្លងលេខកូដលទ្ធផលទៅ lottery-test-suite.fifកុំភ្លេចជំនួសបន្ទាត់ចុងក្រោយ។

យើងពិនិត្យមើលថាការប្រលងបានឆ្លងកាត់:

~/TON/build/crypto/fift -s lottery-test-suite.fif

នៅ​ទី​នេះ អ្នកអាចឃើញការប្តេជ្ញាចិត្តដែលត្រូវគ្នាជាមួយនឹងលទ្ធផលបច្ចុប្បន្ន។

សូមចំណាំថា វាមានការរអាក់រអួលក្នុងការចម្លងកូដដែលបានចងក្រងជាបន្តនៃកិច្ចសន្យាឆ្លាតវៃទៅក្នុងឯកសារដែលមានការធ្វើតេស្ត ដូច្នេះ ចូរយើងសរសេរស្គ្រីបដែលនឹងសរសេរកូដទៅជាថេរសម្រាប់យើង ហើយយើងនឹងភ្ជាប់កូដដែលបានចងក្រងទៅនឹងការធ្វើតេស្តរបស់យើងដោយប្រើ "include".

បង្កើតឯកសារក្នុងថតគម្រោង build.sh ជាមួយនឹងខ្លឹមសារដូចខាងក្រោម។

#!/bin/bash

~/TON/build/crypto/func -SPA -R -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc

ចូរ​ធ្វើ​ឱ្យ​វា​អាច​ប្រតិបត្តិ​បាន។

chmod +x ./build.sh

ឥឡូវនេះគ្រាន់តែដំណើរការស្គ្រីបរបស់យើងដើម្បីចងក្រងកិច្ចសន្យា។ ប៉ុន្តែក្រៅពីនេះយើងត្រូវសរសេរវាទៅជាថេរ code. ដូច្នេះយើងនឹងបង្កើតឯកសារថ្មី។ lotter-compiled-for-test.fifដែលយើងនឹងបញ្ចូលក្នុងឯកសារ lottery-test-suite.fif.

តោះបន្ថែម skirt code ទៅ sh ដែលនឹងចម្លងឯកសារដែលបានចងក្រងជាធម្មតា។ lotter-compiled-for-test.fif ហើយផ្លាស់ប្តូរបន្ទាត់ចុងក្រោយនៅក្នុងវា។

# copy and change for test 
cp lottery-compiled.fif lottery-compiled-for-test.fif
sed '$d' lottery-compiled-for-test.fif > test.fif
rm lottery-compiled-for-test.fif
mv test.fif lottery-compiled-for-test.fif
echo -n "}END>s constant code" >> lottery-compiled-for-test.fif

ឥឡូវនេះ ដើម្បីពិនិត្យមើល សូមដំណើរការស្គ្រីបលទ្ធផល ហើយឯកសារមួយនឹងត្រូវបានបង្កើត lottery-compiled-for-test.fifដែលយើងនឹងរួមបញ្ចូលនៅក្នុងរបស់យើង។ lottery-test-suite.fif

В lottery-test-suite.fif លុបលេខកូដកិច្ចសន្យា ហើយបន្ថែមបន្ទាត់ "lottery-compiled-for-test.fif" include.

យើងដំណើរការតេស្តដើម្បីពិនិត្យមើលថាពួកគេឆ្លងកាត់។

~/TON/build/crypto/fift -s lottery-test-suite.fif

ជាការប្រសើរណាស់ ឥឡូវនេះ ដើម្បីធ្វើស្វ័យប្រវត្តិកម្មនៃការចាប់ផ្តើមការធ្វើតេស្ត សូមយើងបង្កើតឯកសារមួយ។ test.shដែលនឹងប្រតិបត្តិដំបូង build.shហើយបន្ទាប់មកដំណើរការការធ្វើតេស្ត។

touch test.sh
chmod +x test.sh

យើងសរសេរនៅខាងក្នុង

./build.sh 

echo "nCompilation completedn"

export FIFTPATH=~/TON/ton/crypto/fift/lib
~/TON/build/crypto/fift -s lottery-test-suite.fif

តោះ​ធ្វើ​វា test.sh ហើយដំណើរការវា ដើម្បីប្រាកដថាការធ្វើតេស្តដំណើរការ។

chmod +x ./test.sh
./test.sh

យើងពិនិត្យមើលថាកិច្ចសន្យាចងក្រង ហើយការធ្វើតេស្តត្រូវបានប្រតិបត្តិ។

ល្អណាស់ ឥឡូវនេះនៅពេលចាប់ផ្តើម test.sh ការធ្វើតេស្តនឹងត្រូវបានចងក្រង និងដំណើរការភ្លាមៗ។ នេះគឺជាតំណភ្ជាប់ទៅ ប្តេជ្ញាចិត្ត.

មិនអីទេ មុននឹងបន្ត យើងធ្វើរឿងមួយបន្ថែមទៀត ដើម្បីភាពងាយស្រួល។

តោះបង្កើតថតឯកសារ build កន្លែងដែលយើងនឹងរក្សាទុកកិច្ចសន្យាដែលបានចម្លង និងក្លូនរបស់វាដែលសរសេរជាថេរ lottery-compiled.fif, lottery-compiled-for-test.fif. ចូរយើងបង្កើតថតឯកសារផងដែរ។ test តើឯកសារសាកល្បងនឹងត្រូវរក្សាទុកនៅឯណា? lottery-test-suite.fif និងឯកសារគាំទ្រដ៏មានសក្តានុពលផ្សេងទៀត។ ភ្ជាប់ទៅការផ្លាស់ប្តូរដែលពាក់ព័ន្ធ.

ចូរបន្តអភិវឌ្ឍកិច្ចសន្យាឆ្លាតវៃ។

បន្ទាប់មកគួរតែមានការធ្វើតេស្តដែលពិនិត្យមើលថាសារត្រូវបានទទួលហើយបញ្ជរត្រូវបានធ្វើបច្ចុប្បន្នភាពនៅក្នុងហាងនៅពេលដែលយើងផ្ញើលេខត្រឹមត្រូវ។ ប៉ុន្តែយើងនឹងធ្វើវានៅពេលក្រោយ។

ឥឡូវនេះ ចូរយើងគិតពីរចនាសម្ព័ន្ធទិន្នន័យ និងទិន្នន័យអ្វីដែលត្រូវរក្សាទុកនៅក្នុងកិច្ចសន្យាឆ្លាតវៃ។

ខ្ញុំ​នឹង​រៀបរាប់​អ្វី​គ្រប់​យ៉ាង​ដែល​យើង​រក្សា​ទុក។

`seqno` 32-х битное целое положительное число счетчик. 

`pubkey` 256-ти битное целое положительное число публичный ключ, с помощью которого, мы будем проверять подпись отправленного извне сообщения, о чем ниже. 

`order_seqno` 32-х битное целое положительное число хранит счетчик количества ставок. 

`number_of_wins` 32-х битное целое положительное число хранит  количество побед. 

`incoming_amount` тип данных Gram (первые 4 бита отвечает за длину), хранит общее количество грамов, которые были отправлены на контртакт. 

`outgoing_amount` общее количество грамов, которое было отправлено победителям. 

`owner_wc` номер воркчейна, 32-х битное (в некоторых местах написано, что 8-ми битное) целое число. В данный момент всего два -1 и 0. 

`owner_account_id` 256-ти битное целое положительное число, адрес контракта в текущем воркчейне. 

`orders` переменная типа словарь, хранит последние двадцать ставок. 

បន្ទាប់អ្នកត្រូវសរសេរមុខងារពីរ។ តោះហៅដំបូង pack_state()ដែលនឹងខ្ចប់ទិន្នន័យសម្រាប់ការរក្សាទុកជាបន្តបន្ទាប់នៅក្នុងកន្លែងផ្ទុកកិច្ចសន្យាឆ្លាតវៃ។ តោះហៅទីពីរ unpack_state() នឹងអាន និងត្រឡប់ទិន្នន័យពីកន្លែងផ្ទុក។

_ pack_state(int seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) inline_ref {
    return begin_cell()
            .store_uint(seqno, 32)
            .store_uint(pubkey, 256)
            .store_uint(order_seqno, 32)
            .store_uint(number_of_wins, 32)
            .store_grams(incoming_amount)
            .store_grams(outgoing_amount)
            .store_int(owner_wc, 32)
            .store_uint(owner_account_id, 256)
            .store_dict(orders)
            .end_cell();
}

_ unpack_state() inline_ref {
    var ds = begin_parse(get_data());
    var unpacked = (ds~load_uint(32), ds~load_uint(256), ds~load_uint(32), ds~load_uint(32), ds~load_grams(), ds~load_grams(), ds~load_int(32), ds~load_uint(256), ds~load_dict());
    ds.end_parse();
    return unpacked;
}

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

ដើម្បីរក្សាទុកទិន្នន័យ អ្នកនឹងត្រូវហៅមុខងារដែលភ្ជាប់មកជាមួយ set_data() ហើយវានឹងសរសេរទិន្នន័យពី pack_state() នៅក្នុងការផ្ទុកកិច្ចសន្យាឆ្លាតវៃ។

cell packed_state = pack_state(arg_1, .., arg_n); 
set_data(packed_state);

ឥឡូវនេះយើងមានមុខងារងាយស្រួលសម្រាប់ការសរសេរ និងអានទិន្នន័យ យើងអាចបន្តទៅមុខទៀត។

យើងត្រូវពិនិត្យមើលថាសារដែលចូលមកពីខាងក្រៅត្រូវបានចុះហត្ថលេខាដោយម្ចាស់កិច្ចសន្យា (ឬអ្នកប្រើប្រាស់ផ្សេងទៀតដែលមានសិទ្ធិចូលប្រើសោឯកជន)។

នៅពេលដែលយើងបោះផ្សាយកិច្ចសន្យាឆ្លាតវៃ យើងអាចចាប់ផ្តើមវាជាមួយនឹងទិន្នន័យដែលយើងត្រូវការនៅក្នុងការផ្ទុក ដែលនឹងត្រូវបានរក្សាទុកសម្រាប់ការប្រើប្រាស់នាពេលអនាគត។ យើងនឹងកត់ត្រាសោសាធារណៈនៅទីនោះ ដើម្បីឱ្យយើងអាចផ្ទៀងផ្ទាត់ថាសារចូលត្រូវបានចុះហត្ថលេខាជាមួយនឹងសោឯកជនដែលត្រូវគ្នា។

មុននឹងបន្ត យើងបង្កើតសោឯកជន ហើយសរសេរវាទៅ test/keys/owner.pk. ដើម្បីធ្វើដូចនេះសូមបើកដំណើរការ Fift នៅក្នុងរបៀបអន្តរកម្មហើយប្រតិបត្តិពាក្យបញ្ជាចំនួនបួន។

`newkeypair` генерация публичного и приватного ключа и запись их в стек. 

`drop` удаления из стека верхнего элемента (в данном случае публичный ключ)  

`.s` просто посмотреть что лежит в стеке в данный момент 

`"owner.pk" B>file` запись приватного ключа в файл с именем `owner.pk`. 

`bye` завершает работу с Fift. 

តោះបង្កើតថតឯកសារ keys នៅខាងក្នុងថត test ហើយសរសេរសោឯកជននៅទីនោះ។

mkdir test/keys
cd test/keys
~/TON/build/crypto/fift -i 
newkeypair
 ok
.s 
BYTES:128DB222CEB6CF5722021C3F21D4DF391CE6D5F70C874097E28D06FCE9FD6917 BYTES:DD0A81AAF5C07AAAA0C7772BB274E494E93BB0123AA1B29ECE7D42AE45184128 
drop 
 ok
"owner.pk" B>file
 ok
bye

យើងឃើញឯកសារមួយនៅក្នុងថតបច្ចុប្បន្ន owner.pk.

យើងដកសោសាធារណៈចេញពីជង់ ហើយនៅពេលចាំបាច់ យើងអាចយកវាពីសោឯកជនបាន។

ឥឡូវនេះយើងត្រូវសរសេរការផ្ទៀងផ្ទាត់ហត្ថលេខា។ ចូរចាប់ផ្តើមជាមួយនឹងការសាកល្បង។ ដំបូងយើងអានកូនសោឯកជនពីឯកសារដោយប្រើមុខងារ file>B ហើយសរសេរវាទៅជាអថេរ owner_private_keyបន្ទាប់មកប្រើមុខងារ priv>pub បំប្លែងសោឯកជនទៅជាសោសាធារណៈ ហើយសរសេរលទ្ធផលជា owner_public_key.

variable owner_private_key
variable owner_public_key 

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !

យើងនឹងត្រូវការសោទាំងពីរ។

យើងចាប់ផ្តើមការផ្ទុកកិច្ចសន្យាឆ្លាតវៃជាមួយនឹងទិន្នន័យបំពានក្នុងលំដាប់ដូចគ្នានឹងមុខងារ pack_state()ហើយសរសេរវាទៅជាអថេរ storage.

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !
dictnew orders !
0 owner_wc !
0 owner_account_id !

<b 0 32 u, owner_public_key @ B, 0 32 u, 0 32 u, 0 Gram, 0 Gram, owner_wc @ 32 i, owner_account_id @ 256 u,  orders @ dict, b> storage !

បន្ទាប់មក យើងនឹងសរសេរសារដែលមានហត្ថលេខា វានឹងមានតែហត្ថលេខា និងតម្លៃរាប់ប៉ុណ្ណោះ។

ដំបូង យើងបង្កើតទិន្នន័យដែលយើងចង់បញ្ជូន បន្ទាប់មកយើងចុះហត្ថលេខាវាដោយប្រើសោឯកជន ហើយចុងក្រោយយើងបង្កើតសារដែលបានចុះហត្ថលេខា។

variable message_to_sign
variable message_to_send
variable signature
<b 0 32 u, b> message_to_sign !
message_to_sign @ hashu owner_private_key @ ed25519_sign_uint signature !
<b signature @ B, 0 32 u, b> <s  message_to_send !  

ជាលទ្ធផល សារដែលយើងនឹងផ្ញើទៅកាន់កិច្ចសន្យាឆ្លាតវៃត្រូវបានកត់ត្រាក្នុងអថេរមួយ។ message_to_send, អំពីមុខងារ hashu, ed25519_sign_uint អ្នកអាចអាន នៅក្នុងឯកសារ Fift.

ហើយដើម្បីដំណើរការការសាកល្បង យើងហៅម្តងទៀត។

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

នៅទីនេះ ឯកសារដែលមានការធ្វើតេស្តគួរតែមើលទៅដូចនេះនៅដំណាក់កាលនេះ។

សូមដំណើរការសាកល្បង ហើយវានឹងបរាជ័យ ដូច្នេះយើងនឹងផ្លាស់ប្តូរកិច្ចសន្យាឆ្លាតវៃ ដើម្បីឱ្យវាអាចទទួលបានសារនៃទម្រង់នេះ និងផ្ទៀងផ្ទាត់ហត្ថលេខា។

ដំបូងយើងរាប់ 512 ប៊ីតនៃហត្ថលេខាពីសារហើយសរសេរវាទៅអថេរមួយ បន្ទាប់មកយើងរាប់ 32 ប៊ីតនៃអថេររាប់។

ដោយសារយើងមានមុខងារសម្រាប់អានទិន្នន័យពីកន្លែងផ្ទុកកិច្ចសន្យាឆ្លាតវៃ យើងនឹងប្រើវា។

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

var signature = in_msg~load_bits(512);
var message = in_msg;
int msg_seqno = message~load_uint(32);
(int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
throw_unless(33, msg_seqno == stored_seqno);
throw_unless(34, check_signature(slice_hash(in_msg), signature, pubkey));

ការប្តេជ្ញាចិត្តដែលពាក់ព័ន្ធ នៅទីនេះ.

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

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

ចូរយើងសរសេរការសាកល្បងលើកទីបួន ដែលយើងនឹងផ្ញើសារដែលចុះហត្ថលេខាជាមួយនឹងសោឯកជនរបស់នរណាម្នាក់។ តោះបង្កើតកូនសោឯកជនមួយទៀត ហើយរក្សាទុកវាទៅក្នុងឯកសារ not-owner.pk. យើងនឹងចុះហត្ថលេខាលើសារដោយប្រើសោឯកជននេះ។ ចូរ​ដំណើរការ​ការ​ធ្វើ​តេ​ស្ត​ហើយ​ធ្វើ​ឱ្យ​ប្រាកដ​ថា​ការ​ធ្វើ​តេ​ស្ត​ទាំងអស់​បាន​ឆ្លង​កាត់​។ ប្តេជ្ញាចិត្ត នៅពេលនេះ។

ឥឡូវនេះយើងអាចបន្តទៅការអនុវត្តតក្កវិជ្ជាកិច្ចសន្យាឆ្លាតវៃ។
В recv_external() យើងនឹងទទួលយកសារពីរប្រភេទ។

ដោយសារកិច្ចសន្យារបស់យើងនឹងប្រមូលការខាតបង់របស់អ្នកលេង លុយនេះត្រូវតែផ្ទេរទៅឱ្យអ្នកបង្កើតឆ្នោត។ អាសយដ្ឋានកាបូបរបស់អ្នកបង្កើតឆ្នោតត្រូវបានកត់ត្រានៅក្នុងកន្លែងផ្ទុកនៅពេលដែលកិច្ចសន្យាត្រូវបានបង្កើត។

ក្នុងករណីដែលយើងត្រូវការសមត្ថភាពក្នុងការផ្លាស់ប្តូរអាសយដ្ឋានដែលយើងផ្ញើក្រាមរបស់អ្នកចាញ់។ យើងក៏គួរតែអាចផ្ញើក្រាមពីឆ្នោតទៅអាសយដ្ឋានរបស់ម្ចាស់។

ចូរចាប់ផ្តើមជាមួយទីមួយ។ ចូរយើងសរសេរការសាកល្បងជាមុនសិនដែលនឹងពិនិត្យមើលថាបន្ទាប់ពីការផ្ញើសារ កិច្ចសន្យាឆ្លាតវៃបានរក្សាទុកអាសយដ្ឋានថ្មីនៅក្នុងកន្លែងផ្ទុក។ សូមចំណាំថានៅក្នុងសារ បន្ថែមពីលើបញ្ជរ និងអាសយដ្ឋានថ្មី យើងក៏បញ្ជូនផងដែរ។ action ចំនួនគត់មិនអវិជ្ជមាន 7 ប៊ីត អាស្រ័យលើវា យើងនឹងជ្រើសរើសរបៀបដំណើរការសារនៅក្នុងកិច្ចសន្យាឆ្លាតវៃ។

<b 0 32 u, 1 @ 7 u, new_owner_wc @  32 i, new_owner_account_id @ 256 u, b> message_to_sign !

នៅក្នុងការធ្វើតេស្ត អ្នកអាចមើលឃើញពីរបៀបដែលការផ្ទុកកិច្ចសន្យាឆ្លាតវៃត្រូវបាន deserialized storage នៅក្នុង Fift ។ Deserialization នៃអថេរត្រូវបានពិពណ៌នានៅក្នុងឯកសារ Fift ។

តំណ​ភ្ជាប់ ជាមួយនឹងការបន្ថែម dough ។

ចូរ​រត់​ការ​ធ្វើ​តេ​ស្ត​ហើយ​ធ្វើ​ឱ្យ​ប្រាកដ​ថា​វា​បរាជ័យ​។ ឥឡូវនេះ សូមបន្ថែមតក្កវិជ្ជាដើម្បីផ្លាស់ប្តូរអាសយដ្ឋានរបស់ម្ចាស់ឆ្នោត។

នៅក្នុងកិច្ចសន្យាឆ្លាតវៃ យើងបន្តញែក message, អាន action. ចូរយើងរំលឹកអ្នកថាយើងនឹងមានពីរ action៖ ផ្លាស់ប្តូរអាសយដ្ឋាន និងផ្ញើក្រាម។

បន្ទាប់មកយើងអានអាសយដ្ឋានថ្មីរបស់ម្ចាស់កិច្ចសន្យាហើយរក្សាទុកវានៅក្នុងកន្លែងផ្ទុក។
យើង​ដំណើរការ​ការ​ធ្វើ​តេស្ត​ហើយ​ឃើញ​ថា​ការ​ធ្វើ​តេស្ត​ទី​បី​បរាជ័យ។ វាគាំងដោយសារតែការពិតដែលថាកិច្ចសន្យាឥឡូវនេះបន្ថែម 7 ប៊ីតពីសារដែលបាត់នៅក្នុងការសាកល្បង។ បន្ថែមធាតុដែលមិនមានទៅសារ action. ចូរ​យើង​ដំណើរការ​ការ​ធ្វើ​តេ​ស្ត​ហើយ​មើល​ថា​អ្វី​គ្រប់​យ៉ាង​បាន​កន្លង​ផុត​ទៅ​។ នៅទីនេះ ប្តេជ្ញាចិត្តចំពោះការផ្លាស់ប្តូរ។ អស្ចារ្យ។

ឥឡូវនេះ ចូរយើងសរសេរតក្កវិជ្ជាសម្រាប់ការផ្ញើចំនួនក្រាមដែលបានបញ្ជាក់ទៅកាន់អាសយដ្ឋានដែលបានរក្សាទុកពីមុន។

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

ឥឡូវនេះសូមបន្ថែមលេខកូដ។ ដំបូងយើងសរសេរវិធីជំនួយពីរ។ វិធីសាស្រ្តទទួលបានដំបូងគឺដើម្បីស្វែងរកសមតុល្យបច្ចុប្បន្ននៃកិច្ចសន្យាឆ្លាតវៃ។

int balance() inline_ref method_id {
    return get_balance().pair_first();
}

ហើយទីពីរគឺសម្រាប់ការផ្ញើក្រាមទៅកិច្ចសន្យាឆ្លាតមួយផ្សេងទៀត។ ខ្ញុំបានចម្លងវិធីសាស្រ្តនេះទាំងស្រុងពីកិច្ចសន្យាឆ្លាតវៃមួយផ្សេងទៀត។

() send_grams(int wc, int addr, int grams) impure {
    ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000
    cell msg = begin_cell()
    ;;  .store_uint(0, 1) ;; 0 <= format indicator int_msg_info$0 
    ;;  .store_uint(1, 1) ;; 1 <= ihr disabled
    ;;  .store_uint(1, 1) ;; 1 <= bounce = true
    ;;  .store_uint(0, 1) ;; 0 <= bounced = false
    ;;  .store_uint(4, 5)  ;; 00100 <= address flags, anycast = false, 8-bit workchain
        .store_uint (196, 9)
        .store_int(wc, 8)
        .store_uint(addr, 256)
        .store_grams(grams)
        .store_uint(0, 107) ;; 106 zeroes +  0 as an indicator that there is no cell with the data.
        .end_cell(); 
    send_raw_message(msg, 3); ;; mode, 2 for ignoring errors, 1 for sender pays fees, 64 for returning inbound message value
}

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

int amount_to_send = message~load_grams();
throw_if(36, amount_to_send + 500000000 > balance());
accept_message();
send_grams(owner_wc, owner_account_id, amount_to_send);
set_data(pack_state(stored_seqno + 1, pubkey, order_seqno, number_of_wins, incoming_amount, outgoing_amount, owner_wc, owner_account_id, orders));

នៅទីនេះ មើលទៅដូចជាកិច្ចសន្យាឆ្លាតវៃនៅពេលនេះ។ ចូរ​រត់​ការ​ធ្វើ​តេ​ស្ត​និង​ធ្វើ​ឱ្យ​ប្រាកដ​ថា​ពួក​គេ​បាន​ឆ្លង​កាត់​។

ដោយវិធីនេះ កម្រៃជើងសារមួយត្រូវបានកាត់ចេញពីកិច្ចសន្យាឆ្លាតវៃរាល់ពេលសម្រាប់សារដែលបានដំណើរការ។ ដើម្បីឱ្យសារកិច្ចសន្យាឆ្លាតវៃអាចប្រតិបត្តិសំណើ បន្ទាប់ពីការត្រួតពិនិត្យជាមូលដ្ឋាន អ្នកត្រូវហៅទូរសព្ទ accept_message().

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

ជាដំបូង ចូរយើងសរសេរការធ្វើតេស្តសាមញ្ញ។ ដើម្បីធ្វើដូចនេះយើងត្រូវការអាសយដ្ឋានសាកល្បងនៃកិច្ចសន្យាឆ្លាតវៃដែលយើងសន្មត់ថាផ្ញើក្រាមទៅកិច្ចសន្យាឆ្លាតវៃ។

អាសយដ្ឋានកិច្ចសន្យាឆ្លាតវៃមានលេខពីរ ចំនួនគត់ 32 ប៊ីតដែលទទួលខុសត្រូវចំពោះសង្វាក់ការងារ និងលេខគណនីតែមួយគត់ចំនួនគត់ដែលមិនអវិជ្ជមាន 256 ប៊ីតនៅក្នុងសង្វាក់ការងារនេះ។ ឧទាហរណ៍ -1 និង 12345 នេះគឺជាអាសយដ្ឋានដែលយើងនឹងរក្សាទុកក្នុងឯកសារមួយ។

ខ្ញុំបានចម្លងមុខងារសម្រាប់រក្សាទុកអាសយដ្ឋានពី TonUtil.fif.

// ( wc addr fname -- )  Save address to file in 36-byte format
{ -rot 256 u>B swap 32 i>B B+ swap B>file } : save-address

សូមក្រឡេកមើលថាតើមុខងារនេះដំណើរការយ៉ាងដូចម្តេច វានឹងផ្តល់ការយល់ដឹងអំពីរបៀបដែល Fift ដំណើរការ។ បើកដំណើរការ Fift នៅក្នុងរបៀបអន្តរកម្ម។

~/TON/build/crypto/fift -i 

ដំបូងយើងរុញ -1, 12345 និងឈ្មោះឯកសារនាពេលអនាគត "sender.addr" ទៅលើជង់៖

-1 12345 "sender.addr" 

ជំហានបន្ទាប់គឺត្រូវអនុវត្តមុខងារ -rotដែលផ្លាស់ប្តូរជង់តាមរបៀបដែលនៅផ្នែកខាងលើនៃជង់មានលេខកិច្ចសន្យាឆ្លាតវៃតែមួយគត់៖

"sender.addr" -1 12345

256 u>B បំប្លែងចំនួនគត់មិនអវិជ្ជមាន 256 ប៊ីតទៅជាបៃ។

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap ប្តូរធាតុទាំងពីរខាងលើនៃជង់។

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B បំប្លែងចំនួនគត់ 32 ប៊ីតទៅជាបៃ។

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ ភ្ជាប់​លំដាប់​បៃ​ពីរ។

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

ម្តងទៀត swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

ហើយទីបំផុតបៃត្រូវបានសរសេរទៅឯកសារ B>file. បន្ទាប់ពីនេះជង់របស់យើងគឺទទេ។ តោះឈប់ Fift. ឯកសារមួយត្រូវបានបង្កើតនៅក្នុងថតបច្ចុប្បន្ន sender.addr. តោះផ្លាស់ទីឯកសារទៅថតដែលបានបង្កើត test/addresses/.

ចូរយើងសរសេរការសាកល្បងសាមញ្ញដែលនឹងបញ្ជូនក្រាមទៅកិច្ចសន្យាឆ្លាតវៃ។ នេះគឺជាការប្តេជ្ញាចិត្ត.

ឥឡូវនេះសូមក្រឡេកមើលតក្កវិជ្ជានៃឆ្នោត។

រឿងដំបូងដែលយើងធ្វើគឺពិនិត្យមើលសារ bounced ឬមិនប្រសិនបើ bouncedបន្ទាប់មកយើងមិនអើពើនឹងវា។ bounced មានន័យថាកិច្ចសន្យានឹងត្រឡប់ក្រាមប្រសិនបើមានកំហុសមួយចំនួនកើតឡើង។ យើងនឹងមិនត្រឡប់ក្រាមទេប្រសិនបើមានកំហុសកើតឡើងភ្លាមៗ។

យើងពិនិត្យមើល ប្រសិនបើសមតុល្យមានតិចជាងកន្លះក្រាម នោះយើងគ្រាន់តែទទួលយកសារ ហើយមិនអើពើ។

បន្ទាប់មក យើងញែកអាសយដ្ឋាននៃកិច្ចសន្យាឆ្លាតវៃដែលសារមក។

យើងអានទិន្នន័យពីកន្លែងផ្ទុក ហើយបន្ទាប់មកលុបការភ្នាល់ចាស់ចេញពីប្រវត្តិប្រសិនបើមានច្រើនជាងម្ភៃ។ ដើម្បីភាពងាយស្រួល ខ្ញុំបានសរសេរមុខងារបីបន្ថែមទៀត pack_order(), unpack_order(), remove_old_orders().

បន្ទាប់ យើងពិនិត្យមើលប្រសិនបើសមតុល្យមិនគ្រប់គ្រាន់សម្រាប់ការទូទាត់នោះ យើងពិចារណាថានេះមិនមែនជាការភ្នាល់ទេ ប៉ុន្តែជាការបំពេញបន្ថែម និងរក្សាទុកការបំពេញបន្ថែមនៅក្នុង orders.

បន្ទាប់មកទីបំផុតខ្លឹមសារនៃកិច្ចសន្យាឆ្លាតវៃ។

ទីមួយ ប្រសិនបើអ្នកលេងចាញ់ យើងរក្សាទុកវាក្នុងប្រវត្តិភ្នាល់ ហើយប្រសិនបើចំនួនលើសពី 3 ក្រាម យើងផ្ញើ 1/3 ទៅម្ចាស់កិច្ចសន្យាឆ្លាតវៃ។

ប្រសិនបើអ្នកលេងឈ្នះ នោះយើងផ្ញើចំនួនពីរដងទៅកាន់អាសយដ្ឋានរបស់អ្នកលេង បន្ទាប់មករក្សាទុកព័ត៌មានអំពីការភ្នាល់ក្នុងប្រវត្តិសាស្ត្រ។

() recv_internal(int order_amount, cell in_msg_cell, slice in_msg) impure {
    var cs = in_msg_cell.begin_parse();
    int flags = cs~load_uint(4);  ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
    if (flags & 1) { ;; ignore bounced
        return ();
    }
    if (order_amount < 500000000) { ;; just receive grams without changing state 
        return ();
    }
    slice src_addr_slice = cs~load_msg_addr();
    (int src_wc, int src_addr) = parse_std_addr(src_addr_slice);
    (int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
    orders = remove_old_orders(orders, order_seqno);
    if (balance() < 2 * order_amount + 500000000) { ;; not enough grams to pay the bet back, so this is re-fill
        builder order = pack_order(order_seqno, 1, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        return ();
    }
    if (rand(10) >= 4) {
        builder order = pack_order(order_seqno, 3, now(), order_amount, src_wc, src_addr);
        orders~udict_set_builder(32, order_seqno, order);
        set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins, incoming_amount + order_amount, outgoing_amount, owner_wc, owner_account_id, orders));
        if (order_amount > 3000000000) {
            send_grams(owner_wc, owner_account_id, order_amount / 3);
        }
        return ();
    }
    send_grams(src_wc, src_addr, 2 * order_amount);
    builder order = pack_order(order_seqno, 2, now(), order_amount, src_wc, src_addr);
    orders~udict_set_builder(32, order_seqno, order);
    set_data(pack_state(stored_seqno, pubkey, order_seqno + 1, number_of_wins + 1, incoming_amount, outgoing_amount + 2 * order_amount, owner_wc, owner_account_id, orders));
}

នោះជាអ្វីទាំងអស់។ ការប្តេជ្ញាចិត្តដែលត្រូវគ្នា។.

ឥឡូវនេះអ្វីទាំងអស់ដែលនៅសេសសល់គឺសាមញ្ញ សូមបង្កើតវិធីសាស្រ្តទទួលបាន ដូច្នេះយើងអាចទទួលបានព័ត៌មានអំពីស្ថានភាពនៃកិច្ចសន្យាពីពិភពខាងក្រៅ (តាមពិត អានទិន្នន័យពីកន្លែងផ្ទុកកិច្ចសន្យាឆ្លាតវៃរបស់ពួកគេ)។

តោះបន្ថែមវិធីសាស្រ្ត. យើងនឹងសរសេរខាងក្រោមអំពីរបៀបទទួលព័ត៌មានអំពីកិច្ចសន្យាឆ្លាតវៃ។

ខ្ញុំក៏ភ្លេចបន្ថែមលេខកូដដែលនឹងដំណើរការសំណើដំបូងបំផុតដែលកើតឡើងនៅពេលបោះផ្សាយកិច្ចសន្យាឆ្លាតវៃ។ ការប្តេជ្ញាចិត្តដែលត្រូវគ្នា។. និងបន្ថែមទៀត កែ កំហុសជាមួយនឹងការផ្ញើ 1/3 នៃចំនួនទឹកប្រាក់ទៅគណនីរបស់ម្ចាស់។

ជំហានបន្ទាប់គឺបោះផ្សាយកិច្ចសន្យាឆ្លាតវៃ។ តោះបង្កើតថតឯកសារ requests.

ខ្ញុំ​យក​កូដ​បោះពុម្ព​ជា​មូលដ្ឋាន simple-wallet-code.fc ដែល អាចរកបាន នៅក្នុងឃ្លាំងផ្លូវការ។

អ្វីមួយដែលគួរយកចិត្តទុកដាក់។ យើងបង្កើតកន្លែងផ្ទុកកិច្ចសន្យាឆ្លាតវៃ និងសារបញ្ចូល។ បន្ទាប់ពីនេះ អាស័យដ្ឋាននៃកិច្ចសន្យាឆ្លាតវៃត្រូវបានបង្កើត នោះគឺអាសយដ្ឋានត្រូវបានគេស្គាល់សូម្បីតែមុនពេលបោះពុម្ពនៅក្នុង TON ។ បន្ទាប់មកអ្នកត្រូវផ្ញើក្រាមជាច្រើនទៅអាសយដ្ឋាននេះ ហើយបន្ទាប់ពីនោះអ្នកត្រូវផ្ញើឯកសារជាមួយកិច្ចសន្យាឆ្លាតវៃដោយខ្លួនឯង ព្រោះបណ្តាញយកកម្រៃជើងសារសម្រាប់ការរក្សាទុកកិច្ចសន្យាឆ្លាតវៃ និងប្រតិបត្តិការនៅក្នុងវា (អ្នកផ្តល់សុពលភាពដែលរក្សាទុក និងប្រតិបត្តិឆ្លាតវៃ កិច្ចសន្យា)។ លេខកូដអាចមើលបាននៅទីនេះ.

បន្ទាប់​មក​យើង​ប្រតិបត្តិ​កូដ​បោះពុម្ព​និង​ទទួល​បាន​ lottery-query.boc ឯកសារកិច្ចសន្យាឆ្លាតវៃ និងអាសយដ្ឋាន។

~/TON/build/crypto/fift -s requests/new-lottery.fif 0

កុំភ្លេចរក្សាទុកឯកសារដែលបានបង្កើត៖ lottery-query.boc, lottery.addr, lottery.pk.

ក្នុងចំណោមរបស់ផ្សេងទៀត យើងនឹងឃើញអាសយដ្ឋាននៃកិច្ចសន្យាឆ្លាតវៃនៅក្នុងកំណត់ហេតុប្រតិបត្តិ។

new wallet address = 0:044910149dbeaf8eadbb2b28722e7d6a2dc6e264ec2f1d9bebd6fb209079bc2a 
(Saving address to file lottery.addr)
Non-bounceable address (for init): 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd
Bounceable address (for later access): kQAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8KpFY

គ្រាន់​តែ​ជា​ការ​សប្បាយ​សូម​ធ្វើ​ការ​ស្នើ​សុំ​ទៅ TON

$ ./lite-client/lite-client -C ton-lite-client-test1.config.json 
getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ហើយយើងនឹងឃើញថាគណនីដែលមានអាសយដ្ឋាននេះគឺទទេ។

account state is empty

យើងផ្ញើទៅអាសយដ្ឋាន 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 ក្រាមហើយបន្ទាប់ពីពីរបីវិនាទីយើងប្រតិបត្តិពាក្យបញ្ជាដូចគ្នា។ ដើម្បីផ្ញើក្រាមខ្ញុំប្រើ កាបូបផ្លូវការហើយ​អ្នក​អាច​សួរ​អ្នក​ណា​ម្នាក់​ពី​ការ​ជជែក​សម្រាប់​តេស្តក្រាម ដែល​ខ្ញុំ​នឹង​និយាយ​នៅ​ចុង​អត្ថបទ។

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

មើល​ទៅ​ដូច​ជា​មិន​ទាន់​បាន​បង្កើត​ឡើង (state:account_uninit) កិច្ចសន្យាឆ្លាតវៃដែលមានអាសយដ្ឋានដូចគ្នា និងសមតុល្យនៃ 1 nanograms ។

account state is (account
  addr:(addr_std
    anycast:nothing workchain_id:0 address:x044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A)
  storage_stat:(storage_info
    used:(storage_used
      cells:(var_uint len:1 value:1)
      bits:(var_uint len:1 value:103)
      public_cells:(var_uint len:0 value:0)) last_paid:1583257959
    due_payment:nothing)
  storage:(account_storage last_trans_lt:3825478000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:2000000000))
      other:(extra_currencies
        dict:hme_empty))
    state:account_uninit))
x{C00044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A20259C2F2F4CB3800000DEAC10776091DCD650004_}
last transaction lt = 3825478000001 hash = B043616AE016682699477FFF01E6E903878CDFD6846042BA1BFC64775E7AC6C4
account balance is 2000000000ng

ឥឡូវនេះ ចូរយើងផ្សព្វផ្សាយកិច្ចសន្យាឆ្លាតវៃ។ តោះបើកដំណើរការអតិថិជន Lite និងប្រតិបត្តិ។

> sendfile lottery-query.boc
[ 1][t 2][1583008371.631410122][lite-client.cpp:966][!testnode] sending query from file lottery-query.boc
[ 3][t 1][1583008371.828550100][lite-client.cpp:976][!query]    external message status is 1 

សូមពិនិត្យមើលថាកិច្ចសន្យាត្រូវបានបោះពុម្ព

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

ក្នុងចំណោមរបស់ផ្សេងទៀតដែលយើងទទួលបាន។

  storage:(account_storage last_trans_lt:3825499000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:1987150999))
      other:(extra_currencies
        dict:hme_empty))
    state:(account_active

យើងឃើញនោះ។ account_active.

ការប្តេជ្ញាចិត្តដែលត្រូវគ្នាជាមួយនឹងការផ្លាស់ប្តូរ នៅទីនេះ.

ឥឡូវនេះ ចូរយើងបង្កើតសំណើដើម្បីធ្វើអន្តរកម្មជាមួយកិច្ចសន្យាឆ្លាតវៃ។

កាន់តែច្បាស់ជាងនេះទៅទៀត យើងនឹងទុកកន្លែងទីមួយសម្រាប់ការផ្លាស់ប្តូរអាសយដ្ឋានជាការងារឯករាជ្យ ហើយយើងនឹងធ្វើទីពីរសម្រាប់ការផ្ញើក្រាមទៅកាន់អាសយដ្ឋានរបស់ម្ចាស់។ ជាការពិត យើងនឹងត្រូវធ្វើដូចគ្នានឹងការធ្វើតេស្តសម្រាប់ការបញ្ជូនក្រាមដែរ។

នេះគឺជាសារដែលយើងនឹងផ្ញើទៅកាន់កិច្ចសន្យាឆ្លាតវៃដែលជាកន្លែងដែល msg_seqno 165, action 2 និង 9.5 ក្រាមសម្រាប់ការផ្ញើ។

<b 165 32 u, 2 7 u, 9500000000 Gram, b>

កុំភ្លេចចុះហត្ថលេខាលើសារដោយប្រើសោឯកជនរបស់អ្នក។ lottery.pkដែលត្រូវបានបង្កើតមុននេះ នៅពេលបង្កើតកិច្ចសន្យាឆ្លាតវៃ។ នេះគឺជាការប្តេជ្ញាចិត្តដែលត្រូវគ្នា។.

ការទទួលព័ត៌មានពីកិច្ចសន្យាឆ្លាតវៃដោយប្រើវិធីសាស្រ្តទទួលបាន

ឥឡូវនេះសូមក្រឡេកមើលវិធីដំណើរការកិច្ចសន្យាឆ្លាតវៃ។

បើកដំណើរការ lite-client ហើយដំណើរការវិធីសាស្រ្តទទួលបានដែលយើងបានសរសេរ។

$ ./lite-client/lite-client -C ton-lite-client-test1.config.json
> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd balance
arguments:  [ 104128 ] 
result:  [ 64633878952 ] 
...

В result មាន​តម្លៃ​ដែល​អនុគមន៍​ត្រឡប់ balance() ពីកិច្ចសន្យាឆ្លាតវៃរបស់យើង។
យើងនឹងធ្វើដូចគ្នាសម្រាប់វិធីសាស្រ្តជាច្រើនទៀត។

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_seqno
...
arguments:  [ 77871 ] 
result:  [ 1 ] 

តោះសួររកប្រវត្តិភ្នាល់របស់អ្នក។

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_orders
...
arguments:  [ 67442 ] 
result:  [ ([0 1 1583258284 10000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308] [1 3 1583258347 4000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308] [2 1 1583259901 50000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308]) ] 

យើងនឹងប្រើប្រាស់ Lite-Client និងទទួលបានវិធីសាស្រ្តដើម្បីបង្ហាញព័ត៌មានអំពីកិច្ចសន្យាឆ្លាតវៃនៅលើគេហទំព័រ។

បង្ហាញទិន្នន័យកិច្ចសន្យាឆ្លាតវៃនៅលើគេហទំព័រ

ខ្ញុំបានសរសេរគេហទំព័រសាមញ្ញមួយនៅក្នុង Python ដើម្បីបង្ហាញទិន្នន័យពីកិច្ចសន្យាឆ្លាតវៃតាមរបៀបងាយស្រួល។ នៅទីនេះខ្ញុំនឹងមិនរស់នៅលើវានៅក្នុងលម្អិតទេហើយនឹងផ្សព្វផ្សាយគេហទំព័រ នៅក្នុងការប្តេជ្ញាចិត្តមួយ។.

សំណើទៅ TON ត្រូវបានធ្វើឡើងពី Python ដោយមានជំនួយ lite-client. ដើម្បីភាពងាយស្រួល គេហទំព័រនេះត្រូវបានខ្ចប់នៅក្នុង Docker ហើយបោះផ្សាយនៅលើ Google Cloud។ តំណភ្ជាប់.

កំពុងព្យាយាម

ឥឡូវនេះសូមព្យាយាមផ្ញើក្រាមនៅទីនោះសម្រាប់ការបំពេញបន្ថែមពី កាបូប. យើងនឹងផ្ញើ 40 ក្រាម។ ហើយសូមធ្វើការភ្នាល់ពីរបីដើម្បីភាពច្បាស់លាស់។ យើងឃើញថាគេហទំព័របង្ហាញពីប្រវត្តិនៃការភ្នាល់ ភាគរយដែលឈ្នះបច្ចុប្បន្ន និងព័ត៌មានមានប្រយោជន៍ផ្សេងទៀត។

យើង​ឃើញថាយើងឈ្នះលើកទីមួយ ចាញ់ទីពីរ។

Afterword

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

ប្រហែលជាទិដ្ឋភាពមួយចំនួននៃការអនុវត្តអាចត្រូវបានអនុវត្តកាន់តែមានប្រសិទ្ធភាព និងឆើតឆាយ ប៉ុន្តែបន្ទាប់មកវានឹងត្រូវការពេលច្រើនជាងមុនដើម្បីរៀបចំអត្ថបទ។ វាក៏អាចទៅរួចដែលថាខ្ញុំបានធ្វើខុសនៅកន្លែងណាមួយ ឬមិនយល់អ្វីមួយ ដូច្នេះប្រសិនបើអ្នកកំពុងធ្វើអ្វីធ្ងន់ធ្ងរ អ្នកត្រូវពឹងផ្អែកលើឯកសារផ្លូវការ ឬឃ្លាំងផ្លូវការដែលមានលេខកូដ TON ។

វាគួរតែត្រូវបានកត់សម្គាល់ថាចាប់តាំងពី TON ខ្លួនវានៅតែស្ថិតក្នុងដំណាក់កាលសកម្មនៃការអភិវឌ្ឍន៍ការផ្លាស់ប្តូរអាចកើតឡើងដែលនឹងបំបែកជំហានណាមួយនៅក្នុងអត្ថបទនេះ (ដែលបានកើតឡើងខណៈពេលដែលខ្ញុំកំពុងសរសេរវាត្រូវបានកែតម្រូវរួចហើយ) ប៉ុន្តែវិធីសាស្រ្តទូទៅគឺ ទំនងជាមិនផ្លាស់ប្តូរ។

ខ្ញុំនឹងមិននិយាយអំពីអនាគតរបស់ TON ទេ។ ប្រហែលជាវេទិកានេះនឹងក្លាយជាអ្វីដែលធំ ហើយយើងគួរតែចំណាយពេលសិក្សាវា ហើយបំពេញទីផ្សារពិសេសជាមួយផលិតផលរបស់យើងឥឡូវនេះ។

វាក៏មាន Libra មកពី Facebook ដែលមានទស្សនិកជនសក្តានុពលនៃអ្នកប្រើប្រាស់ធំជាង TON ។ ខ្ញុំស្ទើរតែមិនដឹងអ្វីទាំងអស់អំពី Libra ដោយវិនិច្ឆ័យដោយវេទិកាមានសកម្មភាពច្រើនជាងនៅក្នុងសហគមន៍ TON ។ ទោះបីជាអ្នកអភិវឌ្ឍន៍ និងសហគមន៍របស់ TON មានលក្ខណៈដូចនៅក្រោមដីក៏ដោយ ដែលវាត្រជាក់ផងដែរ។

សេចក្តីយោង

1. ឯកសារ TON ផ្លូវការ៖ https://test.ton.org
2. ឃ្លាំង TON ផ្លូវការ៖ https://github.com/ton-blockchain/ton
3. កាបូបផ្លូវការសម្រាប់វេទិកាផ្សេងៗគ្នា៖ https://wallet.ton.org
4. ឃ្លាំងកិច្ចសន្យាឆ្លាតវៃពីអត្ថបទនេះ៖ https://github.com/raiym/astonished
5. ភ្ជាប់ទៅគេហទំព័រកិច្ចសន្យាឆ្លាតវៃ៖ https://ton-lottery.appspot.com
6. ឃ្លាំងសម្រាប់ផ្នែកបន្ថែមសម្រាប់ Visual Studio Code សម្រាប់ FunC៖ https://github.com/raiym/func-visual-studio-plugin
7. ជជែកអំពី TON នៅក្នុង Telegram ដែលពិតជាបានជួយដោះស្រាយវានៅដំណាក់កាលដំបូង។ ខ្ញុំ​គិត​ថា​វា​នឹង​មិន​មាន​កំហុស​ទេ​ប្រសិន​បើ​ខ្ញុំ​និយាយ​ថា​អ្នក​រាល់​គ្នា​ដែល​បាន​សរសេរ​អ្វី​មួយ​សម្រាប់ TON គឺ​នៅ​ទីនោះ។ អ្នកក៏អាចសួររកក្រាមតេស្តនៅទីនោះ។ https://t.me/tondev_ru
8. ការជជែកមួយទៀតអំពី TON ដែលខ្ញុំបានរកឃើញព័ត៌មានមានប្រយោជន៍៖ https://t.me/TONgramDev
9. ដំណាក់កាលដំបូងនៃការប្រកួតប្រជែង៖ https://contest.com/blockchain
10. ដំណាក់កាលទីពីរនៃការប្រកួត៖ https://contest.com/blockchain-2

ប្រភព: www.habr.com