कैसे करें: PIRL नेटवर्क पर एक टोकन बनाएं

इस घोषणा पत्र को बाँट दो

facebook पर साझा करें
linkedin पर साझा करें
twitter पर साझा करें
email पर साझा करें

सिक्का

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

मिनिमल विडियो टोकन

मानक टोकन अनुबंध काफी जटिल हो सकता है। लेकिन संक्षेप में यह एक बहुत ही बुनियादी टोकन उबलता है:

अनुबंध MyToken {/ * यह सभी संतुलन के साथ एक सरणी बनाता है * / मानचित्रण (पता => uint256) सार्वजनिक संतुलन; / * अनुबंध के निर्माता के लिए प्रारंभिक आपूर्ति टोकन के साथ अनुबंध को प्रारंभ करता है * / फ़ंक्शन MyToken (uint256 initialSupply) {balanceOf [msg.sender] = initialSupply; // निर्माता को सभी प्रारंभिक टोकन दें} / * सिक्के भेजें * / समारोह हस्तांतरण (पता _to, uint256 _value) {आवश्यकता (शेष राशि] [msg.sender]> = _value); // जांचें कि क्या प्रेषक के पास पर्याप्त आवश्यकता है (शेष राशि [_to] + _value> = balanceOf [_to]); // ओवरफ्लो के लिए चेक करें balanceOf [msg.sender] - = _value; // प्रेषक से घटाएं शेष राशि [_to] + = _value; // प्राप्तकर्ता में समान जोड़ें}}

कोड

लेकिन अगर आप सिर्फ एक अधिक संपूर्ण कोड पेस्ट करना चाहते हैं, तो इसका उपयोग करें:

प्राग्म सॉलिडिटी ^ 0.4.16;

इंटरफ़ेस tokenRecipient {function getApproval (पता _from, uint256 _value, पता _token, बाइट्स _extraData) सार्वजनिक; }

अनुबंध टोकनेन 20 {
   // टोकन के सार्वजनिक चर
   स्ट्रिंग सार्वजनिक नाम;
   स्ट्रिंग सार्वजनिक प्रतीक;
   uint8 सार्वजनिक दशमलव = 18;
   // 18 दशमलव दृढ़ता से सुझाया गया डिफ़ॉल्ट है, इसे बदलने से बचें
   uint256 सार्वजनिक कुल मिलाकर;

   // यह सभी शेष के साथ एक सरणी बनाता है
   मैपिंग (पता => uint256) सार्वजनिक शेष राशि;
   मानचित्रण (पता => मानचित्रण (पता => uint256)) सार्वजनिक भत्ता;

   // यह ब्लॉकचैन पर एक सार्वजनिक कार्यक्रम बनाता है जो ग्राहकों को सूचित करेगा
   ईवेंट ट्रांसफ़र (एड्रेस इंडेक्स फ्रॉम, एड्रेस इंडेक्स टू, यूइंट256 वैल्यू);

   // यह जलाई गई राशि के बारे में ग्राहकों को सूचित करता है
   ईवेंट बर्न (पते से अनुक्रमित, uint256 मान);

   /**
    * कंस्ट्रक्टर फ़ंक्शन
    *
    * अनुबंध के निर्माता को प्रारंभिक आपूर्ति टोकन के साथ अनुबंध को प्रारंभिक करता है
    */
   फ़ंक्शन टोकनेन 20 (
       प्रारंभिक रूप से uint256,
       स्ट्रिंग टोकननाम,
       स्ट्रिंग टोकन
   ) जनता {
       TotalSupply = initialSupply * 10 ** uint256 (दशमलव); // दशमलव राशि के साथ कुल आपूर्ति का अद्यतन करें
       balanceOf [msg.sender] = कुल मिलाकर; // निर्माता को सभी शुरुआती टोकन दें
       name = tokenName; // प्रदर्शन उद्देश्यों के लिए नाम सेट करें
       प्रतीक = tokenSymbol; // प्रदर्शन उद्देश्यों के लिए प्रतीक सेट करें
   }

   /**
    * आंतरिक हस्तांतरण, केवल इस अनुबंध द्वारा बुलाया जा सकता है
    */
   फ़ंक्शन _transfer (पता _from, पता _to, uint _value) आंतरिक {
       // 0x0 पते पर स्थानांतरण रोकें। इसके बजाय बर्न () का उपयोग करें
       आवश्यकता (_to! = 0x0);
       // जांचें कि क्या प्रेषक के पास पर्याप्त है
       आवश्यकता है (balanceOf [_from]> = _value);
       // ओवरफ्लो की जांच करें
       आवश्यकता (balanceOf [_to] + _value> balanceOf [_to]);
       // इसे भविष्य में जोर देने के लिए बचाएं
       uint lastBalances = balanceOf [_from] + balanceOf [_to];
       // प्रेषक से घटाना
       balanceOf [_from] - = _value;
       // प्राप्तकर्ता के लिए समान जोड़ें
       balanceOf [_to] + = _value;
       स्थानांतरण (_from, _to, _value);
       // अपने कोड में बग ढूंढने के लिए स्थैतिक विश्लेषण का उपयोग करने के लिए Asserts का उपयोग किया जाता है। उन्हें कभी असफल नहीं होना चाहिए
       मुखर (balanceOf [_from] + balanceOf [_to] == पिछलेBalances);
   }

   /**
    * ट्रांसफर टोकन
    *
    * अपने खाते से `_value` को` _to` को भेजें
    *
    * @पारम _तो प्राप्तकर्ता का पता
    * @ अपरम_ भेजने की राशि
    */
   समारोह हस्तांतरण (पता _to, uint256 _value) सार्वजनिक {
       _transfer (msg.sender, _to, _value);
   }

   /**
    * अन्य पते से टोकन स्थानांतरित करें
    *
    * `_From` की ओर से` _to` को `_to` को भेजें
    *
    * @पारम _फ्रॉम प्रेषक का पता
    * @पारम _तो प्राप्तकर्ता का पता
    * @ अपरम_ भेजने की राशि
    */
   समारोह हस्तांतरण (पता _from, पता _to, uint256 _value) सार्वजनिक रिटर्न (बूल सफलता) {
       आवश्यकता (_value <= भत्ता [_from] [msg.sender]); // चेक भत्ता
       भत्ता [_from] [msg.sender] - = _value;
       _transfer (_from, _to, _value);
       सच लौटना;
   }

   /**
    * अन्य पते के लिए भत्ता निर्धारित करें
    *
    * `_Spender` को आपकी ओर से` _value` टोकन से अधिक खर्च करने की अनुमति नहीं देता है
    *
    * @param_spender खर्च करने के लिए अधिकृत पता
    * @ अपरम_ अधिक से अधिक राशि वे खर्च कर सकते हैं
    */
   फ़ंक्शन स्वीकृत (पते _spender, uint256 _value) सार्वजनिक
       रिटर्न (बूल की सफलता) {
       भत्ता [msg.sender] [_ spender] = _value;
       सच लौटना;
   }

   /**
    * अन्य पते के लिए भत्ता निर्धारित करें और सूचित करें
    *
    * `_Spender` को आपकी ओर से` _value` टोकन से अधिक खर्च करने की अनुमति नहीं है, और फिर इसके बारे में अनुबंध पिंग करें
    *
    * @param_spender खर्च करने के लिए अधिकृत पता
    * @ अपरम_ अधिक से अधिक राशि वे खर्च कर सकते हैं
    * @param_extraData अनुमोदित अनुबंध को भेजने के लिए कुछ अतिरिक्त जानकारी
    */
   फ़ंक्शन को स्वीकार करें और पता (पते _spender, uint256 _value, बाइट्स _extraData)
       जनता
       रिटर्न (बूल की सफलता) {
       tokenRecipient spender = tokenRecipient (_spender);
       अगर (अनुमोदन (_spender, _value)) {
           spender.receiveApproval (msg.sender, _value, this, _extraData);
           सच लौटना;
       }
   }

   /**
    * टोकन को नष्ट करें
    *
    * अपरिवर्तनीय रूप से सिस्टम से `_value` टोकन निकालें
    *
    * @ परम्_ जलाने के लिए धन की मात्रा कम करें
    */
   फ़ंक्शन बर्न (uint256 _value) सार्वजनिक रिटर्न (बूल सफलता) {
       आवश्यकता (शेष राशि] [msg.sender]> = _value); // जांचें कि क्या प्रेषक के पास पर्याप्त है
       balanceOf [msg.sender] - = _value; // प्रेषक से घटाना
       TotalSupply - = _value; // अपडेट कुल मिलाकर
       बर्न (msg.sender, _value);
       सच लौटना;
   }

   /**
    * अन्य खाते से टोकन को नष्ट करें
    *
    * `_From` की ओर से अपरिवर्तनीय रूप से सिस्टम से` _value` टोकन निकालें।
    *
    * @पारम _ प्रेषक का पता
    * @ परम्_ जलाने के लिए धन की मात्रा कम करें
    */
   समारोह burnFrom (पता _from, uint256 _value) सार्वजनिक रिटर्न (बूल सफलता) {
       आवश्यकता है (balanceOf [_from]> = _value); // जांचें कि क्या लक्षित शेष पर्याप्त है
       आवश्यकता (_value <= भत्ता [_from] [msg.sender]); // चेक भत्ता
       balanceOf [_from] - = _value; // लक्षित शेष राशि से घटाएं
       भत्ता [_from] [msg.sender] - = _value; // प्रेषक के भत्ते से घटाएं
       TotalSupply - = _value; // अपडेट करें कुल मिलाकर
       बर्न (_from, _value);
       सच लौटना;
   }
}

कोड को समझना

तो चलिए मूल बातें से शुरू करते हैं। वॉलेट ऐप खोलें, कॉन्ट्रैक्ट्स टैब पर जाएं और फिर नए कॉन्ट्रैक्ट पर जाएं। सॉलिडिटी कॉन्ट्रैक्ट सोर्स कोड टेक्स्ट फ़ील्ड पर, नीचे दिया गया कोड टाइप करें:

अनुबंध MyToken {
       / * यह सभी शेष के साथ एक सरणी बनाता है * /
       मैपिंग (पता => uint256) सार्वजनिक शेष राशि;
   }

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

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

फ़ंक्शन MyToken () {
       balanceOf [msg.sender] = 21000000;
   }

ध्यान दें कि फ़ंक्शन MyToken का अनुबंध MyToken के समान नाम है। यह बहुत महत्वपूर्ण है और यदि आप एक का नाम बदलते हैं, तो आपको दूसरे का भी नाम बदलना होगा: यह एक विशेष, स्टार्टअप फ़ंक्शन है जो केवल एक बार और केवल एक बार चलता है जब अनुबंध पहली बार नेटवर्क पर अपलोड किया जाता है। यह फ़ंक्शन msg.sender का संतुलन सेट करेगा, जो उपयोगकर्ता ने अनुबंध को तैनात किया है, जिसमें 21 मिलियन का संतुलन है।

21 मिलियन का विकल्प बल्कि मनमाना था, और आप इसे कोड में अपनी इच्छित किसी भी चीज़ में बदल सकते हैं, लेकिन इसका एक बेहतर तरीका है: इसके बजाय, इसे फ़ंक्शन के पैरामीटर के रूप में इस तरह से आपूर्ति करें:

फ़ंक्शन MyToken (uint256 आरंभिक रूप से) सार्वजनिक {
       balanceOf [msg.sender] = initialSupply;
   }

अनुबंध के पास दाएं कॉलम पर एक नज़र डालें और आपको एक ड्रॉप-डाउन सूची दिखाई देगी, जिसे अनुबंध चुना जाएगा। "MyToken" अनुबंध का चयन करें और आप देखेंगे कि अब यह कन्स्ट्रक्टर पैरामीटर नामक एक अनुभाग दिखाता है। ये आपके टोकन के लिए परिवर्तनशील पैरामीटर हैं, इसलिए आप एक ही कोड का पुन: उपयोग कर सकते हैं और केवल भविष्य में इन चरों को बदल सकते हैं।

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

/ * सिक्के भेजें * /
   समारोह हस्तांतरण (पता _to, uint256 _value) {
       / * नए शेष जोड़ें और घटाना * /
       balanceOf [msg.sender] - = _value;
       balanceOf [_to] + = _value;
   }

यह एक बहुत ही सीधा कार्य है: इसमें एक प्राप्तकर्ता और एक मान होता है जो पैरामीटर के रूप में होता है और जब भी कोई इसे कहता है, यह _value को उनके संतुलन से घटा देगा और इसे _to संतुलन में जोड़ देगा। अभी एक स्पष्ट समस्या है: क्या होता है यदि व्यक्ति अपने मालिक से अधिक भेजना चाहता है? चूंकि हम इस विशेष अनुबंध में ऋण को संभालना नहीं चाहते हैं, हम बस एक त्वरित जांच करने जा रहे हैं और यदि प्रेषक के पास पर्याप्त धन नहीं है तो अनुबंध निष्पादन आसानी से बंद हो जाएगा। यह ओवरफ्लो के लिए जांचना भी है, एक संख्या इतनी बड़ी होने से बचने के लिए कि यह फिर से शून्य हो जाए।

मध्य निष्पादन को रोकने के लिए, आप या तो वापस लौट सकते हैं या फेंक सकते हैं, पूर्व में कम गैस खर्च होगी, लेकिन यह अधिक सिरदर्द हो सकता है क्योंकि आपने अनुबंध में अब तक किए गए किसी भी बदलाव को रखा जाएगा। दूसरी ओर, 'थ्रो' सभी अनुबंध निष्पादन को रद्द कर देगा, लेन-देन में किए गए किसी भी परिवर्तन को वापस कर सकता है और प्रेषक को वह सभी Pirl खो देगा जो उसने गैस के लिए भेजा था। लेकिन चूंकि वॉलेट यह पता लगा सकता है कि एक अनुबंध फेंक देगा, यह हमेशा एक चेतावनी दिखाता है, इसलिए किसी भी पर्टल को खर्च करने से रोकना चाहिए।

समारोह हस्तांतरण (पता _to, uint256 _value) {
       / * जांचें कि क्या प्रेषक के पास शेष राशि है और ओवरफ्लो के लिए * /
       आवश्यकता है (balanceOf [msg.sender]> = _value && balanceOf [_to] + _value> = balanceOf [_to]);

       / * नए शेष जोड़ें और घटाना * /
       balanceOf [msg.sender] - = _value;
       balanceOf [_to] + = _value;
   }

 

अब जो सब गायब है वह अनुबंध के बारे में कुछ बुनियादी जानकारी रखता है। निकट भविष्य में यह एक टोकन रजिस्ट्री द्वारा संभाला जा सकता है, लेकिन अब हम उन्हें सीधे अनुबंध में जोड़ देंगे:

स्ट्रिंग सार्वजनिक नाम;
स्ट्रिंग सार्वजनिक प्रतीक;
uint8 सार्वजनिक दशमलव;

और अब हम उन सभी चरों को शुरू करने की अनुमति देने के लिए कंस्ट्रक्टर फ़ंक्शन को अपडेट करते हैं:

/ * अनुबंध के निर्माता को प्रारंभिक आपूर्ति टोकन के साथ अनुबंध को प्रारंभ करता है * /
   फ़ंक्शन MyToken (uint256 आरंभिक रूप से, स्ट्रिंग टोकन, नाम, टोकन टोकन, uint8 दशमलव)
       balanceOf [msg.sender] = initialSupply; // निर्माता को सभी शुरुआती टोकन दें
       name = tokenName; // प्रदर्शन उद्देश्यों के लिए नाम सेट करें
       प्रतीक = tokenSymbol; // प्रदर्शन उद्देश्यों के लिए प्रतीक सेट करें
       दशमलव = दशमलव; // प्रदर्शन उद्देश्यों के लिए दशमलव की राशि
   }

अंत में, हमें अब इवेंट्स नामक somPirling की आवश्यकता है। ये विशेष, खाली कार्य हैं जिन्हें आप क्लाइंट की मदद करने के लिए कहते हैं जैसे कि Pirl Wallet अनुबंध में हो रही गतिविधियों पर नज़र रखता है। घटनाओं को एक बड़े अक्षर से शुरू करना चाहिए। घटना की घोषणा करने के लिए अनुबंध की शुरुआत में इस पंक्ति को जोड़ें:

ईवेंट ट्रांसफ़र (एड्रेस इंडेक्स फ्रॉम, एड्रेस इंडेक्स टू, यूइंट256 वैल्यू);
 

और फिर आपको केवल "स्थानांतरण" फ़ंक्शन के अंदर इन दो लाइनों को जोड़ने की आवश्यकता है:

      / * यह सुनकर किसी को सूचित करें कि यह स्थानांतरण *
       स्थानांतरण (msg.sender, _to, _value);

 

और अब आपका टोकन तैयार है!

टिप्पणियां नहीं देखी गईं?

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

कैसे तैनात करें

यदि आप वहां पहले से मौजूद नहीं हैं, तो Pirl Wallet खोलें, कॉन्ट्रैक्ट्स टैब पर जाएं और फिर "नए अनुबंध को परिनियोजित करें" पर क्लिक करें।

अब ऊपर से टोकन स्रोत प्राप्त करें और इसे "सॉलिडिटी सोर्स फ़ील्ड" में पेस्ट करें। यदि कोड बिना किसी त्रुटि के संकलित होता है, तो आपको दाईं ओर "एक अनुबंध चुनें" ड्रॉप-डाउन सूची दिखाई देनी चाहिए। इसे प्राप्त करें और "MyToken" अनुबंध चुनें। सही कॉलम पर, आपको अपने स्वयं के टोकन को निजीकृत करने के लिए आवश्यक सभी पैरामीटर दिखाई देंगे। आप उन्हें अपनी इच्छानुसार ट्विक कर सकते हैं।

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

आपको सामने वाले पृष्ठ पर पुनः निर्देशित किया जाएगा जहाँ आप अपने लेनदेन की पुष्टि के लिए प्रतीक्षा कर सकते हैं। खाते पर क्लिक करें और एक मिनट से अधिक नहीं रहने के बाद आपको यह देखना चाहिए कि आपका खाता दिखाएगा कि आपके पास अभी बनाए गए शेयरों में से 100% हैं। कुछ मित्रों को भेजने के लिए: "भेजें" चुनें, और फिर चुनें कि आप किस मुद्रा को भेजना चाहते हैं (Pirl या अपना नया बनाया गया हिस्सा), अपने मित्र के पते को "से" फ़ील्ड पर पेस्ट करें और "भेजें" दबाएं।

यदि आप इसे किसी मित्र को भेजते हैं, तो वे अभी तक अपने बटुए में कुछ भी नहीं देखेंगे। इसका कारण यह है कि बटुआ केवल टोकन को ट्रैक करता है जिसके बारे में वह जानता है, और आपको इन्हें मैन्युअल रूप से जोड़ना होगा। अब "अनुबंध" टैब पर जाएं और आपको अपने नए बनाए गए अनुबंध का लिंक देखना चाहिए। इसके पेज पर जाने के लिए इस पर क्लिक करें। चूंकि यह एक बहुत ही सरल अनुबंध पृष्ठ है, इसलिए यहां बहुत कुछ नहीं है, बस "कॉपी एड्रेस" पर क्लिक करें और अनुबंध के पते को टेक्स्ट एडिटर में पेस्ट करें, आपको जल्द ही इसकी आवश्यकता होगी।

देखने के लिए एक टोकन जोड़ने के लिए, अनुबंध पृष्ठ पर जाएं और फिर "वॉच टोकन देखें" पर क्लिक करें। एक पॉप-अप दिखाई देगा और आपको केवल अनुबंध पता पेस्ट करना होगा। टोकन नाम, प्रतीक और दशमलव संख्या स्वचालित रूप से भरी जानी चाहिए, लेकिन यदि आप ऐसा कुछ नहीं रख सकते हैं जो आप चाहते हैं (यह केवल यह प्रभावित करेगा कि यह आपके बटुए पर कैसे प्रदर्शित होता है)। एक बार जब आप ऐसा कर लेते हैं, तो आपको स्वचालित रूप से आपके पास उस टोकन का कोई भी संतुलन दिखाया जाएगा और आप इसे किसी और को भेज पाएंगे।

और अब आपके पास अपना स्वयं का क्रिप्टो टोकन है! स्वयं द्वारा टोकन स्थानीय समुदायों पर मूल्य विनिमय के रूप में उपयोगी हो सकते हैं, काम के घंटे या अन्य वफादारी कार्यक्रमों पर नज़र रखने के तरीके। लेकिन क्या हम एक मुद्रा को उपयोगी बनाकर एक आंतरिक मूल्य बना सकते हैं?

अपने टोकन में सुधार करें

आप कभी भी कोड की एक पंक्ति को छूने के बिना अपने पूरे क्रिप्टो टोकन को तैनात कर सकते हैं, लेकिन असली जादू तब होता है जब आप इसे अनुकूलित करना शुरू करते हैं। निम्नलिखित अनुभाग उन कार्यों पर सुझाव देंगे जिन्हें आप अपने टोकन में जोड़ सकते हैं ताकि यह आपकी आवश्यकताओं के अनुरूप हो सके।

अधिक बुनियादी कार्य

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

क्योंकि इनमें से कई कार्य टोकन के हस्तांतरण को फिर से लागू करने के लिए हो रहे हैं, यह उन्हें एक आंतरिक फ़ंक्शन में बदलने के लिए समझ में आता है, जिसे केवल अनुबंध द्वारा ही कहा जा सकता है:

/ * आंतरिक स्थानांतरण, केवल इस अनुबंध द्वारा बुलाया जा सकता है * /
   फ़ंक्शन _transfer (पता _from, पता _to, uint _value) आंतरिक {
       आवश्यकता (_to! = 0x0); // 0x0 पते पर स्थानांतरण रोकें। इसके बजाय बर्न () का उपयोग करें
       आवश्यकता है (balanceOf [_from]> = _value); // जांचें कि क्या प्रेषक के पास पर्याप्त है
       आवश्यकता (balanceOf [_to] + _value> balanceOf [_to]); // ओवरफ्लो की जांच करें
       की आवश्यकता होती है (frozenAccount [_from]!); // जांचें कि क्या प्रेषक जमे हुए है
       की आवश्यकता होती है (frozenAccount [_to]!); // जांचें कि क्या प्राप्तकर्ता फ्रोजन है
       balanceOf [_from] - = _value; // प्रेषक से घटाना
       balanceOf [_to] + = _value; // प्राप्तकर्ता के लिए समान जोड़ें
       स्थानांतरण (_from, _to, _value);
   }

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

केंद्रीकृत प्रशासक

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

ऐसा होने के लिए, आपको मुद्रा के एक केंद्रीय नियंत्रक की आवश्यकता होती है। यह एक साधारण खाता हो सकता है, लेकिन एक अनुबंध भी हो सकता है और इसलिए अधिक टोकन बनाने का निर्णय अनुबंध पर निर्भर करेगा: यदि यह एक लोकतांत्रिक संगठन है जो वोट देने के लिए हो सकता है, या हो सकता है कि यह सीमित करने का एक तरीका हो सकता है टोकन मालिक की शक्ति।

ऐसा करने के लिए, हम अनुबंधों की एक बहुत ही उपयोगी संपत्ति सीखेंगे: विरासत। वंशानुक्रम एक अनुबंध को उन सभी को फिर से परिभाषित करने के बिना, एक मूल अनुबंध के गुणों को प्राप्त करने की अनुमति देता है। इससे कोड क्लीनर और पुन: उपयोग करना आसान हो जाता है। MyToken {अनुबंध से पहले, इस कोड को अपने कोड की पहली पंक्ति में जोड़ें।

अनुबंध स्वामित्व {
       सार्वजनिक स्वामी को संबोधित करें;

       कार्य स्वामित्व () {
           मालिक = msg.sender;
       }

       संशोधक onlyOwner {
           आवश्यकता (msg.sender == स्वामी);
           _;
       }

       फंक्शन ट्रांसफरओवरशिप (एड्रेस न्यूऑनर) onlyOwner {
           मालिक = newOwner;
       }
   }

यह एक बहुत ही मूल अनुबंध बनाता है जो कुछ भी नहीं करता है सिवाय एक अनुबंध के बारे में कुछ सामान्य कार्यों को परिभाषित करने के जो "स्वामित्व" हो सकता है। अब अगला कदम यह है कि पाठ को आपके अनुबंध के स्वामित्व में जोड़ा जाए:

 अनुबंध MyToken के स्वामित्व में है {
       / * अनुबंध के बाकी हमेशा की तरह * /

इसका मतलब यह है कि MyToken के अंदर सभी कार्य अब चर स्वामी और संशोधक onlyOwner तक पहुँच सकते हैं। अनुबंध को स्वामित्व स्थानांतरित करने के लिए एक फ़ंक्शन भी मिलता है। चूंकि स्टार्टअप में अनुबंध के मालिक को सेट करना दिलचस्प हो सकता है, इसलिए आप इसे कंस्ट्रक्टर फ़ंक्शन में भी जोड़ सकते हैं:

फ़ंक्शन MyToken (
       प्रारंभिक रूप से uint256,
       स्ट्रिंग टोकननाम,
       uint8 दशमलव,
       स्ट्रिंग टोकन
       पता केंद्रीय केंद्र
       ) {
       if (centralMinter! = 0) मालिक = centralMinter;
   }

सेंट्रल मिंट

मान लीजिए कि आप बदलने के लिए प्रचलन में सिक्कों की मात्रा चाहते हैं। यह वह स्थिति है जब आपके टोकन वास्तव में एक ऑफ ब्लॉकचेन परिसंपत्ति (जैसे सोने के प्रमाण पत्र या सरकारी मुद्राओं) का प्रतिनिधित्व करते हैं और आप चाहते हैं कि आभासी सूची वास्तविक को प्रतिबिंबित करे। यह मामला भी हो सकता है जब मुद्रा धारक टोकन की कीमत के कुछ नियंत्रण की उम्मीद करते हैं, और टोकन जारी करना या निकालना चाहते हैं।

सबसे पहले, हमें कुल स्टोर करने के लिए एक वैरिएबल जोड़ना होगा और इसे हमारे कंस्ट्रक्टर फंक्शन को असाइन करना होगा।

अनुबंध MyToken {
       uint256 सार्वजनिक कुल मिलाकर;

       फ़ंक्शन MyToken (…) {
           TotalSupply = initialSupply;
           …
       }
       …
   }

अब एक नया फंक्शन जोड़ते हैं जो आखिरकार मालिक को नए टोकन बनाने में सक्षम करेगा:

फ़ंक्शन मिंटटोकन (पता लक्ष्य, uint256 मिन्टआमाउंट) onlyOwner {
       balanceOf [लक्ष्य] + = mintedAmount;
       TotalSupply + = mintedAmount;
       स्थानांतरण (0, मालिक, mintedAmount);
       स्थानांतरण (मालिक, लक्ष्य, खनन)
   }

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

आस्तियों का जमना

आपके उपयोग के मामले के आधार पर, आपको कुछ नियामक बाधाओं की आवश्यकता हो सकती है जो आपके टोकन का उपयोग नहीं कर सकते हैं। ऐसा होने के लिए, आप एक पैरामीटर जोड़ सकते हैं जो अनुबंध के मालिक को संपत्ति को फ्रीज या अनफ्रीज करने में सक्षम बनाता है।

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

मैपिंग (पता => बूल) सार्वजनिक जमे हुए;
   घटना फ्रोजनफंड्स (पता लक्ष्य, बूल फ्रोजन);

   फ़ंक्शन फ्रीज़एक्ाउंट (एड्रेस टारगेट, बूल फ़्रीज़) onlyOwner {
       जमे हुए [लक्ष्य] = फ्रीज;
       फ्रोजनफंड (लक्ष्य, फ्रीज);
   }

इस कोड के साथ, सभी खाते डिफ़ॉल्ट रूप से अक्षम हैं, लेकिन मालिक उनमें से किसी को भी फ्रीज खाता कहकर फ्रीज स्थिति में सेट कर सकते हैं। दुर्भाग्य से, ठंड का कोई व्यावहारिक प्रभाव नहीं है क्योंकि हमने स्थानांतरण फ़ंक्शन में कुछ भी नहीं जोड़ा है। अब हम बदल रहे हैं:

समारोह हस्तांतरण (पता _to, uint256 _value) {
       की आवश्यकता होती है (frozenAccount [msg.sender]!);

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

की आवश्यकता होती है (approvedAccount [msg.sender]);

स्वचालित बेचना और खरीदना

अब तक, आपने अपने टोकन को महत्व देने के लिए उपयोगिता और विश्वास पर भरोसा किया है। लेकिन अगर आप चाहते हैं कि आप टोकन के मूल्य को Pirl (या अन्य टोकन) द्वारा एक फंड बनाकर बेच सकते हैं जो स्वचालित रूप से बेचता है और उन्हें बाजार मूल्य पर खरीदता है।

पहले, चलो खरीदने और बेचने के लिए मूल्य निर्धारित करें:

uint256 पब्लिक सेलप्रीस;
   uint256 सार्वजनिक खरीदेंप्राइस;

   फंक्शन सेटप्रिसिंस (uint256 newSellPrice, uint256 newBuyPrice) onlywwi {
       sellPrice = newSellPrice;
       buyPrice = newBuyPrice;
   }

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

अगला कदम खरीद और बिक्री कार्य करना है:

समारोह खरीद () देय रिटर्न (यूंट राशि) {
       राशि = msg.value / buyPrice; // राशि की गणना करता है
       आवश्यकता (balanceOf [यह]> = राशि); // अगर यह बेचने के लिए पर्याप्त है की जाँच करता है
       balanceOf [msg.sender] + = राशि; // खरीदार की शेष राशि में राशि जोड़ता है
       balanceOf [यह] - = राशि; // विक्रेता के शेष से राशि घटाता है
       स्थानांतरण (यह, msg.sender, राशि); // परिवर्तन को दर्शाती एक घटना को अंजाम
       वापसी राशि; // फ़ंक्शन और रिटर्न समाप्त करता है
   }

   फंक्शन सेल (यूइंट अमाउंट) रिटर्न (यूइंट रेवेन्यू) {
       आवश्यकता (balanceOf [msg.sender]> = राशि); // चेक अगर प्रेषक के पास बेचने के लिए पर्याप्त है
       balanceOf [यह] + = राशि; // मालिक की शेष राशि में राशि जोड़ता है
       balanceOf [msg.sender] - = राशि; // विक्रेता के शेष से राशि को घटाता है
       राजस्व = राशि * sellPrice;
       msg.sender.transfer (राजस्व); // विक्रेता को Pirl भेजता है: पुनरावृत्ति के हमलों को रोकने के लिए यह अंतिम करना महत्वपूर्ण है
       स्थानांतरण (msg.sender, यह, राशि); // परिवर्तन पर प्रतिबिंबित करने वाली घटना को निष्पादित करता है
       राजस्व लौटाना; // फ़ंक्शन और रिटर्न समाप्त करता है
   }

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

नोट खरीदें और बेचें "कीमतें", पिर्ल में सेट नहीं हैं, लेकिन सिस्टम की न्यूनतम मुद्रा में (यूरो और डॉलर में प्रतिशत के बराबर, या बिटकॉइन में सातोशी के बराबर)। वन पाइरल 1000000000000000000 वी है। इसलिए जब आप Pirl में अपने टोकन के लिए कीमतें निर्धारित करते हैं, तो अंत में 18 शून्य जोड़ें।

कॉन्ट्रैक्ट बनाते समय, उसे पर्याप्त पर्च भेजें ताकि वह बाजार के सभी टोकन वापस खरीद सके अन्यथा आपका कॉन्ट्रैक्ट दिवालिया हो जाएगा और आपके उपयोगकर्ता अपने टोकन नहीं बेच पाएंगे।

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

Autorefill

हर बार, आप Pirl पर एक लेन-देन करते हैं, आपको ब्लॉक के खनिक को एक शुल्क का भुगतान करने की आवश्यकता होती है जो आपके स्मार्ट अनुबंध के परिणाम की गणना करेगा। हालांकि यह भविष्य में बदल सकता है, पल भर के लिए शुल्क केवल Pirl में भुगतान किया जा सकता है और इसलिए आपके टोकन के सभी उपयोगकर्ताओं को इसकी आवश्यकता है। शुल्क से छोटे बैलेंस वाले खाते तब तक अटके रहते हैं जब तक कि मालिक आवश्यक शुल्क का भुगतान नहीं कर सकते। लेकिन कुछ उपयोग के मामलों में, आप अपने उपयोगकर्ताओं को Pirl, blockchain या Pirl प्राप्त करने के बारे में सोचने के लिए नहीं कह सकते हैं, इसलिए एक संभावित दृष्टिकोण से आपका सिक्का स्वचालित रूप से उपयोगकर्ता संतुलन को फिर से भर देगा क्योंकि यह पता लगाता है कि संतुलन खतरनाक रूप से कम है।

ऐसा करने के लिए, पहले आपको एक वैरिएबल बनाने की आवश्यकता है जो कि थ्रेशोल्ड राशि और इसे बदलने के लिए एक फ़ंक्शन रखेगा।

uint minBalanceForAccounts;

   फ़ंक्शन सेटमिनबालेंस (यूंट मिनिममबेलेंसइन्नी) ओनलीऑनर {
        minBalanceForAccounts = minimalBalanceInFinney * 1 फ़िननी;
   }

 

फिर, ट्रांसफ़र फ़ंक्शन में इस लाइन को जोड़ें ताकि प्रेषक वापस कर दिया जाए:

  / * सिक्के भेजें * /
   समारोह हस्तांतरण (पता _to, uint256 _value) {
       …
       अगर (msg.sender.balance <minBalanceForAccounts)
           sell ((minBalanceForAccounts - msg.sender.balance) / sellPrice);
   }

 

आप इसके बजाय इसे बदल भी सकते हैं ताकि प्राप्तकर्ता द्वारा प्राप्तकर्ता को शुल्क का भुगतान किया जाए:

  / * सिक्के भेजें * /
   समारोह हस्तांतरण (पता _to, uint256 _value) {
       …
       अगर (_to.balance            _to.send (बेचना ((minBalanceForAccounts - _to.balance) / sellPrice));
   }

यह सुनिश्चित करेगा कि टोकन प्राप्त करने वाले किसी भी खाते के पास शुल्क का भुगतान करने के लिए आवश्यक Pirl से कम नहीं है।

काम का प्रमाण

गणितीय सूत्र में अपने सिक्के की आपूर्ति को टाई करने के कुछ तरीके हैं। सबसे सरल तरीकों में से एक यह होगा कि इसे “मर्ज किए गए माइनिंग” के साथ Pirl बनाया जाए, जिसका अर्थ है कि जो कोई भी Pirl पर ब्लॉक ढूंढता है, उसे आपके सिक्के से एक इनाम भी मिलेगा, यह देखते हुए कि कोई भी उस ब्लॉक पर रिवॉर्ड फंक्शन कहता है। आप इसे उस विशेष कीवर्ड कॉइनबेस का उपयोग करके कर सकते हैं जो ब्लॉक खोजने वाले खनिक को संदर्भित करता है।

फ़ंक्शन देना
       balanceOf [block.coinbase] + = 1;
   }

गणितीय सूत्र जोड़ना भी संभव है, ताकि जो कोई भी गणित कर सकता है वह इनाम जीत सके। इस अगले उदाहरण पर आपको वर्तमान चुनौती के क्यूबिक रूट की गणना करनी है और अगली चुनौती निर्धारित करने का अधिकार प्राप्त होता है:

uint currentChallenge = 1; // क्या आप इस संख्या का घनमूल ज्ञात कर सकते हैं?

   फ़ंक्शन रिवार्डमैथजेनियस (uint answerToCurrentReward, uint nextChallenge) {
       आवश्यकता है (answerToCurrentReward ** 3 == currentChallenge); // यदि उत्तर गलत है तो जारी न रखें
       balanceOf [msg.sender] + = 1; // खिलाड़ी को पुरस्कृत करें
       currentChallenge = nextChallenge; // अगली चुनौती निर्धारित करें
   }

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

यह प्रक्रिया पहली बार 1997 में एडम बैक द्वारा प्रस्तावित की गई थी Hashcash और फिर 2008 में सतोशी नाकामोतो द्वारा प्रूफ ऑफ वर्क के रूप में बिटकॉइन में लागू किया गया।

यदि आप सिक्कों के यादृच्छिक जारी करने के एक रूप के रूप में हैशिंग को पसंद करते हैं, तो आप अभी भी अपनी स्वयं की Pirl आधारित मुद्रा बना सकते हैं, जिसमें कार्य जारी करने का प्रमाण हो:

बाइट्स 32 पब्लिक करचेलेंज; // सिक्का एक चुनौती से शुरू होता है
   uint सार्वजनिक timeOfLastProof; // पुरस्कार दिए जाने पर नज़र रखने के लिए चर
   uint सार्वजनिक कठिनाई = 10 ** 32; // कठिनाई काफी कम शुरू होती है

   फंक्शन प्रूफऑफवर्क (यूंट नॉनस) {
       बाइट्स 8 एन = बाइट्स 8 (शै 3 (नॉनस, करेंटचैलेज)); // इनपुट के आधार पर एक यादृच्छिक हैश उत्पन्न करें
       आवश्यकता (n> = बाइट्स 8 (कठिनाई)); // जांचें कि क्या यह कठिनाई के तहत है

       uint timeSinceLastProof = (अब - timeOfLastProof); // अंतिम इनाम दिए जाने के बाद से समय की गणना करें
       आवश्यकता (timeSinceLastProof> = 5 सेकंड); // पुरस्कार बहुत जल्दी नहीं दिए जा सकते
       balanceOf [msg.sender] + = timeSinceLastProof / 60 सेकंड; // विजेता को इनाम मिनट से बढ़ता है

       कठिनाई = कठिनाई * 10 मिनट / timeSinceLastProof + 1; // कठिनाई को समायोजित करता है

       timeOfLastProof = now; // काउंटर को रीसेट करें
       currentChallenge = sha3 (nonce, currentChallenge, block.blockhash (block.number - 1)); // अगले प्रमाण के रूप में उपयोग किया जाएगा एक हैश सहेजें
   }

इस पंक्ति को जोड़ने के लिए कंस्ट्रक्टर फ़ंक्शन (जिस अनुबंध के समान नाम है, जिसे पहले अपलोड में कहा जाता है) को बदलें, ताकि कठिनाई समायोजन पागल न हो जाए:

timeOfLastProof = now;

एक बार अनुबंध ऑनलाइन होने के बाद, फ़ंक्शन "कार्य का प्रमाण" चुनें, अपने पसंदीदा नंबर को गैर-फ़ील्ड पर जोड़ें और इसे निष्पादित करने का प्रयास करें। यदि पुष्टिकरण विंडो एक लाल चेतावनी देते हुए कहती है कि "डेटा निष्पादित नहीं किया जा सकता है" तो वापस जाएं और एक अन्य नंबर चुनें जब तक कि आप एक ऐसा न पाएं जो लेनदेन को आगे बढ़ने की अनुमति देता है: यह प्रक्रिया यादृच्छिक है। यदि आप पाते हैं कि आपको अंतिम इनाम दिए जाने के बाद से पारित किए गए प्रत्येक मिनट के लिए 1 टोकन दिया जाएगा, और फिर प्रति मिनट औसतन 10 मिनट का लक्ष्य करने के लिए चुनौती कठिनाई को समायोजित या नीचे किया जाएगा।

नंबर खोजने की कोशिश करने की यह प्रक्रिया आपको एक इनाम देगी जिसे खनन कहा जाता है: यदि कठिनाई बढ़ती है तो एक भाग्यशाली संख्या ढूंढना बहुत मुश्किल हो सकता है, लेकिन यह सत्यापित करना हमेशा आसान होगा कि आपने एक पाया।

बेहतर सिक्का

पूरा देश कोड
यदि आप सभी उन्नत विकल्प जोड़ते हैं, तो यह है कि अंतिम कोड कैसा दिखना चाहिए:

प्राग्म सॉलिडिटी ^ 0.4.16;

अनुबंध स्वामित्व {
   सार्वजनिक स्वामी को संबोधित करें;

   कार्य स्वामित्व () सार्वजनिक {
       मालिक = msg.sender;
   }

   संशोधक onlyOwner {
       आवश्यकता (msg.sender == स्वामी);
       _;
   }

   फ़ंक्शन ट्रांसफ़रऑनरशिप (पता newOwner) onlyOwner पब्लिक {
       मालिक = newOwner;
   }
}


प्राग्म सॉलिडिटी ^ 0.4.16;

अनुबंध स्वामित्व {
   सार्वजनिक स्वामी को संबोधित करें;

   कार्य स्वामित्व () सार्वजनिक {
       मालिक = msg.sender;
   }

   संशोधक onlyOwner {
       आवश्यकता (msg.sender == स्वामी);
       _;
   }

   फ़ंक्शन ट्रांसफ़रऑनरशिप (पता newOwner) onlyOwner पब्लिक {
       मालिक = newOwner;
   }
}

इंटरफ़ेस tokenRecipient {function getApproval (पता _from, uint256 _value, पता _token, बाइट्स _extraData) सार्वजनिक; }

अनुबंध टोकनेन 20 {
   // टोकन के सार्वजनिक चर
   स्ट्रिंग सार्वजनिक नाम;
   स्ट्रिंग सार्वजनिक प्रतीक;
   uint8 सार्वजनिक दशमलव = 18;
   // 18 दशमलव दृढ़ता से सुझाया गया डिफ़ॉल्ट है, इसे बदलने से बचें
   uint256 सार्वजनिक कुल मिलाकर;

   // यह सभी शेष के साथ एक सरणी बनाता है
   मैपिंग (पता => uint256) सार्वजनिक शेष राशि;
   मानचित्रण (पता => मानचित्रण (पता => uint256)) सार्वजनिक भत्ता;

   // यह ब्लॉकचैन पर एक सार्वजनिक कार्यक्रम बनाता है जो ग्राहकों को सूचित करेगा
   ईवेंट ट्रांसफ़र (एड्रेस इंडेक्स फ्रॉम, एड्रेस इंडेक्स टू, यूइंट256 वैल्यू);

   // यह जलाई गई राशि के बारे में ग्राहकों को सूचित करता है
   ईवेंट बर्न (पते से अनुक्रमित, uint256 मान);

   /**
    * कंस्ट्रक्टर फ़ंक्शन
    *
    * अनुबंध के निर्माता को प्रारंभिक आपूर्ति टोकन के साथ अनुबंध को प्रारंभिक करता है
    */
   फ़ंक्शन टोकनेन 20 (
       प्रारंभिक रूप से uint256,
       स्ट्रिंग टोकननाम,
       स्ट्रिंग टोकन
   ) जनता {
       TotalSupply = initialSupply * 10 ** uint256 (दशमलव); // दशमलव राशि के साथ कुल आपूर्ति का अद्यतन करें
       balanceOf [msg.sender] = कुल मिलाकर; // निर्माता को सभी शुरुआती टोकन दें
       name = tokenName; // प्रदर्शन उद्देश्यों के लिए नाम सेट करें
       प्रतीक = tokenSymbol; // प्रदर्शन उद्देश्यों के लिए प्रतीक सेट करें
   }

   /**
    * आंतरिक हस्तांतरण, केवल इस अनुबंध द्वारा बुलाया जा सकता है
    */
   फ़ंक्शन _transfer (पता _from, पता _to, uint _value) आंतरिक {
       // 0x0 पते पर स्थानांतरण रोकें। इसके बजाय बर्न () का उपयोग करें
       आवश्यकता (_to! = 0x0);
       // जांचें कि क्या प्रेषक के पास पर्याप्त है
       आवश्यकता है (balanceOf [_from]> = _value);
       // ओवरफ्लो की जांच करें
       आवश्यकता (balanceOf [_to] + _value> balanceOf [_to]);
       // इसे भविष्य में जोर देने के लिए बचाएं
       uint lastBalances = balanceOf [_from] + balanceOf [_to];
       // प्रेषक से घटाना
       balanceOf [_from] - = _value;
       // प्राप्तकर्ता के लिए समान जोड़ें
       balanceOf [_to] + = _value;
       स्थानांतरण (_from, _to, _value);
       // अपने कोड में बग ढूंढने के लिए स्थैतिक विश्लेषण का उपयोग करने के लिए Asserts का उपयोग किया जाता है। उन्हें कभी असफल नहीं होना चाहिए
       मुखर (balanceOf [_from] + balanceOf [_to] == पिछलेBalances);
   }

   /**
    * ट्रांसफर टोकन
    *
    * अपने खाते से `_value` को` _to` को भेजें
    *
    * @पारम _तो प्राप्तकर्ता का पता
    * @ अपरम_ भेजने की राशि
    */
   समारोह हस्तांतरण (पता _to, uint256 _value) सार्वजनिक {
       _transfer (msg.sender, _to, _value);
   }

   /**
    * अन्य पते से टोकन स्थानांतरित करें
    *
    * `_From` की ओर से` _to` को `_to` को भेजें
    *
    * @पारम _फ्रॉम प्रेषक का पता
    * @पारम _तो प्राप्तकर्ता का पता
    * @ अपरम_ भेजने की राशि
    */
   समारोह हस्तांतरण (पता _from, पता _to, uint256 _value) सार्वजनिक रिटर्न (बूल सफलता) {
       आवश्यकता (_value <= भत्ता [_from] [msg.sender]); // चेक भत्ता
       भत्ता [_from] [msg.sender] - = _value;
       _transfer (_from, _to, _value);
       सच लौटना;
   }

   /**
    * अन्य पते के लिए भत्ता निर्धारित करें
    *
    * `_Spender` को आपकी ओर से` _value` टोकन से अधिक खर्च करने की अनुमति नहीं देता है
    *
    * @param_spender खर्च करने के लिए अधिकृत पता
    * @ अपरम_ अधिक से अधिक राशि वे खर्च कर सकते हैं
    */
   फ़ंक्शन स्वीकृत (पते _spender, uint256 _value) सार्वजनिक
       रिटर्न (बूल की सफलता) {
       भत्ता [msg.sender] [_ spender] = _value;
       सच लौटना;
   }

   /**
    * अन्य पते के लिए भत्ता निर्धारित करें और सूचित करें
    *
    * `_Spender` को आपकी ओर से` _value` टोकन से अधिक खर्च करने की अनुमति नहीं है, और फिर इसके बारे में अनुबंध पिंग करें
    *
    * @param_spender खर्च करने के लिए अधिकृत पता
    * @ अपरम_ अधिक से अधिक राशि वे खर्च कर सकते हैं
    * @param_extraData अनुमोदित अनुबंध को भेजने के लिए कुछ अतिरिक्त जानकारी
    */
   फ़ंक्शन को स्वीकार करें और पता (पते _spender, uint256 _value, बाइट्स _extraData)
       जनता
       रिटर्न (बूल की सफलता) {
       tokenRecipient spender = tokenRecipient (_spender);
       अगर (अनुमोदन (_spender, _value)) {
           spender.receiveApproval (msg.sender, _value, this, _extraData);
           सच लौटना;
       }
   }

   /**
    * टोकन को नष्ट करें
    *
    * अपरिवर्तनीय रूप से सिस्टम से `_value` टोकन निकालें
    *
    * @ परम्_ जलाने के लिए धन की मात्रा कम करें
    */
   फ़ंक्शन बर्न (uint256 _value) सार्वजनिक रिटर्न (बूल सफलता) {
       आवश्यकता (शेष राशि] [msg.sender]> = _value); // जांचें कि क्या प्रेषक के पास पर्याप्त है
       balanceOf [msg.sender] - = _value; // प्रेषक से घटाना
       TotalSupply - = _value; // अपडेट कुल मिलाकर
       बर्न (msg.sender, _value);
       सच लौटना;
   }

   /**
    * अन्य खाते से टोकन को नष्ट करें
    *
    * `_From` की ओर से अपरिवर्तनीय रूप से सिस्टम से` _value` टोकन निकालें।
    *
    * @पारम _ प्रेषक का पता
    * @ परम्_ जलाने के लिए धन की मात्रा कम करें
    */
   समारोह burnFrom (पता _from, uint256 _value) सार्वजनिक रिटर्न (बूल सफलता) {
       आवश्यकता है (balanceOf [_from]> = _value); // जांचें कि क्या लक्षित शेष पर्याप्त है
       आवश्यकता (_value <= भत्ता [_from] [msg.sender]); // चेक भत्ता
       balanceOf [_from] - = _value; // लक्षित शेष राशि से घटाएं
       भत्ता [_from] [msg.sender] - = _value; // प्रेषक के भत्ते से घटाएं
       TotalSupply - = _value; // अपडेट करें कुल मिलाकर
       बर्न (_from, _value);
       सच लौटना;
   }
}

/******************************************/
/ * उन्नत टोकन सितारे यहां * /
/******************************************/

अनुबंध MyAdvancedToken का स्वामित्व है, टोकनेन 20 {

   uint256 पब्लिक सेलप्रीस;
   uint256 सार्वजनिक खरीदेंप्राइस;

   मैपिंग (पता => बूल) सार्वजनिक जमे हुए;

   / * यह ब्लॉकचेन पर एक सार्वजनिक कार्यक्रम बनाता है जो ग्राहकों को सूचित करेगा * /
   घटना फ्रोजनफंड्स (पता लक्ष्य, बूल फ्रोजन);

   / * अनुबंध के निर्माता को प्रारंभिक आपूर्ति टोकन के साथ अनुबंध को प्रारंभ करता है * /
   फ़ंक्शन MyAdvancedToken (
       प्रारंभिक रूप से uint256,
       स्ट्रिंग टोकननाम,
       स्ट्रिंग टोकन
   ) टोकनेन 20 (आरंभिक तौर पर, टोकननाम, टोकनस्मॉलबोल) सार्वजनिक {}

   / * आंतरिक स्थानांतरण, केवल इस अनुबंध द्वारा बुलाया जा सकता है * /
   फ़ंक्शन _transfer (पता _from, पता _to, uint _value) आंतरिक {
       आवश्यकता (_to! = 0x0); // 0x0 पते पर स्थानांतरण रोकें। इसके बजाय बर्न () का उपयोग करें
       आवश्यकता है (balanceOf [_from]> = _value); // जांचें कि क्या प्रेषक के पास पर्याप्त है
       आवश्यकता (balanceOf [_to] + _value> balanceOf [_to]); // ओवरफ्लो की जांच करें
       की आवश्यकता होती है (frozenAccount [_from]!); // जांचें कि क्या प्रेषक जमे हुए है
       की आवश्यकता होती है (frozenAccount [_to]!); // जांचें कि क्या प्राप्तकर्ता फ्रोजन है
       balanceOf [_from] - = _value; // प्रेषक से घटाना
       balanceOf [_to] + = _value; // प्राप्तकर्ता के लिए समान जोड़ें
       स्थानांतरण (_from, _to, _value);
   }

   /// @notice `mintedAmount` टोकन बनाएँ और इसे` target` पर भेजें
   टोकन प्राप्त करने के लिए /// @param लक्ष्य पता
   /// @param ने यह प्राप्त किया टोकन की मात्रा का मूल्यांकन किया
   फ़ंक्शन mintToken (पता लक्ष्य, uint256 mintedAmount) onlyOwner जनता {
       balanceOf [लक्ष्य] + = mintedAmount;
       TotalSupply + = mintedAmount;
       स्थानांतरण (0, यह, mintedAmount);
       स्थानांतरण (यह, लक्ष्य, mintedAmount);
   }

   /// @notice `फ्रीज? रोकें | टोकन भेजने और प्राप्त करने से `` लक्ष्य` 'की अनुमति दें
   /// @param लक्ष्य पता जमे हुए होने के लिए
   /// @param को फ्रीज करने के लिए या तो फ्रीज करें या नहीं
   फ़ंक्शन फ्रीज़एक्ाउंट (एड्रेस टारगेट, बूल फ़्रीज़) onlyOwner public {
       जमे हुए [लक्ष्य] = फ्रीज;
       फ्रोजनफंड (लक्ष्य, फ्रीज);
   }

   /// @notice उपयोगकर्ताओं को `newBuyPrice` के लिए टोकन खरीदने और` newSellPrice` Pirl के लिए टोकन बेचने की अनुमति दें
   /// @param newSellPrice उपयोगकर्ता को अनुबंध पर बेच सकते हैं
   /// @param newBuyPrice मूल्य उपयोगकर्ता अनुबंध से खरीद सकते हैं
   फ़ंक्शन सेटप्रिस (uint256 newSellPrice, uint256 newBuyPrice) केवल ओनर पब्लिक {{
       sellPrice = newSellPrice;
       buyPrice = newBuyPrice;
   }

   /// @notice Pirl भेजकर कांट्रेक्ट से टोकन खरीदें
   समारोह खरीद () देय जनता {
       uint राशि = msg.value / buyPrice; // राशि की गणना करता है
       _transfer (यह, msg.sender, राशि); // स्थानान्तरण करता है
   }

   /// @notice कॉन्ट्रैक्ट के लिए `राशि` टोकन बेचें
   /// @ अपरम टोकन राशि बेची जाएगी
   समारोह बेचने (uint256 राशि) सार्वजनिक {
       आवश्यकता होती है (यह। असंतुलन = = राशि * बिक्री); // अगर अनुबंध पर्याप्त खरीदने के लिए Pirl है जाँच करता है
       _transfer (msg.sender, यह, राशि); // स्थानान्तरण करता है
       msg.sender.transfer (राशि * sellPrice); // विक्रेता को Pirl भेजता है। पुनरावृत्ति के हमलों से बचने के लिए यह अंतिम करना महत्वपूर्ण है
   }
}

परिनियोजित

नीचे स्क्रॉल करें और आपको परिनियोजन के लिए अनुमानित लागत दिखाई देगी। यदि आप चाहते हैं कि आप एक छोटा शुल्क निर्धारित करने के लिए स्लाइडर को बदल सकते हैं, लेकिन यदि कीमत औसत बाजार दर से बहुत कम है, तो आपके लेनदेन को लेने में अधिक समय लग सकता है। Deploy पर क्लिक करें और अपना पासवर्ड टाइप करें। कुछ सेकंड के बाद आपको डैशबोर्ड पर पुनर्निर्देशित किया जाएगा और नवीनतम लेन-देन के तहत आपको "अनुबंध बनाते हुए" एक पंक्ति दिखाई देगी। किसी को अपने लेनदेन को लेने के लिए कुछ सेकंड के लिए प्रतीक्षा करें और फिर आप एक धीमी नीली आयत देखेंगे, जिसमें यह दिखाया जाएगा कि कितने अन्य नोड्स ने आपके लेनदेन को देखा है और उनकी पुष्टि की है। आपके पास जितने अधिक पुष्टिकरण होंगे, आपके पास उतने अधिक आश्वासन होंगे कि आपका कोड तैनात किया गया है।

उस लिंक पर क्लिक करें जो व्यवस्थापक पृष्ठ कहता है और आपको दुनिया का सबसे सरल केंद्रीय बैंक डैशबोर्ड लिया जाएगा, जहां आप अपनी नई बनाई गई मुद्रा के साथ कुछ भी कर सकते हैं।

अनुबंध से पढ़ें के तहत बाईं ओर आपके पास सभी विकल्प और कार्य हैं, जिनका उपयोग आप अनुबंध से जानकारी पढ़ने के लिए कर सकते हैं, मुफ्त में। यदि आपके टोकन में कोई स्वामी है, तो वह यहां अपना पता प्रदर्शित करेगा। उस पते को कॉपी करें और उसे शेष राशि में पेस्ट करें और यह आपको किसी भी खाते का शेष दिखाएगा (शेष राशि स्वचालित रूप से किसी भी खाता पृष्ठ पर दिखाया गया है जिसमें टोकन हैं)।

दाईं ओर, राइट टू कॉन्ट्रैक्ट के तहत आप उन सभी कार्यों को देखेंगे जिन्हें आप किसी भी तरह से ब्लॉकचेन को बदलने या बदलने के लिए उपयोग कर सकते हैं। इनमें गैस खर्च होगी। यदि आपने एक अनुबंध बनाया है जो आपको नए सिक्कों का टकसाल बनाने की अनुमति देता है, तो आपके पास "मिंट टोकन" नामक एक फ़ंक्शन होना चाहिए। इसका चयन करें।

उस पते का चयन करें जहां उन नई मुद्राओं का निर्माण किया जाएगा और फिर राशि (यदि आपके पास दशमलव 2 पर सेट है, तो राशि के बाद 2 शून्य जोड़ें, सही मात्रा बनाने के लिए)। मालिक के रूप में सेट किए गए खाते का चयन करने से छूट पर, शून्य पर Pirl राशि छोड़ दें और फिर निष्पादित करें दबाएं।

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

अपने सिक्के का उपयोग करना

एक बार जब आप अपने टोकन को तैनात कर लेते हैं, तो उन्हें आपके द्वारा देखे गए टोकन की सूची में जोड़ दिया जाएगा, और आपके खाते में कुल शेष राशि दिखाई जाएगी। टोकन भेजने के लिए, बस Send टैब पर जाएं और एक खाता चुनें जिसमें टोकन हों। टोकन को केवल Pirl के तहत सूचीबद्ध किया जाएगा। उन्हें चुनें और फिर आपके द्वारा भेजे जाने वाले टोकन की मात्रा लिखें।

यदि आप किसी और का टोकन जोड़ना चाहते हैं, तो बस कॉन्ट्रैक्ट टैब पर जाएं और वॉच टोकन पर क्लिक करें। उदाहरण के लिए, अपनी वॉच लिस्ट में Pirl Vortex टोकन जोड़ने के लिए, बस पता 0x0489A975393A1cD0330740040141D702C35180cb जोड़ें

अब क्या?

आपने अभी-अभी सीखा कि आप किस तरह से टोकन जारी करने के लिए Pirl का उपयोग कर सकते हैं, जो कि आप जो भी चाहते हैं उसका प्रतिनिधित्व कर सकते हैं। लेकिन आप टोकन के साथ क्या कर सकते हैं? उदाहरण के लिए, आप किसी कंपनी में शेयर का प्रतिनिधित्व करने के लिए टोकन का उपयोग कर सकते हैं या मुद्रास्फीति को नियंत्रित करने के लिए नए सिक्के जारी करने के लिए मतदान करने के लिए एक केंद्रीय समिति का उपयोग कर सकते हैं। तुम भी एक भीड़ के माध्यम से, एक कारण के लिए पैसे जुटाने के लिए उनका उपयोग कर सकते हैं। आगे क्या बनाएंगे?

संदर्भ सामग्री: ethereum.org


हमारे समाचार पत्र के सदस्य बनें

अपडेट प्राप्त करें और सबसे अच्छे से सीखें

अधिक अन्वेषण करने के लिए

Pirl और Vseed चिकित्सा व्यवसाय में क्रांति लाते हैं

Pirl और Vseed ने चिकित्सा व्यवसाय में क्रांति ला दी Pirl संयुक्त उद्यम Vseed के साथ दीर्घकालिक साझेदारी की घोषणा करने के लिए उत्साहित है। Veded का पूरा उपयोग करेंगे

क्या विदेशी मुद्रा बाजार ब्लॉकचेन प्रौद्योगिकी को गले लगाएगा?

क्या विदेशी मुद्रा बाजार ब्लॉकचेन प्रौद्योगिकी को गले लगाएगा? ब्लॉकचैन को आमतौर पर क्रिप्टोकरेंसी के हस्तांतरण के लिए एक तरह की नींव के रूप में माना जाता है, और ऐसा इसलिए है

hi_INहिन्दी
en_USEnglish fr_FRFrançais nl_NLNederlands tr_TRTürkçe es_ESEspañol pt_PTPortuguês ru_RUРусский ko_KR한국어 zh_CN简体中文 hi_INहिन्दी