იმის შესახებ, თუ როგორ უნდა დაწეროთ და გამოაქვეყნოთ ჭკვიანი კონტრაქტი TON-ში

რაზეა ეს სტატია?

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

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

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

ლატარიის მაგალითის გამოყენებით, მე გადავალ გარემოს დაყენებიდან ჭკვიანი კონტრაქტის გამოქვეყნებამდე, მასთან ინტერაქციაზე და მონაცემების მიღებისა და გამოქვეყნების საიტის დაწერაზე.

კონკურსში მონაწილეობის შესახებ

გასულ ოქტომბერში Telegram-მა გამოაცხადა ბლოკჩეინის კონკურსი ახალი ენებით Fift и FunC. საჭირო იყო არჩევანის გაკეთება ხუთი შემოთავაზებული ჭკვიანი კონტრაქტიდან რომელიმეს დასაწერად. მე მივხვდი, რომ კარგი იქნებოდა რაიმე უჩვეულო გამეკეთებინა, ენა ვისწავლო და რაღაც გავაკეთო, თუნდაც მომავალში სხვა რამის დაწერა არ მომიწიოს. გარდა ამისა, თემა მუდმივად ისმის.

აღსანიშნავია, რომ მე არ მქონდა გამოცდილება ჭკვიანი კონტრაქტების შემუშავებაში.

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

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

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

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

ჭკვიანი კონტრაქტების კონცეფცია TON-ში

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

ჩვენ ყურადღებას გავამახვილებთ ჭკვიანი კონტრაქტის დაწერაზე და მასთან მუშაობაზე TON Virtual Machine (TVM), Fift и FunC, ასე რომ, სტატია უფრო ჰგავს ჩვეულებრივი პროგრამის შემუშავების აღწერას. ჩვენ არ ვისაუბრებთ იმაზე, თუ როგორ მუშაობს თავად პლატფორმა აქ.

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

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

დავუშვათ, ჩვენ უკვე დავწერეთ ჭკვიანი კონტრაქტი FunC, ამის შემდეგ ჩვენ ვაგროვებთ კოდს Fift ასამბლერში.

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

ტონში მიღებული ჭკვიანი კონტრაქტის გამოქვეყნება .boc ფაილი უნდა გაიგზავნოს ბლოკჩეინში მსუბუქი კლიენტის გამოყენებით (დაწვრილებით ამის შესახებ ქვემოთ). ოღონდ გამოქვეყნებამდე საჭიროა გრამების გადატანა გენერირებულ მისამართზე, წინააღმდეგ შემთხვევაში სმარტ კონტრაქტი არ გამოქვეყნდება. გამოქვეყნების შემდეგ, შესაძლებელი იქნება სმარტ კონტრაქტთან ურთიერთობა გარედან (მაგალითად, მსუბუქი კლიენტის გამოყენებით) ან შიგნიდან (მაგალითად, ერთი ჭკვიანი კონტრაქტი მეორეს გზავნის შეტყობინებას 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. In ~/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-დან, მაგალითად, როდესაც ჩვენ თვითონ ვქმნით შეტყობინებას და ვაგზავნით მას lite-client-ის საშუალებით. მეორე, 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 ასამბლერის კოდი 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 Fift ასამბლერში.

ვინაიდან გვსურს სმარტ კონტრაქტის გაშვება და ტესტირება, ჩვენ შევქმნით ფაილს ადგილობრივად 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.

მოდით დავამატოთ კოდი 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 შეგიძლია წაიკითხო მეხუთე დოკუმენტაციაში.

და ჩვენ კვლავ მოვუწოდებთ ტესტის გასატარებლად.

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 !

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

ბმული ვალდებულებაზე დამატებული ტესტით.

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

სმარტ კონტრაქტში ჩვენ ვაგრძელებთ ანალიზს 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));
}

აი ეს. შესაბამისი ვალდებულება.

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

დაამატეთ Get Methods. როგორ მივიღოთ ინფორმაცია ჭკვიანი კონტრაქტის შესახებ ქვემოთ დავწერთ.

ასევე დამავიწყდა კოდის დამატება, რომელიც დაამუშავებს პირველივე მოთხოვნას, რომელიც წარმოიქმნება ჭკვიანი კონტრაქტის გამოქვეყნებისას. შესაბამისი ვალდებულება. და შემდგომ შესწორებული შეცდომა მესაკუთრის ანგარიშზე თანხის 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 ნანოგრამი.

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-client და შევასრულოთ.

> 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 via lite-client. მოხერხებულობისთვის, საიტი შეფუთულია Docker-ში და გამოქვეყნებულია Google Cloud-ზე. Ბმული.

ცდილობს

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

Ჩვენ ვხედავთრომ პირველი მოვიგეთ, მეორე წავაგეთ.

Afterword

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

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

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

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

ასევე არის Libra ფეისბუქიდან, რომელსაც ჰყავს მომხმარებელთა უფრო დიდი პოტენციური აუდიტორია, ვიდრე TON. მე თითქმის არაფერი ვიცი სასწორის შესახებ, თუ ვიმსჯელებთ აქტივობის ფორუმის მიხედვით, გაცილებით მეტი აქტივობაა ვიდრე 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 კოდის გაფართოების საცავი 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