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 वरील लेखात वर्णन केलेल्या सर्व गोष्टी केल्या आणि डॉकरवरील स्वच्छ उबंटू 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 साठी कोड हायलाइट केला आहे; प्लगइन व्हिज्युअल स्टुडिओ कोड शोध मध्ये शोधले आणि स्थापित केले जाऊ शकते; तुम्हाला अचानक काहीतरी जोडायचे असल्यास, मी प्लगइन सार्वजनिकरित्या उपलब्ध केले आहे. तसेच, कोणीतरी पूर्वी फिफ्टसह कार्य करण्यासाठी प्लगइन बनवले आहे, आपण ते स्थापित करू शकता आणि व्हीएससीमध्ये शोधू शकता.

चला ताबडतोब एक रेपॉजिटरी तयार करूया जिथे आम्ही इंटरमीडिएट निकाल देऊ.

आमचे जीवन सोपे करण्यासाठी, आम्ही एक स्मार्ट करार लिहू आणि ते तयार होईपर्यंत स्थानिक पातळीवर त्याची चाचणी करू. त्यानंतरच आम्ही ते 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.

चला एक व्हेरिएबल बनवू 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.

चला skrpt कोड 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 पाच मध्ये. व्हेरिएबल्सचे डीसीरियलायझेशन फिफ्ट डॉक्युमेंटेशनमध्ये वर्णन केले आहे.

लिंक कमिट करा जोडलेल्या dough सह.

चला चाचणी चालवू आणि ते अयशस्वी झाले याची खात्री करा. आता लॉटरी मालकाचा पत्ता बदलण्यासाठी तर्क जोडूया.

स्मार्ट कॉन्ट्रॅक्टमध्ये आम्ही विश्लेषण करणे सुरू ठेवतो message, मध्ये वाचा action. आम्ही तुम्हाला आठवण करून देतो की आमच्याकडे दोन असतील action: पत्ता बदला आणि ग्राम पाठवा.

मग आम्ही कराराच्या मालकाचा नवीन पत्ता वाचतो आणि स्टोरेजमध्ये जतन करतो.
आम्ही चाचण्या चालवतो आणि पाहतो की तिसरी चाचणी अयशस्वी झाली. ते क्रॅश झाले आहे कारण करार आता मेसेजमधील 7 बिट्स देखील पार्स करतो, जे चाचणीमध्ये गहाळ आहेत. संदेशामध्ये अस्तित्वात नसलेला जोडा action. चला चाचण्या चालवू आणि सर्वकाही उत्तीर्ण झाल्याचे पहा. येथे बदलांसाठी वचनबद्ध. मस्त.

आता आधी सेव्ह केलेल्या पत्त्यावर निर्दिष्ट ग्राम संख्या पाठवण्याचे तर्क लिहू.

प्रथम, एक चाचणी लिहूया. आम्ही दोन चाचण्या लिहू, एक पुरेशी शिल्लक नसताना, दुसरी जेव्हा सर्वकाही यशस्वीरित्या उत्तीर्ण व्हावे. चाचण्या पाहता येतील या वचनबद्धतेमध्ये.

आता कोड टाकू. प्रथम, दोन सहाय्यक पद्धती लिहू. स्मार्ट कॉन्ट्रॅक्टची सध्याची शिल्लक शोधणे ही पहिली गेट पद्धत आहे.

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

आणि दुसरा दुसरा स्मार्ट कॉन्ट्रॅक्टवर ग्रॅम पाठवण्यासाठी आहे. मी दुसर्‍या स्मार्ट कॉन्ट्रॅक्टमधून ही पद्धत पूर्णपणे कॉपी केली.

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

चला या दोन पद्धती स्मार्ट कॉन्ट्रॅक्टमध्ये जोडू आणि तर्क लिहू. प्रथम, आम्ही संदेशातील ग्राम संख्येचे विश्लेषण करतो. पुढे आम्ही शिल्लक तपासतो, जर ते पुरेसे नसेल तर आम्ही अपवाद टाकतो. सर्व काही ठीक असल्यास, आम्ही जतन केलेल्या पत्त्यावर ग्रॅम पाठवतो आणि काउंटर अद्यतनित करतो.

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

याप्रमाणे या क्षणी स्मार्ट करार दिसत आहे. चला चाचण्या चालवू आणि त्या उत्तीर्ण झाल्याची खात्री करा.

तसे, प्रक्रिया केलेल्या संदेशासाठी प्रत्येक वेळी स्मार्ट करारातून कमिशन कापले जाते. विनंती अंमलात आणण्यासाठी स्मार्ट कॉन्ट्रॅक्ट मेसेजसाठी, मूलभूत तपासणीनंतर तुम्हाला कॉल करणे आवश्यक आहे accept_message().

आता अंतर्गत संदेशांकडे वळूया. खरेतर, आम्ही फक्त ग्रॅम स्वीकारू आणि खेळाडू जिंकल्यास त्याच्या दुप्पट रक्कम परत पाठवू आणि जर तो हरला तर मालकाला एक तृतीयांश रक्कम परत पाठवू.

प्रथम, एक साधी चाचणी लिहूया. हे करण्यासाठी, आम्हाला स्मार्ट कॉन्ट्रॅक्टचा एक चाचणी पत्ता आवश्यक आहे ज्यावरून आम्ही स्मार्ट कॉन्ट्रॅक्टमध्ये ग्राम पाठवतो.

स्मार्ट कॉन्ट्रॅक्ट अॅड्रेसमध्ये दोन नंबर असतात, वर्कचेनसाठी जबाबदार असलेला 32-बिट पूर्णांक आणि या वर्कचेनमधील 256-बिट नॉन-नकारात्मक पूर्णांक अद्वितीय खाते क्रमांक. उदाहरणार्थ, -1 आणि 12345, हा पत्ता आहे जो आपण फाईलमध्ये सेव्ह करू.

पत्ता सेव्ह करण्यासाठी मी फंक्शन कॉपी केले TonUtil.fif.

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

फंक्शन कसे कार्य करते ते पाहू या, यावरून फिफ्ट कसे कार्य करते हे समजेल. संवादात्मक मोडमध्ये फिफ्ट लाँच करा.

~/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 आणि आम्ही लिहिलेल्या get पद्धती चालवा.

$ ./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 क्लाउडवर प्रकाशित केली आहे. दुवा.

प्रयत्न करत आहे

आता पुन्हा भरण्यासाठी हरभरे तेथे पाठवण्याचा प्रयत्न करूया पाकीट. आम्ही 40 ग्रॅम पाठवू. आणि स्पष्टतेसाठी दोन पैज लावूया. आम्ही पाहतो की साइट बेटांचा इतिहास, वर्तमान जिंकण्याची टक्केवारी आणि इतर उपयुक्त माहिती दर्शवते.

आम्ही ते पाहूकी आम्ही पहिला जिंकलो, दुसरा हरलो.

नंतरचा शब्द

लेख माझ्या अपेक्षेपेक्षा खूप मोठा होता, कदाचित तो लहान असू शकतो, किंवा कदाचित अशा व्यक्तीसाठी ज्याला TON बद्दल काहीच माहिती नाही आणि ज्याला संवाद साधण्याच्या क्षमतेसह एक-सोपा स्मार्ट करार लिहायचा आणि प्रकाशित करायचा आहे. ते कदाचित काही गोष्टी अधिक सोप्या पद्धतीने समजावून सांगता आल्या असत्या.

कदाचित अंमलबजावणीचे काही पैलू अधिक कार्यक्षमतेने आणि सुबकपणे करता आले असते, परंतु नंतर लेख तयार करण्यास आणखी वेळ लागला असता. हे देखील शक्य आहे की मी कुठेतरी चूक केली आहे किंवा मला काहीतरी समजले नाही, म्हणून आपण काहीतरी गंभीर करत असल्यास, आपल्याला अधिकृत दस्तऐवजांवर किंवा TON कोडसह अधिकृत भांडारावर अवलंबून राहण्याची आवश्यकता आहे.

हे लक्षात घेतले पाहिजे की TON स्वतः अद्याप विकासाच्या सक्रिय टप्प्यात असल्याने, बदल घडू शकतात ज्यामुळे या लेखातील कोणतीही पायरी खंडित होईल (जे मी लिहित असताना घडले, ते आधीच दुरुस्त केले गेले आहे), परंतु सामान्य दृष्टीकोन आहे. बदलण्याची शक्यता नाही.

मी TON च्या भविष्याबद्दल बोलणार नाही. कदाचित प्लॅटफॉर्म काहीतरी मोठे होईल आणि आपण त्याचा अभ्यास करण्यासाठी वेळ घालवला पाहिजे आणि आता आमच्या उत्पादनांनी जागा भरली पाहिजे.

Facebook वरून लिब्रा देखील आहे, ज्याचे संभाव्य प्रेक्षक TON पेक्षा मोठे आहेत. मला तूळ राशीबद्दल जवळजवळ काहीही माहित नाही, फोरमच्या मते, तेथे 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 साठी व्हिज्युअल स्टुडिओ कोडच्या विस्तारासाठी भांडार: https://github.com/raiym/func-visual-studio-plugin
टेलीग्राममध्ये TON बद्दल चॅट करा, ज्याने सुरुवातीच्या टप्प्यावर ते शोधण्यात खरोखर मदत केली. मला वाटते की TON साठी काहीतरी लिहिलेले प्रत्येकजण तेथे आहे असे मी म्हटले तर चूक होणार नाही. तुम्ही तेथे चाचणी ग्रॅम देखील मागू शकता. https://t.me/tondev_ru
TON बद्दल आणखी एक चॅट ज्यामध्ये मला उपयुक्त माहिती मिळाली: https://t.me/TONgramDev
स्पर्धेचा पहिला टप्पा: https://contest.com/blockchain
स्पर्धेचा दुसरा टप्पा: https://contest.com/blockchain-2

स्त्रोत: www.habr.com

टेलीग्राम ओपन नेटवर्क (TON) मध्ये स्मार्ट करार कसा लिहावा आणि प्रकाशित करावा याबद्दल