TON मा स्मार्ट अनुबंध कसरी लेख्ने र प्रकाशित गर्ने बारे

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

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

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

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

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

प्रतियोगितामा भाग लिने बारे

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

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

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

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

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

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

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

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

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

सामान्य मा यो कसरी काम गर्दछ TVM र भाषा Fift त्यहाँ राम्रो आधिकारिक कागजात छ। प्रतियोगितामा भाग लिँदा र अहिले हालको ठेक्का लेख्दै गर्दा म प्रायः उनीतिर फर्किएँ ।

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

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

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

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

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

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

यो सिद्धान्तबाट व्यवहारमा जाने समय हो।

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

मैले MacOS मा लेखमा वर्णन गरिने सबै कुरा गरें र डकरमा सफा Ubuntu 18.04 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 ग्राम वा हराउँछ। हामी लगभग 40% जित्ने सम्भावना बनाउनेछौं। यदि भुक्तानीको लागि पर्याप्त ग्रामहरू छैनन् भने, हामी लेनदेनलाई टप-अपको रूपमा विचार गर्नेछौं।

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

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

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

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

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

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

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

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

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

यहाँ हामीले यो के हो भनेर व्याख्या गर्न आवश्यक छ slice। TON Blockchain मा भण्डारण गरिएका सबै डेटा संग्रह हो TVM cell या बस cell, यस्तो सेलमा तपाईले 1023 बिट सम्म डाटा र अन्य सेलहरूमा 4 लिङ्क सम्म भण्डारण गर्न सक्नुहुन्छ।

TVM cell slice वा slice यो अवस्थित को एक भाग हो cell यसलाई पार्स गर्न प्रयोग गरिन्छ, यो पछि स्पष्ट हुनेछ। हाम्रो लागि मुख्य कुरा यो हो कि हामी स्थानान्तरण गर्न सक्छौं slice र सन्देशको प्रकारमा निर्भर गर्दै, डाटालाई प्रशोधन गर्नुहोस् recv_external() वा recv_internal().

impure - एक कुञ्जी शब्द जसले संकेत गर्दछ कि प्रकार्यले स्मार्ट अनुबंध डेटा परिमार्जन गर्दछ।

सम्झौताको कोड सुरक्षित गरौं lottery-code.fc र कम्पाइल।

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

झण्डाको अर्थ आदेश प्रयोग गरेर हेर्न सकिन्छ

~/TON/build/crypto/func -help

हामीले फिफ्ट एसेम्बलर कोड कम्पाइल गरेका छौं lottery-compiled.fif:

// lottery-compiled.fif

"Asm.fif" include
// automatically generated from `/Users/rajymbekkapisev/TON/ton/crypto/smartcont/stdlib.fc` `./lottery-code.fc` 
PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>c

यसलाई स्थानीय रूपमा सञ्चालन गर्न सकिन्छ, त्यसका लागि वातावरण तयार गर्नेछौं।

ध्यान दिनुहोस् कि पहिलो रेखा जडान हुन्छ Asm.fif, यो फिफ्ट एसेम्बलरको लागि फिफ्टमा लेखिएको कोड हो।

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

"TonUtil.fif" include
"Asm.fif" include

PROGRAM{
  DECLPROC recv_internal
  DECLPROC recv_external
  recv_internal PROC:<{
    //  in_msg
    DROP    // 
  }>
  recv_external PROC:<{
    //  in_msg
    DROP    // 
  }>
}END>s constant code

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

0 tuple 0x076ef1ea , // magic
0 , 0 , // actions msg_sents
1570998536 , // unix_time
1 , 1 , 3 , // block_lt, trans_lt, rand_seed
0 tuple 100000000000000 , dictnew , , // remaining balance
0 , dictnew , // contract_address, global_config
1 tuple // wrap to another tuple
constant c7

0 constant recv_internal // to run recv_internal() 
-1 constant recv_external // to invoke recv_external()

В c7 हामी सन्दर्भ रेकर्ड गर्छौं, त्यो डाटा जसको साथ TVM (वा नेटवर्क अवस्था) सुरु हुनेछ। प्रतिस्पर्धाको समयमा पनि, एक विकासकर्ताले कसरी सिर्जना गर्ने भनेर देखाए c7 र मैले प्रतिलिपि गरें। यस लेखमा हामीले परिवर्तन गर्न आवश्यक हुन सक्छ rand_seed किनकि अनियमित संख्याको जेनेरेसन यसमा निर्भर हुन्छ र यदि परिवर्तन गरिएको छैन भने, उही संख्या प्रत्येक पटक फर्काइनेछ।

recv_internal и recv_external 0 र -1 मानहरू भएका स्थिरांकहरू स्मार्ट अनुबंधमा सम्बन्धित कार्यहरू कल गर्न जिम्मेवार हुनेछन्।

अब हामी हाम्रो खाली स्मार्ट सम्झौताको लागि पहिलो परीक्षण सिर्जना गर्न तयार छौं। स्पष्टताको लागि, अहिलेको लागि हामी एउटै फाइलमा सबै परीक्षणहरू थप्नेछौं lottery-test-suite.fif.

एउटा चर सिर्जना गरौं storage र यसमा एउटा खाली लेख्नुहोस् cell, यो स्मार्ट अनुबंध भण्डारण हुनेछ।

message यो सन्देश हो कि हामी बाहिरबाट स्मार्ट सम्पर्कमा प्रसारण गर्नेछौं। हामी यसलाई अहिलेको लागि खाली पनि बनाउँछौं।

variable storage 
<b b> storage ! 

variable message 
<b b> message !

हामीले स्थिरांक र चरहरू तयार गरिसकेपछि, हामी आदेश प्रयोग गरेर TVM सुरु गर्छौं runvmctx र सिर्जना गरिएका प्यारामिटरहरूलाई इनपुटमा पास गर्नुहोस्।

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

अन्तमा हामी सफल हुनेछौं जस्तो को लागि मध्यवर्ती कोड Fift.

अब हामी परिणाम कोड चलाउन सक्छौं।

export FIFTPATH=~/TON/ton/crypto/fift/lib // выполняем один раз для удобства 
~/TON/build/crypto/fift -s lottery-test-suite.fif

कार्यक्रम त्रुटि बिना चल्नु पर्छ र आउटपुटमा हामी कार्यान्वयन लग देख्नेछौं:

execute SETCP 0
execute DICTPUSHCONST 19 (xC_,1)
execute DICTIGETJMPZ
execute DROP
execute implicit RET
[ 3][t 0][1582281699.325381279][vm.cpp:479]     steps: 5 gas: used=304, max=9223372036854775807, limit=9223372036854775807, credit=0

राम्रो, हामीले स्मार्ट अनुबंधको पहिलो कार्य संस्करण लेखेका छौं।

अब हामी कार्यक्षमता थप्न आवश्यक छ। पहिले बाहिरी संसारबाट आउने सन्देशहरूसँग व्यवहार गरौं recv_external()

विकासकर्ता आफैले सन्देश ढाँचा छनोट गर्दछ जुन सम्झौता स्वीकार गर्न सकिन्छ।

तर सामान्यतया

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

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

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

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

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

<b 166 32 u, b> storage !
<b 165 32 u, b> message !

message @ 
recv_external 
code 
storage @ 
c7 
runvmctx

drop 
exit_code ! 
."Exit code " exit_code @ . cr 
exit_code @ 33 - abort"Test #2 Not passed"

सुरु गरौं।

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

र हामी देख्नेछौं कि परीक्षण त्रुटि संग कार्यान्वयन भएको छ।

[ 1][t 0][1582283084.210902214][words.cpp:3046] lottery-test-suite.fif:67: abort": Test #2 Not passed
[ 1][t 0][1582283084.210941076][fift-main.cpp:196]      Error interpreting file `lottery-test-suite.fif`: error interpreting included file `lottery-test-suite.fif` : lottery-test-suite.fif:67: abort": Test #2 Not passed

यो समय मा lottery-test-suite.fif जस्तो देखिनु पर्छ लिङ्क.

अब स्मार्ट अनुबंधमा काउन्टर तर्क थपौं lottery-code.fc.

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

() recv_external(slice in_msg) impure {
    if (slice_empty?(in_msg)) {
        return (); 
    }
    int msg_seqno = in_msg~load_uint(32);
    var ds = begin_parse(get_data());
    int stored_seqno = ds~load_uint(32);
    throw_unless(33, msg_seqno == stored_seqno);
}

В slice in_msg हामीले पठाएको सन्देश झूटो हो।

हामीले गर्ने पहिलो कुरा भनेको सन्देशमा डाटा समावेश छ कि छैन भनेर जाँच गर्नु हो, यदि छैन भने, त्यसपछि हामी बाहिर निस्कन्छौं।

अर्को हामी सन्देशलाई पार्स गर्छौं। in_msg~load_uint(32) नम्बर 165, 32-बिट लोड गर्दछ unsigned int प्रसारित सन्देशबाट।

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

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

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

नतिजा कोड प्रतिलिपि गर्नुहोस् lottery-test-suite.fif, अन्तिम रेखा प्रतिस्थापन गर्न नबिर्सनुहोस्।

हामी जाँच गर्छौं कि परीक्षण पास हुन्छ:

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

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

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

परियोजना फोल्डरमा फाइल सिर्जना गर्नुहोस् build.sh निम्न सामग्री संग।

#!/bin/bash

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

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

chmod +x ./build.sh

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

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

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

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

В lottery-test-suite.fif अनुबंध कोड मेटाउनुहोस् र लाइन थप्नुहोस् "lottery-compiled-for-test.fif" include.

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

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

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

touch test.sh
chmod +x test.sh

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

./build.sh 

echo "nCompilation completedn"

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

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

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

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

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

ठीक छ, हामीले जारी राख्नु अघि, सुविधाको लागि अर्को कुरा गरौं।

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

variable owner_private_key
variable owner_public_key 

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

हामीलाई दुवै कुञ्जीहरू चाहिन्छ।

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

variable owner_private_key
variable owner_public_key 
variable orders
variable owner_wc
variable owner_account_id

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

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

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

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

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

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

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

message_to_send @ 
recv_external 
code 
storage @
c7
runvmctx

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

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

पहिले, हामी सन्देशबाट हस्ताक्षरको 512 बिटहरू गणना गर्छौं र यसलाई चरमा लेख्छौं, त्यसपछि हामी काउन्टर भेरिएबलको 32 बिट्स गणना गर्छौं।

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

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

var signature = in_msg~load_bits(512);
var message = in_msg;
int msg_seqno = message~load_uint(32);
(int stored_seqno, int pubkey, int order_seqno, int number_of_wins, int incoming_amount, int outgoing_amount, int owner_wc, int owner_account_id, cell orders) = unpack_state();
throw_unless(33, msg_seqno == stored_seqno);
throw_unless(34, check_signature(slice_hash(in_msg), signature, pubkey));

सान्दर्भिक प्रतिबद्धता ठीक छ.

परीक्षणहरू चलाउनुहोस् र हेर्नुहोस् कि दोस्रो परीक्षण असफल भयो। दुई कारणले, सन्देशमा पर्याप्त बिटहरू छैनन् र भण्डारणमा पर्याप्त बिटहरू छैनन्, त्यसैले पार्सिङ गर्दा कोड क्र्यास हुन्छ। हामीले पठाउने सन्देशमा हस्ताक्षर थप्न र अन्तिम परीक्षणबाट भण्डारण प्रतिलिपि गर्न आवश्यक छ।

दोस्रो परीक्षणमा, हामी सन्देश हस्ताक्षर थप्नेछौं र स्मार्ट सम्झौता भण्डारण परिवर्तन गर्नेछौं। यहाँ यति परीक्षणको साथ फाइल अहिले जस्तो देखिन्छ।

चौथो परीक्षण लेखौं, जसमा हामी अरू कसैको निजी कुञ्जीसँग हस्ताक्षर गरिएको सन्देश पठाउनेछौं। अर्को निजी कुञ्जी सिर्जना गरौं र फाइलमा बचत गरौं not-owner.pk। हामी यो निजी कुञ्जीले सन्देशमा हस्ताक्षर गर्नेछौं। परीक्षणहरू चलाउनुहोस् र सुनिश्चित गर्नुहोस् कि सबै परीक्षणहरू उत्तीर्ण हुन्छन्। प्रतिबद्ध यो क्षण मा।

अब हामी अन्ततः स्मार्ट अनुबंध तर्क लागू गर्न अगाडि बढ्न सक्छौं।
В recv_external() हामी दुई प्रकारका सन्देशहरू स्वीकार गर्नेछौं।

हाम्रो सम्झौताले खेलाडीहरूको घाटा जम्मा गर्ने भएकोले, यो पैसा चिठ्ठाको सिर्जनाकर्तालाई हस्तान्तरण गरिनुपर्छ। लटरी सिर्जनाकर्ताको वालेट ठेगाना भण्डारणमा रेकर्ड गरिन्छ जब सम्झौता सिर्जना गरिन्छ।

केवल के अवस्थामा, हामीलाई ठेगाना परिवर्तन गर्ने क्षमता चाहिन्छ जसमा हामीले हराउनेहरूको ग्राम पठाउँछौं। हामीले चिठ्ठाबाट मालिकको ठेगानामा ग्राम पठाउन पनि सक्षम हुनुपर्छ।

पहिलोबाट सुरु गरौं। पहिले एउटा परीक्षण लेखौं कि सन्देश पठाए पछि, स्मार्ट सम्झौताले भण्डारणमा नयाँ ठेगाना सुरक्षित गर्यो भनेर जाँच गर्नेछ। कृपया नोट गर्नुहोस् कि सन्देशमा, काउन्टर र नयाँ ठेगानाको अतिरिक्त, हामी पनि प्रसारण गर्छौं action एक 7-बिट पूर्णांक गैर-ऋणात्मक संख्या, यसको आधारमा, हामी स्मार्ट अनुबंधमा सन्देश कसरी प्रशोधन गर्ने छनौट गर्नेछौं।

<b 0 32 u, 1 @ 7 u, new_owner_wc @  32 i, new_owner_account_id @ 256 u, b> message_to_sign !

परीक्षणमा तपाईले स्मार्ट कन्ट्र्याक्ट भण्डारण कसरी डिसेरियलाइज गरिएको छ भनेर हेर्न सक्नुहुन्छ storage पाँच मा। चरहरूको डिसेरियलाइजेसन फिफ्ट कागजातमा वर्णन गरिएको छ।

कमिट लिङ्क थपिएको आटा संग।

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

स्मार्ट अनुबंधमा हामी पार्स गर्न जारी राख्छौं message, मा पढ्नुहोस् action। हामी तपाईंलाई सम्झाउने गरौं कि हामी दुई हुनेछौं action: ठेगाना परिवर्तन गर्नुहोस् र ग्राम पठाउनुहोस्।

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

अब पहिले सेभ गरिएको ठेगानामा ग्रामको निर्दिष्ट संख्या पठाउनको लागि तर्क लेखौं।

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

अब कोड थपौं। पहिले, दुई सहायक विधिहरू लेखौं। पहिलो प्राप्त विधि स्मार्ट अनुबंधको हालको ब्यालेन्स पत्ता लगाउनु हो।

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

र दोस्रो अर्को स्मार्ट अनुबंधमा ग्राम पठाउनको लागि हो। मैले अर्को स्मार्ट अनुबंधबाट यो विधि पूर्ण रूपमा प्रतिलिपि गरें।

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

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

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

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

वैसे, प्रसोधित सन्देशको लागि प्रत्येक पटक स्मार्ट अनुबंधबाट कमिशन कटौती गरिन्छ। अनुरोध कार्यान्वयन गर्न स्मार्ट अनुबंध सन्देशहरूको लागि, आधारभूत जाँचहरू पछि तपाईंले कल गर्न आवश्यक छ accept_message().

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

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

स्मार्ट अनुबंध ठेगानामा दुई नम्बरहरू हुन्छन्, वर्कचेनका लागि जिम्मेवार 32-बिट पूर्णांक र यस वर्कचेनमा 256-बिट गैर-नकारात्मक पूर्णांक अद्वितीय खाता नम्बर। उदाहरण को लागी, -1 र 12345, यो ठेगाना हो जुन हामीले फाइलमा बचत गर्नेछौं।

मैले ठेगाना बचत गर्नको लागि प्रकार्य प्रतिलिपि गरें TonUtil.fif.

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

फंक्शनले कसरी काम गर्छ हेरौं, यसले फिफ्टले कसरी काम गर्छ भन्ने बुझाइ दिनेछ। अन्तरक्रियात्मक मोडमा फिफ्ट सुरु गर्नुहोस्।

~/TON/build/crypto/fift -i

पहिले हामी स्ट्याकमा -1, 12345 र भविष्यको फाइल "sender.addr" को नाम पुश गर्छौं:

-1 12345 "sender.addr"

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

"sender.addr" -1 12345

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

"sender.addr" -1 BYTES:0000000000000000000000000000000000000000000000000000000000003039

swap स्ट्याकको शीर्ष दुई तत्वहरू स्वैप गर्दछ।

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 -1

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

"sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039 BYTES:FFFFFFFF

B+ बाइटको दुई अनुक्रम जोड्छ।

 "sender.addr" BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF

फेरी swap.

BYTES:0000000000000000000000000000000000000000000000000000000000003039FFFFFFFF "sender.addr"

र अन्तमा बाइटहरू फाइलमा लेखिएका छन् B>file। यस पछि हाम्रो स्ट्याक खाली छ। हामी रोक्छौं Fift। हालको फोल्डरमा एउटा फाइल सिर्जना गरिएको छ sender.addr। फाइललाई सिर्जना गरिएको फोल्डरमा सारौं test/addresses/.

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

अब लटरी को तर्क हेरौं।

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

हामी जाँच गर्छौं, यदि ब्यालेन्स आधा ग्राम भन्दा कम छ भने, हामी केवल सन्देश स्वीकार गर्छौं र यसलाई बेवास्ता गर्छौं।

अर्को, हामी स्मार्ट सम्झौताको ठेगाना पार्स गर्छौं जसबाट सन्देश आयो।

हामी भण्डारणबाट डाटा पढ्छौं र यदि बीस भन्दा बढी छन् भने इतिहासबाट पुरानो शर्तहरू मेटाउनुहोस्। सुविधाको लागि, मैले तीन अतिरिक्त प्रकार्यहरू लेखें pack_order(), unpack_order(), remove_old_orders().

अर्को, हामी हेर्छौं यदि ब्यालेन्स भुक्तानीको लागि पर्याप्त छैन भने, हामी विचार गर्छौं कि यो शर्त होइन, तर पुन: भर्ना हो र पुनःपूर्ति बचत गर्नुहोस्। orders.

त्यसपछि अन्तमा स्मार्ट अनुबंधको सार।

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

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

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

त्यो सबै छ। अनुरूप प्रतिबद्धता.

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

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

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

अर्को चरण स्मार्ट अनुबंध प्रकाशित गर्न हो। फोल्डर सिर्जना गरौं requests.

मैले प्रकाशन कोडलाई आधारको रूपमा लिएँ simple-wallet-code.fc जो पाउन सक्नुहुन्छ आधिकारिक भण्डारमा।

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

अर्को हामी प्रकाशन कोड कार्यान्वयन र प्राप्त lottery-query.boc स्मार्ट अनुबंध फाइल र ठेगाना।

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

उत्पन्न फाइलहरू बचत गर्न नबिर्सनुहोस्: lottery-query.boc, lottery.addr, lottery.pk.

अन्य चीजहरू मध्ये, हामी कार्यान्वयन लगहरूमा स्मार्ट सम्झौताको ठेगाना देख्नेछौं।

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

केवल रमाइलोको लागि, TON लाई अनुरोध गरौं

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

र हामी यो ठेगाना भएको खाता खाली भएको देख्नेछौं।

account state is empty

ठेगानामा पठाउँछौं 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd 2 ग्राम र केहि सेकेन्ड पछि हामी समान आदेश कार्यान्वयन गर्छौं। ग्राम पठाउन म प्रयोग गर्छु आधिकारिक वालेट, र तपाइँ च्याटबाट कसैलाई टेस्ट ग्रामको लागि सोध्न सक्नुहुन्छ, जसको बारेमा म लेखको अन्त्यमा कुरा गर्नेछु।

> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

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

account state is (account
  addr:(addr_std
    anycast:nothing workchain_id:0 address:x044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A)
  storage_stat:(storage_info
    used:(storage_used
      cells:(var_uint len:1 value:1)
      bits:(var_uint len:1 value:103)
      public_cells:(var_uint len:0 value:0)) last_paid:1583257959
    due_payment:nothing)
  storage:(account_storage last_trans_lt:3825478000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:2000000000))
      other:(extra_currencies
        dict:hme_empty))
    state:account_uninit))
x{C00044910149DBEAF8EADBB2B28722E7D6A2DC6E264EC2F1D9BEBD6FB209079BC2A20259C2F2F4CB3800000DEAC10776091DCD650004_}
last transaction lt = 3825478000001 hash = B043616AE016682699477FFF01E6E903878CDFD6846042BA1BFC64775E7AC6C4
account balance is 2000000000ng

अब स्मार्ट सम्झौता प्रकाशित गरौं। लाइट क्लाइन्ट सुरु गरौं र कार्यान्वयन गरौं।

> sendfile lottery-query.boc
[ 1][t 2][1583008371.631410122][lite-client.cpp:966][!testnode] sending query from file lottery-query.boc
[ 3][t 1][1583008371.828550100][lite-client.cpp:976][!query]    external message status is 1

सम्झौता प्रकाशित भएको छ कि छैन जाँच गरौं।

> last
> getaccount 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd

अन्य चीजहरू मध्ये हामी पाउँछौं।

  storage:(account_storage last_trans_lt:3825499000002
    balance:(currencies
      grams:(nanograms
        amount:(var_uint len:4 value:1987150999))
      other:(extra_currencies
        dict:hme_empty))
    state:(account_active

हामी त्यो देख्छौं account_active.

परिवर्तनहरूसँग अनुरूप प्रतिबद्धता ठीक छ.

अब स्मार्ट अनुबंधसँग अन्तरक्रिया गर्न अनुरोधहरू सिर्जना गरौं।

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

यो सन्देश हामीले स्मार्ट सम्झौतामा पठाउने छौँ, जहाँ msg_seqno 165, action पठाउनको लागि 2 र 9.5 ग्राम।

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

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

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

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

लन्च गर्नुहोस् lite-client र हामीले लेखेका प्राप्त विधिहरू चलाउनुहोस्।

$ ./lite-client/lite-client -C ton-lite-client-test1.config.json
> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd balance
arguments:  [ 104128 ] 
result:  [ 64633878952 ] 
...

В result प्रकार्यले फर्काउने मान समावेश गर्दछ balance() हाम्रो स्मार्ट सम्झौताबाट।
हामी धेरै अन्य विधिहरूको लागि पनि त्यस्तै गर्नेछौं।

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_seqno
...
arguments:  [ 77871 ] 
result:  [ 1 ]

तपाईंको शर्त इतिहासको लागि सोधौं।

> runmethod 0QAESRAUnb6vjq27KyhyLn1qLcbiZOwvHZvr1vsgkHm8Ksyd get_orders
...
arguments:  [ 67442 ] 
result:  [ ([0 1 1583258284 10000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308] [1 3 1583258347 4000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308] [2 1 1583259901 50000000000 0 74649920601963823558742197308127565167945016780694342660493511643532213172308]) ]

हामी लाइट क्लाइन्ट प्रयोग गर्नेछौं र साइटमा स्मार्ट अनुबंधको बारेमा जानकारी प्रदर्शन गर्न विधिहरू प्राप्त गर्नेछौं।

वेबसाइटमा स्मार्ट अनुबंध डेटा प्रदर्शन गर्दै

मैले पाइथनमा एक सरल वेबसाइट लेखेको छु स्मार्ट अनुबंधबाट डाटालाई सुविधाजनक तरिकामा प्रदर्शन गर्न। यहाँ म यसमा विस्तृत रूपमा बस्ने छैन र साइट प्रकाशित गर्नेछु एक प्रतिबद्धता मा.

TON लाई अनुरोधहरू बाट गरिन्छ Python सहयोगको साथ lite-client। सुविधाको लागि, साइट डकरमा प्याकेज गरिएको छ र Google क्लाउडमा प्रकाशित गरिएको छ। लिङ्क.

कोसिस गर्दै

अब त्यहाँबाट पुनःपूर्तिको लागि ग्राम पठाउने प्रयास गरौं वालेट। हामी 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
FunC को लागि भिजुअल स्टुडियो कोडको लागि विस्तारको लागि भण्डार: https://github.com/raiym/func-visual-studio-plugin
टेलिग्राममा TON को बारेमा कुराकानी गर्नुहोस्, जसले प्रारम्भिक चरणमा यो पत्ता लगाउन मद्दत गर्‍यो। मलाई लाग्छ कि यो गल्ती हुनेछैन यदि मैले TON को लागी केहि लेख्ने सबै त्यहाँ छन्। तपाईं त्यहाँ परीक्षण ग्रामहरू पनि सोध्न सक्नुहुन्छ। https://t.me/tondev_ru
TON को बारेमा अर्को च्याट जसमा मैले उपयोगी जानकारी फेला पारे: https://t.me/TONgramDev
प्रतियोगिताको पहिलो चरण: https://contest.com/blockchain
प्रतियोगिताको दोस्रो चरण: https://contest.com/blockchain-2

स्रोत: www.habr.com

टेलिग्राम ओपन नेटवर्क (TON) मा स्मार्ट अनुबंध कसरी लेख्ने र प्रकाशित गर्ने बारे।