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 के साथ काम करने के लिए वातावरण तैयार करना

मैंने मैकओएस पर वह सब कुछ किया जो लेख में वर्णित किया जाएगा और डॉकर पर स्वच्छ उबंटू 18.04 एलटीएस में इसकी दोबारा जांच की।

पहली चीज़ जो आपको करने की ज़रूरत है वह डाउनलोड और इंस्टॉल है lite-client जिससे आप TON को अनुरोध भेज सकते हैं।

आधिकारिक वेबसाइट पर दिए गए निर्देश इंस्टॉलेशन प्रक्रिया का काफी विस्तार से और स्पष्ट रूप से वर्णन करते हैं और कुछ विवरण छोड़ देते हैं। यहां हम निर्देशों का पालन करते हैं, रास्ते में लापता निर्भरताएं स्थापित करते हैं। मैंने प्रत्येक प्रोजेक्ट को स्वयं संकलित नहीं किया और आधिकारिक उबंटू रिपॉजिटरी (मैकओएस पर मैंने उपयोग किया) से इंस्टॉल किया 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 से दांव और परिणाम दिखाएगी।

एक स्मार्ट अनुबंध लिखना

सुविधा के लिए, मैंने फ़नसी के लिए कोड को हाइलाइट किया है; प्लगइन को विज़ुअल स्टूडियो कोड खोज में पाया और इंस्टॉल किया जा सकता है; यदि आप अचानक कुछ जोड़ना चाहते हैं, तो मैंने प्लगइन को सार्वजनिक रूप से उपलब्ध करा दिया है। इसके अलावा, किसी ने पहले फिफ्ट के साथ काम करने के लिए एक प्लगइन बनाया था, आप इसे इंस्टॉल भी कर सकते हैं और इसे वीएससी में ढूंढ सकते हैं।

आइए तुरंत एक रिपॉजिटरी बनाएं जहां हम मध्यवर्ती परिणाम देंगे।

अपने जीवन को आसान बनाने के लिए, हम एक स्मार्ट अनुबंध लिखेंगे और इसके तैयार होने तक स्थानीय स्तर पर इसका परीक्षण करेंगे। उसके बाद ही हम इसे 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 ब्लॉकचेन में संग्रहीत सभी डेटा एक संग्रह है 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 !

स्थिरांक और चर तैयार करने के बाद, हम कमांड का उपयोग करके टीवीएम लॉन्च करते हैं 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

आइए देखें कि फ़ंक्शन कैसे काम करता है, इससे यह समझ आएगा कि Fift कैसे काम करता है। इंटरएक्टिव मोड में फाइव लॉन्च करें।

~/TON/build/crypto/fift -i

सबसे पहले हम स्टैक पर -1, 12345 और भविष्य की फ़ाइल का नाम "sender.addr" दबाते हैं:

-1 12345 "sender.addr"

अगला कदम फ़ंक्शन को निष्पादित करना है -rot, जो स्टैक को इस तरह से स्थानांतरित करता है कि स्टैक के शीर्ष पर एक अद्वितीय स्मार्ट अनुबंध संख्या होती है:

"sender.addr" -1 12345

256 u>B 256-बिट गैर-नकारात्मक पूर्णांक को बाइट्स में परिवर्तित करता है।

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap स्टैक के शीर्ष दो तत्वों को स्वैप करता है।

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B 32-बिट पूर्णांक को बाइट्स में परिवर्तित करता है।

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ बाइट्स के दो अनुक्रमों को जोड़ता है।

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

फिर swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr"

और अंत में बाइट्स फ़ाइल में लिखे जाते हैं B>file. इसके बाद हमारा स्टैक खाली है. हम रुकते हैं Fift. वर्तमान फ़ोल्डर में एक फ़ाइल बनाई गई है sender.addr. आइए फ़ाइल को बनाए गए फ़ोल्डर में ले जाएँ test/addresses/.

आइए एक सरल परीक्षण लिखें जो ग्राम को स्मार्ट अनुबंध में भेजेगा। यहाँ प्रतिबद्धता है.

अब लॉटरी के तर्क पर नजर डालते हैं।

सबसे पहले हम संदेश की जांच करते हैं bounced या नहीं तो bounced, तो हम इसे नजरअंदाज कर देते हैं। bounced इसका मतलब है कि यदि कोई त्रुटि होती है तो अनुबंध ग्राम वापस कर देगा। यदि अचानक कोई त्रुटि होती है तो हम ग्राम वापस नहीं करेंगे।

हम चेक करते हैं, अगर बैलेंस आधा ग्राम से कम है तो हम मैसेज को स्वीकार कर लेते हैं और उसे नजरअंदाज कर देते हैं।

इसके बाद, हम उस स्मार्ट अनुबंध का पता पार्स करते हैं जिससे संदेश आया था।

हम स्टोरेज से डेटा पढ़ते हैं और फिर यदि पुराने दांव बीस से अधिक हैं तो उन्हें इतिहास से हटा देते हैं। सुविधा के लिए, मैंने तीन अतिरिक्त फ़ंक्शन लिखे pack_order(), unpack_order(), remove_old_orders().

इसके बाद, हम देखते हैं कि यदि भुगतान के लिए शेष राशि पर्याप्त नहीं है, तो हम मानते हैं कि यह एक शर्त नहीं है, बल्कि एक पुनःपूर्ति है और पुनःपूर्ति को बचाएं orders.

फिर अंततः स्मार्ट अनुबंध का सार।

सबसे पहले, यदि खिलाड़ी हार जाता है, तो हम इसे सट्टेबाजी इतिहास में सहेजते हैं और यदि राशि 3 ग्राम से अधिक है, तो हम स्मार्ट अनुबंध के मालिक को 1/3 भेजते हैं।

यदि खिलाड़ी जीत जाता है तो हम खिलाड़ी के पते पर दोगुनी रकम भेज देते हैं और फिर दांव की जानकारी इतिहास में सेव कर लेते हैं।

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

बस. संगत प्रतिबद्धता.

अब जो कुछ बचा है वह सरल है, आइए गेट-मेथड बनाएं ताकि हम बाहरी दुनिया से अनुबंध की स्थिति के बारे में जानकारी प्राप्त कर सकें (वास्तव में, उनके स्मार्ट अनुबंध भंडारण से डेटा पढ़ें)।

आइए get विधियाँ जोड़ें. स्मार्ट अनुबंध के बारे में जानकारी कैसे प्राप्त करें, इसके बारे में हम नीचे लिखेंगे।

मैं वह कोड जोड़ना भी भूल गया जो स्मार्ट अनुबंध प्रकाशित करते समय होने वाले पहले अनुरोध को संसाधित करेगा। संगत प्रतिबद्धता. और आगे संशोधित स्वामी के खाते में राशि का 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 क्लाउड पर प्रकाशित किया गया है। संपर्क.

आओ कोशिश करते हैं

आइए अब पुनःपूर्ति के लिए वहां चने भेजने का प्रयास करें पर्स. हम 40 ग्राम भेजेंगे. और आइए स्पष्टता के लिए कुछ दांव लगाएं। हम देखते हैं कि साइट दांव का इतिहास, वर्तमान जीत प्रतिशत और अन्य उपयोगी जानकारी दिखाती है।

हम देखते हैंकि हमने पहला जीता, दूसरा हारे।

अंतभाषण

लेख मेरी अपेक्षा से कहीं अधिक लंबा निकला, शायद यह छोटा हो सकता था, या शायद केवल उस व्यक्ति के लिए जो TON के बारे में कुछ नहीं जानता है और बातचीत करने की क्षमता के साथ एक बहुत ही सरल स्मार्ट अनुबंध लिखना और प्रकाशित करना चाहता है यह। शायद कुछ बातें अधिक सरलता से समझायी जा सकती थीं।

शायद कार्यान्वयन के कुछ पहलुओं को अधिक कुशलतापूर्वक और सुरुचिपूर्ण ढंग से किया जा सकता था, लेकिन तब लेख तैयार करने में और भी अधिक समय लगता। यह भी संभव है कि मैंने कहीं कोई गलती की हो या कुछ समझ नहीं पाया हो, इसलिए यदि आप कुछ गंभीर कर रहे हैं, तो आपको आधिकारिक दस्तावेज या TON कोड के साथ आधिकारिक रिपॉजिटरी पर भरोसा करना होगा।

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

मैं TON के भविष्य के बारे में बात नहीं करूंगा। शायद प्लेटफ़ॉर्म कुछ बड़ा हो जाएगा और हमें इसका अध्ययन करने में समय लगाना चाहिए और अब अपने उत्पादों के साथ एक जगह भरनी चाहिए।

फेसबुक से लिब्रा भी है, जिसके उपयोगकर्ताओं की संभावित ऑडियंस 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
फ़नसी के लिए विज़ुअल स्टूडियो कोड के विस्तार के लिए रिपोजिटरी: 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