TON හි ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලියන ආකාරය සහ ප්‍රකාශනය කරන ආකාරය ගැන

මෙම ලිපිය කුමක් ගැනද?

ලිපියෙන් මම පළමු (දෙකෙන්) ටෙලිග්‍රාම් බ්ලොක්චේන් තරඟයට සහභාගී වූ ආකාරය ගැන කතා කරමි, ත්‍යාගයක් නොගත් අතර, මගේ අත්දැකීම් අමතක නොවන ලෙස ලිපියක සටහන් කිරීමට සහ සමහර විට උදව් කිරීමට තීරණය කළෙමි. කෙනෙක්.

මට වියුක්ත කේතය ලිවීමට අවශ්‍ය නොවූ නමුත් වැඩ කරන දෙයක් කිරීමට, ලිපිය සඳහා මම ක්ෂණික ලොතරැයියක් සඳහා ස්මාර්ට් කොන්ත්‍රාත්තුවක් සහ අතරමැදි ආචයනය භාවිතා නොකර TON වෙතින් ස්මාර්ට් කොන්ත්‍රාත්තු දත්ත කෙලින්ම පෙන්වන වෙබ් අඩවියක් ලිව්වෙමි.

TON හි පළමු ස්මාර්ට් කොන්ත්‍රාත්තුවක් කිරීමට කැමති අයට ලිපිය ප්‍රයෝජනවත් වනු ඇත, නමුත් ආරම්භ කළ යුත්තේ කොතැනින්දැයි නොදනී.

උදාහරණයක් ලෙස ලොතරැයිය භාවිතා කරමින්, මම පරිසරය ස්ථාපනය කිරීමේ සිට ස්මාර්ට් කොන්ත්‍රාත්තුවක් ප්‍රකාශයට පත් කිරීම, එය සමඟ අන්තර් ක්‍රියා කිරීම සහ දත්ත ලබා ගැනීම සහ ප්‍රකාශ කිරීම සඳහා වෙබ් අඩවියක් ලිවීම දක්වා යන්නෙමි.

තරඟයට සහභාගී වීම ගැන

පසුගිය ඔක්තෝම්බර් මාසයේදී ටෙලිග්‍රාම් නව භාෂා සමඟ බ්ලොක්චේන් තරඟයක් නිවේදනය කළේය Fift и FunC. යෝජිත ස්මාර්ට් කොන්ත්‍රාත්තු පහෙන් එකක් ලිවීමෙන් තෝරා ගැනීම අවශ්‍ය විය. ඉස්සරහට ලියන්න ඕන නැති උනත් වෙනස් දෙයක් කරලා, භාෂාවක් ඉගෙනගෙන මොනවා හරි කරගත්තොත් හොඳයි කියලා හිතුනා. Plus, මාතෘකාව නිරන්තරයෙන් තොල් මත වේ.

ස්මාර්ට් කොන්ත්‍රාත්තු සංවර්ධනය කිරීමේ අත්දැකීමක් මට නොතිබූ බව පැවසීම වටී.

මට හැකි වන තුරු අවසානය දක්වා සහභාගී වී පසුව සමාලෝචන ලිපියක් ලිවීමට මම සැලසුම් කළ නමුත් පළමු ලිපියේදීම මම අසාර්ථක විය. මම මුදල් පසුම්බියක් ලිවීය බහු අත්සන් සහිතව FunC සහ එය සාමාන්යයෙන් වැඩ කළා. මම එය පදනමක් ලෙස ගත්තා Solidity පිළිබඳ ස්මාර්ට් ගිවිසුම.

අඩුම තරමේ යම් ත්‍යාග ස්ථානයක් ගන්නට නම් මෙය අනිවාර්යයෙන්ම ප්‍රමාණවත් යැයි මට එදා සිතුණි. එහි ප්‍රතිඵලයක් ලෙස සහභාගි වූවන් 40 දෙනෙකුගෙන් 60ක් පමණ ත්‍යාගලාභීන් බවට පත් වූ අතර මම ඔවුන් අතර සිටියේ නැත. පොදුවේ ගත් කල, මෙහි කිසිදු වරදක් නැත, නමුත් එක් දෙයක් මට කරදර විය. ප්‍රතිඵල ප්‍රකාශයට පත් කරන විට, මගේ කොන්ත්‍රාත්තුවේ පරීක්ෂණය පිළිබඳ සමාලෝචනය සිදු කර නොතිබුණි, මම චැට් එකට සහභාගී වූවන්ගෙන් එය නොමැති වෙනත් අය සිටීදැයි විමසුවෙමි, කිසිවෙක් නැත.

පෙනෙන විදිහට මගේ පණිවිඩ කෙරෙහි අවධානය යොමු කරමින්, දින දෙකකට පසුව විනිසුරුවන් අදහස් දැක්වීමක් ප්‍රකාශයට පත් කළ අතර, විනිශ්චය අතරතුරේදී ඔවුන්ට අහම්බෙන් මගේ ස්මාර්ට් කොන්ත්‍රාත්තුව මග හැරුණාද නැතහොත් එය එතරම් නරක යැයි සිතුවේ අදහස් දැක්වීමක් අවශ්‍ය නොවන බව මට තවමත් තේරෙන්නේ නැත. මම පිටුවේ ප්‍රශ්නයක් ඇසුවෙමි, නමුත් පිළිතුරක් නොලැබුණි. විනිශ්චය කළේ කවුරුන්ද යන්න රහසක් නොවූවත්, පුද්ගලික පණිවිඩ ලිවීම අනවශ්‍ය යැයි මම සැලකුවෙමි.

අවබෝධය සඳහා බොහෝ කාලයක් වැය වූ නිසා ලිපියක් ලිවීමට තීරණය විය. තවමත් බොහෝ තොරතුරු නොමැති බැවින්, මෙම ලිපිය උනන්දුවක් දක්වන සෑම කෙනෙකුටම කාලය ඉතිරි කර ගැනීමට උපකාරී වනු ඇත.

TON හි ස්මාර්ට් ගිවිසුම් සංකල්පය

ඔබ යමක් ලිවීමට පෙර, මෙම දෙයට ප්‍රවේශ විය යුත්තේ කුමන පැත්තෙන්ද යන්න ඔබ සොයා බැලිය යුතුය. එමනිසා, පද්ධතිය සමන්විත වන්නේ කුමන කොටස්ද යන්න දැන් මම ඔබට කියමි. වඩාත් නිවැරදිව, අවම වශයෙන් යම් ආකාරයක වැඩ කොන්ත්රාත්තුවක් ලිවීමට ඔබ දැනගත යුතු කොටස් මොනවාද?

අපි ස්මාර්ට් කොන්ත්රාත්තුවක් ලිවීමට සහ වැඩ කිරීමට අවධානය යොමු කරමු TON Virtual Machine (TVM), Fift и FunC, එබැවින් ලිපිය සාමාන්‍ය වැඩසටහනක වර්ධනය පිළිබඳ විස්තරයක් වැනි ය. වේදිකාවම මෙහි ක්‍රියා කරන ආකාරය ගැන අපි වාසය නොකරමු.

සාමාන්යයෙන් එය ක්රියා කරන ආකාරය ගැන TVM සහ භාෂාව Fift හොඳ නිල ලේඛන තිබේ. තරඟයට සහභාගී වන අතරතුර සහ දැන් වත්මන් කොන්ත්රාත්තුව ලියන විට, මම බොහෝ විට ඇය වෙත හැරුණෙමි.

ස්මාර්ට් ගිවිසුම් ලියා ඇති ප්රධාන භාෂාව වේ FunC. මේ මොහොතේ ඒ පිළිබඳ ලියකියවිලි නොමැත, එබැවින් යමක් ලිවීමට ඔබ නිල ගබඩාවෙන් ස්මාර්ට් කොන්ත්‍රාත්තු පිළිබඳ උදාහරණ සහ එහි භාෂාව ක්‍රියාත්මක කිරීම අධ්‍යයනය කළ යුතුය, තවද ඔබට පසුගිය දෙකේ ස්මාර්ට් කොන්ත්‍රාත්තු පිළිබඳ උදාහරණ දෙස බැලිය හැකිය. තරඟ. ලිපිය අවසානයේ සබැඳි.

අපි දැනටමත් ස්මාර්ට් ගිවිසුමක් ලියා ඇති බව කියමු FunC, ඊට පසු අපි කේතය ෆිෆ්ට් එකලස් කරන්නා වෙත සම්පාදනය කරමු.

සම්පාදනය කරන ලද ස්මාර්ට් කොන්ත්‍රාත්තුව ප්‍රකාශයට පත් කිරීමට ඉතිරිව ඇත. මෙය සිදු කිරීම සඳහා, ඔබට කාර්යයක් ලිවිය යුතුය Fift, එය ස්මාර්ට් කොන්ත්‍රාත් කේතය සහ වෙනත් පරාමිති ආදානය ලෙස ගන්නා අතර ප්‍රතිදානය දිගුව සහිත ගොනුවක් වනු ඇත .boc (එයින් අදහස් වන්නේ "සෛල බෑගය"), සහ, අප එය ලියන ආකාරය මත පදනම්ව, ස්මාර්ට් කොන්ත්‍රාත් කේතය මත පදනම්ව ජනනය කරන පුද්ගලික යතුරක් සහ ලිපිනයක්. ඔබට දැනටමත් ප්‍රකාශනය කර නොමැති ස්මාර්ට් කොන්ත්‍රාත්තුවක ලිපිනයට ග්‍රෑම් යැවිය හැක.

ලැබුණු TON වලින් ස්මාර්ට් කොන්ත්‍රාත්තුවක් ප්‍රකාශ කිරීමට .boc සැහැල්ලු සේවාලාභියෙකු භාවිතයෙන් ගොනුව බ්ලොක්චේන් වෙත යැවීමට අවශ්‍ය වනු ඇත (පහත ඒ ගැන වැඩි විස්තර). නමුත් ප්‍රකාශනය කිරීමට පෙර, ඔබ විසින් ජනනය කරන ලද ලිපිනයට ග්රෑම් මාරු කළ යුතුය, එසේ නොමැතිනම් ස්මාර්ට් කොන්ත්රාත්තුව ප්රකාශයට පත් නොකෙරේ. ප්‍රකාශනයෙන් පසුව, ඔබට ස්මාර්ට් කොන්ත්‍රාත්තුවට පිටතින් (උදාහරණයක් ලෙස, සැහැල්ලු සේවාලාභියෙකු භාවිතා කරමින්) හෝ ඇතුළතින් පණිවිඩ යැවීමෙන් (උදාහරණයක් ලෙස, එක් ස්මාර්ට් කොන්ත්‍රාත්තුවක් TON ඇතුළත තවත් පණිවිඩයක් යවයි) සමඟ අන්තර් ක්‍රියා කළ හැක.

කේතය ප්‍රකාශයට පත් කරන ආකාරය අපි තේරුම් ගත් පසු, එය පහසු වේ. අපට ලිවීමට අවශ්‍ය කුමක්ද සහ අපගේ වැඩසටහන ක්‍රියා කරන්නේ කෙසේද යන්න අපි දළ වශයෙන් දනිමු. සහ ලියන අතරතුර, දැනට පවතින ස්මාර්ට් කොන්ත්‍රාත්තු වල මෙය දැනටමත් ක්‍රියාත්මක වන්නේ කෙසේදැයි අපි සොයන්නෙමු, නැතහොත් අපි ක්‍රියාත්මක කිරීමේ කේතය දෙස බලමු Fift и FunC නිල ගබඩාවේ, හෝ නිල ලේඛන බලන්න.

බොහෝ විට මම ටෙලිග්‍රාම් කතාබස් හි සියලුම තරඟකරුවන් සහ ටෙලිග්‍රාම් සේවකයින් එක්රැස් වූ මූල පද සෙවූ අතර, එය එසේ වූයේ තරඟය අතරතුර සෑම කෙනෙකුම එහි රැස් වී ෆිෆ්ට් සහ ෆන්සී ගැන සාකච්ඡා කිරීමට පටන් ගත් බැවිනි. ලිපිය අවසානයේ සබැඳිය.

න්‍යායේ සිට ප්‍රායෝගිකත්වයට යාමට කාලයයි.

TON සමඟ වැඩ කිරීමට පරිසරය සකස් කිරීම

මම MacOS හි ලිපියේ විස්තර කරන සෑම දෙයක්ම කළ අතර එය Docker හි පිරිසිදු Ubuntu 18.04 LTS හි දෙවරක් පරීක්ෂා කර ඇත.

ඔබ කළ යුතු පළමු දෙය බාගත කර ස්ථාපනය කිරීමයි lite-client ඔබට TON වෙත ඉල්ලීම් යැවිය හැක.

නිල වෙබ් අඩවියේ ඇති උපදෙස් ස්ථාපන ක්‍රියාවලිය තරමක් සවිස්තරාත්මකව සහ පැහැදිලිව විස්තර කරන අතර සමහර විස්තර මඟ හැරේ. මෙන්න අපි උපදෙස් අනුගමනය කරමු, මඟ දිගේ අතුරුදහන් වූ පරායත්තතා ස්ථාපනය කරමු. මම එක් එක් ව්‍යාපෘතිය තනිවම සම්පාදනය නොකළ අතර නිල උබුන්ටු ගබඩාවෙන් (මා භාවිතා කළ 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 සඳහා කේතය උද්දීපනය කළෙමි; ප්ලගිනය විෂුවල් ස්ටූඩියෝ කේත සෙවුමේ සොයා ගෙන ස්ථාපනය කළ හැකිය; ඔබට හදිසියේ යමක් එක් කිරීමට අවශ්‍ය නම්, මම ප්ලගිනය ප්‍රසිද්ධියේ ලබා ගත හැකි කර ඇත. එසේම, කවුරුහරි මීට පෙර ෆිෆ්ට් සමඟ වැඩ කිරීම සඳහා ප්ලගිනයක් සාදා ඇත, ඔබට එය ස්ථාපනය කර 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

අපි ෆිෆ්ට් එකලස් කිරීමේ කේතය සම්පාදනය කර ඇත 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, මෙය ෆිෆ්ට් එකලස් කරන්නා සඳහා ෆිෆ්ට් වලින් ලියා ඇති කේතයකි.

අපට ස්මාර්ට් කොන්ත්‍රාත්තුව දේශීයව ක්‍රියාත්මක කර පරීක්ෂා කිරීමට අවශ්‍ය බැවින්, අපි ගොනුවක් සාදන්නෙමු 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.

අපි variable එකක් හදමු storage සහ එහි හිස් එකක් ලියන්න cell, මෙය ස්මාර්ට් කොන්ත්‍රාත්තු ගබඩාව වනු ඇත.

message අපි පිටත සිට ස්මාර්ට් සම්බන්ධතාවයට සම්ප්‍රේෂණය කරන පණිවිඩය මෙයයි. අපි එයත් දැනට හිස් කරන්නෙමු.

variable storage 
<b b> storage ! 

variable message 
<b b> message !

අපි නියතයන් සහ විචල්‍යයන් සකස් කළ පසු, අපි විධානය භාවිතයෙන් TVM දියත් කරමු runvmctx සහ සාදන ලද පරාමිති ආදානය වෙත යොමු කරන්න.

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

අවසානයේදී අපි සාර්ථක වනු ඇත මේ සඳහා අතරමැදි කේතය Fift.

දැන් අපිට ලැබෙන code එක run කරන්න පුළුවන්.

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-bit අංකය පූරණය කරයි unsigned int සම්ප්රේෂණය කළ පණිවිඩයෙන්.

මීළඟට අපි ස්මාර්ට් කොන්ත්‍රාත්තු ගබඩාවෙන් බිටු 32 ක් පූරණය කරමු. පටවන ලද අංකය සමත් වූ අංකයට ගැළපෙන බව අපි පරීක්ෂා කරමු; එසේ නොවේ නම්, අපි ව්‍යතිරේකයක් විසි කරමු. අපගේ නඩුවේදී, අපි තරඟයක් නොවන තරඟයක් සමත් වන බැවින්, ව්යතිරේකයක් දැමිය යුතුය.

දැන් අපි compile කරමු.

~/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. මෙය සිදු කිරීම සඳහා, අපි අන්තර්ක්‍රියාකාරී මාදිලියේ ෆිෆ්ට් දියත් කර විධාන හතරක් ක්‍රියාත්මක කරමු.

`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-bit නිඛිල ඍණ නොවන අංකයක්, එය මත පදනම්ව, අපි ස්මාර්ට් කොන්ත්රාත්තුවේ පණිවිඩය සකසන ආකාරය තෝරා ගනිමු.

<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

අපි බලමු කොහොමද function එක වැඩ කරන්නේ කියලා, මේකෙන් Fif එක වැඩ කරන හැටි ගැන අවබෝධයක් ලැබෙනවා. අන්තර්ක්‍රියාකාරී මාදිලියේ ෆිෆ්ට් දියත් කරන්න.

~/TON/build/crypto/fift -i

පළමුව අපි -1, 12345 සහ අනාගත ගොනුවේ නම "sender.addr" තොගය මතට තල්ලු කරමු:

-1 12345 "sender.addr"

ඊළඟ පියවර වන්නේ කාර්යය ක්රියාත්මක කිරීමයි -rot, අට්ටියේ මුදුනේ අද්විතීය ස්මාර්ට් කොන්ත්‍රාත්තු අංකයක් ඇති ආකාරයට තොගය මාරු කරයි:

"sender.addr" -1 12345

256 u>B 256-bit ඍණ නොවන පූර්ණ සංඛ්‍යාවක් බයිට් බවට පරිවර්තනය කරයි.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap තොගයේ ඉහළම මූලද්‍රව්‍ය දෙක මාරු කරයි.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B 32-bit පූර්ණ සංඛ්‍යාවක් බයිට් බවට පරිවර්තනය කරයි.

"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, ස්මාර්ට් කොන්ත්රාත්තුව නිර්මාණය කිරීමේදී කලින් ජනනය කරන ලදී. මෙන්න ඊට අදාල කැපවීම.

ලබා ගැනීමේ ක්‍රම භාවිතා කරමින් ස්මාර්ට් කොන්ත්‍රාත්තුවෙන් තොරතුරු ලබා ගැනීම

දැන් අපි බලමු smart contract get methods run කරන්නේ කොහොමද කියලා.

අපි දියත් කරනවා 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]) ]

අපි ලයිට්-සේවාලාභියා භාවිතා කරන අතර වෙබ් අඩවියේ ස්මාර්ට් කොන්ත්‍රාත්තුවේ තොරතුරු ප්‍රදර්ශනය කිරීමට ක්‍රම ලබා ගන්නෙමු.

වෙබ් අඩවියේ ස්මාර්ට් කොන්ත්‍රාත්තු දත්ත ප්‍රදර්ශනය කිරීම

ස්මාර්ට් කොන්ත්‍රාත්තුවේ දත්ත පහසු ආකාරයකින් ප්‍රදර්ශනය කිරීමට මම පයිතන් හි සරල වෙබ් අඩවියක් ලිව්වෙමි. මෙන්න මම එය විස්තරාත්මකව වාසය නොකරන අතර වෙබ් අඩවිය ප්‍රකාශයට පත් කරමි එක කැපවීමකින්.

TON වෙත ඉල්ලීම් සිදු කරනු ලැබේ Python උදව්වෙන් lite-client. පහසුව සඳහා, අඩවිය Docker හි ඇසුරුම් කර Google Cloud මත ප්‍රකාශනය කර ඇත. සබැඳිය.

උත්සාහ කරනවා

දැන් අපි නැවත පිරවීම සඳහා එහි ග්‍රෑම් යැවීමට උත්සාහ කරමු පසුම්බිය. අපි ග්රෑම් 40 ක් එවන්නෙමු. සහ පැහැදිලිකම සඳහා ඔට්ටු කිහිපයක් සාදා ගනිමු. වෙබ් අඩවිය ඔට්ටු ඇල්ලීමේ ඉතිහාසය, වර්තමාන ජයග්‍රාහී ප්‍රතිශතය සහ වෙනත් ප්‍රයෝජනවත් තොරතුරු පෙන්වන බව අපට පෙනේ.

අපි දකිනවාඅපි පළවෙනි එක දිනුවා, දෙවෙනි එක පැරදුණා කියලා.

පසු පදය

ලිපිය මා බලාපොරොත්තු වූවාට වඩා දිගු විය, සමහර විට එය කෙටි විය හැකිය, නැතහොත් TON ගැන කිසිවක් නොදන්නා සහ අන්තර් ක්‍රියා කිරීමේ හැකියාව ඇති එතරම් සරල නොවන ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලිවීමට සහ ප්‍රකාශයට පත් කිරීමට කැමති පුද්ගලයෙකුට විය හැකිය. එය. සමහරවිට සමහර දේවල් සරලව පැහැදිලි කරන්න තිබුණා.

සමහර විට ක්‍රියාවට නැංවීමේ සමහර අංග වඩාත් කාර්යක්ෂමව හා අලංකාර ලෙස සිදු කළ හැකිව තිබුණි, නමුත් එවිට ලිපිය සකස් කිරීමට ඊටත් වඩා කාලයක් ගතවනු ඇත. මම කොතැනක හෝ වැරැද්දක් කර ඇති බව හෝ යමක් නොතේරෙන නිසා විය හැකිය, එබැවින් ඔබ බරපතල දෙයක් කරන්නේ නම්, ඔබ TON කේතය සහිත නිල ලේඛන හෝ නිල ගබඩාව මත විශ්වාසය තැබිය යුතුය.

TON තවමත් සංවර්ධනයේ සක්‍රීය අවධියේ පවතින බැවින්, මෙම ලිපියේ ඕනෑම පියවරක් බිඳ දැමිය හැකි වෙනස්කම් සිදුවිය හැකි බව සටහන් කළ යුතුය (මා ලියන අතරතුර එය සිදු විය, එය දැනටමත් නිවැරදි කර ඇත), නමුත් සාමාන්‍ය ප්‍රවේශය වන්නේ වෙනස් විය නොහැක.

මම TON හි අනාගතය ගැන කතා නොකරමි. සමහර විට වේදිකාව විශාල දෙයක් බවට පත්වනු ඇති අතර අපි එය අධ්‍යයනය කිරීමට කාලය ගත කළ යුතු අතර දැන් අපගේ නිෂ්පාදන සමඟ ස්ථානයක් පුරවා ගත යුතුය.

TON ට වඩා විශාල පරිශීලකයින්ගේ විභව ප්‍රේක්ෂක පිරිසක් සිටින Facebook වෙතින් Libra ද ඇත. මම ලිබ්රාව ගැන කිසිවක් නොදනිමි, සංසදය අනුව විනිශ්චය කිරීම TON ප්‍රජාවට වඩා බොහෝ ක්‍රියාකාරකම් එහි පවතී. TON හි සංවර්ධකයින් සහ ප්‍රජාව වඩාත් සිසිල් ය.

යොමු

නිල TON ලේඛන: https://test.ton.org
නිල TON ගබඩාව: https://github.com/ton-blockchain/ton
විවිධ වේදිකා සඳහා නිල මුදල් පසුම්බිය: https://wallet.ton.org
මෙම ලිපියෙන් ස්මාර්ට් කොන්ත්‍රාත් ගබඩාව: https://github.com/raiym/astonished
ස්මාර්ට් කොන්ත්රාත් වෙබ් අඩවිය වෙත සබැඳිය: https://ton-lottery.appspot.com
FunC සඳහා Visual Studio කේතය සඳහා දිගුව සඳහා ගබඩාව: https://github.com/raiym/func-visual-studio-plugin
ටෙලිග්‍රාම් හි ටොන් ගැන කතාබස් කරන්න, එය මූලික අදියරේදී එය හඳුනා ගැනීමට සැබවින්ම උපකාරී විය. TON සඳහා යමක් ලියූ සියල්ලෝම එහි සිටින බව පැවසුවහොත් එය වරදක් නොවනු ඇතැයි මම සිතමි. එතනදි ටෙස්ට් ග්‍රෑම් ඉල්ලන්නත් පුළුවන්. https://t.me/tondev_ru
මට ප්‍රයෝජනවත් තොරතුරු සොයාගත් TON ගැන තවත් කතාබස්: https://t.me/TONgramDev
තරඟයේ පළමු අදියර: https://contest.com/blockchain
තරඟයේ දෙවන අදියර: https://contest.com/blockchain-2

මූලාශ්රය: www.habr.com

ටෙලිග්‍රාම් විවෘත ජාලයේ (TON) ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලිවීම සහ ප්‍රකාශනය කරන්නේ කෙසේද යන්න ගැන

TON හි ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලියන ආකාරය සහ ප්‍රකාශනය කරන ආකාරය ගැන

මෙම ලිපිය කුමක් ගැනද?

තරඟයට සහභාගී වීම ගැන

TON හි ස්මාර්ට් ගිවිසුම් සංකල්පය

TON සමඟ වැඩ කිරීමට පරිසරය සකස් කිරීම

TON වෙත පළමු ඉල්ලීම් කිරීම

Реализация

අදහස

බුද්ධිමත් ගිවිසුමක් ලිවීම

ලබා ගැනීමේ ක්‍රම භාවිතා කරමින් ස්මාර්ට් කොන්ත්‍රාත්තුවෙන් තොරතුරු ලබා ගැනීම

වෙබ් අඩවියේ ස්මාර්ට් කොන්ත්‍රාත්තු දත්ත ප්‍රදර්ශනය කිරීම

උත්සාහ කරනවා

පසු පදය

යොමු

අදහස් එක් කරන්න

ටෙලිග්‍රාම් විවෘත ජාලයේ (TON) ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලිවීම සහ ප්‍රකාශනය කරන්නේ කෙසේද යන්න ගැන

TON හි ස්මාර්ට් කොන්ත්‍රාත්තුවක් ලියන ආකාරය සහ ප්‍රකාශනය කරන ආකාරය ගැන

මෙම ලිපිය කුමක් ගැනද?

තරඟයට සහභාගී වීම ගැන

TON හි ස්මාර්ට් ගිවිසුම් සංකල්පය

TON සමඟ වැඩ කිරීමට පරිසරය සකස් කිරීම

TON වෙත පළමු ඉල්ලීම් කිරීම

Реализация

අදහස

බුද්ධිමත් ගිවිසුමක් ලිවීම

ලබා ගැනීමේ ක්‍රම භාවිතා කරමින් ස්මාර්ට් කොන්ත්‍රාත්තුවෙන් තොරතුරු ලබා ගැනීම

වෙබ් අඩවියේ ස්මාර්ට් කොන්ත්‍රාත්තු දත්ත ප්‍රදර්ශනය කිරීම

උත්සාහ කරනවා

පසු පදය

යොමු

අදහස් එක් කරන්න ඊ-මේල් මගින් පිලිතුරු දෙන්න අවලංගු

අදහස් එක් කරන්න