TON இல் ஸ்மார்ட் ஒப்பந்தத்தை எழுதுவது மற்றும் வெளியிடுவது எப்படி என்பது பற்றி

இந்தக் கட்டுரை எதைப் பற்றியது?

கட்டுரையில் நான் முதல் (இரண்டில்) டெலிகிராம் பிளாக்செயின் போட்டியில் எவ்வாறு பங்கேற்றேன், பரிசு பெறவில்லை, எனது அனுபவத்தை ஒரு கட்டுரையில் பதிவு செய்ய முடிவு செய்தேன், அது மறதியில் மூழ்காமல் இருக்கவும், ஒருவேளை உதவவும். யாரோ.

நான் சுருக்கக் குறியீட்டை எழுத விரும்பவில்லை, ஆனால் ஏதாவது வேலை செய்ய, கட்டுரைக்காக உடனடி லாட்டரிக்கான ஸ்மார்ட் ஒப்பந்தம் மற்றும் இடைநிலை சேமிப்பகத்தைப் பயன்படுத்தாமல் TON இலிருந்து நேரடியாக ஸ்மார்ட் ஒப்பந்தத் தரவைக் காட்டும் இணையதளம் எழுதினேன்.

TON இல் தங்கள் முதல் ஸ்மார்ட் ஒப்பந்தத்தை செய்ய விரும்புவோருக்கு கட்டுரை பயனுள்ளதாக இருக்கும், ஆனால் எங்கு தொடங்குவது என்று தெரியவில்லை.

லாட்டரியை உதாரணமாகப் பயன்படுத்தி, நான் சூழலை நிறுவுவதில் இருந்து ஒரு ஸ்மார்ட் ஒப்பந்தத்தை வெளியிடுவது, அதனுடன் தொடர்புகொள்வது மற்றும் தரவைப் பெறுவதற்கும் வெளியிடுவதற்கும் ஒரு வலைத்தளத்தை எழுதுவது வரை செல்வேன்.

போட்டியில் பங்கேற்பது பற்றி

கடந்த அக்டோபரில், டெலிகிராம் புதிய மொழிகளுடன் பிளாக்செயின் போட்டியை அறிவித்தது Fift и FunC. முன்மொழியப்பட்ட ஐந்து ஸ்மார்ட் ஒப்பந்தங்களில் ஏதேனும் ஒன்றை எழுதுவதிலிருந்து தேர்வு செய்வது அவசியம். வருங்காலத்தில் வேறு எதுவும் எழுத வேண்டியதில்லை என்றாலும், வித்தியாசமாக ஏதாவது செய்து, ஒரு மொழியைக் கற்றுக்கொண்டு, ஏதாவது செய்தால் நன்றாக இருக்கும் என்று நினைத்தேன். கூடுதலாக, தலைப்பு தொடர்ந்து உதடுகளில் உள்ளது.

ஸ்மார்ட் ஒப்பந்தங்களை உருவாக்குவதில் எனக்கு எந்த அனுபவமும் இல்லை என்று சொல்வது மதிப்பு.

என்னால் முடியும் வரை கடைசி வரை கலந்துகொண்டு மறுஆய்வுக் கட்டுரை எழுதத் திட்டமிட்டிருந்தேன், ஆனால் முதல் கட்டுரையில் உடனே தோல்வியடைந்தேன். நான் ஒரு பணப்பையை எழுதினார் பல கையொப்பத்துடன் FunC அது பொதுவாக வேலை செய்தது. நான் அதை ஒரு அடிப்படையாக எடுத்துக் கொண்டேன் சாலிடிட்டி மீதான ஸ்மார்ட் ஒப்பந்தம்.

குறைந்த பட்சம் பரிசு இடத்தையாவது பிடிக்க இதுவே போதுமானது என்று அப்போது நினைத்தேன். இதன் விளைவாக, 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 இல் காணலாம்.

உடனடியாக ஒரு களஞ்சியத்தை உருவாக்குவோம், அங்கு இடைநிலை முடிவுகளைச் செய்வோம்.

எங்கள் வாழ்க்கையை எளிதாக்க, நாங்கள் ஒரு ஸ்மார்ட் ஒப்பந்தத்தை எழுதி, அது தயாராகும் வரை உள்ளூரில் சோதனை செய்வோம். அதன் பிறகுதான் டோனில் வெளியிடுவோம்.

ஸ்மார்ட் ஒப்பந்தத்தில் அணுகக்கூடிய இரண்டு வெளிப்புற முறைகள் உள்ளன. முதலில், recv_external() ஒப்பந்தத்திற்கான கோரிக்கை வெளி உலகத்திலிருந்து வரும்போது, ​​அதாவது TON இலிருந்து அல்ல, எடுத்துக்காட்டாக, நாமே ஒரு செய்தியை உருவாக்கி அதை லைட்-கிளையன்ட் மூலம் அனுப்பும்போது இந்த செயல்பாடு செயல்படுத்தப்படுகிறது. இரண்டாவது, recv_internal() இதுவே, TONக்குள், எந்த ஒப்பந்தமும் நம்முடையதைக் குறிக்கிறது. இரண்டு சந்தர்ப்பங்களிலும், நீங்கள் செயல்பாட்டிற்கு அளவுருக்களை அனுப்பலாம்.

ஒரு எளிய உதாரணத்துடன் தொடங்குவோம், அது வெளியிடப்பட்டால் வேலை செய்யும், ஆனால் அதில் செயல்பாட்டு சுமை இல்லை.

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

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

அது என்ன என்பதை இங்கு விளக்க வேண்டும் slice. டன் பிளாக்செயினில் சேமிக்கப்பட்ட அனைத்து தரவுகளும் ஒரு தொகுப்பு ஆகும் 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

இதுவரை தெளிவாகத் தெரிகிறது, இப்போது அதே கோப்பில் டிவிஎம் தொடங்குவதற்குப் பயன்படுத்தும் குறியீட்டைச் சேர்ப்போம்.

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 டிவிஎம் (அல்லது நெட்வொர்க் நிலை) தொடங்கப்படும் சூழலை நாங்கள் பதிவு செய்கிறோம். போட்டியின் போது கூட, டெவலப்பர்களில் ஒருவர் எவ்வாறு உருவாக்குவது என்பதைக் காட்டினார் 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. இதைச் செய்ய, ஃபிஃப்ட்டை ஊடாடும் பயன்முறையில் துவக்கி நான்கு கட்டளைகளை இயக்குவோம்.

`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

செயல்பாடு எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம், இது ஃபிஃப்ட் எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்ளும். ஊடாடும் பயன்முறையில் ஃபிஃப்டைத் தொடங்கவும்.

~/TON/build/crypto/fift -i 

முதலில் நாம் -1, 12345 மற்றும் எதிர்கால கோப்பின் பெயரை "sender.addr" அடுக்கில் தள்ளுகிறோம்:

-1 12345 "sender.addr" 

அடுத்த படி செயல்பாட்டை செயல்படுத்த வேண்டும் -rot, இது அடுக்கின் மேல் ஒரு தனித்துவமான ஸ்மார்ட் ஒப்பந்த எண் இருக்கும் வகையில் அடுக்கை மாற்றுகிறது:

"sender.addr" -1 12345

256 u>B 256-பிட் எதிர்மறை அல்லாத முழு எண்ணை பைட்டுகளாக மாற்றுகிறது.

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap அடுக்கின் மேல் இரண்டு கூறுகளை மாற்றுகிறது.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B 32-பிட் முழு எண்ணை பைட்டுகளாக மாற்றுகிறது.

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ பைட்டுகளின் இரண்டு வரிசைகளை இணைக்கிறது.

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

மீண்டும் swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr" 

இறுதியாக பைட்டுகள் கோப்பில் எழுதப்படுகின்றன B>file. இதற்குப் பிறகு எங்கள் அடுக்கு காலியாக உள்ளது. நாங்கள் நிறுத்துகிறோம் Fift. தற்போதைய கோப்புறையில் ஒரு கோப்பு உருவாக்கப்பட்டது sender.addr. உருவாக்கப்பட்ட கோப்புறைக்கு கோப்பை நகர்த்துவோம் test/addresses/.

ஒரு ஸ்மார்ட் ஒப்பந்தத்திற்கு கிராம் அனுப்பும் எளிய தேர்வை எழுதுவோம். இதோ உறுதி.

இப்போது லாட்டரியின் தர்க்கத்தைப் பார்ப்போம்.

நாம் செய்யும் முதல் விஷயம், செய்தியைச் சரிபார்ப்பதுதான் bounced அல்லது இல்லை என்றால் bounced, பின்னர் நாங்கள் அதை புறக்கணிக்கிறோம். bounced சில பிழை ஏற்பட்டால் ஒப்பந்தம் கிராம் திரும்பும் என்று அர்த்தம். திடீரென்று ஒரு பிழை ஏற்பட்டால் நாங்கள் கிராம் திரும்ப மாட்டோம்.

நாங்கள் சரிபார்க்கிறோம், இருப்பு அரை கிராமுக்கு குறைவாக இருந்தால், நாங்கள் செய்தியை ஏற்றுக்கொண்டு அதை புறக்கணிக்கிறோம்.

அடுத்து, செய்தி வந்த ஸ்மார்ட் ஒப்பந்தத்தின் முகவரியை அலசுவோம்.

சேமிப்பகத்திலிருந்து தரவைப் படித்து, இருபதுக்கும் மேற்பட்டவை இருந்தால் வரலாற்றிலிருந்து பழைய சவால்களை நீக்குவோம். வசதிக்காக, நான் மூன்று கூடுதல் செயல்பாடுகளை எழுதினேன் pack_order(), unpack_order(), remove_old_orders().

அடுத்து, பணம் செலுத்துவதற்கு இருப்பு போதுமானதாக இல்லை என்றால், இது ஒரு பந்தயம் அல்ல, ஆனால் நிரப்புதல் என்று நாங்கள் கருதுகிறோம் orders.

பின்னர் இறுதியாக ஸ்மார்ட் ஒப்பந்தத்தின் சாராம்சம்.

முதலில், வீரர் தோற்றால், அதை பந்தய வரலாற்றில் சேமிப்போம், மேலும் 3 கிராமுக்கு மேல் தொகை இருந்தால், ஸ்மார்ட் ஒப்பந்தத்தின் உரிமையாளருக்கு 1/3 அனுப்புகிறோம்.

வீரர் வெற்றி பெற்றால், நாங்கள் வீரரின் முகவரிக்கு இரட்டிப்புத் தொகையை அனுப்புகிறோம், பின்னர் வரலாற்றில் பந்தயம் பற்றிய தகவலைச் சேமிக்கிறோம்.

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

அவ்வளவுதான். தொடர்புடைய உறுதி.

இப்போது எஞ்சியிருப்பது எளிமையானது, ஒப்பந்தத்தின் நிலையைப் பற்றிய தகவல்களை வெளி உலகத்திலிருந்து பெறுவதற்கு வழிகளை உருவாக்குவோம் (உண்மையில், அவர்களின் ஸ்மார்ட் ஒப்பந்த சேமிப்பகத்திலிருந்து தரவைப் படிக்கவும்).

பெறு முறைகளைச் சேர்ப்போம். ஸ்மார்ட் ஒப்பந்தத்தைப் பற்றிய தகவலைப் பெறுவது பற்றி கீழே எழுதுவோம்.

ஸ்மார்ட் ஒப்பந்தத்தை வெளியிடும் போது ஏற்படும் முதல் கோரிக்கையைச் செயல்படுத்தும் குறியீட்டைச் சேர்க்க மறந்துவிட்டேன். தொடர்புடைய உறுதி. மேலும் மேலும் சரி செய்யப்பட்டது 1/3 தொகையை உரிமையாளரின் கணக்கிற்கு அனுப்புவதில் பிழை.

அடுத்த கட்டமாக ஸ்மார்ட் ஒப்பந்தத்தை வெளியிட வேண்டும். ஒரு கோப்புறையை உருவாக்குவோம் requests.

பிரசுரக் குறியீட்டை அடிப்படையாக எடுத்துக் கொண்டேன் simple-wallet-code.fc இது கண்டுபிடிக்க முடியும் அதிகாரப்பூர்வ களஞ்சியத்தில்.

கவனம் செலுத்த வேண்டிய ஒன்று. நாங்கள் ஒரு ஸ்மார்ட் ஒப்பந்த சேமிப்பகத்தையும் உள்ளீட்டு செய்தியையும் உருவாக்குகிறோம். இதற்குப் பிறகு, ஸ்மார்ட் ஒப்பந்தத்தின் முகவரி உருவாக்கப்படுகிறது, அதாவது, TON இல் வெளியிடப்படுவதற்கு முன்பே முகவரி அறியப்படுகிறது. அடுத்து, நீங்கள் இந்த முகவரிக்கு பல கிராம்களை அனுப்ப வேண்டும், அதன் பிறகுதான் ஸ்மார்ட் ஒப்பந்தத்துடன் ஒரு கோப்பை அனுப்ப வேண்டும், ஏனெனில் ஸ்மார்ட் ஒப்பந்தம் மற்றும் செயல்பாடுகளைச் சேமிப்பதற்காக நெட்வொர்க் கமிஷன் எடுக்கும் (ஸ்மார்ட்டைச் சேமித்து செயல்படுத்தும் சரிபார்ப்பாளர்கள். ஒப்பந்தங்கள்). குறியீட்டை இங்கே பார்க்கலாம்.

அடுத்து நாம் வெளியீட்டு குறியீட்டை இயக்கவும் மற்றும் பெறவும் lottery-query.boc ஸ்மார்ட் ஒப்பந்த கோப்பு மற்றும் முகவரி.

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

உருவாக்கப்பட்ட கோப்புகளைச் சேமிக்க மறக்காதீர்கள்: lottery-query.boc, lottery.addr, lottery.pk.

மற்றவற்றுடன், செயல்படுத்தல் பதிவுகளில் ஸ்மார்ட் ஒப்பந்தத்தின் முகவரியைப் பார்ப்போம்.

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

வேடிக்கைக்காக, TON க்கு கோரிக்கை விடுப்போம்

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

இந்த முகவரியுடன் கணக்கு காலியாக இருப்பதைப் பார்ப்போம்.

account state is empty

முகவரிக்கு அனுப்புகிறோம் 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 கிராம் மற்றும் சில வினாடிகளுக்குப் பிறகு அதே கட்டளையை இயக்குகிறோம். கிராம் அனுப்ப நான் பயன்படுத்துகிறேன் அதிகாரப்பூர்வ பணப்பை, மற்றும் நீங்கள் அரட்டையிலிருந்து ஒருவரிடம் சோதனை கிராம்களைக் கேட்கலாம், அதை நான் கட்டுரையின் முடிவில் பேசுவேன்.

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

தொடங்கப்படாதது போல் தெரிகிறது (state:account_uninit) அதே முகவரியுடன் கூடிய ஸ்மார்ட் ஒப்பந்தம் மற்றும் 1 நானோகிராம் இருப்பு.

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

இப்போது ஸ்மார்ட் ஒப்பந்தத்தை வெளியிடுவோம். லைட்-கிளையண்டைத் துவக்கி செயல்படுத்துவோம்.

> 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]) ] 

நாங்கள் லைட்-கிளையண்டைப் பயன்படுத்துவோம் மற்றும் தளத்தில் ஸ்மார்ட் ஒப்பந்தத்தைப் பற்றிய தகவலைக் காண்பிக்கும் முறைகளைப் பெறுவோம்.

இணையதளத்தில் ஸ்மார்ட் ஒப்பந்தத் தரவைக் காட்டுகிறது

ஸ்மார்ட் ஒப்பந்தத்திலிருந்து தரவை வசதியான வழியில் காட்ட பைத்தானில் ஒரு எளிய இணையதளத்தை எழுதினேன். இங்கே நான் அதைப் பற்றி விரிவாகக் கூறமாட்டேன் மற்றும் தளத்தை வெளியிடுவேன் ஒரு உறுதிமொழியில்.

TONக்கான கோரிக்கைகள் இதிலிருந்து செய்யப்படுகின்றன Python உதவியுடன் lite-client. வசதிக்காக, தளம் டோக்கரில் தொகுக்கப்பட்டு Google Cloud இல் வெளியிடப்பட்டது. இணைப்பு.

நாம் முயற்சிப்போம்

இப்போது அங்கு இருந்து நிரப்புவதற்கு கிராம் அனுப்ப முயற்சி செய்யலாம் பணப்பை. நாங்கள் 40 கிராம் அனுப்புவோம். மேலும் தெளிவுக்காக ஒரு ஜோடி சவால் செய்வோம். பந்தயங்களின் வரலாறு, தற்போதைய வெற்றி சதவீதம் மற்றும் பிற பயனுள்ள தகவல்களை தளம் காட்டுவதை நாங்கள் காண்கிறோம்.

நாங்கள் பார்க்கிறோம்முதலில் வென்றோம், இரண்டாவதாக தோற்றோம்.

பின்னுரை

கட்டுரை நான் எதிர்பார்த்ததை விட மிக நீண்டதாக மாறியது, ஒருவேளை அது குறுகியதாக இருக்கலாம் அல்லது டன் பற்றி எதுவும் தெரியாத ஒரு நபருக்கு மற்றும் தொடர்பு கொள்ளும் திறனுடன் மிகவும் எளிமையானது அல்லாத ஸ்மார்ட் ஒப்பந்தத்தை எழுதி வெளியிட விரும்புபவர். அது. ஒருவேளை சில விஷயங்களை இன்னும் எளிமையாக விளக்கியிருக்கலாம்.

ஒருவேளை செயல்படுத்துதலின் சில அம்சங்களை இன்னும் திறமையாகவும் நேர்த்தியாகவும் செய்திருக்கலாம், ஆனால் கட்டுரையைத் தயாரிக்க இன்னும் அதிக நேரம் எடுத்திருக்கும். நான் எங்காவது தவறு செய்திருக்கலாம் அல்லது ஏதாவது புரியவில்லை, எனவே நீங்கள் தீவிரமாக ஏதாவது செய்கிறீர்கள் என்றால், நீங்கள் அதிகாரப்பூர்வ ஆவணங்கள் அல்லது டன் குறியீட்டைக் கொண்ட அதிகாரப்பூர்வ களஞ்சியத்தை நம்பியிருக்க வேண்டும்.

TON இன்னும் வளர்ச்சியின் செயலில் உள்ள கட்டத்தில் இருப்பதால், இந்த கட்டுரையில் உள்ள எந்த படிநிலையையும் உடைக்கும் மாற்றங்கள் ஏற்படலாம் (நான் எழுதும் போது இது நடந்தது, அது ஏற்கனவே சரி செய்யப்பட்டது), ஆனால் பொதுவான அணுகுமுறை மாற வாய்ப்பில்லை.

நான் TON இன் எதிர்காலத்தைப் பற்றி பேசமாட்டேன். ஒருவேளை இயங்குதளம் பெரியதாக மாறும், அதைப் படிப்பதில் நேரத்தைச் செலவழித்து, இப்போது எங்கள் தயாரிப்புகளில் ஒரு முக்கிய இடத்தை நிரப்ப வேண்டும்.

ஃபேஸ்புக்கிலிருந்து துலாம் உள்ளது, இது TON ஐ விட அதிகமான பயனர்களின் பார்வையாளர்களைக் கொண்டுள்ளது. துலாம் பற்றி எனக்கு எதுவும் தெரியாது, மன்றத்தின் மூலம் மதிப்பிடுவது டன் சமூகத்தை விட அதிக செயல்பாடு உள்ளது. TON இன் டெவலப்பர்கள் மற்றும் சமூகம் நிலத்தடி போன்றது என்றாலும், இது குளிர்ச்சியாகவும் இருக்கிறது.

குறிப்புகள்

1. அதிகாரப்பூர்வ டன் ஆவணங்கள்: https://test.ton.org
2. அதிகாரப்பூர்வ டன் களஞ்சியம்: https://github.com/ton-blockchain/ton
3. வெவ்வேறு தளங்களுக்கான அதிகாரப்பூர்வ பணப்பை: https://wallet.ton.org
4. இந்தக் கட்டுரையிலிருந்து ஸ்மார்ட் ஒப்பந்தக் களஞ்சியம்: https://github.com/raiym/astonished
5. ஸ்மார்ட் ஒப்பந்த இணையதளத்திற்கான இணைப்பு: https://ton-lottery.appspot.com
6. FunCக்கான விஷுவல் ஸ்டுடியோ குறியீட்டிற்கான நீட்டிப்புக்கான களஞ்சியம்: https://github.com/raiym/func-visual-studio-plugin
7. டெலிகிராமில் டன் பற்றி அரட்டையடிக்கவும், இது ஆரம்ப கட்டத்தில் அதைக் கண்டுபிடிக்க உதவியது. 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