TON मा स्मार्ट सम्झौता कसरी लेख्ने र प्रकाशित गर्ने

यो लेख के बारे मा हो?

यस लेखमा, म तपाईंलाई कसरी (दुई मध्ये) पहिलो टेलिग्राम ब्लकचेन प्रतियोगितामा भाग लिएँ, पुरस्कार जित्न सकिनँ, र अनुभवलाई एउटा लेखमा रेकर्ड गर्ने निर्णय गरें ताकि यो विस्मृतिमा नपुगोस् र सायद कसैलाई मद्दत गरोस् भन्ने कुरा बताउनेछु।

म अमूर्त कोड लेख्न चाहन्नथें, तर केही काम गर्ने बनाउन चाहन्थें, त्यसैले लेखको लागि मैले स्मार्ट कन्ट्र्याक्ट इन्स्ट्यान्ट लटरी र एउटा वेबसाइट लेखें जसले मध्यवर्ती भण्डारण प्रयोग नगरी TON बाट सिधै स्मार्ट कन्ट्र्याक्ट डेटा देखाउँछ।

यो लेख TON मा आफ्नो पहिलो स्मार्ट सम्झौता गर्न चाहने तर कहाँबाट सुरु गर्ने थाहा नभएकाहरूका लागि उपयोगी हुनेछ।

उदाहरणको रूपमा लटरीको प्रयोग गर्दै, म वातावरण सेटअप गर्नेदेखि स्मार्ट सम्झौता प्रकाशित गर्ने, त्यससँग अन्तर्क्रिया गर्ने, र डेटा प्राप्त गर्ने र प्रकाशन गर्ने वेबसाइट लेख्ने काम गर्नेछु।

प्रतियोगितामा सहभागिताको बारेमा

गत अक्टोबरमा, टेलिग्रामले नयाँ भाषाहरूसँग ब्लकचेन प्रतियोगिताको घोषणा गर्‍यो। Fift и FunC। मलाई पाँच स्मार्ट सम्झौताहरू मध्ये एक छनौट गर्नुपर्‍यो। मैले सोचें कि केहि असामान्य गर्नु, भाषा सिक्नु, र केहि गर्नु राम्रो विचार हुनेछ, भविष्यमा मलाई अरू केहि लेख्नु नपरे पनि। साथै, विषय सधैं सबैको ओठमा हुन्छ।

यो भन्न लायक छ कि मलाई स्मार्ट अनुबंधहरू विकास गर्ने कुनै अनुभव थिएन।

मैले सकुन्जेलसम्म भाग लिने र त्यसपछि समीक्षा लेख लेख्ने योजना बनाएको थिएँ, तर पहिलो लेखमै म असफल भएँ। लेखिएको वालेट बहु-हस्ताक्षर अन भएको FunC र यसले सामान्यतया काम गर्यो। मैले यसलाई आधारको रूपमा लिएँ। सोलिडिटीमा स्मार्ट सम्झौता.

त्यो क्षणमा मैले सोचेँ कि यो निश्चित रूपमा कम्तिमा केही पुरस्कार स्थान लिन पर्याप्त छ। अन्तमा, ६० मध्ये ४० जना सहभागी पुरस्कार विजेता बने र म तिनीहरूमध्ये थिइनँ। सामान्यतया, यसमा केही नराम्रो छैन, तर एउटा कुराले मलाई सताएको थियो। मेरो सम्झौताको परीक्षण नभएको समीक्षाको नतिजा घोषणाको समयमा, मैले च्याटमा सहभागीहरूलाई सोधें कि के त्यहाँ अरू कोही छ जसको यो छैन, त्यहाँ कोही थिएनन्।

मेरो सन्देशहरू देखेर, न्यायाधीशहरूले दुई दिन पछि एउटा टिप्पणी प्रकाशित गरे र मलाई अझै पनि थाहा छैन कि उनीहरूले निर्णयको क्रममा गल्तिले मेरो स्मार्ट सम्झौता छुटाए वा यो यति खराब थियो कि यसलाई टिप्पणीको आवश्यकता पर्दैन भन्ने सोचेका थिए। मैले पृष्ठमा एउटा प्रश्न सोधें तर जवाफ पाइन। यद्यपि यो कसले निर्णय गर्यो भन्ने कुरा गोप्य छैन, मलाई लाग्यो कि व्यक्तिगत सन्देशहरू लेख्नु अनावश्यक थियो।

बुझ्न धेरै समय लाग्यो, त्यसैले लेख लेख्ने निर्णय गरियो। अझै धेरै जानकारी नभएकोले, लेखले इच्छुक सबैको समय बचत गर्न मद्दत गर्नेछ।

TON मा स्मार्ट अनुबंधको अवधारणा

केहि लेख्नु अघि, तपाईंले यो कुरालाई कुन पक्षबाट हेर्ने भनेर पत्ता लगाउनु पर्छ। त्यसैले अब म तपाईंलाई प्रणालीमा कुन भागहरू छन् भनेर बताउनेछु। अझ स्पष्ट रूपमा, कम्तिमा कुनै प्रकारको काम सम्झौता लेख्नको लागि तपाईंलाई कुन भागहरू जान्न आवश्यक छ।

हामी स्मार्ट सम्झौता लेख्न र काम गर्नमा ध्यान केन्द्रित गर्नेछौं TON Virtual Machine (TVM), Fift и FunC, त्यसैले लेख नियमित कार्यक्रमको विकासको विवरण जस्तै छ। हामी यहाँ प्लेटफर्म आफैंले कसरी काम गर्छ भन्ने बारेमा छलफल गर्ने छैनौं।

यो कसरी काम गर्छ भन्ने बारेमा सामान्य रूपमा TVM र भाषा Fift राम्रो आधिकारिक कागजातहरू छन्। प्रतियोगिताको समयमा र अहिले हालको सम्झौता लेख्दा, म प्रायः यसलाई उल्लेख गर्थें।

स्मार्ट अनुबंधहरू लेखिने मुख्य भाषा हो FunC। हाल यसमा कुनै कागजात छैन, त्यसैले केहि लेख्नको लागि, तपाईंले आधिकारिक भण्डारबाट स्मार्ट अनुबंधहरूको उदाहरणहरू र त्यहाँ भाषाको कार्यान्वयनको अध्ययन गर्न आवश्यक छ, साथै तपाईं विगतका दुई प्रतियोगिताहरूको लागि स्मार्ट अनुबंधहरूको उदाहरणहरू हेर्न सक्नुहुन्छ। लेखको अन्त्यमा लिङ्कहरू।

मानौं हामीले पहिले नै एउटा स्मार्ट सम्झौता लेखिसकेका छौं FunC, त्यसपछि हामी कोडलाई Fift एसेम्बलरमा कम्पाइल गर्छौं।

संकलित स्मार्ट सम्झौता प्रकाशित हुन बाँकी छ। यो गर्नको लागि, तपाईंले एउटा प्रकार्य लेख्न आवश्यक छ Fift, जसले स्मार्ट अनुबंध कोड र केही अन्य प्यारामिटरहरूलाई इनपुटको रूपमा स्वीकार गर्नेछ, र आउटपुट एक्सटेन्सन भएको फाइल हुनेछ .boc (जसको अर्थ "कोषहरूको झोला" हो), र, हामीले यसलाई कसरी लेख्छौं भन्ने आधारमा, एउटा निजी कुञ्जी र स्मार्ट अनुबंध कोडको आधारमा उत्पन्न हुने ठेगाना। तपाईंले पहिले नै स्मार्ट अनुबंध ठेगानामा ग्राम पठाउन सक्नुहुन्छ, जुन अहिलेसम्म प्रकाशित भएको छैन।

प्राप्त TON मा स्मार्ट सम्झौता प्रकाशित गर्न .boc फाइललाई लाइट क्लाइन्ट प्रयोग गरेर ब्लकचेनमा पठाउनु पर्नेछ (यसको बारेमा तल थप जानकारी)। तर प्रकाशन गर्नु अघि, तपाईंले उत्पन्न ठेगानामा ग्राम स्थानान्तरण गर्न आवश्यक छ, अन्यथा स्मार्ट सम्झौता प्रकाशित हुनेछैन। प्रकाशन पछि, तपाईं स्मार्ट सम्झौतालाई बाहिरबाट सन्देशहरू पठाएर (उदाहरणका लागि, लाइट क्लाइन्ट प्रयोग गरेर) वा भित्रबाट (उदाहरणका लागि, एउटा स्मार्ट सम्झौताले अर्कोलाई TON भित्र सन्देश पठाउँछ) अन्तर्क्रिया गर्न सक्नुहुन्छ।

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

धेरैजसो म टेलिग्राम च्याटमा किवर्डहरू खोज्थें जहाँ प्रतियोगिताका सबै सहभागीहरू र टेलिग्राम कर्मचारीहरू भेला हुन्थे, यस्तो भयो कि प्रतियोगिताको क्रममा सबैजना त्यहाँ भेला भए र लेखको अन्त्यमा रहेको फिफ्ट र फनसी लिङ्कको बारेमा छलफल गर्न थाले।

सिद्धान्तबाट अभ्यासमा जाने समय आएको छ।

TON सँग काम गर्ने वातावरण तयार गर्दै

मैले MacOS मा लेखमा वर्णन गरिने सबै कुरा गरें र यसलाई सफासँग दोहोरो जाँच गरें Ubuntu डकरमा १८.०४ LTS।

तपाईंले गर्नुपर्ने पहिलो कुरा भनेको डाउनलोड र स्थापना गर्नु हो lite-client जसको साथ तपाईंले TON मा अनुरोधहरू पठाउन सक्नुहुन्छ।

आधिकारिक वेबसाइटमा भएका निर्देशनहरूले स्थापना प्रक्रियालाई राम्ररी र स्पष्ट रूपमा वर्णन गर्दछन्, केही विवरणहरू हटाउँदै। यहाँ हामी निर्देशनहरू पालना गर्छौं, बाटोमा छुटेका कुनै पनि निर्भरताहरू स्थापना गर्दै। मैले प्रत्येक परियोजना आफैं कम्पाइल गरिनँ र आधिकारिक भण्डारबाट स्थापना गरें। Ubuntu (मैले प्रयोग गरेको MacOS मा brew).

apt -y install git 
apt -y install wget 
apt -y install cmake 
apt -y install g++ 
apt -y install zlib1g-dev 
apt -y install libssl-dev

सबै निर्भरताहरू स्थापित भएपछि, तपाईं स्थापना गर्न सक्नुहुन्छ lite-client, Fift, FunC.

पहिले, हामी निर्भरताहरू सहित TON भण्डार क्लोन गर्छौं। सुविधाको लागि, हामी फोल्डरमा सबै कुरा गर्नेछौं। ~/TON.

cd ~/TON
git clone https://github.com/ton-blockchain/ton.git
cd ./ton
git submodule update --init --recursive

भण्डारले कार्यान्वयनहरू पनि भण्डारण गर्दछ। Fift и FunC.

अब हामी परियोजना निर्माण गर्न तयार छौं। रिपोजिटरी कोड फोल्डरमा क्लोन गरिएको छ। ~/TON/ton। को ~/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 ग्राम वा हार। हामी जित्ने सम्भावना लगभग ४०% बनाउनेछौं। यदि भुक्तानीको लागि पर्याप्त ग्राम छैन भने, हामी लेनदेनलाई पुनःपूर्ति मान्नेछौं।

यसबाहेक, यो महत्त्वपूर्ण छ कि बेट्स वास्तविक समयमा र सुविधाजनक रूपमा देख्न सकिन्छ, ताकि प्रयोगकर्ताले तुरुन्तै बुझ्न सकून् कि उसले जितेको छ वा हारेको छ। त्यसैले, एउटा वेबसाइट सिर्जना गर्नु आवश्यक छ जसले बेट्स र नतिजा सिधै TON बाट देखाउनेछ।

स्मार्ट सम्झौता लेख्दै

सुविधाको लागि, मैले FunC को लागि कोड हाइलाइट बनाएको छु, प्लगइन भिजुअल स्टुडियो कोड खोजमा फेला पार्न र स्थापना गर्न सकिन्छ, यदि तपाईं अचानक केहि थप्न चाहनुहुन्छ भने, मैले प्लगइनलाई सार्वजनिक डोमेनमा पोस्ट गरें। साथै, कसैले पहिले Fift सँग काम गर्नको लागि प्लगइन बनाएको थियो, तपाईं यसलाई स्थापना गर्न र VSC मा फेला पार्न पनि सक्नुहुन्छ।

तुरुन्तै एउटा भण्डार सिर्जना गरौं जहाँ हामी मध्यवर्ती परिणामहरू प्रतिबद्ध गर्नेछौं।

हाम्रो जीवनलाई सजिलो बनाउन, हामी एउटा स्मार्ट सम्झौता लेख्नेछौं र यो तयार नभएसम्म स्थानीय रूपमा परीक्षण गर्नेछौं। त्यसपछि मात्र हामी यसलाई TON मा प्रकाशित गर्नेछौं।

स्मार्ट अनुबंधमा दुई बाह्य विधिहरू छन् जसलाई कल गर्न सकिन्छ। पहिलो, recv_external() यो प्रकार्य तब कार्यान्वयन हुन्छ जब सम्झौताको अनुरोध बाहिरी संसारबाट आउँछ, अर्थात्, TON बाट होइन, उदाहरणका लागि, जब हामी आफैंले सन्देश बनाउँछौं र यसलाई lite-client मार्फत पठाउँछौं। दोस्रो, recv_internal() यो तब हुन्छ जब TON भित्रै केही सम्झौताले हाम्रोलाई जनाउँछ। दुबै अवस्थामा, प्यारामिटरहरू प्रकार्यमा पास गर्न सकिन्छ।

एउटा साधारण उदाहरणबाट सुरु गरौं जुन प्रकाशित भएमा काम गर्नेछ, तर यसले कुनै कार्यक्षमता प्रदान गर्दैन।

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

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

यहाँ हामीले यो के हो भनेर व्याख्या गर्न आवश्यक छ slice। TON Blockchain मा भण्डारण गरिएका सबै डेटा एक संग्रह हो TVM cell या बस cell, यस्तो सेलले १०२३ बिटसम्म डेटा र अन्य सेलहरूमा ४ वटा सन्दर्भहरू भण्डारण गर्न सक्छ।

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 मान ० र -१ भएका स्थिरांकहरू स्मार्ट अनुबंधमा सम्बन्धित प्रकार्यहरू कल गर्न जिम्मेवार हुनेछन्।

अब हामी हाम्रो खाली स्मार्ट अनुबंधको लागि पहिलो परीक्षण सिर्जना गर्न तयार छौं। स्पष्टताको लागि, हामी अहिलेको लागि एउटै फाइलमा सबै परीक्षणहरू थप्नेछौं। 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 लाई मान्य सन्देश पठाउँछौं, हामी यो एक पटक मात्र होस् भन्ने चाहन्छौं, र जब हामी फेरि उही सन्देश पठाउँछौं, स्मार्ट अनुबंधले यसलाई अस्वीकार गर्दछ।

त्यसैले लगभग हरेक सम्झौताले यी दुई मुद्दाहरूसँग सम्बन्धित छ, किनकि हाम्रो सम्झौताले बाह्य सन्देशहरू प्राप्त गर्दछ, हामीले त्यसको पनि ख्याल राख्नु पर्छ।

हामी यसलाई उल्टो क्रममा गर्नेछौं। पहिले, हामी दोहोर्याएर समस्या समाधान गर्नेछौं, यदि सम्झौताले पहिले नै यस्तो सन्देश प्राप्त गरिसकेको छ र यसलाई प्रशोधन गरिसकेको छ भने, यसले दोस्रो पटक कार्यान्वयन गर्दैन। र त्यसपछि हामी समस्या समाधान गर्नेछौं ताकि मानिसहरूको एक निश्चित सर्कलले मात्र स्मार्ट सम्झौतामा सन्देशहरू पठाउन सकून्।

डुप्लिकेट सन्देशहरूको समस्या समाधान गर्ने विभिन्न तरिकाहरू छन्। हामी यो कसरी गर्नेछौं भन्ने कुरा यहाँ छ। स्मार्ट अनुबंधमा, हामी प्राप्त सन्देशहरूको काउन्टरलाई ० को प्रारम्भिक मानको साथ सुरु गर्छौं। स्मार्ट अनुबंधमा प्रत्येक सन्देशमा, हामी हालको काउन्टर मान थप्नेछौं। यदि सन्देशमा रहेको काउन्टर मान स्मार्ट अनुबंधको मानसँग मेल खाँदैन भने, हामी यसलाई प्रशोधन गर्दैनौं; यदि यसले गर्छ भने, हामी यसलाई प्रशोधन गर्छौं र स्मार्ट अनुबंधमा काउन्टरलाई १ ले बढाउँछौं।

हामी फर्कदैछौं lottery-test-suite.fif र त्यसमा दोस्रो परीक्षण थप्नुहोस्। अमान्य नम्बर पठाउनुहोस्, कोडले अपवाद राख्नु पर्छ। उदाहरणका लागि, मानौं अनुबंध डेटाले १६६ भण्डारण गर्छ, र हामी १६५ पठाउँछौं।

<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) नम्बर १६५, ३२-बिट लोड गर्छ unsigned int प्रसारित सन्देशबाट।

अर्को, हामी स्मार्ट कन्ट्र्याक्ट स्टोरेजबाट ३२ बिट लोड गर्छौं। हामी लोड गरिएको नम्बर ट्रान्समिटेडसँग मेल खान्छ कि खाँदैन भनेर जाँच गर्छौं, यदि होइन भने, हामी अपवाद फ्याँक्छौं। हाम्रो अवस्थामा, हामी बेमेल ट्रान्समिट गरिरहेका हुनाले, अपवाद फ्याँक्नुपर्छ।

अब कम्पाइल गरौं।

~/TON/build/crypto/func -APSR -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc

परिणामस्वरूप कोड प्रतिलिपि गर्नुहोस् lottery-test-suite.fif, अन्तिम लाइन बदल्न नबिर्सनुहोस्।

परीक्षण पास भयो कि भएन जाँच गरौं:

~/TON/build/crypto/fift -s lottery-test-suite.fif

ठ्याक्क यहाँ तपाईंले हालको नतिजाहरूसँग सम्बन्धित कमिट हेर्न सक्नुहुन्छ।

ध्यान दिनुहोस् कि स्मार्ट अनुबंधको कम्पाइल गरिएको कोडलाई परीक्षणको साथ फाइलमा निरन्तर प्रतिलिपि गर्न असुविधाजनक छ, त्यसैले हामी एउटा स्क्रिप्ट लेख्नेछौं जसले कोडलाई हाम्रो लागि स्थिरांकमा लेख्नेछ, र हामी केवल कम्पाइल गरिएको कोडलाई हाम्रो परीक्षणहरूमा जडान गर्नेछौं। "include".

परियोजना फोल्डरमा, एउटा फाइल सिर्जना गर्नुहोस् build.sh निम्न सामग्री सहित।

#!/bin/bash

~/TON/build/crypto/func -SPA -R -o lottery-compiled.fif ~/TON/ton/crypto/smartcont/stdlib.fc ./lottery-code.fc

यसलाई कार्यान्वयनयोग्य बनाऔं।

chmod +x ./build.sh

अब, सम्झौता संकलन गर्न हाम्रो स्क्रिप्ट चलाउनु पर्याप्त छ। तर यसको अतिरिक्त, हामीले यसलाई स्थिरांकमा लेख्नु आवश्यक छ code. त्यसैले हामी एउटा नयाँ फाइल सिर्जना गर्नेछौं lotter-compiled-for-test.fif, जुन हामी फाइलमा समावेश गर्नेछौं lottery-test-suite.fif.

sh स्क्रिप्टमा केही कोड थपौं जसले कम्पाइल गरिएको फाइललाई डुप्लिकेट गर्नेछ lotter-compiled-for-test.fif र त्यसमा अन्तिम लाइन परिवर्तन गर्नुहोस्।

# copy and change for test 
cp lottery-compiled.fif lottery-compiled-for-test.fif
sed '$d' lottery-compiled-for-test.fif > test.fif
rm lottery-compiled-for-test.fif
mv test.fif lottery-compiled-for-test.fif
echo -n "}END>s constant code" >> lottery-compiled-for-test.fif

अब, जाँच गर्न, परिणामस्वरूप स्क्रिप्ट चलाउनुहोस् र एउटा फाइल उत्पन्न हुनेछ। lottery-compiled-for-test.fif, जुन हामी हाम्रो lottery-test-suite.fif

В lottery-test-suite.fif सम्झौता कोड मेटाउनुहोस् र एउटा लाइन थप्नुहोस्। "lottery-compiled-for-test.fif" include.

हामी परीक्षणहरू पास गर्छौं कि हुँदैन भनेर जाँच गर्छौं।

~/TON/build/crypto/fift -s lottery-test-suite.fif

राम्रो, अब परीक्षणहरू स्वचालित रूपमा सञ्चालन गर्न हामी एउटा फाइल सिर्जना गर्छौं। test.sh, जसले पहिले प्रदर्शन गर्नेछ build.sh, र त्यसपछि परीक्षणहरू चलाउनुहोस्।

touch test.sh
chmod +x test.sh

हामी भित्र लेख्छौं।

./build.sh 

echo "nCompilation completedn"

export FIFTPATH=~/TON/ton/crypto/fift/lib
~/TON/build/crypto/fift -s lottery-test-suite.fif

गरौं। test.sh र परीक्षणहरू काम गर्छन् भनी सुनिश्चित गर्न यसलाई चलाउनुहोस्।

chmod +x ./test.sh
./test.sh

हामी सम्झौता कम्पाइल भएको र परीक्षणहरू चलेको छ कि छैन जाँच गर्छौं।

राम्रो, अब स्टार्टअपमा छु। test.sh परीक्षणहरू कम्पाइल गरिनेछ र तुरुन्तै सञ्चालन गरिनेछ। यहाँ लिङ्क छ प्रतिबद्ध.

ठीक छ, हामी अगाडि बढ्नु अघि, सुविधाको लागि अर्को एउटा काम गरौं।

एउटा फोल्डर सिर्जना गरौं। build जहाँ हामी कम्पाइल गरिएको अनुबंध र यसको क्लोन स्थिरांकमा लेखिएको भण्डारण गर्नेछौं। lottery-compiled.fif, lottery-compiled-for-test.fifहामी एउटा फोल्डर पनि सिर्जना गर्नेछौं test जहाँ परीक्षण फाइल भण्डारण गरिनेछ। lottery-test-suite.fif र सम्भावित रूपमा अन्य समर्थन फाइलहरू। सान्दर्भिक परिवर्तनहरूको लिङ्क.

स्मार्ट सम्झौताको विकास जारी राखौं।

त्यसपछि एउटा परीक्षण हुनुपर्छ जसले सन्देश प्राप्त भयो कि भएन र हामीले सही नम्बर पठाउँदा स्टोरमा काउन्टर अपडेट भयो कि भएन भनेर जाँच गर्छ। तर हामी त्यो पछि गर्नेछौं।

अब स्मार्ट अनुबंधमा कस्तो डेटा संरचना र कुन डेटा भण्डारण गर्न आवश्यक छ भन्ने बारेमा सोचौं।

हामीले भण्डारण गर्ने सबै कुराको वर्णन गर्नेछु।

`seqno` 32-х битное целое положительное число счетчик. 

`pubkey` 256-ти битное целое положительное число публичный ключ, с помощью которого, мы будем проверять подпись отправленного извне сообщения, о чем ниже. 

`order_seqno` 32-х битное целое положительное число хранит счетчик количества ставок. 

`number_of_wins` 32-х битное целое положительное число хранит  количество побед. 

`incoming_amount` тип данных Gram (первые 4 бита отвечает за длину), хранит общее количество грамов, которые были отправлены на контртакт. 

`outgoing_amount` общее количество грамов, которое было отправлено победителям. 

`owner_wc` номер воркчейна, 32-х битное (в некоторых местах написано, что 8-ми битное) целое число. В данный момент всего два -1 и 0. 

`owner_account_id` 256-ти битное целое положительное число, адрес контракта в текущем воркчейне. 

`orders` переменная типа словарь, хранит последние двадцать ставок.

अब, तपाईंले दुई प्रकार्यहरू लेख्नु पर्छ। हामी पहिलोलाई कल गर्नेछौं। pack_state(), जसले स्मार्ट अनुबंध भण्डारणमा पछिको भण्डारणको लागि डेटा प्याक गर्नेछ। दोस्रो, हामी कल गर्नेछौं unpack_state() भण्डारणबाट डेटा पढ्नेछ र फिर्ता गर्नेछ।

_ pack_state(int seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) inline_ref {
    return begin_cell()
            .store_uint(seqno, 32)
            .store_uint(pubkey, 256)
            .store_uint(order_seqno, 32)
            .store_uint(number_of_wins, 32)
            .store_grams(incoming_amount)
            .store_grams(outgoing_amount)
            .store_int(owner_wc, 32)
            .store_uint(owner_account_id, 256)
            .store_dict(orders)
            .end_cell();
}

_ unpack_state() inline_ref {
    var ds = begin_parse(get_data());
    var unpacked = (ds~load_uint(32), ds~load_uint(256), ds~load_uint(32), ds~load_uint(32), ds~load_grams(), ds~load_grams(), ds~load_int(32), ds~load_uint(256), ds~load_dict());
    ds.end_parse();
    return unpacked;
}

हामी स्मार्ट अनुबंधको सुरुमा यी दुई प्रकार्यहरू थप्छौं। हामी पाउँछौं यसरी मध्यवर्ती परिणाम।

डेटा बचत गर्न तपाईंले बिल्ट-इन प्रकार्यलाई कल गर्नुपर्नेछ। set_data() र यसले डेटा रेकर्ड गर्नेछ pack_state() स्मार्ट अनुबंध भण्डारणमा।

cell packed_state = pack_state(arg_1, .., arg_n); 
set_data(packed_state);

अब हामीसँग डेटा लेख्न र पढ्नको लागि सुविधाजनक प्रकार्यहरू छन्, हामी अगाडि बढ्न सक्छौं।

हामीले बाहिरबाट आउने सन्देश सम्झौताको मालिक (वा निजी कुञ्जीमा पहुँच भएको अर्को प्रयोगकर्ता) द्वारा हस्ताक्षर गरिएको छ कि छैन भनेर जाँच गर्न आवश्यक छ।

जब हामी स्मार्ट सम्झौता प्रकाशित गर्छौं, हामी यसलाई भण्डारणमा आवश्यक पर्ने डेटाको साथ सुरु गर्न सक्छौं, जुन भविष्यमा प्रयोगको लागि सुरक्षित गरिनेछ। हामी त्यहाँ सार्वजनिक कुञ्जी लेख्नेछौं ताकि हामी आगमन सन्देशको हस्ताक्षर सम्बन्धित निजी कुञ्जीद्वारा गरिएको हो भनी प्रमाणित गर्न सकौं।

अगाडि बढ्नु अघि, एउटा निजी कुञ्जी सिर्जना गरौं र यसलाई लेखौं test/keys/owner.pkयो गर्नको लागि, हामी अन्तरक्रियात्मक मोडमा Fift सुरु गर्नेछौं र चार आदेशहरू कार्यान्वयन गर्नेछौं।

`newkeypair` генерация публичного и приватного ключа и запись их в стек. 

`drop` удаления из стека верхнего элемента (в данном случае публичный ключ)  

`.s` просто посмотреть что лежит в стеке в данный момент 

`"owner.pk" B>file` запись приватного ключа в файл с именем `owner.pk`. 

`bye` завершает работу с Fift.

एउटा फोल्डर सिर्जना गरौं। keys फोल्डर भित्र test र हामी त्यहाँ निजी कुञ्जी लेख्नेछौं।

mkdir test/keys
cd test/keys
~/TON/build/crypto/fift -i 
newkeypair
 ok
.s 
BYTES:128DB222CEB6CF5722021C3F21D4DF391CE6D5F70C874097E28D06FCE9FD6917 BYTES:DD0A81AAF5C07AAAA0C7772BB274E494E93BB0123AA1B29ECE7D42AE45184128 
drop 
 ok
"owner.pk" B>file
 ok
bye

हामी हालको फोल्डरमा फाइल देख्छौं। owner.pk.

हामी स्ट्याकबाट सार्वजनिक कुञ्जी हटाउँछौं र आवश्यक पर्दा निजी कुञ्जीबाट प्राप्त गर्न सक्छौं।

अब हामीले सिग्नेचर चेक लेख्नु पर्छ। परीक्षणबाट सुरु गरौं। पहिले, हामी फंक्शन प्रयोग गरेर फाइलबाट निजी कुञ्जी पढ्छौं। file>B र यसलाई एउटा चरमा लेख्नुहोस् owner_private_key, त्यसपछि प्रकार्य प्रयोग गरेर priv>pub निजी कुञ्जीलाई सार्वजनिक कुञ्जीमा रूपान्तरण गर्नुहोस् र परिणाम लेख्नुहोस् owner_public_key.

variable owner_private_key
variable owner_public_key 

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !

हामीलाई दुवै साँचो चाहिन्छ।

प्रकार्यमा जस्तै अनुक्रममा मनमानी डेटाको साथ स्मार्ट अनुबंध भण्डारण सुरु गर्नुहोस्। pack_state()र यसलाई एउटा चरमा लेख्नुहोस् storage.

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

"./keys/owner.pk" file>B owner_private_key !
owner_private_key @ priv>pub owner_public_key !
dictnew orders !
0 owner_wc !
0 owner_account_id !

<b 0 32 u, owner_public_key @ B, 0 32 u, 0 32 u, 0 Gram, 0 Gram, owner_wc @ 32 i, owner_account_id @ 256 u,  orders @ dict, b> storage !

अर्को, हामी एउटा हस्ताक्षरित सन्देश रचना गर्नेछौं, यसमा केवल हस्ताक्षर र काउन्टर मान हुनेछ।

पहिले हामी प्रसारण गर्न चाहेको डेटा सिर्जना गर्छौं, त्यसपछि हामी यसलाई निजी कुञ्जीले हस्ताक्षर गर्छौं, र अन्तमा हामी हस्ताक्षरित सन्देश बनाउँछौं।

variable message_to_sign
variable message_to_send
variable signature
<b 0 32 u, b> message_to_sign !
message_to_sign @ hashu owner_private_key @ ed25519_sign_uint signature !
<b signature @ B, 0 32 u, b> <s  message_to_send !

फलस्वरूप, हामीले स्मार्ट अनुबंधमा पठाउने सन्देश एक चरमा लेखिएको हुन्छ message_to_send, कार्यहरूको बारेमा hashu, ed25519_sign_uint तपाईं पढ्न सक्नुहुन्छ फिफ्ट कागजातमा.

र परीक्षण चलाउन हामी यसलाई फेरि कल गर्छौं।

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

यहाँ यति यस चरणमा परीक्षण फाइल यस्तो देखिनु पर्छ।

परीक्षण चलाउछौं र यो असफल हुनेछ, त्यसैले स्मार्ट अनुबंध परिवर्तन गरौं ताकि यसले यस ढाँचाका सन्देशहरू प्राप्त गर्न सकोस् र हस्ताक्षर जाँच गर्न सकोस्।

पहिले, हामी सन्देशबाट हस्ताक्षरको ५१२ बिट पढ्छौं र तिनीहरूलाई चरमा लेख्छौं, त्यसपछि हामी काउन्टर चरको ३२ बिट पढ्छौं।

हामीसँग स्मार्ट कन्ट्र्याक्ट भण्डारणबाट डेटा पढ्ने प्रकार्य भएकोले, हामी यसलाई प्रयोग गर्नेछौं।

त्यसपछि, भण्डारणसँग स्थानान्तरण गरिएको काउन्टर जाँच गर्नुहोस् र हस्ताक्षर जाँच गर्नुहोस्। यदि केहि मेल खाएन भने, सम्बन्धित कोडको साथ अपवाद राख्नुहोस्।

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 ७-बिट गैर-ऋणात्मक पूर्णांक, यसको आधारमा, हामी स्मार्ट अनुबंधमा सन्देश कसरी प्रशोधन गर्ने भनेर छनौट गर्नेछौं।

<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: ठेगाना परिवर्तन र ग्राम पठाउने।

त्यसपछि हामी ठेक्का मालिकको नयाँ ठेगाना पढ्छौं र भण्डारणमा सुरक्षित गर्छौं।
हामी परीक्षणहरू चलाउँछौं र देख्छौं कि तेस्रो परीक्षण असफल भयो। यो असफल हुन्छ किनभने अब सम्झौताले सन्देशबाट ७ बिटहरू पार्स गर्दछ, जुन परीक्षणमा हराइरहेको छ। एउटा अवस्थित नभएको थपौं। 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().

अब आन्तरिक सन्देशमा जाऔं। वास्तवमा, हामी ग्राम मात्र स्वीकार गर्नेछौं र खेलाडीले जितेमा दोब्बर रकम र हार्यो भने मालिकलाई एक तिहाइ रकम फिर्ता पठाउँछौं।

पहिले, एउटा साधारण परीक्षण लेखौं। यसको लागि, हामीलाई स्मार्ट अनुबंधको परीक्षण ठेगाना चाहिन्छ जसबाट हामी स्मार्ट अनुबंधमा ग्राम पठाउँछौं।

स्मार्ट कन्ट्र्याक्ट ठेगानामा दुई संख्याहरू हुन्छन्, वर्कचेनको लागि जिम्मेवार ३२-बिट पूर्णांक र यस वर्कचेनमा २५६-बिट गैर-ऋणात्मक पूर्णांक अद्वितीय खाता नम्बर। उदाहरणका लागि, -१ र १२३४५, यो ठेगाना र फाइलमा बचत गर्नुहोस्।

मैले ठेगाना बचत गर्न प्रकार्य प्रतिलिपि गरें 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

पहिले हामीले स्ट्याकमा -१, १२३४५ र भविष्यको फाइल "sender.addr" को नाम राख्यौं:

-1 12345 "sender.addr"

अर्को चरण भनेको प्रकार्य कार्यान्वयन गर्नु हो -rot, जसले स्ट्याकलाई परिवर्तन गर्छ ताकि अद्वितीय स्मार्ट अनुबंध नम्बर स्ट्याकको शीर्षमा होस्:

"sender.addr" -1 12345

256 u>B २५६-बिट गैर-ऋणात्मक पूर्णांकलाई बाइटमा रूपान्तरण गर्दछ।

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap स्ट्याकको माथिल्लो दुई तत्वहरू स्वैप गर्दछ।

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

32 i>B ३२-बिट पूर्णांकलाई बाइटमा रूपान्तरण गर्छ।

"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.

अब, अन्तमा, स्मार्ट सम्झौताको सार।

पहिले, यदि खेलाडी हारे भने, हामी यसलाई बेटिंग इतिहासमा बचत गर्छौं र यदि रकम ३ ग्राम भन्दा बढी छ भने, हामी स्मार्ट अनुबंधको मालिकलाई १/३ पठाउँछौं।

यदि खेलाडीले जित्यो भने, हामी दोब्बर रकम खेलाडीको ठेगानामा पठाउँछौं र त्यसपछि इतिहासमा बाजी जानकारी सुरक्षित गर्छौं।

() 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));
}

त्यो सबै छ। सम्बन्धित कमिट.

अब यो सरल छ: बाहिरी संसारबाट सम्झौताको अवस्थाको बारेमा जानकारी प्राप्त गर्न सकियोस् भनेर विधिहरू बनाउनुहोस् (वास्तवमा, स्मार्ट सम्झौता भण्डारणबाट डेटा पढ्नुहोस्)।

गेट मेथडहरू थपौं।। स्मार्ट सम्झौताको बारेमा जानकारी कसरी प्राप्त गर्ने भन्ने बारे हामी तल लेख्नेछौं।

स्मार्ट अनुबंध प्रकाशित हुँदा हुने पहिलो अनुरोधलाई सम्हाल्ने कोड पनि थप्न बिर्सिएँ। सम्बन्धित कमिट। र अधिक सच्याइएको मालिकको खातामा रकमको १/३ भाग पठाउने समस्या।

अब स्मार्ट सम्झौता प्रकाशित गर्न मात्र बाँकी छ। एउटा फोल्डर सिर्जना गरौं। 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 २ ग्राम र केहि सेकेन्ड पछि उही आदेश कार्यान्वयन गर्नुहोस्। ग्राम पठाउन म प्रयोग गर्छु आधिकारिक वालेट, र तपाईंले च्याटबाट कसैसँग परीक्षण ग्राम माग्न सक्नुहुन्छ, जसको बारेमा म लेखको अन्त्यमा कुरा गर्नेछु।

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

नेटवर्कमा सुरु नगरिएको ( देखा परेको जस्तो देखिन्छstate:account_uninit) यस्तो ठेगाना र १,०००,०००,००० न्यानोग्राम ब्यालेन्स भएको स्मार्ट सम्झौता।

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 ढुवानीको लागि २ र ९.५ ग्राम।

<b 165 32 u, 2 7 u, 9500000000 Gram, b>

सन्देशमा निजी कुञ्जीले हस्ताक्षर गर्न नबिर्सनुहोस्। lottery.pk, जुन स्मार्ट अनुबंध सिर्जना गर्दा पहिले उत्पन्न भएको थियो। यहाँ सम्बन्धित समिति छ.

गेट विधिहरू प्रयोग गरेर स्मार्ट अनुबंधबाट जानकारी प्राप्त गर्दै

अब स्मार्ट कन्ट्र्याक्ट गेट विधिहरू कसरी चलाउने भनेर हेरौं।

लन्च गर्नुहोस् lite-client र हामीले लेखेका get methods चलाउनुहोस्।

$ ./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सुविधाको लागि, साइट डकरमा प्याकेज गरिएको छ र गुगल क्लाउडमा प्रकाशित गरिएको छ। लिङ्क.

कोसिस गर्दै

अब त्यहाँबाट पुनःपूर्ति गर्न ग्राम पठाउने प्रयास गरौं वालेट। हामी ४० ग्राम पठाउनेछौं। र स्पष्टताको लागि केही बाजी लगाउँछौं। हामी देख्छौं कि साइटले बाजी इतिहास, हालको जित्ने प्रतिशत र अन्य उपयोगी जानकारी देखाउँछ।

हामी देख्छौं, हामीले पहिलो जित्यौं र दोस्रो हार्यौं।

पछिशब्द

लेख मैले अपेक्षा गरेको भन्दा धेरै लामो भयो, सायद यो छोटो हुन सक्थ्यो, वा हुनसक्छ यो केवल एक व्यक्तिको लागि हो जसलाई 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
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