कौन भाग ले सकता है?
+ 18 वर्ष से अधिक आयु का कोई भी व्यक्ति, जो कम से कम एक गैर-अंग्रेजी भाषा का मूल वक्ता और अंग्रेजी में कुशल हो। +क्या मुझे अनुवादक होने की आवश्यकता है?
+ नहीं। आपको केवल द्विभाषी होना है और मानव अनुवाद का सुझाव देना है (मशीनी अनुवाद का उपयोग निषिद्ध है!) अपनी क्षमता के अनुसार, किसी पेशेवर अनुभव की आवश्यकता नहीं है। +मुझे कितना समय देना होगा?
+ जितना आप चाहें। पुरस्कारों के लिए पात्र होने की न्यूनतम सीमा 1,000 अनूदित शब्द है, जिसे पूरा करने में लगभग 2 घंटे लगने चाहिए, जबकि शीर्ष पुरस्कारों के लिए प्रतिस्पर्धा करने के लिए अधिक समय की प्रतिबद्धता की आवश्यकता होगी। +क्या मुझे एथेरियम से परिचित होने की आवश्यकता है?
+ नहीं। हालांकि एथेरियम से परिचित होना आपकी उत्पादकता और गुणवत्ता में मदद कर सकता है, ट्रांसलेटाथॉन एक सीखने का अनुभव भी है, और सभी को भाग लेने के दौरान एथेरियम के बारे में अधिक जानने और शामिल होने के लिए आमंत्रित किया जाता है। +`nonce``
+
+`` - _ओपनिंग टैग, जिसमें एक कोड स्निपेट होता है_`
+
+nonce - _गैर-अनुवाद योग्य टेक्स्ट_
+
+`` - _क्लोजिंग टैग_
+
+
+
+स्रोत पाठ में संक्षिप्त टैग्स भी होते हैं, जो केवल संख्याएँ शामिल करते हैं, जिससे उनकी कार्यप्रणाली तुरंत स्पष्ट नहीं होती। इन टैग्स पर होवर करने पर आप देख सकते हैं कि वे ठीक से कौन सा कार्य करते हैं।
+
+नीचे दिए गए उदाहरण में, आप देख सकते हैं कि `<0>` टैग पर होवर करने से पता चलता है कि यह `` का प्रतिनिधित्व करता है और इसमें एक कोड स्निपेट है, इसलिए इन टैग्स के अंदर की सामग्री का अनुवाद नहीं किया जाना चाहिए।
+
+
+
+## संक्षिप्त बनाम पूर्ण रूप/संक्षिप्ताक्षर {#short-vs-full-forms}
+
+वेबसाइट पर बहुत सारे संक्षिप्ताक्षर उपयोग किए जाते हैं, जैसे, डैप्स, NFT, DAO, DeFi, आदि। ये संक्षिप्त रूप आमतौर पर अंग्रेजी में उपयोग किए जाते हैं और वेबसाइट पर आने वाले अधिकांश लोग इन्हें जानते हैं।
+
+चूंकि इनका आमतौर पर अन्य भाषाओं में स्थापित अनुवाद नहीं होता, इसलिए इन और समान शब्दों को संभालने का सबसे अच्छा तरीका है कि पूर्ण रूप का वर्णनात्मक अनुवाद प्रदान करें और इंग्लिश संक्षिप्त रूप को ब्रैकेट्स में जोड़ें।
+
+इन संक्षिप्त रूपों का अनुवाद न करें, क्योंकि अधिकांश लोग इनके बारे में परिचित नहीं होंगे, और स्थानीयकृत संस्करण अधिकांश आगंतुकों के लिए समझ में नहीं आएंगे।
+
+डैप्स का अनुवाद कैसे करें इसका उदाहरण:
+
+- विकेंद्रीकृत अनुप्रयोग (डैप्स) → _अनुवादित पूर्ण रूप (कोष्ठक में अंग्रेजी संक्षिप्ताक्षर)_
+
+## स्थापित अनुवाद के बिना शब्द {#terms-without-established-translations}
+
+कुछ शब्दों के अन्य भाषाओं में स्थापित अनुवाद नहीं होते, और वे मूल अंग्रेजी शब्द से ही व्यापक रूप से ज्ञात होते हैं। ऐसे शब्द अक्सर नए अवधारणाओं को शामिल करते हैं, जैसे कि प्रूफ-ऑफ-वर्क, प्रूफ-ऑफ-स्टेक, बीकन चेन, स्टेकिंग, आदि।
+
+हालांकि इन शब्दों का अनुवाद अजीब लग सकता है, क्योंकि अंग्रेजी संस्करण अन्य भाषाओं में भी सामान्यतः उपयोग किया जाता है, लेकिन इनका अनुवाद करना अत्यधिक अनुशंसित है।
+
+उनका अनुवाद करते समय, रचनात्मक बनने, वर्णनात्मक अनुवादों का उपयोग करने, या बस उनका शाब्दिक अनुवाद करने के लिए स्वतंत्र महसूस करें।
+
+**अधिकांश शब्दों का अनुवाद किए जाने का कारण, कुछ को अंग्रेजी में छोड़ने के बजाय, यह तथ्य है कि यह नई शब्दावली भविष्य में और अधिक व्यापक हो जाएगी, क्योंकि अधिक लोग Ethereum और संबंधित तकनीकों का उपयोग करना शुरू कर देंगे।** यदि हम दुनिया भर से अधिक लोगों को इस क्षेत्र में शामिल करना चाहते हैं, तो हमें जितनी संभव हो उतनी भाषाओं में समझने योग्य शब्दावली प्रदान करने की आवश्यकता है, भले ही हमें इसे स्वयं बनाना पड़े।\*\*
+
+## बटन और CTA {#buttons-and-ctas}
+
+The website contains numerous buttons, which should be translated differently than other content.
+
+बटन टेक्स्ट को संदर्भ स्क्रीनशॉट्स देखकर पहचाना जा सकता है, जो अधिकांश स्ट्रिंग्स से जुड़े होते हैं, या संपादक में संदर्भ जांचकर, जिसमें शब्द ‘’button’’ शामिल होता है।
+
+बटनों के अनुवाद जितना संभव हो सके उतना संक्षिप्त होना चाहिए, ताकि फॉर्मेटिंग में असंगतियां न हों। इसके अतिरिक्त, बटन अनुवाद आज्ञासूचक होने चाहिए, यानी, एक आदेश या अनुरोध प्रस्तुत करें।
+
+
+
+## समावेशिता के लिए अनुवाद {#translating-for-inclusivity}
+
+Ethereum.org के आगंतुक पूरी दुनिया से और विभिन्न पृष्ठभूमियों से आते हैं। वेबसाइट की भाषा इसलिए तटस्थ, सभी के लिए स्वागतयोग्य और असंलग्न होनी चाहिए।
+
+वेबसाइट की भाषा इसलिए तटस्थ, सभी के लिए स्वागतयोग्य और विशिष्टता से रहित होनी चाहिए। यह औपचारिक संबोधन का उपयोग करके और अनुवादों में किसी भी लिंग-विशिष्ट शब्दों से बचकर आसानी से प्राप्त किया जा सकता है।
+
+समावेशिता का एक और रूप वैश्विक दर्शकों के लिए अनुवाद करने का प्रयास करना है, जो किसी देश, जाति या क्षेत्र के लिए विशिष्ट नहीं है।
+
+अंत में, भाषा सभी दर्शकों और उम्र के लिए उपयुक्त होनी चाहिए।
+
+## भाषा-विशिष्ट अनुवाद {#language-specific-translations}
+
+अनुवाद करते समय, यह महत्वपूर्ण है कि आप अपनी भाषा में उपयोग की जाने वाली व्याकरण नियमों, परंपराओं और फॉर्मेटिंग का पालन करें, स्रोत से कॉपी करने के बजाय। स्रोत पाठ अंग्रेजी व्याकरण नियमों और परंपराओं का पालन करता है, जो कई अन्य भाषाओं पर लागू नहीं होते।
+
+आपको अपनी भाषा के नियमों के बारे में जानकारी होनी चाहिए और अनुवाद उसी के अनुसार करना चाहिए। अगर आपको मदद की ज़रूरत हो, तो हमसे संपर्क करें और हम आपको आपके भाषा में इन तत्वों का उपयोग कैसे किया जाए, इस पर कुछ संसाधन खोजने में मदद करेंगे।
+
+विशेष रूप से ध्यान देने योग्य कुछ उदाहरण:
+
+### विराम चिह्न, स्वरूपण {#punctuation-and-formatting}
+
+**कैपिटलाइज़ेशन**
+
+- विभिन्न भाषाओं में बड़े अक्षरों का उपयोग करने में बड़े अंतर होते हैं।
+- अंग्रेजी में, शीर्षकों और नामों, महीनों और दिनों, भाषाओं के नाम, छुट्टियों, आदि में सभी शब्दों को बड़े अक्षरों में लिखना सामान्य है। कई अन्य भाषाओं में, यह व्याकरणिक रूप से गलत होता है, क्योंकि उनके बड़े अक्षर उपयोग के नियम अलग होते हैं।
+- कुछ भाषाओं में व्यक्तिगत सर्वनामों, संज्ञाओं, और कुछ विशेषणों को बड़े अक्षरों में लिखने के नियम होते हैं, जबकि अंग्रेजी में इन्हें बड़े अक्षरों में नहीं लिखा जाता।
+
+**स्पेसिंग**
+
+- वर्तनी नियम प्रत्येक भाषा के लिए स्पेस के उपयोग को परिभाषित करते हैं। चूंकि रिक्त स्थान हर जगह उपयोग किए जाते हैं, ये नियम सबसे अलग होते हैं, और रिक्त स्थान सबसे अधिक गलत अनुवादित तत्व होते हैं।
+- अंग्रेजी और अन्य भाषाओं के बीच रिक्त स्थान के कुछ सामान्य अंतर:
+ - माप की इकाइयों और मुद्राओं से पहले स्पेस (उदाहरण के लिए, USD, EUR, kB, MB)
+ - डिग्री चिह्नों से पहले स्पेस (उदाहरण के लिए, °C, ℉)
+ - कुछ विराम चिह्नों से पहले स्पेस, विशेष रूप से एलिप्सिस (…)
+ - स्लैश (/) से पहले और बाद में स्पेस
+
+**सूचियाँ**
+
+- हर भाषा के पास सूचियाँ लिखने के लिए विविध और जटिल नियमों का सेट होता है। ये अंग्रेजी से काफी भिन्न हो सकते हैं।
+- कुछ भाषाओं में, प्रत्येक नई पंक्ति के पहले शब्द को बड़े अक्षरों में लिखा जाना चाहिए, जबकि अन्य भाषाओं में नई पंक्तियाँ छोटे अक्षरों से शुरू की जाती हैं। कई भाषाओं में सूचियों में बड़े अक्षरों के उपयोग के विभिन्न नियम होते हैं, जो प्रत्येक पंक्ति की लंबाई पर निर्भर करते हैं।
+- लाइन आइटम्स की विराम चिह्न के मामले में भी यही बात लागू होती है। सूचियों में अंतिम विराम चिह्न भाषा के आधार पर पूर्ण विराम (.), अल्पविराम (,), या अर्धविराम (;) हो सकता है।
+
+**उद्धरण चिह्न**
+
+- भाषाएँ कई विभिन्न प्रकार के उद्धरण चिह्नों का उपयोग करती हैं। स्रोत से अंग्रेजी उद्धरण चिह्नों को बस कॉपी करना अक्सर गलत होता है।
+- कुछ सबसे सामान्य प्रकार के उद्धरण चिह्नों में शामिल हैं:
+ - „उदाहरण टेक्स्ट“
+ - ‚उदाहरण टेक्स्ट’
+ - »उदाहरण टेक्स्ट«
+ - “उदाहरण टेक्स्ट”
+ - ‘उदाहरण टेक्स्ट’
+ - «उदाहरण टेक्स्ट»
+
+**हाइफ़न और डैश**
+
+- अंग्रेजी में, एक हाइफ़न (-) का उपयोग शब्दों या किसी शब्द के विभिन्न भागों को जोड़ने के लिए किया जाता है, जबकि एक डैश (–) का उपयोग एक रेंज या विराम को इंगित करने के लिए किया जाता है।
+- कई भाषाओं में हाइफ़न और डैश का उपयोग करने के लिए अलग-अलग नियम हैं जिनका पालन किया जाना चाहिए।
+
+### प्रारूप {#formats}
+
+**संख्याएँ**
+
+- विभिन्न भाषाओं में संख्याएँ लिखने में मुख्य अंतर दशमलव और हजार के लिए उपयोग किया जाने वाला सेपरेटर है। हजार के लिए, यह एक पूर्ण विराम, अल्पविराम या स्पेस हो सकता है। इसी तरह, कुछ भाषाएं दशमलव बिंदु का उपयोग करती हैं, जबकि अन्य दशमलव अल्पविराम का उपयोग करती हैं।
+ - बड़ी संख्याओं के कुछ उदाहरण:
+ - अंग्रेजी – **1,000.50**
+ - स्पेनिश – **1.000,50**
+ - फ्रेंच – **1 000,50**
+- संख्याओं का अनुवाद करते समय एक और महत्वपूर्ण विचार प्रतिशत चिह्न है। इसे अलग-अलग तरीकों से लिखा जा सकता है: **100%**, **100 %** या **%100**।
+- अंत में, भाषा के आधार पर ऋणात्मक संख्याओं को अलग-अलग तरीके से प्रदर्शित किया जा सकता है: -100, 100-, (100) या [100]।
+
+**तिथियाँ**
+
+- तिथियों का अनुवाद करते समय, भाषा के आधार पर कई विचार और अंतर होते हैं। इनमें तिथि प्रारूप, सेपरेटर, कैपिटलाइज़ेशन और लीडिंग ज़ीरो शामिल हैं। पूर्ण-लंबाई और संख्यात्मक तिथियों के बीच भी अंतर हैं।
+ - विभिन्न तिथि प्रारूपों के कुछ उदाहरण:
+ - अंग्रेजी यूके (dd/mm/yyyy) – 1st January, 2022
+ - अंग्रेजी यूएस (mm/dd/yyyy) – January 1st, 2022
+ - चीनी (yyyy-mm-dd) – 2022 年 1 月 1 日
+ - फ्रेंच (dd/mm/yyyy) – 1er janvier 2022
+ - इतालवी (dd/mm/yyyy) – 1º gennaio 2022
+ - जर्मन (dd/mm/yyyy) – 1. Januar 2022
+
+**मुद्राएँ**
+
+- मुद्राओं का अनुवाद चुनौतीपूर्ण हो सकता है, क्योंकि विभिन्न प्रारूप, परंपराएँ और रूपांतरण होते हैं। एक सामान्य नियम के रूप में, कृपया मुद्राओं को स्रोत के समान ही रखें। आप पाठक की सुविधा के लिए ब्रैकेट्स में अपनी स्थानीय मुद्रा और रूपांतरण जोड़ सकते हैं।
+- विभिन्न भाषाओं में मुद्राएँ लिखने में मुख्य अंतरों में प्रतीक प्लेसमेंट, दशमलव अल्पविराम बनाम दशमलव बिंदु, स्पेसिंग और संक्षिप्ताक्षर बनाम प्रतीक शामिल हैं।
+ - प्रतीक प्लेसमेंट: $100 या 100$
+ - दशमलव अल्पविराम बनाम दशमलव बिंदु: 100,50$ या 100.50$
+ - स्पेसिंग: 100$ या 100 $
+ - संक्षिप्ताक्षर बनाम प्रतीक: 100 $ या 100 USD
+
+**माप की इकाइयाँ**
+
+- एक सामान्य नियम के रूप में, कृपया माप की इकाइयों को स्रोत के अनुसार रखें। अगर आपके देश में अलग सिस्टम का उपयोग होता है, तो आप ब्रैकेट्स में रूपांतरण शामिल कर सकते हैं।
+- माप की इकाइयों की स्थानीयकरण के अलावा, यह भी महत्वपूर्ण है कि भाषाएँ इन इकाइयों को कैसे दृष्टिगत करती हैं, इसके बीच के अंतर को ध्यान में रखें। मुख्य अंतर संख्या और इकाई के बीच रिक्त स्थान में होता है, जो भाषा के आधार पर भिन्न हो सकता है। इसके उदाहरणों में 100kB बनाम 100 kB या 50ºF बनाम 50 ºF शामिल हैं।
+
+## निष्कर्ष {#conclusion}
+
+ethereum.org का अनुवाद करना Ethereum के विभिन्न पहलुओं के बारे में जानने का एक शानदार अवसर है।
+
+अनुवाद करते समय, जल्दी करने की कोशिश न करें। आराम से काम करें और मज़ा लें!
+
+अनुवाद कार्यक्रम में शामिल होने और वेबसाइट को व्यापक दर्शकों के लिए सुलभ बनाने में हमारी मदद करने के लिए धन्यवाद। एथेरियम समुदाय वैश्विक है, और हमें खुशी है कि आप इसका हिस्सा हैं!
diff --git a/public/content/translations/hi/dao/index.md b/public/content/translations/hi/dao/index.md
index 7b6344f3c04..6767c0e960a 100644
--- a/public/content/translations/hi/dao/index.md
+++ b/public/content/translations/hi/dao/index.md
@@ -1,24 +1,25 @@
---
-title: विकेन्द्रीकृत स्वायत्त संगठन (DAO)
-description: इथेरियम पर DAO का अवलोकन
+title: "डीएओ क्या है?"
+metaTitle: "डीएओ क्या है? | विकेंद्रीकृत स्वायत्त संगठन"
+description: "इथेरियम पर DAO का अवलोकन"
lang: hi
template: use-cases
emoji: ":handshake:"
sidebarDepth: 2
image: /images/use-cases/dao-2.png
-alt: किसी प्रस्ताव पर मतदान करने वाले DAO का प्रतिनिधित्व।
-summaryPoint1: केंद्रीकृत नेतृत्व के बिना सदस्य के स्वामित्व वाले समुदाय।
-summaryPoint2: इंटरनेट पर अजनबियों के साथ सहयोग करने का एक सुरक्षित तरीका।
-summaryPoint3: किसी विशिष्ट उद्देश्य के लिए धन जमा करने के लिए एक सुरक्षित स्थान।
+alt: "किसी प्रस्ताव पर मतदान करने वाले DAO का प्रतिनिधित्व।"
+summaryPoint1: "केंद्रीकृत नेतृत्व के बिना सदस्य के स्वामित्व वाले समुदाय।"
+summaryPoint2: "इंटरनेट पर अजनबियों के साथ सहयोग करने का एक सुरक्षित तरीका।"
+summaryPoint3: "किसी विशिष्ट उद्देश्य के लिए धन जमा करने के लिए एक सुरक्षित स्थान।"
---
## DAO क्या होते हैं? {#what-are-daos}
-DAO एक सामूहिक स्वामित्व वाला, ब्लॉकचेन-शासित संगठन है जो एक साझा मिशन की दिशा में काम करता है।
+डीएओ एक सामूहिक स्वामित्व वाला संगठन है जो एक साझा मिशन की दिशा में काम कर रहा है।
DAO हमें धन या संचालन के प्रबंधन के लिए किसी परोपकारी नेता पर भरोसा किए बिना दुनिया भर में समान विचारधारा वाले लोगों के साथ काम करने की अनुमति देते हैं। इनमें ऐसा कोई CEO नहीं होता जो मनमर्जी से पैसा खर्च कर सके या CFO जो बही-खातों में हेर-फेर कर सके। इसके बजाय, कोड में अंतर्निहित ब्लॉकचेन-आधारित नियम परिभाषित करते हैं कि संगठन कैसे काम करता है और धन कैसे खर्च किया जाता है।
-उनके पास बिल्ट-इन तिजोरी होते हैं जिन्हें समूह की स्वीकृति के बिना किसी को भी एक्सेस करने का अधिकार नहीं है। निर्णय प्रस्तावों और मतदान द्वारा शासित होते हैं ताकि यह सुनिश्चित किया जा सके कि संगठन में सभी के पास एक आवाज हो, और सब कुछ पारदर्शी रूप से ऑन-चेन होता है।
+उनके पास बिल्ट-इन तिजोरी होते हैं जिन्हें समूह की स्वीकृति के बिना किसी को भी एक्सेस करने का अधिकार नहीं है। निर्णय प्रस्तावों और मतदान द्वारा शासित होते हैं ताकि यह सुनिश्चित किया जा सके कि संगठन में सभी के पास अपनी बात रखने का अधिकार हो और सब कुछ पारदर्शी रूप से [ऑनचेन](/glossary/#onchain) हो।
## हमें DAO की जरूरत क्यों है? {#why-dao}
@@ -28,138 +29,141 @@ DAO हमें धन या संचालन के प्रबंधन
### एक तुलना {#dao-comparison}
-| डीएओ | एक पारंपरिक संगठन |
-| -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
-| आम तौर पर फ्लैट, और पूरी तरह से लोकतांत्रिक। | आमतौर पर पदानुक्रमित। |
-| किसी भी परिवर्तन को लागू करने के लिए सदस्यों द्वारा मतदान आवश्यक है। | संरचना के आधार पर, एक एकल पार्टी से परिवर्तन की मांग की जा सकती है, या मतदान की पेशकश की जा सकती है। |
-| वोटों का मिलान किया जाता है, और परिणाम बिना किसी विश्वसनीय मध्यस्थ के स्वचालित रूप से लागू किया जाता है। | यदि मतदान की अनुमति है, तो वोटों की आंतरिक रूप से गणना की जाती है, और मतदान के परिणाम को मैन्युअल रूप से नियंत्रित किया जाता है। |
+| डीएओ | एक पारंपरिक संगठन |
+| --------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| आम तौर पर फ्लैट, और पूरी तरह से लोकतांत्रिक। | आमतौर पर पदानुक्रमित। |
+| किसी भी परिवर्तन को लागू करने के लिए सदस्यों द्वारा मतदान आवश्यक है। | संरचना के आधार पर, एक एकल पार्टी से परिवर्तन की मांग की जा सकती है, या मतदान की पेशकश की जा सकती है। |
+| वोटों का मिलान किया जाता है, और परिणाम बिना किसी विश्वसनीय मध्यस्थ के स्वचालित रूप से लागू किया जाता है। | यदि मतदान की अनुमति है, तो वोटों की आंतरिक रूप से गणना की जाती है, और मतदान के परिणाम को मैन्युअल रूप से नियंत्रित किया जाता है। |
| दी जाने वाली सेवाओं को विकेन्द्रीकृत तरीके से स्वचालित रूप से नियंत्रित किया जाता है (उदाहरण के लिए परोपकारी धन का वितरण)। | मानव संचालन की आवश्यकता है, या केंद्र द्वारा नियंत्रित स्वचालन, हेरफेर की संभावना है। |
-| सभी गतिविधियां पारदर्शी और पूरी तरह सार्वजनिक हैं। | गतिविधि आम तौर पर निजी होती है, और जनता तक सीमित मात्रा मे होती है। |
+| सभी गतिविधियां पारदर्शी और पूरी तरह सार्वजनिक हैं। | गतिविधि आम तौर पर निजी होती है, और जनता तक सीमित मात्रा मे होती है। |
-### DAO के उदाहरण {#dao-examples}
+### डीएओ के उदाहरण {#dao-examples}
इसे और अधिक समझने में मदद करने के लिए, यहां कुछ उदाहरण दिए गए हैं कि आप DAO का उपयोग कैसे कर सकते हैं:
-- दान – आप दुनिया में किसी से भी दान स्वीकार कर सकते हैं और वोट कर सकते हैं कि किन कारणों से फंड करना है।
-- सामूहिक स्वामित्व – आप भौतिक या डिजिटल संपत्ति खरीद सकते हैं और सदस्य उनका उपयोग कैसे करें, इस पर मतदान कर सकते हैं।
-- उद्यम और अनुदान – आप एक उद्यम निधि बना सकते हैं जो निवेश पूंजी को जमा करती है और उपक्रमों पर वोट देती है। चुकाए गए धन को बाद में DAO-सदस्यों के बीच पुनर्वितरित किया जा सकता है।
+- **एक चैरिटी** – आप दुनिया में किसी से भी दान स्वीकार कर सकते हैं और वोट कर सकते हैं कि किन कारणों से फंड करना है।
+- **सामूहिक स्वामित्व** – आप भौतिक या डिजिटल संपत्ति खरीद सकते हैं और सदस्य उनका उपयोग कैसे करें, इस पर मतदान कर सकते हैं।
+- **उद्यम और अनुदान** – आप एक उद्यम निधि बना सकते हैं जो निवेश पूंजी को जमा करती है और समर्थन करने के लिए उद्यमों पर वोट देती है। चुकाए गए धन को बाद में DAO-सदस्यों के बीच पुनर्वितरित किया जा सकता है।
+
+
- स्मार्ट अनुबंध के बारे में अधिक जानकारी
-
-
-## इथेरियम और DAO {#ethereum-and-daos}
+## एथेरियम और डीएओ {#ethereum-and-daos}
-इथेरियम कई कारणों से DAO के लिए एकदम सही आधार है:
+इथेरियम कई कारणों से डीएओ के लिए एकदम सटीक आधार है:
-- इथेरियम की अपनी सर्वसम्मति नेटवर्क पर भरोसा करने के लिए संगठनों के लिए पर्याप्त रूप से वितरित और स्थापित की गई है।
+- एथेरियम की अपनी सहमति विकेंद्रीकृत है और संगठनों हेतु नेटवर्क पर भरोसा करने के लिए पर्याप्त रूप से स्थापित है।
- स्मार्ट अनुबंध कोड को एक बार लाइव होने के बाद संशोधित नहीं किया जा सकता, यहां तक कि इसके मालिक भी नहीं कर सकते। यह DAO को उन नियमों के अनुसार चलने की अनुमति देता है जिनके साथ इसे प्रोग्राम किया गया था।
- स्मार्ट अनुबंध धन भेज/प्राप्त कर सकते हैं। इसके बिना आपको समूह निधियों का प्रबंधन करने के लिए एक विश्वसनीय मध्यस्थ की आवश्यकता होगी।
- इथेरियम समुदाय प्रतिस्पर्धी की तुलना में अधिक सहयोगी साबित हुआ है, जिससे सर्वोत्तम प्रथाओं और समर्थन प्रणालियों को जल्दी से उभरने की अनुमति मिलती है।
-## DAO शासन {#dao-governance}
+## डीएओ शासन {#dao-governance}
-DAO को संचालित करते समय कई बातों पर विचार किया जाता है, जैसे कि मतदान और प्रस्ताव कैसे काम करते हैं।
+डीएओ को संचालित करते समय कई बातों पर विचार किया जाता है, जैसे कि मतदान और प्रस्ताव कैसे काम करते हैं।
-### प्रतिनिधान {#governance-delegation}
+### प्रत्यायोजन {#governance-delegation}
-प्रतिनिधान लोकतंत्र के DAO संस्करण की तरह है। टोकन धारक उन उपयोगकर्ताओं को वोट देते हैं जो खुद को नामांकित करते हैं और प्रोटोकॉल को चलाने और सूचित रहने के लिए प्रतिबद्ध होते हैं।
+प्रतिनिधान, प्रतिनिधिक लोकतंत्र के डीएओ संस्करण की तरह ही होता है। टोकन धारक उन उपयोगकर्ताओं को वोट देते हैं जो खुद को नामांकित करते हैं और प्रोटोकॉल को चलाने और सूचित रहने के लिए प्रतिबद्ध होते हैं।
#### एक प्रसिद्ध उदाहरण {#governance-example}
-[ENS](https://claim.ens.domains/delegate-ranking) – ENS धारक अपने वोट समुदाय के सदस्यों को उनका प्रतिनिधित्व करने के लिए सौंप सकते हैं।
+[ENS](https://claim.ens.domains/delegate-ranking) – ENS धारक उनका प्रतिनिधित्व करने के लिए अपने वोटों को सक्रिय समुदाय के सदस्यों को सौंप सकते हैं।
### स्वचालित लेनदेन शासन {#governance-example}
-कई DAO में, यदि सदस्यों का एक कोरम सकारात्मक वोट करता है तो लेन-देन स्वचालित रूप से निष्पादित हो जाएगा।
+कई डीएओ में, यदि सदस्यों का एक कोरम सकारात्मक वोट करता है तो लेन-देन स्वचालित रूप से निष्पादित हो जाएगा।
#### एक प्रसिद्ध उदाहरण {#governance-example}
-[Nouns](https://nouns.wtf) – Nouns DAO में, एक लेन-देन स्वचालित रूप से निष्पादित किया जाता है यदि वोटों का एक कोरम पूरा हो जाता है और बहुमत के वोट सकारात्मक होते हैं, जब तक कि यह संस्थापकों द्वारा वीटो नहीं किया जाता है।
+[Nouns](https://nouns.wtf) – Nouns डीएओ में, यदि वोटों का कोरम पूरा हो जाता है और बहुमत सकारात्मक वोट देता है, तो एक लेनदेन स्वचालित रूप से निष्पादित हो जाता है, जब तक कि इसे संस्थापकों द्वारा वीटो नहीं किया जाता है।
### मल्टीसिग शासन {#governance-example}
-जबकि DAO में हजारों वोटिंग सदस्य हो सकते हैं, फंड 5-20 सक्रिय सामुदायिक सदस्यों द्वारा साझा किए गए वॉलेट में रह सकते हैं, जो भरोसेमंद होते हैं और आमतौर पर डॉक्स किए जाते हैं (सार्वजनिक पहचान समुदाय के लिए जानी जाती है)। एक वोट के बाद, मल्टीसिग साइनर्स समुदाय की इच्छा को पूरा करते हैं।
+हालांकि डीएओ में हजारों मतदान सदस्य हो सकते हैं, फंड 5-20 सक्रिय समुदाय के सदस्यों द्वारा साझा किए गए [वॉलेट](/glossary/#wallet) में रह सकते हैं जो भरोसेमंद हैं और आमतौर पर डॉक्स किए गए हैं (सार्वजनिक पहचान समुदाय के लिए जानी जाती है)। एक वोट के बाद, [मल्टीसिग](/glossary/#multisig) हस्ताक्षरकर्ता समुदाय की इच्छा को पूरा करते हैं।
-## DAO कानून {#dao-laws}
+## डीएओ कानून {#dao-laws}
-1977 में व्योमिंग ने LLC का आविष्कार किया, जो उद्यमियों की सुरक्षा करता है और उनके दायित्व को सीमित करता है। हाल ही में, उन्होंने DAO कानून का बीड़ा उठाया है जो DAO के लिए कानूनी स्थिति स्थापित करता है। वर्तमान में व्योमिंग, वर्मोंट और वर्जिन द्वीप समूह में किसी न किसी रूप में DAO कानून हैं।
+1977 में व्योमिंग ने LLC का आविष्कार किया, जो उद्यमियों की सुरक्षा करता है और उनके दायित्व को सीमित करता है। हाल ही में, उन्होंने डीएओ कानून का बीड़ा उठाया है जो डीएओ के लिए कानूनी स्थिति स्थापित करता है। वर्तमान में व्योमिंग, वर्मोंट और वर्जिन द्वीप समूह में किसी न किसी रूप में डीएओ कानून हैं।
### एक प्रसिद्ध उदाहरण {#law-example}
-[CityDAO](https://citizen.citydao.io/) – CityDAO ने येलोस्टोन नेशनल पार्क के पास 40 एकड़ जमीन खरीदने के लिए व्योमिंग के DAO कानून का इस्तेमाल किया।
+[CityDAO](https://citizen.citydao.io/) – CityDAO ने येलोस्टोन नेशनल पार्क के पास 40 एकड़ जमीन खरीदने के लिए व्योमिंग के डीएओ कानून का इस्तेमाल किया।
-## DAO की सदस्यता {#dao-membership}
+## डीएओ सदस्यता {#dao-membership}
-DAO सदस्यता के लिए अलग-अलग मॉडल हैं। सदस्यता यह निर्धारित कर सकती है कि मतदान कैसे काम करता है और DAO के अन्य प्रमुख भाग क्या है।
+डीएओ सदस्यता के लिए अलग-अलग मॉडल हैं। सदस्यता यह निर्धारित कर सकती है कि मतदान कैसे काम करता है और डीएओ के अन्य प्रमुख भाग क्या है।
-### टोकन आधारित सदस्यता {#token-based-membership}
+### टोकन-आधारित सदस्यता {#token-based-membership}
-आमतौर पर पूरी तरह से बिना अनुमति के और इस्तेमाल किए गए टोकन पर निर्भर करता है। अधिकतर इन गवर्नेंस टोकन का विकेंद्रीकृत एक्सचेंज पर बिना अनुमति के कारोबार किया जा सकता है। दूसरों को तरलता प्रदान करके या किसी अन्य 'काम का प्रमाण' प्रदान करके अर्जित किया जाना चाहिए। किसी भी तरह से, केवल टोकन धारण करने से मतदान तक पहुंच प्राप्त होती है।
+आमतौर पर इस्तेमाल किए गए टोकन के आधार पर पूरी तरह से [अनुमतिहीन](/glossary/#permissionless)। अधिकतर इन गवर्नेंस टोकन का [विकेंद्रीकृत एक्सचेंज](/glossary/#dex) पर बिना अनुमति के कारोबार किया जा सकता है। दूसरों को लिक्विडिटी प्रदान करके या किसी अन्य 'काम का सबूत' प्रदान करके अर्जित किया जाना चाहिए। किसी भी तरह से, केवल टोकन धारण करने से मतदान तक पहुंच प्राप्त होती है।
-_आमतौर पर व्यापक विकेन्द्रीकृत प्रोटोकॉल और/या टोकन को स्वयं नियंत्रित करने के लिए उपयोग किया जाता है।_
+_आम तौर पर व्यापक विकेंद्रीकृत प्रोटोकॉल और/या स्वयं टोकन को शासित करने के लिए उपयोग किया जाता है।_
#### एक प्रसिद्ध उदाहरण {#token-example}
-[MakerDAO](https://makerdao.com) – MakerDAO का टोकन MKR विकेन्द्रीकृत एक्सचेंजों पर व्यापक रूप से उपलब्ध है और कोई भी निर्माता प्रोटोकॉल के भविष्य पर मतदान शक्ति प्राप्त कर सकता है।
+[MakerDAO](https://makerdao.com) – MakerDAO का टोकन MKR विकेंद्रीकृत एक्सचेंजों पर व्यापक रूप से उपलब्ध है और कोई भी मेकर प्रोटोकॉल के भविष्य पर मतदान शक्ति खरीद सकता है।
### शेयर-आधारित सदस्यता {#share-based-membership}
-शेयर-आधारित DAO अधिक अनुमति वाले हैं, लेकिन फिर भी काफी खुले हैं। कोई भी संभावित सदस्य DAO में शामिल होने के लिए एक प्रस्ताव प्रस्तुत कर सकता है, आमतौर पर टोकन या काम के रूप में कुछ मूल्य की श्रद्धांजलि अर्पित करता है। शेयर प्रत्यक्ष मतदान शक्ति और स्वामित्व को दर्शाते हैं। सदस्य ट्रेजरी के अपने आनुपातिक हिस्से के साथ किसी भी समय बाहर निकल सकते हैं।
+शेयर-आधारित डीएओ अधिक अनुमति वाले हैं, लेकिन फिर भी काफी खुले हैं। कोई भी संभावित सदस्य डीएओ में शामिल होने के लिए एक प्रस्ताव प्रस्तुत कर सकता है, आमतौर पर टोकन या काम के रूप में कुछ मूल्य की श्रद्धांजलि अर्पित करता है। शेयर प्रत्यक्ष मतदान शक्ति और स्वामित्व को दर्शाते हैं। सदस्य ट्रेजरी के अपने आनुपातिक हिस्से के साथ किसी भी समय बाहर निकल सकते हैं।
-_आम तौर पर अधिक घनिष्ठ, मानव-केंद्रित संगठनों जैसे दान, कार्यकर्ता सामूहिक, और निवेश क्लबों के लिए उपयोग किया जाता है। प्रोटोकॉल और टोकन को भी नियंत्रित कर सकते हैं।_
+_आम तौर पर चैरिटी, कार्यकर्ता समूहों और निवेश क्लब जैसे अधिक घनिष्ठ, मानव-केंद्रित संगठनों के लिए उपयोग किया जाता है। प्रोटोकॉल और टोकन को भी शासित कर सकते हैं।_
#### एक प्रसिद्ध उदाहरण {#share-example}
-[MolochDAO](http://molochdao.com/) – MolochDAO - इथेरियम परियोजनाओं के वित्तपोषण पर केंद्रित है। उन्हें सदस्यता के लिए एक प्रस्ताव की आवश्यकता होती है ताकि समूह यह आकलन कर सके कि क्या आपके पास संभावित अनुदानकर्ताओं के बारे में सूचित निर्णय लेने के लिए आवश्यक विशेषज्ञता और पूंजी है। आप खुले बाजार में केवल DAO तक पहुंच नहीं खरीद सकते।
+[MolochDAO](http://molochdao.com/) – MolochDAO एथेरियम परियोजनाओं को फंड करने पर केंद्रित है। उन्हें सदस्यता के लिए एक प्रस्ताव की आवश्यकता होती है ताकि समूह यह आकलन कर सके कि क्या आपके पास संभावित अनुदानकर्ताओं के बारे में सूचित निर्णय लेने के लिए आवश्यक विशेषज्ञता और पूंजी है। आप खुले बाजार में केवल डीएओ तक पहुंच नहीं खरीद सकते।
### प्रतिष्ठा-आधारित सदस्यता {#reputation-based-membership}
-DAO में, प्रतिष्ठा इस बात का प्रमाण है कि आपने कुछ काम किया है और मतदान शक्ति प्रदान करता है। टोकन या शेयर-आधारित सदस्यता के विपरीत, प्रतिष्ठा-आधारित DAO योगदानकर्ताओं के स्वामित्व को स्थानांतरित नहीं करते हैं। प्रतिष्ठा को खरीदा, स्थानांतरित या प्रत्यायोजित नहीं किया जा सकता है; DAO सदस्यों को भागीदारी के माध्यम से प्रतिष्ठा अर्जित करनी चाहिए। ऑन-चेन मतदान अनुमतिहीन है और संभावित सदस्य स्वतंत्र रूप से DAO में शामिल होने के लिए प्रस्ताव प्रस्तुत कर सकते हैं और अपने योगदान के बदले में पुरस्कार के रूप में प्रतिष्ठा और टोकन प्राप्त करने का अनुरोध कर सकते हैं।
+डीएओ में, प्रतिष्ठा इस बात का सबूत है कि आपने भाग लिया है, जिससे मतदान शक्ति मिलती है। टोकन या शेयर-आधारित सदस्यता के विपरीत, प्रतिष्ठा-आधारित DAO योगदानकर्ताओं के स्वामित्व को स्थानांतरित नहीं करते हैं। प्रतिष्ठा को खरीदा, स्थानांतरित या प्रत्यायोजित नहीं किया जा सकता है; डीएओ सदस्यों को भागीदारी के माध्यम से प्रतिष्ठा अर्जित करनी चाहिए। ऑनचेन मतदान अनुमतिहीन है और भावी सदस्य डीएओ में शामिल होने के लिए स्वतंत्र रूप से प्रस्ताव प्रस्तुत कर सकते हैं और अपने योगदान के बदले में पुरस्कार के रूप में प्रतिष्ठा और टोकन प्राप्त करने का अनुरोध कर सकते हैं।
-_आम तौर पर विकेन्द्रीकृत विकास और प्रोटोकॉल और dapps के शासन के लिए इस्तेमाल किया, लेकिन यह भी अच्छी तरह से दान, कार्यकर्ता सामूहिक, निवेश क्लब, आदि जैसे संगठनों के एक विविध सेट के लिए अनुकूल।_
+_आम तौर पर प्रोटोकॉल और [डैप्स](/glossary/#dapp) के विकेंद्रीकृत विकास और शासन के लिए उपयोग किया जाता है, लेकिन यह चैरिटी, कार्यकर्ता समूहों, निवेश क्लब आदि जैसे विभिन्न प्रकार के संगठनों के लिए भी उपयुक्त है।_
#### एक प्रसिद्ध उदाहरण {#reputation-example}
-[DXdao](https://DXdao.eth.link) – 2019 के बाद से एक वैश्विक संप्रभु सामूहिक भवन और विकेंद्रीकृत प्रोटोकॉल और अनुप्रयोगों को नियंत्रित कर रहा है। यह धन के समन्वय और प्रबंधन के लिए प्रतिष्ठा-आधारित शासन और होलोग्राफिक आम सहमति का लाभ उठाता है, जिसका अर्थ है कि कोई भी अपने भविष्य को प्रभावित करने में अपना रास्ता नहीं खरीद सकता है।
+[DXdao](https://DXdao.eth.limo) – DXdao 2019 से विकेंद्रीकृत प्रोटोकॉल और अनुप्रयोगों का निर्माण और शासन करने वाला एक वैश्विक संप्रभु समूह था। इसने धन के समन्वय और प्रबंधन के लिए प्रतिष्ठा-आधारित शासन और [होलोग्राफिक सहमति](/glossary/#holographic-consensus) का लाभ उठाया, जिसका अर्थ है कि कोई भी पैसे के दम पर इसके भविष्य या शासन को प्रभावित नहीं कर सकता था।
-## DAO में शामिल हों / शुरू करें {#join-start-a-dao}
+## डीएओ में शामिल हों / एक डीएओ शुरू करें {#join-start-a-dao}
### डीएओ में शामिल हों {#join-a-dao}
-- [इथेरियम समुदाय DAO](/community/get-involved/#decentralized-autonomous-organizations-daos)
-- [DAOHaus के DAO की सूची](https://app.daohaus.club/explore)
-- [DAO की Tally.xyz सूची](https://www.tally.xyz)
+- [एथेरियम कम्युनिटी डीएओ](/community/get-involved/#decentralized-autonomous-organizations-daos)
+- [DAOHaus की डीएओ की सूची](https://app.daohaus.club/explore)
+- [Tally.xyz की डीएओ की सूची](https://www.tally.xyz/explore)
+- [DeGov.AI की डीएओ की सूची](https://apps.degov.ai/)
-### DAO शुरू करें {#start-a-dao}
+### एक डीएओ शुरू करें {#start-a-dao}
-- [DAOHaus के साथ एक DAO को बुलाओ](https://app.daohaus.club/summon)
-- [Tally के साथ एक गवर्नर DAO शुरू करें](https://www.tally.xyz/add-a-dao)
-- [Aragon-संचालित DAO बनाएं](https://aragon.org/product)
-- [कॉलोनी शुरू करो](https://colony.io/)
-- [DAOstack की होलोग्राफिक आम सहमति के साथ एक DAO बनाएं](https://alchemy.daostack.io/daos/create)
+- [DAOHaus के साथ एक डीएओ बनाएं](https://app.daohaus.club/summon)
+- [Tally के साथ एक गवर्नर डीएओ शुरू करें](https://www.tally.xyz/get-started)
+- [Aragon-संचालित डीएओ बनाएं](https://aragon.org/product)
+- [एक कॉलोनी शुरू करें](https://colony.io/)
+- [DAOstack की होलोग्राफिक सहमति के साथ एक डीएओ बनाएं](https://alchemy.daostack.io/daos/create)
+- [DeGov लॉन्चर के साथ एक डीएओ लॉन्च करें](https://docs.degov.ai/integration/deploy)
-## अग्रिम पठन {#further-reading}
+## आगे की रीडिंग {#further-reading}
-### DAO आलेख {#dao-articles}
+### डीएओ लेख {#dao-articles}
-- [DAO क्या है?](https://aragon.org/dao) – [Aragon](https://aragon.org/)
-- [DAO हैंडबुक](https://daohandbook.xyz)
-- [DAO का घर](https://wiki.metagame.wtf/docs/great-houses/house-of-daos) – [मेटागेम](https://wiki.metagame.wtf/)
-- [DAO क्या है और इसका उपयोग किसके लिए होता है?](https://daohaus.substack.com/p/-what-is-a-dao-and-what-is-it-for) – [DAOhaus](https://daohaus.club/)
-- [DAO-संचालित डिजिटल समुदाय कैसे शुरू करें](https://daohaus.substack.com/p/four-and-a-half-steps-to-start-a) – [DAOhaus](https://daohaus.club/)
-- [DAO क्या है?](https://coinmarketcap.com/alexandria/article/what-is-a-dao) – [कॉइनमार्केटकैप](https://coinmarketcap.com)
-- [क्या है होलोग्राफिक सहमति?](https://medium.com/daostack/holographic-consensus-part-1-116a73ba1e1c) - [DAOstack](https://daostack.io/)
-- [DAO निगम नहीं हैं: जहां विटालिक द्वारा स्वायत्त संगठनों में विकेंद्रीकरण मायने रखता है](https://vitalik.eth.limo/general/2022/09/20/daos.html)
-- [DAO, DAC, DA और बहुत कुछ: एक अधूरी शब्दावली गाइड](https://blog.ethereum.org/2014/05/06/daos-dacs-das-and-more-an-incomplete-terminology-guide) - [इथेरियम ब्लॉग](https://blog.ethereum.org)
+- [डीएओ क्या है?](https://aragon.org/dao) – [Aragon](https://aragon.org/)
+- [हाउस ऑफ डीएओ](https://wiki.metagame.wtf/docs/great-houses/house-of-daos) – [Metagame](https://wiki.metagame.wtf/)
+- [डीएओ क्या है और यह किस लिए है?](https://daohaus.substack.com/p/-what-is-a-dao-and-what-is-it-for) – [DAOhaus](https://daohaus.club/)
+- [डीएओ-संचालित डिजिटल कम्युनिटी कैसे शुरू करें](https://daohaus.substack.com/p/four-and-a-half-steps-to-start-a) – [DAOhaus](https://daohaus.club/)
+- [डीएओ क्या है?](https://coinmarketcap.com/alexandria/article/what-is-a-dao) – [Coinmarketcap](https://coinmarketcap.com)
+- [होलोग्राफिक सहमति क्या है?](https://medium.com/daostack/holographic-consensus-part-1-116a73ba1e1c) - [DAOstack](https://daostack.io/)
+- [डीएओ कॉर्पोरेशन नहीं हैं: जहां विटालिक द्वारा स्वायत्त संगठनों में विकेंद्रीकरण मायने रखता है](https://vitalik.eth.limo/general/2022/09/20/daos.html)
+- [डीएओ, डीएसी, डीए और बहुत कुछ: एक अधूरी शब्दावली गाइड](https://blog.ethereum.org/2014/05/06/daos-dacs-das-and-more-an-incomplete-terminology-guide) - [एथेरियम ब्लॉग](https://blog.ethereum.org)
### वीडियो {#videos}
-- [क्रिप्टो में DAO क्या है?](https://youtu.be/KHm0uUPqmVE)
-- [क्या कोई DAO एक शहर बना सकता है?](https://www.ted.com/talks/scott_fitsimones_could_a_dao_build_the_next_great_city) – [TED](https://www.ted.com/)
+- [क्रिप्टो में डीएओ क्या है?](https://youtu.be/KHm0uUPqmVE)
+- [क्या एक डीएओ शहर बना सकता है?](https://www.ted.com/talks/scott_fitsimones_could_a_dao_build_the_next_great_city) – [TED](https://www.ted.com/)
+
+
- DeFi ऐप्स खोजें
+ DeFi डैप्स एक्सप्लोर करें
## यह बिटकॉइन के साथ शुरू हुआ... {#bitcoin}
@@ -59,16 +60,17 @@ DeFi की क्षमता को देखने का एक सबसे
- अगर आप इथेरियम में नए हैं, तो DeFi एप्लिकेशन्स के लिए हमारे सुझावों का अन्वेषण करें।
+
+ अगर आप इथेरियम में नए हैं, तो DeFi एप्लिकेशन्स के लिए हमारे सुझावों का अन्वेषण करें।
+
- DeFi ऐप्स खोजें
+ DeFi डैप्स एक्सप्लोर करें
@@ -77,49 +79,49 @@ DeFi की क्षमता को देखने का एक सबसे
अधिकांश वित्तीय सेवाओं के लिए एक विकेन्द्रीकृत विकल्प है। लेकिन इथेरियम पूरी तरह से नए वित्तीय उत्पादों की सृजनात्मक संभावनाओं को बनाने के लिए अवसर पैदा करता है। यह एक सदैव बढ़ती सूची है।
-- [दुनियाभर में मुद्रा भेजें](#send-money)
-- [दुनियाभर में मुद्रा प्रवाहित करें](#stream-money)
-- [स्थिर मुद्राएँ प्राप्त करें](#stablecoins)
+- [दुनिया भर में पैसे भेजें](#send-money)
+- [दुनिया भर में मुद्रा प्रवाहित करें](#stream-money)
+- [स्थिर मुद्राओं तक पहुँचें](#stablecoins)
- [गिरवी के साथ उधार लें](#lending)
-- [गिरवी के बिना उधार लें](#flash-loans)
-- [क्रिप्टो बचत प्रारंभ करें](#saving)
-- [टोकन व्यापार](#swaps)
-- [अपने पोर्टफोलियो को बढ़ाएं](#investing)
-- [अपने विचारों को वित्तपोषित करें](#crowdfunding)
+- [बिना गिरवी के उधार लें](#flash-loans)
+- [क्रिप्टो बचत शुरू करें](#saving)
+- [टोकन ट्रे़ड करें](#swaps)
+- [अपना पोर्टफोलियो बढ़ाएँ](#investing)
+- [अपने विचारों को फंड करें](#crowdfunding)
- [बीमा खरीदें](#insurance)
-- [अपने पोर्टफोलियो का प्रबंधन करें](#aggregators)
+- [अपने पोर्टफोलियो को प्रबंधित करें](#aggregators)
- भुगतान संबंधित dapps देखें
+ भुगतान डैप्स देखें
#### दुनियाभर में मुद्रा प्रवाहित करें... {#stream-money}
आप इथेरियम पर भी मुद्रा प्रवाहित कर सकते हैं। यह आपको किसी का वेतन प्रति सेकंड भुगतान करने की अनुमति देता है, जिससे उन्हें उनके मुद्रा तक कभी भी पहुँचने की सुविधा होती है। या फिर किसी चीज़ को सेकंडों में किराये पर दें, जैसे कि एक स्टोरेज लॉकर या इलेक्ट्रिक स्कूटर।
-और यदि आप [ETH](/glossary/#ether) को भेजना या स्ट्रीम नहीं करना चाहते हैं क्योंकि इसके मूल्य में होने वाले बदलाव की सीमा नहीं है, इसलिए एथेरियम पर वैकल्पिक मुद्राएं होती हैं: [स्थिर मुद्राएँ](/glossary/#stablecoin)।
+और यदि आप [ETH](/glossary/#ether) नहीं भेजना या स्ट्रीम करना चाहते हैं क्योंकि इसका मूल्य बहुत बदल सकता है, तो एथेरियम पर वैकल्पिक मुद्राएँ हैं: [स्टेबलकॉइन्स](/glossary/#stablecoin)।
- स्थिर मुद्राओं पर अधिक जानकारी
+ स्थिर मुद्रा के बारे में और जानें
- उधार लेने वाले dapps देखें
+ उधार लेने वाले डैप्स देखें
विकेंद्रीकृत ऋणदाता का उपयोग करने के कई फायदे हैं...
@@ -136,19 +138,19 @@ DeFi की क्षमता को देखने का एक सबसे
आज, पैसा उधार देना और उधार लेना संबंधित व्यक्तियों के इर्द-गिर्द घूमता है। बैंकों को ऋण देने से पहले यह जानना आवश्यक है कि आपके द्वारा ऋण चुकाने की संभावना है या नहीं।
-विकेंद्रीकृत ऋण किसी भी पक्ष की पहचान बताए बिना काम करता है। इसके बजाय, उधारकर्ता को संपार्श्विक रखना होगा जो ऋणदाता को स्वचालित रूप से प्राप्त होगा यदि उनका ऋण चुकाया नहीं गया है। कुछ ऋणदाता [NFTs](/glossary/#nft) को संपार्श्विक के रूप में भी स्वीकार करते हैं। NFT एक पेंटिंग की तरह एक अद्वितीय संपत्ति का एक दस्तावेज है। [NFT पर अधिक जानकारी](/nft/)
+विकेंद्रीकृत ऋण किसी भी पक्ष की पहचान बताए बिना काम करता है। इसके बजाय, उधारकर्ता को संपार्श्विक रखना होगा जो ऋणदाता को स्वचालित रूप से प्राप्त होगा यदि उनका ऋण चुकाया नहीं गया है। कुछ ऋणदाता [NFTs](/glossary/#nft) को संपार्श्विक के रूप में भी स्वीकार करते हैं। NFT एक पेंटिंग की तरह एक अद्वितीय संपत्ति का एक दस्तावेज है। [NFTs के बारे में और जानें](/nft/)
यह आपको क्रेडिट जांच या निजी जानकारी सौंपे बिना मुद्रा उधार लेने की अनुमति देता है।
-#### वैश्विक निधियों तक पहुंच {#access-global-funds}
+#### वैश्विक फंड तक पहुँच {#access-global-funds}
जब आप एक विकेन्द्रीकृत ऋणदाता का उपयोग करते हैं तो आपके पास दुनिया भर से जमा किए गए धन तक पहुंच होती है, न कि केवल आपके चुने हुए बैंक या संस्थान की निगरानी में मौजूद धन तक। इससे ऋण अधिक सुलभ हो जाता है और ब्याज दरों में सुधार होता है।
#### कर-दक्षताएँ {#tax-efficiencies}
-उधार लेने से आपको अपना ETH बेचने (एक कर योग्य घटना) की आवश्यकता के बिना आवश्यक धनराशि तक पहुंच मिल सकती है। इसके बजाय, आप स्थिर मुद्रा ऋण के लिए गिरवी के रूप में ETH का उपयोग कर सकते हैं। यह आपको आवश्यक नकदी प्रवाह प्रदान करता है और आपको आपके ETH को रखने की अनुमति देता है। स्थिर मुद्राएँ टोकन होती हैं जो बहुत अधिक अच्छी होती हैं जब आपको नकदी की आवश्यकता होती है क्योंकि उनकी मूल्य में ETH की तरह परिवर्तन नहीं होता। [स्थिर मुद्राओं पर अधिक जानकारी](#stablecoins)
+उधार लेने से आपको अपना ETH बेचने (एक कर योग्य घटना) की आवश्यकता के बिना आवश्यक धनराशि तक पहुंच मिल सकती है। इसके बजाय, आप स्थिर मुद्रा ऋण के लिए गिरवी के रूप में ETH का उपयोग कर सकते हैं। यह आपको आवश्यक नकदी प्रवाह प्रदान करता है और आपको आपके ETH को रखने की अनुमति देता है। स्थिर मुद्राएँ टोकन होती हैं जो बहुत अधिक अच्छी होती हैं जब आपको नकदी की आवश्यकता होती है क्योंकि उनकी मूल्य में ETH की तरह परिवर्तन नहीं होता। [स्टेबलकॉइन्स के बारे में और जानें](#stablecoins)
-#### फ़्लैश ऋण {#flash-loans}
+#### फ्लैश लोन {#flash-loans}
फ्लैश ऋण विकेन्द्रीकृत ऋण का एक अधिक प्रयोगात्मक रूप है जो आपको गिरवी या कोई व्यक्तिगत जानकारी प्रदान किए बिना उधार देता है।
@@ -172,27 +174,27 @@ DeFi की क्षमता को देखने का एक सबसे
उपरोक्त उदाहरण को पारंपरिक वित्त दुनिया में करने के लिए, आपको बड़ी मात्रा में धन की आवश्यकता होती है। ये पैसे कमाने की रणनीतियाँ केवल उन्हीं तक पहुँचती हैं जिनके पास पहले से ही धन है। फ्लैश ऋण एक ऐसे भविष्य का उदाहरण है जहाँ पैसे कमाने के लिए पैसे होना आवश्यक नहीं है।
- फ़्लैश ऋण पर अधिक जानकारी
+ फ्लैश लोन के बारे में और जानें
- लेनदेन वाले dapps देखें
+ उधार देने वाले डैप्स देखें
-#### नो-लॉस लॉटरी {#no-loss-lotteries}
+#### बिना-नुकसान वाली लॉटरी {#no-loss-lotteries}
PoolTogether जैसी नो-लॉस लॉटरी पैसे बचाने का एक मज़ेदार और नया तरीका है।
@@ -210,43 +212,43 @@ PoolTogether जैसी नो-लॉस लॉटरी पैसे बच
- टोकन एक्सचेंजेस देखें
+ टोकन एक्सचेंज देखें
- ट्रेडिंग dapps देखें
+ ट्रेडिंग डैप्स देखें
- निवेश के dapps देखें।
+ निवेश डैप्स देखें
- क्राउडफंडिंग dapps देखें
+ क्राउडफंडिंग डैप्स देखें
#### द्विघात निधिकरण {#quadratic-funding}
@@ -272,7 +274,7 @@ PoolTogether जैसी नो-लॉस लॉटरी पैसे बच
इसका मतलब यह है कि प्रोजेक्ट A अपने 1 डॉलर के 100 दान के साथ, B की तुलना में जो 10,000 डॉलर (मिलान पूल के आकार पर निर्भर) के एकल दान के साथ अधिक फंडिंग के साथ समाप्त हो सकता है।
- द्विघात निधिकरण पर अधिक जानकारी
+ द्विघात निधिकरण के बारे में और जानें
- dapps बीमा देखें
+ बीमा डैप्स देखें
- पोर्टफोलियो dapps देखें
+ पोर्टफोलियो डैप्स देखें
- dapps के निर्माण पर अधिक जानकारी
+ डैप्स बनाने के बारे में और जानें
-## अग्रिम पठन {#further-reading}
+## आगे की रीडिंग {#further-reading}
-### DeFi डाटा {#defi-data}
+### DeFi डेटा {#defi-data}
-- [DeFi प्राइम](https://defiprime.com/)
+- [DeFi Prime](https://defiprime.com/)
- [DeFi Llama](https://defillama.com/)
### DeFi लेख {#defi-articles}
-- [DeFi के लिए एक शुरुआती मार्गदर्शिका](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) – _सीड कोएल्हो-प्रभु 6 जनवरी, 2020_
+- [DeFi के लिए एक शुरुआती गाइड](https://blog.coinbase.com/a-beginners-guide-to-decentralized-finance-defi-574c68ff43c4) – _सिड कोएल्हो-प्रभु, 6 जनवरी, 2020_
+- [EEA DeFi जोखिम मूल्यांकन दिशानिर्देश](https://entethalliance.org/specs/defi-risks/) – DeFi प्रोटोकॉल में प्रमुख जोखिमों की पहचान और मूल्यांकन कैसे करें, इस पर उद्योग-समर्थित अवलोकन।
### वीडियो {#videos}
-- [फिनेमैटिक्स - विकेन्द्रीकृत वित्त शिक्षा](https://finematics.com/) – _DeFi पर वीडियो_
-- [डेफिएंट](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) - _DeFi की मूल बातें: इस क्षेत्र में शुरुआत करने के लिए आपको जो कुछ जानने की जरूरत है।_
-- [व्हाइटबोर्ड क्रिप्टो](https://youtu.be/17QRFlml4pA) – _DeFi क्या है?_
+- [Finematics - विकेंद्रीकृत वित्त शिक्षा](https://finematics.com/) – _DeFi पर वीडियो_
+- [The Defiant](https://www.youtube.com/playlist?list=PLaDcID4s1KronHMKojfjwiHL0DdQEPDcq) - _DeFi की मूल बातें: इस कभी-कभी हैरान करने वाले क्षेत्र में शुरुआत करने के लिए आपको जो कुछ भी जानने की ज़रूरत है।_
+- [Whiteboard Crypto](https://youtu.be/17QRFlml4pA) _DeFi क्या है?_
### समुदाय {#communities}
diff --git a/public/content/translations/hi/desci/index.md b/public/content/translations/hi/desci/index.md
index 37e2a6acfe3..10df39f67bc 100644
--- a/public/content/translations/hi/desci/index.md
+++ b/public/content/translations/hi/desci/index.md
@@ -1,45 +1,45 @@
---
-title: विकेंद्रीत विज्ञान (DeSci)
-description: इथेरियम पर विकेन्द्रीकृत विज्ञान का अवलोकन
+title: "विकेंद्रीत विज्ञान (DeSci)"
+description: "इथेरियम पर विकेन्द्रीकृत विज्ञान का अवलोकन"
lang: hi
template: use-cases
emoji: ":microscope:"
sidebarDepth: 2
image: /images/future_transparent.png
alt: ""
-summaryPoint1: वर्तमान वैज्ञानिक प्रणाली के लिए एक वैश्विक, खुला विकल्प।
-summaryPoint2: एक तकनीक जो वैज्ञानिकों को धन जुटाने, प्रयोग चलाने, डेटा साझा करने, अंतर्दृष्टि वितरित करने और बहुत कुछ करने में सक्षम बनाती है।
-summaryPoint3: खुले विज्ञान आंदोलन पर निर्माण आधारित है।
+summaryPoint1: "वर्तमान वैज्ञानिक प्रणाली के लिए एक वैश्विक, खुला विकल्प।"
+summaryPoint2: "एक तकनीक जो वैज्ञानिकों को धन जुटाने, प्रयोग चलाने, डेटा साझा करने, अंतर्दृष्टि वितरित करने और बहुत कुछ करने में सक्षम बनाती है।"
+summaryPoint3: "खुले विज्ञान आंदोलन पर निर्माण आधारित है।"
---
## विकेन्द्रीकृत विज्ञान (DeSci) क्या है? {#what-is-desci}
-विकेंद्रीकृत विज्ञान (DeSci) एक आंदोलन है, जिसका उद्देश्य [Web3](/glossary/#web3) स्टैक का उपयोग करके निष्पक्ष और समान रूप से वैज्ञानिक ज्ञान के वित्तपोषण, निर्माण, समीक्षा, श्रेय, भंडारण और प्रसार के लिए सार्वजनिक बुनियादी ढांचे का निर्माण करना है।
+विकेंद्रीकृत विज्ञान (DeSci) एक आंदोलन है जिसका उद्देश्य [Web3](/glossary/#web3) स्टैक का उपयोग करके वैज्ञानिक ज्ञान के वित्त पोषण, निर्माण, समीक्षा, क्रेडिट, भंडारण और प्रसार के लिए सार्वजनिक बुनियादी ढांचे का निर्माण करना है।
DeSci का उद्देश्य एक पारिस्थितिकी तंत्र बनाना है जहां वैज्ञानिकों को खुले तौर पर अपने शोध को साझा करने और अपने काम के लिए क्रेडिट प्राप्त करने के लिए प्रोत्साहित किया जाता है, जबकि किसी को भी आसानी से अनुसंधान तक पहुंचने और योगदान करने की अनुमति मिलती है। DeSci इस विचार से काम करता है कि वैज्ञानिक ज्ञान हर किसी के लिए सुलभ होना चाहिए और वैज्ञानिक अनुसंधान की प्रक्रिया पारदर्शी होनी चाहिए। DeSci एक अधिक विकेन्द्रीकृत और वितरित वैज्ञानिक अनुसंधान मॉडल बना रहा है, जिससे यह केंद्रीय अधिकारियों द्वारा सेंसरशिप और नियंत्रण के लिए अधिक प्रतिरोधी बनाया गया है। DeSci एक ऐसा वातावरण बनाने की उम्मीद करता है जहां नए और अपरंपरागत विचार वित्त पोषण, वैज्ञानिक उपकरणों और संचार चैनलों तक पहुंच को विकेंद्रीकृत करके पनप सकते हैं।
-विकेंद्रीकृत विज्ञान, अधिक विविध वित्तपोषण स्रोतों ([डीएओ](/glossary/#dao), [, द्विघात दान](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531) से लेकर क्राउडफंडिंग तथा और भी कई) की, अधिक सुलभ डेटा और विधियों की, और पुनरुत्पादन के लिए प्रोत्साहन प्रदान करने की अनुमति देता है।
+विकेंद्रीकृत विज्ञान अधिक विविध वित्तपोषण स्रोतों ([DAOs](/glossary/#dao), [द्विघात दान](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2003531) से लेकर क्राउडफंडिंग और अधिक तक), अधिक सुलभ डेटा और विधियों, और पुनरुत्पादन के लिए प्रोत्साहन प्रदान करने की अनुमति देता है।
### जुआन बेनेट - DeSci गतिविधि
+
+बनाए जाने वाले नए खाते के लिए कृपया एक पासवर्ड दर्ज करें:
+>
+
+------------
+INFO [10-28|16:19:09.156] आपकी नई कुंजी बना दी गई है address=0x5e97870f263700f46aa00d967821199b9bc5a120
+WARN [10-28|16:19:09.306] कृपया अपनी कुंजी फ़ाइल का बैकअप लें path=/home/user/go-ethereum/data/keystore/UTC--2022-10-28T15-19-08.000825927Z--5e97870f263700f46aa00d967821199b9bc5a120
+WARN [10-28|16:19:09.306] कृपया अपना पासवर्ड याद रखें!
+बनाया गया खाता 0x5e97870f263700f46aa00d967821199b9bc5a120
+```
+
+[Geth प्रलेखन](https://geth.ethereum.org/docs)
+
+आपकी निजी कुंजी से नई सार्वजनिक कुंजी प्राप्त करना संभव है, लेकिन आप सार्वजनिक कुंजी से निजी कुंजी प्राप्त नहीं कर सकते। अपनी निजी कुंजियों को सुरक्षित रखना और, जैसा कि नाम से पता चलता है, **निजी** रखना बहुत महत्वपूर्ण है।
+
+संदेशों और लेनदेन पर हस्ताक्षर करने के लिए आपको एक निजी कुंजी की आवश्यकता होती है जो एक हस्ताक्षर आउटपुट करता है। संदेश के लेखक को साबित करते हुए अन्य लोग आपकी सार्वजनिक कुंजी प्राप्त करने के लिए हस्ताक्षर ले सकते हैं। अपने आवेदन में, आप नेटवर्क पर लेनदेन भेजने के लिए JavaScript लाइब्रेरी का उपयोग कर सकते हैं।
+
+## अनुबंध खाते {#contract-accounts}
+
+अनुबंध वाले खातों में एक 42 वर्ण का हेक्साडेसिमल पता भी होता है:
+
+उदाहरण:
+
+`0x06012c8cf97bead5deae237070f9587f8e7a266d`
+
+अनुबंध का पता आमतौर पर तब दिया जाता है जब एथेरियम ब्लॉकचेन पर एक अनुबंध डिप्लॉय किया जाता है। पता निर्माता के पते और उस पते से भेजे गए लेनदेन की संख्या ("गैर") से आता है।
+
+## सत्यापनकर्ता कुंजियां {#validators-keys}
+
+एथेरियम में एक अन्य प्रकार की कुंजी भी है, जिसे तब पेश किया गया जब एथेरियम ने प्रूफ-ऑफ-स्टेक से हिस्सेदारी के सबूत पर आधारित सर्वसम्मति पर स्विच किया। ये 'BLS' कुंजियाँ हैं और इनका उपयोग सत्यापनकर्ताओं की पहचान करने के लिए किया जाता है। नेटवर्क को आम सहमति में आने के लिए आवश्यक बैंडविड्थ को कम करने के लिए इन कुंजियों को कुशलता से इकट्ठा किया जा सकता है। इस प्रमुख एकत्रीकरण के बिना, एक सत्यापनकर्ता के लिए न्यूनतम हिस्सेदारी बहुत अधिक होगी।
+
+[सत्यापनकर्ता कुंजियों पर अधिक जानकारी](/developers/docs/consensus-mechanisms/pos/keys/)।
+
+## वॉलेट पर एक नोट {#a-note-on-wallets}
+
+एक खाता एक वॉलेट नहीं है। वॉलेट एक इंटरफ़ेस या एप्लिकेशन है जो आपको अपने एथेरियम खाते के साथ बातचीत करने देता है, या तो बाहरी मालिकाना हक वाला खाता या अनुबंध खाता।
+
+## एक विज़ुअल डेमो {#a-visual-demo}
+
+ऑस्टिन आपको हैश फ़ंक्शंस और कुंजी जोड़े जाने के माध्यम से समझाते हुए देखें।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+कोई नहीं
+
+**रिटर्न**
+
+सटीक वापसी डेटा क्लाइंट कार्यान्वयन के बीच भिन्न होता है। जब नोड सिंक नहीं हो रहा हो तो सभी क्लाइंट `False` लौटाते हैं, और सभी क्लाइंट निम्नलिखित फ़ील्ड लौटाते हैं।
+
+`ऑब्जेक्ट|बूलियन`, सिंक स्थिति डेटा या `FALSE` के साथ एक ऑब्जेक्ट, जब सिंक नहीं हो रहा हो:
+
+- `startingBlock`: `मात्रा` - वह ब्लॉक जिस पर आयात शुरू हुआ (केवल सिंक के अपने हेड तक पहुंचने के बाद ही रीसेट किया जाएगा)
+- `currentBlock`: `मात्रा` - वर्तमान ब्लॉक, eth_blockNumber के समान
+- `highestBlock`: `मात्रा` - अनुमानित उच्चतम ब्लॉक
+
+हालाँकि, व्यक्तिगत क्लाइंट अतिरिक्त डेटा भी प्रदान कर सकते हैं। उदाहरण के लिए, गेथ निम्नलिखित लौटाता है:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "currentBlock": "0x3cf522",
+ "healedBytecodeBytes": "0x0",
+ "healedBytecodes": "0x0",
+ "healedTrienodes": "0x0",
+ "healingBytecode": "0x0",
+ "healingTrienodes": "0x0",
+ "highestBlock": "0x3e0e41",
+ "startingBlock": "0x3cbed5",
+ "syncedAccountBytes": "0x0",
+ "syncedAccounts": "0x0",
+ "syncedBytecodeBytes": "0x0",
+ "syncedBytecodes": "0x0",
+ "syncedStorage": "0x0",
+ "syncedStorageBytes": "0x0"
+ }
+}
+```
+
+जबकि बेसु लौटता है:
+
+```json
+{
+ "jsonrpc": "2.0",
+ "id": 51,
+ "result": {
+ "startingBlock": "0x0",
+ "currentBlock": "0x1518",
+ "highestBlock": "0x9567a3",
+ "pulledStates": "0x203ca",
+ "knownStates": "0x200636"
+ }
+}
+```
+
+अधिक विवरण के लिए अपने विशिष्ट ग्राहक के लिए दस्तावेज़ीकरण देखें।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_syncing\",\"params\":[],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": {
+ startingBlock: '0x384',
+ currentBlock: '0x386',
+ highestBlock: '0x454'
+ }
+}
+// या जब सिंक नहीं हो रहा हो
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": false
+}
+```
+
+### eth_coinbase {#eth_coinbase}
+
+क्लाइंट कॉइनबेस पता देता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+> **नोट:** इस पद्धति को **v1.14.0** से हटा दिया गया है और अब यह समर्थित नहीं है। इस पद्धति का उपयोग करने का प्रयास करने पर "विधि समर्थित नहीं" त्रुटि होगी।
+
+**पैरामीटर**
+
+कोई नहीं
+
+**रिटर्न**
+
+`डेटा`, 20 बाइट्स - वर्तमान कॉइनबेस पता।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_coinbase\",\"params\":[],\"id\":64}'
+// परिणाम
+{
+ \"id\":64,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x407d73d8a49eeb85d32cf465507dd71d507100c1\"
+}
+```
+
+### eth_chainId {#eth_chainId}
+
+रीप्ले-सुरक्षित लेनदेन पर हस्ताक्षर करने के लिए उपयोग की गई चेन ID लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+कोई नहीं
+
+**रिटर्न**
+
+`chainId`, एक स्ट्रिंग के रूप में हेक्साडेसिमल मान जो वर्तमान चेन आईडी के पूर्णांक का प्रतिनिधित्व करता है।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_chainId\",\"params\":[],\"id\":67}'
+// परिणाम
+{
+ \"id\":67,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x1\"
+}
+```
+
+### eth_mining {#eth_mining}
+
+यदि क्लाइंट सक्रिय रूप से नए ब्लॉकों का खनन कर रहा है तो `true` लौटाता है। यह केवल प्रूफ-ऑफ-वर्क नेटवर्क के लिए `true` लौटा सकता है और [द मर्ज](/roadmap/merge/) के बाद से कुछ क्लाइंट में उपलब्ध नहीं हो सकता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+कोई नहीं
+
+**रिटर्न**
+
+`बूलियन` - यदि क्लाइंट खनन कर रहा है तो `true` लौटाता है, अन्यथा `false`।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_mining\",\"params\":[],\"id\":71}'
+//
+{
+ \"id\":71,
+ \"jsonrpc\": \"2.0\",
+ \"result\": true
+}
+```
+
+### eth_hashrate {#eth_hashrate}
+
+प्रति सेकंड हैश की संख्या देता है जिसके साथ नोड खनन कर रहा है. यह केवल प्रूफ-ऑफ-वर्क नेटवर्क के लिए `true` लौटा सकता है और [द मर्ज](/roadmap/merge/) के बाद से कुछ क्लाइंट में उपलब्ध नहीं हो सकता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+कोई नहीं
+
+**रिटर्न**
+
+`मात्रा` - प्रति सेकंड हैश की संख्या।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_hashrate\",\"params\":[],\"id\":71}'
+// परिणाम
+{
+ \"id\":71,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x38a\"
+}
+```
+
+### eth_gasPrice {#eth_gasprice}
+
+वेई में प्रति गैस वर्तमान मूल्य का अनुमान देता है। उदाहरण के लिए, Besu क्लाइंट पिछले 100 ब्लॉकों की जांच करता है और डिफ़ॉल्ट रूप से औसत गैस इकाई मूल्य लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+कोई नहीं
+
+**रिटर्न**
+
+`मात्रा` - वेई में वर्तमान गैस मूल्य का पूर्णांक।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_gasPrice\",\"params\":[],\"id\":73}'
+// परिणाम
+{
+ \"id\":73,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x1dfd14000\" // 8049999872 Wei
+}
+```
+
+### eth_accounts {#eth_accounts}
+
+क्लाइंट के स्वामित्व वाले पतों की एक सूची देता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+कोई नहीं
+
+**रिटर्न**
+
+`डेटा की सारणी`, 20 बाइट्स - क्लाइंट के स्वामित्व वाले पते।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_accounts\",\"params\":[],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": [\"0x407d73d8a49eeb85d32cf465507dd71d507100c1\"]
+}
+```
+
+### eth_blockNumber {#eth_blocknumber}
+
+सबसे हाल के ब्लॉक की संख्या लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+कोई नहीं
+
+**रिटर्न**
+
+`मात्रा` - क्लाइंट जिस वर्तमान ब्लॉक नंबर पर है, उसका पूर्णांक।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_blockNumber\",\"params\":[],\"id\":83}'
+// परिणाम
+{
+ \"id\":83,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x4b7\" // 1207
+}
+```
+
+### eth_getBalance {#eth_getbalance}
+
+दिए गए पते पर खाते की शेष राशि लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 20 बाइट्स - शेष राशि की जांच के लिए पता।
+2. `मात्रा|टैग` - पूर्णांक ब्लॉक नंबर, या स्ट्रिंग `"latest"`, `"earliest"`, `"pending"`, `"safe"`, या `"finalized"`, [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) देखें
+
+```js
+params: ["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]
+```
+
+**रिटर्न**
+
+`मात्रा` - वेई में वर्तमान शेष राशि का पूर्णांक।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getBalance\",\"params\":[\"0x407d73d8a49eeb85d32cf465507dd71d507100c1\", \"latest\"],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x0234c8a3397aab58\" // 158972490234375000
+}
+```
+
+### eth_getStorageAt {#eth_getstorageat}
+
+किसी दिए गए पते पर संग्रहण स्थिति से मान लौटाता है.
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 20 बाइट्स - भंडारण का पता।
+2. `मात्रा` - भंडारण में स्थिति का पूर्णांक।
+3. `मात्रा|टैग` - पूर्णांक ब्लॉक नंबर, या स्ट्रिंग `"latest"`, `"earliest"`, `"pending"`, `"safe"` या `"finalized"`, [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) देखें
+
+**रिटर्न**
+
+`डेटा` - इस भंडारण की स्थिति पर मान।
+
+**उदाहरण**
+सही स्थिति की गणना पुनर्प्राप्त करने के लिए भंडारण पर निर्भर करती है। पते `0x391694e7e0b0cce554cb130d723a9d27458f9298` द्वारा `0x295a70b2de5e3953354a6a8344e616ed314d7251` पर तैनात निम्नलिखित अनुबंध पर विचार करें।
+
+```
+contract Storage {
+ uint pos0;
+ mapping(address => uint) pos1;
+ constructor() {
+ pos0 = 1234;
+ pos1[msg.sender] = 5678;
+ }
+}
+```
+
+pos0 का मान पुनर्प्राप्त करना सीधा है:
+
+```js
+curl -X POST --data '{\"jsonrpc\":\"2.0\", \"method\": \"eth_getStorageAt\", \"params\": [\"0x295a70b2de5e3953354a6a8344e616ed314d7251\", \"0x0\", \"latest\"], \"id\": 1}' localhost:8545
+{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":\"0x00000000000000000000000000000000000000000000000000000000000004d2\"}
+```
+
+मानचित्र के एक तत्व को पुनः प्राप्त करना कठिन है। मानचित्र में किसी तत्व की स्थिति की गणना निम्न के साथ की जाती है:
+
+```js
+keccak(LeftPad32(कुंजी, 0), LeftPad32(नक्शा स्थिति, 0))
+```
+
+इसका मतलब है कि pos1["0x391694e7e0b0cce554cb130d723a9d27458f9298"] पर स्टोरेज को पुनः प्राप्त करने के लिए हमें स्थिति की गणना करने की आवश्यकता है:
+
+```js
+keccak(
+ decodeHex(
+ "000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" +
+ "0000000000000000000000000000000000000000000000000000000000000001"
+ )
+)
+```
+
+Web3 लाइब्रेरी के साथ आने वाले गेथ कंसोल का उपयोग गणना करने के लिए किया जा सकता है:
+
+```js
+> var key = "000000000000000000000000391694e7e0b0cce554cb130d723a9d27458f9298" + "0000000000000000000000000000000000000000000000000000000000000001"
+undefined
+> web3.sha3(key, {"encoding": "hex"})
+"0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9"
+```
+
+अब भंडारण लाने के लिए:
+
+```js
+curl -X POST --data '{\"jsonrpc\":\"2.0\", \"method\": \"eth_getStorageAt\", \"params\": [\"0x295a70b2de5e3953354a6a8344e616ed314d7251\", \"0x6661e9d6d8b923d5bbaab1b96e1dd51ff6ea2a93520fdc9eb75d059238b8c5e9\", \"latest\"], \"id\": 1}' localhost:8545
+{\"jsonrpc\":\"2.0\",\"id\":1,\"result\":\"0x000000000000000000000000000000000000000000000000000000000000162e\"}
+```
+
+### eth_getTransactionCount {#eth_gettransactioncount}
+
+किसी पते से _भेजे गए_ लेन-देन की संख्या लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 20 बाइट्स - पता।
+2. `मात्रा|टैग` - पूर्णांक ब्लॉक नंबर, या स्ट्रिंग `"latest"`, `"earliest"`, `"pending"`, `"safe"` या `"finalized"`, [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) देखें
+
+```js
+params: [
+ "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
+ "latest", // नवीनतम ब्लॉक पर स्टेट
+]
+```
+
+**रिटर्न**
+
+`मात्रा` - इस पते से भेजे गए लेन-देन की संख्या का पूर्णांक।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionCount\",\"params\":[\"0x407d73d8a49eeb85d32cf465507dd71d507100c1\",\"latest\"],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x1\" // 1
+}
+```
+
+### eth_getBlockTransactionCountByHash {#eth_getblocktransactioncountbyhash}
+
+दिए गए ब्लॉक हैश से मेल खाने वाले ब्लॉक से ब्लॉक में लेनदेन की संख्या देता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 32 बाइट्स - एक ब्लॉक का हैश
+
+```js
+पैराम्स: ["0xd03ededb7415d22ae8bac30f96b2d1de83119632693b963642318d87d1bece5b"]
+```
+
+**रिटर्न**
+
+`मात्रा` - इस ब्लॉक में लेन-देन की संख्या का पूर्णांक।
+
+**उदाहरण**
+
+```js
+// Request
+curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockTransactionCountByHash","params":["0xd03ededb7415d22ae8bac30f96b2d1de83119632693b963642318d87d1bece5b"],"id":1}'
+// Result
+{
+ "id":1,
+ "jsonrpc": "2.0",
+ "result": "0x8b" // 139
+}
+```
+
+### eth_getBlockTransactionCountByNumber {#eth_getblocktransactioncountbynumber}
+
+दिए गए ब्लॉक नंबर से मेल खाने वाले ब्लॉक में लेनदेन की संख्या देता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `मात्रा|टैग` - एक ब्लॉक नंबर का पूर्णांक, या स्ट्रिंग `"earliest"`, `"latest"`, `"pending"`, `"safe"` या `"finalized"`, जैसा कि [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) में है।
+
+```js
+params: [
+ "0x13738ca", // 20396234
+]
+```
+
+**रिटर्न**
+
+`मात्रा` - इस ब्लॉक में लेन-देन की संख्या का पूर्णांक।
+
+**उदाहरण**
+
+```js
+params: [
+ "0x13738ca", // 20396234
+]
+```
+
+### eth_getUncleCountByBlockHash {#eth_getunclecountbyblockhash}
+
+Params: [
+"0x13738ca", // 20396234]
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 32 बाइट्स - एक ब्लॉक का हैश
+
+```js
+params: [
+ "0x13738ca", // 20396234]
+```
+
+**रिटर्न**
+
+`मात्रा` - इस ब्लॉक में अंकल की संख्या का पूर्णांक।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getUncleCountByBlockHash\",\"params\":[\"0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2\"],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x1\" // 1
+}
+```
+
+### eth_getUncleCountByBlockNumber {#eth_getunclecountbyblocknumber}
+
+दिए गए ब्लॉक नंबर से मेल खाने वाले ब्लॉक से एक ब्लॉक में अंकल की संख्या लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `मात्रा|टैग` - पूर्णांक ब्लॉक नंबर, या स्ट्रिंग `"latest"`, `"earliest"`, `"pending"`, `"safe"` या `"finalized"`, [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) देखें
+
+```js
+params: [
+ "0xe8", // 232
+]
+```
+
+**रिटर्न**
+
+`मात्रा` - इस ब्लॉक में अंकल की संख्या का पूर्णांक।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getUncleCountByBlockNumber\",\"params\":[\"0xe8\"],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x0\" // 0
+}
+```
+
+### eth_getCode {#eth_getcode}
+
+दिए गए पते पर कोड लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 20 बाइट्स - पता
+2. `मात्रा|टैग` - पूर्णांक ब्लॉक नंबर, या स्ट्रिंग `"latest"`, `"earliest"`, `"pending"`, `"safe"` या `"finalized"`, [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) देखें
+
+```js
+params: [
+ "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+ "0x5daf3b", // 6139707
+]
+```
+
+**रिटर्न**
+
+`डेटा` - दिए गए पते से कोड।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getCode\",\"params\":[\"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2\", \"0x5daf3b\"],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"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\"
+```
+
+### eth_sign {#eth_sign}
+
+साइन विधि एथेरियम विशिष्ट हस्ताक्षर की गणना करती है: `sign(keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)))`।
+
+संदेश में एक उपसर्ग जोड़ने से गणना किए गए हस्ताक्षर को एक एथेरियम विशिष्ट हस्ताक्षर के रूप में पहचानने योग्य बनाता है। यह दुरुपयोग को रोकता है जहां एक दुर्भावनापूर्ण डैप मनमाने डेटा (जैसे, लेन-देन) पर हस्ताक्षर कर सकता है और पीड़ित का प्रतिरूपण करने के लिए हस्ताक्षर का उपयोग कर सकता है।
+
+नोट: हस्ताक्षर करने के लिए पता अनलॉक होना चाहिए।
+
+**पैरामीटर**
+
+1. `डेटा`, 20 बाइट्स - पता
+2. `डेटा`, N बाइट्स - हस्ताक्षर करने के लिए संदेश
+
+**रिटर्न**
+
+`डेटा`: हस्ताक्षर
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_sign\",\"params\":[\"0x9b2055d370f73ec7d8a03e965129118dc8f5bf83\", \"0xdeadbeaf\"],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a12d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee1b\"
+}
+```
+
+### eth_signTransaction {#eth_signtransaction}
+
+एक लेन-देन पर हस्ताक्षर करता है जिसे बाद में [eth_sendRawTransaction](#eth_sendrawtransaction) का उपयोग करके नेटवर्क पर जमा किया जा सकता है।
+
+**पैरामीटर**
+
+1. `ऑब्जेक्ट` - लेन-देन ऑब्जेक्ट
+
+- `प्रकार`:
+- `from`: `डेटा`, 20 बाइट्स - वह पता जिससे लेन-देन भेजा जाता है।
+- `to`: `डेटा`, 20 बाइट्स - (नया अनुबंध बनाते समय वैकल्पिक) वह पता जिस पर लेन-देन निर्देशित किया जाता है।
+- `गैस`: `मात्रा` - (वैकल्पिक, डिफ़ॉल्ट: 90000) लेन-देन निष्पादन के लिए प्रदान की गई गैस का पूर्णांक। यह अप्रयुक्त गैस लौटाएगा।
+- `gasPrice`: `मात्रा` - (वैकल्पिक, डिफ़ॉल्ट: निर्धारित किया जाना है) प्रत्येक भुगतान की गई गैस के लिए उपयोग किए जाने वाले गैस मूल्य का पूर्णांक, वेई में।
+- `value`: `मात्रा` - (वैकल्पिक) इस लेन-देन के साथ भेजे गए मान का पूर्णांक, वेई में।
+- `डेटा`: `डेटा` - किसी अनुबंध का संकलित कोड या लागू की गई विधि हस्ताक्षर का हैश और एन्कोड किए गए पैरामीटर।
+- `nonce`: `मात्रा` - (वैकल्पिक) एक नॉन का पूर्णांक। यह आपको अपने स्वयं के लंबित लेन-देन को ओवरराइट करने की अनुमति देता है जो समान नॉन का उपयोग करते हैं।
+
+**रिटर्न**
+
+`डेटा`, निर्दिष्ट खाते द्वारा हस्ताक्षरित RLP-एन्कोडेड लेन-देन ऑब्जेक्ट।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"id\": 1,\"jsonrpc\": \"2.0\",\"method\": \"eth_signTransaction\",\"params\": [{\"data\":\"0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675\",\"from\": \"0xb60e8dd61c5d32be8058bb8eb970870f07233155\",\"gas\": \"0x76c0\",\"gasPrice\": \"0x9184e72a000\",\"to\": \"0xd46e8dd67c5d32be8058bb8eb970870f07244567\",\"value\": \"0x9184e72a\"}]}'
+// परिणाम
+{
+ \"id\": 1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a12d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee1b\"
+}
+```
+
+### eth_sendTransaction {#eth_sendtransaction}
+
+यदि डेटा फ़ील्ड में कोड है, तो नया संदेश कॉल लेन-देन या एक अनुबंध निर्माण बनाता है, और `from` में निर्दिष्ट खाते का उपयोग करके इस पर हस्ताक्षर करता है।
+
+**पैरामीटर**
+
+1. `ऑब्जेक्ट` - लेन-देन ऑब्जेक्ट
+
+- `from`: `डेटा`, 20 बाइट्स - वह पता जिससे लेन-देन भेजा जाता है।
+- `to`: `डेटा`, 20 बाइट्स - (नया अनुबंध बनाते समय वैकल्पिक) वह पता जिस पर लेन-देन निर्देशित किया जाता है।
+- `गैस`: `मात्रा` - (वैकल्पिक, डिफ़ॉल्ट: 90000) लेन-देन निष्पादन के लिए प्रदान की गई गैस का पूर्णांक। यह अप्रयुक्त गैस लौटाएगा।
+- `gasPrice`: `मात्रा` - (वैकल्पिक, डिफ़ॉल्ट: निर्धारित किया जाना है) प्रत्येक भुगतान की गई गैस के लिए उपयोग किए जाने वाले गैस मूल्य का पूर्णांक।
+- `value`: `मात्रा` - (वैकल्पिक) इस लेन-देन के साथ भेजे गए मान का पूर्णांक।
+- `input`: `डेटा` - किसी अनुबंध का संकलित कोड या लागू की गई विधि हस्ताक्षर का हैश और एन्कोड किए गए पैरामीटर।
+- `nonce`: `मात्रा` - (वैकल्पिक) एक नॉन का पूर्णांक। यह आपको अपने स्वयं के लंबित लेन-देन को ओवरराइट करने की अनुमति देता है जो समान नॉन का उपयोग करते हैं।
+
+```js
+params: [
+ {
+ from: "0xb60e8dd61c5d32be8058bb8eb970870f07233155",
+ to: "0xd46e8dd67c5d32be8058bb8eb970870f07244567",
+ gas: "0x76c0", // 30400
+ gasPrice: "0x9184e72a000", // 10000000000000
+ value: "0x9184e72a", // 2441406250
+ input:
+ "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
+ },
+]
+```
+
+**रिटर्न**
+
+`डेटा`, 32 बाइट्स - लेन-देन का हैश, या शून्य हैश यदि लेन-देन अभी तक उपलब्ध नहीं है।
+
+जब आपने एक अनुबंध बनाया है, तो लेन-देन के एक ब्लॉक में प्रस्तावित होने के बाद, अनुबंध का पता प्राप्त करने के लिए [eth_getTransactionReceipt](#eth_gettransactionreceipt) का उपयोग करें।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_sendTransaction\",\"params\":[{उपर्युक्त देखें}],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331\"
+}
+```
+
+### eth_sendRawTransaction {#eth_sendrawtransaction}
+
+हस्ताक्षरित लेन-देन के लिए नया संदेश कॉल लेन-देन या एक अनुबंध निर्माण बनाता है।
+
+**पैरामीटर**
+
+1. `डेटा`, हस्ताक्षरित लेन-देन डेटा।
+
+```js
+params: [
+ "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675",
+]
+```
+
+**रिटर्न**
+
+`डेटा`, 32 बाइट्स - लेन-देन का हैश, या शून्य हैश यदि लेन-देन अभी तक उपलब्ध नहीं है।
+
+जब आपने एक अनुबंध बनाया है, तो लेन-देन के एक ब्लॉक में प्रस्तावित होने के बाद, अनुबंध का पता प्राप्त करने के लिए [eth_getTransactionReceipt](#eth_gettransactionreceipt) का उपयोग करें।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_sendRawTransaction\",\"params\":[{उपर्युक्त देखें}],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331\"
+}
+```
+
+### eth_call {#eth_call}
+
+ब्लॉकचेन पर लेन-देन बनाए बिना तुरंत एक नया संदेश कॉल निष्पादित करता है। अक्सर केवल-पढ़ने योग्य स्मार्ट अनुबंध कार्यों को निष्पादित करने के लिए उपयोग किया जाता है, उदाहरण के लिए ERC-20 अनुबंध के लिए `balanceOf`।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `ऑब्जेक्ट` - लेन-देन कॉल ऑब्जेक्ट
+
+- `from`: `डेटा`, 20 बाइट्स - (वैकल्पिक) वह पता जिससे लेन-देन भेजा जाता है।
+- `to`: `डेटा`, 20 बाइट्स - वह पता जिस पर लेन-देन निर्देशित किया जाता है।
+- `गैस`: `मात्रा` - (वैकल्पिक) लेन-देन निष्पादन के लिए प्रदान की गई गैस का पूर्णांक। eth_call शून्य गैस की खपत करता है, लेकिन इस पैरामीटर की कुछ निष्पादन के लिए आवश्यकता हो सकती है।
+- `gasPrice`: `मात्रा` - (वैकल्पिक) प्रत्येक भुगतान की गई गैस के लिए उपयोग किए जाने वाले गैस मूल्य का पूर्णांक
+- `value`: `मात्रा` - (वैकल्पिक) इस लेन-देन के साथ भेजे गए मान का पूर्णांक
+- `input`: `डेटा` - (वैकल्पिक) विधि हस्ताक्षर और एन्कोड किए गए मापदंडों का हैश। विवरण के लिए [सॉलिडिटी दस्तावेज़ीकरण में एथेरियम अनुबंध ABI](https://docs.soliditylang.org/en/latest/abi-spec.html) देखें।
+
+2. `मात्रा|टैग` - पूर्णांक ब्लॉक नंबर, या स्ट्रिंग `"latest"`, `"earliest"`, `"pending"`, `"safe"` या `"finalized"`, [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) देखें
+
+**रिटर्न**
+
+`डेटा` - निष्पादित अनुबंध का वापसी मान।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_call\",\"params\":[{उपर्युक्त देखें}],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x\"
+}
+```
+
+### eth_estimateGas {#eth_estimategas}
+
+लेन-देन को पूरा करने के लिए कितनी गैस आवश्यक है, इसका एक अनुमान उत्पन्न करता है और लौटाता है। लेन-देन को ब्लॉकचेन में नहीं जोड़ा जाएगा। ध्यान दें कि अनुमान EVM यांत्रिकी और नोड प्रदर्शन सहित विभिन्न कारणों से लेन-देन द्वारा वास्तव में उपयोग की गई गैस की मात्रा से काफी अधिक हो सकता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+[eth_call](#eth_call) पैरामीटर देखें, सिवाय इसके कि सभी गुण वैकल्पिक हैं। यदि कोई गैस सीमा निर्दिष्ट नहीं है, तो geth लंबित ब्लॉक से ब्लॉक गैस सीमा को ऊपरी सीमा के रूप में उपयोग करता है। परिणामस्वरूप, लौटाया गया अनुमान कॉल/लेन-देन को निष्पादित करने के लिए पर्याप्त नहीं हो सकता है जब गैस की मात्रा लंबित ब्लॉक गैस सीमा से अधिक हो।
+
+**रिटर्न**
+
+`मात्रा` - उपयोग की गई गैस की मात्रा।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_estimateGas\",\"params\":[{उपर्युक्त देखें}],\"id\":1}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x5208\" // 21000
+}
+```
+
+### eth_getBlockByHash {#eth_getblockbyhash}
+
+हैश द्वारा ब्लॉक के बारे में जानकारी लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 32 बाइट्स - एक ब्लॉक का हैश।
+2. `बूलियन` - यदि `true` है तो यह पूर्ण लेन-देन ऑब्जेक्ट लौटाता है, यदि `false` है तो केवल लेन-देन के हैश लौटाता है।
+
+```js
+params: [
+ "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
+ false,
+]
+```
+
+**रिटर्न**
+
+`ऑब्जेक्ट` - एक ब्लॉक ऑब्जेक्ट, या `null` जब कोई ब्लॉक नहीं मिला:
+
+- `number`: `मात्रा` - ब्लॉक नंबर। जब यह लंबित ब्लॉक हो तो `null`।
+- `hash`: `डेटा`, 32 बाइट्स - ब्लॉक का हैश। जब यह लंबित ब्लॉक हो तो `null`।
+- `parentHash`: `डेटा`, 32 बाइट्स - पैरेंट ब्लॉक का हैश।
+- `nonce`: `डेटा`, 8 बाइट्स - उत्पन्न प्रूफ-ऑफ-वर्क का हैश। जब यह लंबित ब्लॉक हो तो `null`, प्रूफ-ऑफ-स्टेक ब्लॉक के लिए `0x0` (द मर्ज के बाद से)
+- `sha3Uncles`: `डेटा`, 32 बाइट्स - ब्लॉक में अंकल डेटा का SHA3।
+- `logsBloom`: `डेटा`, 256 बाइट्स - ब्लॉक के लॉग के लिए ब्लूम फ़िल्टर। जब यह लंबित ब्लॉक हो तो `null`।
+- `transactionsRoot`: `डेटा`, 32 बाइट्स - ब्लॉक के लेन-देन ट्री का रूट।
+- `stateRoot`: `डेटा`, 32 बाइट्स - ब्लॉक के अंतिम स्टेट ट्री का रूट।
+- `receiptsRoot`: `डेटा`, 32 बाइट्स - ब्लॉक के रसीद ट्री का रूट।
+- `miner`: `डेटा`, 20 बाइट्स - उस लाभार्थी का पता जिसे ब्लॉक पुरस्कार दिए गए थे।
+- `difficulty`: `मात्रा` - इस ब्लॉक के लिए कठिनाई का पूर्णांक।
+- `totalDifficulty`: `मात्रा` - इस ब्लॉक तक चेन की कुल कठिनाई का पूर्णांक।
+- `extraData`: `डेटा` - इस ब्लॉक का "अतिरिक्त डेटा" फ़ील्ड।
+- `size`: `मात्रा` - बाइट्स में इस ब्लॉक का आकार का पूर्णांक।
+- `gasLimit`: `मात्रा` - इस ब्लॉक में अनुमत अधिकतम गैस।
+- `gasUsed`: `मात्रा` - इस ब्लॉक में सभी लेन-देन द्वारा उपयोग की गई कुल गैस।
+- `timestamp`: `मात्रा` - जब ब्लॉक को एकत्रित किया गया था तब का यूनिक्स टाइमस्टैम्प।
+- `transactions`: `सारणी` - अंतिम दिए गए पैरामीटर के आधार पर लेन-देन ऑब्जेक्ट्स की सारणी, या 32 बाइट्स लेन-देन हैश।
+- `uncles`: `सारणी` - अंकल हैश की सारणी।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getBlockByHash","params":["0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae", false],"id":1}'
+// परिणाम
+{
+ "jsonrpc": "2.0",
+ "id": 1,
+ "result": {
+ "difficulty": "0x4ea3f27bc",
+ "extraData": "0x476574682f4c5649562f76312e302e302f6c696e75782f676f312e342e32",
+ "gasLimit": "0x1388",
+ "gasUsed": "0x0",
+ "hash": "0xdc0818cf78f21a8e70579cb46a43643f78291264dda342ae31049421c82d21ae",
+ "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ "miner": "0xbb7b8287f3f0a933474a79eae42cbca977791171",
+ "mixHash": "0x4fffe9ae21f1c9e15207b1f472d5bbdd68c9595d461666602f2be20daf5e7843",
+ "nonce": "0x689056015818adbe",
+ "number": "0x1b4",
+ "parentHash": "0xe99e022112df268087ea7eafaf4790497fd21dbeeb6bd7a1721df161a6657a54",
+ "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+ "size": "0x220",
+ "stateRoot": "0xddc8b0234c2e0cad087c8b389aa7ef01f7d79b2570bccb77ce48648aa61c904d",
+ "timestamp": "0x55ba467c",
+ "totalDifficulty": "0x78ed983323d",
+ "transactions": [
+ ],
+ "transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ "uncles": [
+ ]
+ }
+}
+```
+
+### eth_getBlockByNumber {#eth_getblockbynumber}
+
+ब्लॉक नंबर द्वारा ब्लॉक के बारे में जानकारी लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `मात्रा|टैग` - एक ब्लॉक नंबर का पूर्णांक, या स्ट्रिंग `"earliest"`, `"latest"`, `"pending"`, `"safe"` या `"finalized"`, जैसा कि [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) में है।
+2. `बूलियन` - यदि `true` है तो यह पूर्ण लेन-देन ऑब्जेक्ट लौटाता है, यदि `false` है तो केवल लेन-देन के हैश लौटाता है।
+
+```js
+params: [
+ "0x1b4", // 436
+ true,
+]
+```
+
+**रिटर्न**
+[eth_getBlockByHash](#eth_getblockbyhash) देखें
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getBlockByNumber\",\"params\":[\"0x1b4\", true],\"id\":1}'
+```
+
+परिणाम के लिए [eth_getBlockByHash](#eth_getblockbyhash) देखें
+
+### eth_getTransactionByHash {#eth_gettransactionbyhash}
+
+लेन-देन हैश द्वारा अनुरोधित लेन-देन के बारे में जानकारी लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 32 बाइट्स - एक लेन-देन का हैश
+
+```js
+params: ["0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b"]
+```
+
+**रिटर्न**
+
+`ऑब्जेक्ट` - एक लेन-देन ऑब्जेक्ट, या `null` जब कोई लेन-देन नहीं मिला:
+
+- `blockHash`: `डेटा`, 32 बाइट्स - उस ब्लॉक का हैश जहां यह लेन-देन था। लंबित होने पर `null`।
+- `blockNumber`: `मात्रा` - ब्लॉक नंबर जहां यह लेन-देन था। लंबित होने पर `null`।
+- `from`: `डेटा`, 20 बाइट्स - प्रेषक का पता।
+- `गैस`: `मात्रा` - प्रेषक द्वारा प्रदान की गई गैस।
+- `gasPrice`: `मात्रा` - प्रेषक द्वारा वेई में प्रदान की गई गैस की कीमत।
+- `hash`: `डेटा`, 32 बाइट्स - लेन-देन का हैश।
+- `input`: `डेटा` - लेन-देन के साथ भेजा गया डेटा।
+- `nonce`: `मात्रा` - प्रेषक द्वारा इससे पहले किए गए लेन-देन की संख्या।
+- `to`: `डेटा`, 20 बाइट्स - प्राप्तकर्ता का पता। जब यह एक अनुबंध निर्माण लेन-देन है तो `null`।
+- `transactionIndex`: `मात्रा` - ब्लॉक में लेन-देन सूचकांक स्थिति का पूर्णांक। लंबित होने पर `null`।
+- `value`: `मात्रा` - वेई में स्थानांतरित मान।
+- `v`: `मात्रा` - ECDSA रिकवरी आईडी
+- `r`: `मात्रा` - ECDSA हस्ताक्षर r
+- `s`: `मात्रा` - ECDSA हस्ताक्षर s
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionByHash\",\"params\":[\"0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b\"],\"id\":1}'
+// परिणाम
+{
+ \"jsonrpc\":\"2.0\",
+ \"id\":1,
+ \"result\":{
+ \"blockHash\":\"0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2\",
+ \"blockNumber\":\"0x5daf3b\", // 6139707
+ \"from\":\"0xa7d9ddbe1f17865597fbd27ec712455208b6b76d\",
+ \"gas\":\"0xc350\", // 50000
+ \"gasPrice\":\"0x4a817c800\", // 20000000000
+ \"hash\":\"0x88df016429689c079f3b2f6ad39fa052532c56795b733da78a91ebe6a713944b\",
+ \"input\":\"0x68656c6c6f21\",
+ \"nonce\":\"0x15\", // 21
+ \"to\":\"0xf02c1c8e6114b1dbe8937a39260b5b0a374432bb\",
+ \"transactionIndex\":\"0x41\", // 65
+ \"value\":\"0xf3dbb76162000\", // 4290000000000000
+ \"v\":\"0x25\", // 37
+ \"r\":\"0x1b5e176d927f8e9ab405058b2d2457392da3e20f328b16ddabcebc33eaac5fea\",
+ \"s\":\"0x4ba69724e8f69de52f0125ad8b3c5c2cef33019bac3249e2c0a2192766d1721c\"
+ }
+}
+```
+
+### eth_getTransactionByBlockHashAndIndex {#eth_gettransactionbyblockhashandindex}
+
+ब्लॉक हैश और लेन-देन सूचकांक स्थिति द्वारा लेन-देन के बारे में जानकारी लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 32 बाइट्स - एक ब्लॉक का हैश।
+2. `मात्रा` - लेन-देन सूचकांक स्थिति का पूर्णांक।
+
+```js
+params: [
+ "0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2",
+ "0x0", // 0
+]
+```
+
+**रिटर्न**
+[eth_getTransactionByHash](#eth_gettransactionbyhash) देखें
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionByBlockHashAndIndex\",\"params\":[\"0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2\", \"0x0\"],\"id\":1}'
+```
+
+परिणाम के लिए [eth_getTransactionByHash](#eth_gettransactionbyhash) देखें
+
+### eth_getTransactionByBlockNumberAndIndex {#eth_gettransactionbyblocknumberandindex}
+
+ब्लॉक नंबर और लेन-देन सूचकांक स्थिति द्वारा लेन-देन के बारे में जानकारी लौटाता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `मात्रा|टैग` - एक ब्लॉक नंबर, या स्ट्रिंग `"earliest"`, `"latest"`, `"pending"`, `"safe"` या `"finalized"`, जैसा कि [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) में है।
+2. `मात्रा` - लेन-देन सूचकांक स्थिति।
+
+```js
+params: [
+ "0x9c47cf", // 10241999
+ "0x24", // 36
+]
+```
+
+**रिटर्न**
+[eth_getTransactionByHash](#eth_gettransactionbyhash) देखें
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionByBlockNumberAndIndex\",\"params\":[\"0x9c47cf\", \"0x24\"],\"id\":1}'
+```
+
+परिणाम के लिए [eth_getTransactionByHash](#eth_gettransactionbyhash) देखें
+
+### eth_getTransactionReceipt {#eth_gettransactionreceipt}
+
+लेन-देन हैश द्वारा लेन-देन की रसीद लौटाता है।
+
+**नोट** कि रसीद लंबित लेन-देन के लिए उपलब्ध नहीं है।
+
+**पैरामीटर**
+
+1. `डेटा`, 32 बाइट्स - एक लेन-देन का हैश
+
+```js
+params: ["0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5"]
+```
+
+**रिटर्न**
+`ऑब्जेक्ट` - एक लेन-देन रसीद ऑब्जेक्ट, या `null` जब कोई रसीद नहीं मिली:
+
+- `transactionHash `: `डेटा`, 32 बाइट्स - लेन-देन का हैश।
+- `transactionIndex`: `मात्रा` - ब्लॉक में लेन-देन सूचकांक स्थिति का पूर्णांक।
+- `blockHash`: `डेटा`, 32 बाइट्स - उस ब्लॉक का हैश जहां यह लेन-देन था।
+- `blockNumber`: `मात्रा` - ब्लॉक नंबर जहां यह लेन-देन था।
+- `from`: `डेटा`, 20 बाइट्स - प्रेषक का पता।
+- `to`: `डेटा`, 20 बाइट्स - प्राप्तकर्ता का पता। जब यह एक अनुबंध निर्माण लेन-देन है तो `null`।
+- `cumulativeGasUsed` : `मात्रा ` - जब यह लेन-देन ब्लॉक में निष्पादित किया गया था तब उपयोग की गई गैस की कुल राशि।
+- `effectiveGasPrice` : `मात्रा` - प्रति यूनिट गैस के लिए भुगतान किए गए आधार शुल्क और टिप का योग।
+- `gasUsed `: `मात्रा ` - अकेले इस विशिष्ट लेन-देन द्वारा उपयोग की गई गैस की मात्रा।
+- `contractAddress `: `डेटा`, 20 बाइट्स - बनाया गया अनुबंध पता, यदि लेन-देन एक अनुबंध निर्माण था, अन्यथा `null`।
+- `logs`: `सारणी` - लॉग ऑब्जेक्ट्स की सारणी, जो इस लेन-देन द्वारा उत्पन्न हुई।
+- `logsBloom`: `डेटा`, 256 बाइट्स - लाइट क्लाइंट के लिए संबंधित लॉग को जल्दी से पुनर्प्राप्त करने के लिए ब्लूम फ़िल्टर।
+- `type`: `मात्रा` - लेन-देन प्रकार का पूर्णांक, `0x0` लिगेसी लेन-देन के लिए, `0x1` एक्सेस सूची प्रकारों के लिए, `0x2` गतिशील शुल्क के लिए।
+
+यह इनमें से कोई एक भी लौटाता है:
+
+- `root` : `DATA` 32 बाइट्स का पोस्ट-ट्रांजेक्शन स्टेट रूट (प्री-Byzantium)
+- `status`: `मात्रा` या तो `1` (सफलता) या `0` (विफलता)
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getTransactionReceipt\",\"params\":[\"0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5\"],\"id\":1}'
+// परिणाम
+{
+ \"jsonrpc\": \"2.0\",
+ \"id\": 1,
+ \"result\": {
+ \"blockHash\":
+ \"0xa957d47df264a31badc3ae823e10ac1d444b098d9b73d204c40426e57f47e8c3\",
+ \"blockNumber\": \"0xeff35f\",
+ \"contractAddress\": null, // पते की स्ट्रिंग यदि यह बनाया गया था
+ \"cumulativeGasUsed\": \"0xa12515\",
+ \"effectiveGasPrice\": \"0x5a9c688d4\",
+ \"from\": \"0x6221a9c005f6e47eb398fd867784cacfdcfff4e7\",
+ \"gasUsed\": \"0xb4c8\",
+ \"logs\": [{
+ // getFilterLogs, आदि द्वारा लौटाए गए लॉग।
+ }],
+ \"logsBloom\": \"0x00...0\", // 256 बाइट ब्लूम फ़िल्टर
+ \"status\": \"0x1\",
+ \"to\": \"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\",
+ \"transactionHash\":
+ \"0x85d995eba9763907fdf35cd2034144dd9d53ce32cbec21349d4b12823c6860c5\",
+ \"transactionIndex\": \"0x66\",
+ \"type\": \"0x2\"
+ }
+}
+```
+
+### eth_getUncleByBlockHashAndIndex {#eth_getunclebyblockhashandindex}
+
+हैश और अंकल इंडेक्स की स्थिति के अनुसार ब्लॉक के अंकल के बारे में जानकारी देता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `डेटा`, 32 बाइट्स - एक ब्लॉक का हैश।
+2. `मात्रा` - अंकल की सूचकांक स्थिति।
+
+```js
+params: [
+ "0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2",
+ "0x0", // 0
+]
+```
+
+**रिटर्न**
+[eth_getBlockByHash](#eth_getblockbyhash) देखें
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getUncleByBlockHashAndIndex\",\"params\":[\"0x1d59ff54b1eb26b013ce3cb5fc9dab3705b415a67127a003c3e61eb445bb8df2\", \"0x0\"],\"id\":1}'
+```
+
+परिणाम के लिए [eth_getBlockByHash](#eth_getblockbyhash) देखें
+
+**नोट**: एक अंकल में व्यक्तिगत लेन-देन नहीं होते हैं।
+
+### eth_getUncleByBlockNumberAndIndex {#eth_getunclebyblocknumberandindex}
+
+नंबर और अंकल इंडेक्स की स्थिति के अनुसार ब्लॉक के अंकल के बारे में जानकारी देता है।
+
+
+ प्लेग्राउंड में एंडपॉइंट आज़माएं
+
+
+**पैरामीटर**
+
+1. `मात्रा|टैग` - एक ब्लॉक नंबर, या स्ट्रिंग `"earliest"`, `"latest"`, `"pending"`, `"safe"`, `"finalized"`, जैसा कि [ब्लॉक पैरामीटर](/developers/docs/apis/json-rpc/#block-parameter) में है।
+2. `मात्रा` - अंकल की सूचकांक स्थिति।
+
+```js
+params: [
+ "0x29c", // 668
+ "0x0", // 0
+]
+```
+
+**रिटर्न**
+[eth_getBlockByHash](#eth_getblockbyhash) देखें
+
+**नोट**: एक अंकल में व्यक्तिगत लेन-देन नहीं होते हैं।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getUncleByBlockNumberAndIndex\",\"params\":[\"0x29c\", \"0x0\"],\"id\":1}'
+```
+
+परिणाम के लिए [eth_getBlockByHash](#eth_getblockbyhash) देखें
+
+### eth_newFilter {#eth_newfilter}
+
+फ़िल्टर विकल्पों के आधार पर, एक फ़िल्टर ऑब्जेक्ट बनाता है, ताकि जब स्टेट बदल जाए (लॉग) तो सूचित किया जा सके।
+यह जांचने के लिए कि स्टेट बदला है या नहीं, [eth_getFilterChanges](#eth_getfilterchanges) को कॉल करें।
+
+**विषय फ़िल्टर निर्दिष्ट करने पर एक नोट:**
+विषय क्रम-निर्भर हैं। विषयों [A, B] के साथ लॉग वाला एक लेन-देन निम्नलिखित विषय फ़िल्टर द्वारा मेल खाएगा:
+
+- `[]` "कुछ भी"
+- `[A]` "पहली स्थिति में A (और बाद में कुछ भी)"
+- `[null, B]` "पहली स्थिति में कुछ भी और दूसरी स्थिति में B (और बाद में कुछ भी)"
+- `[A, B]` "पहली स्थिति में A और दूसरी स्थिति में B (और बाद में कुछ भी)"
+- `[[A, B], [A, B]]` "(A या B) पहली स्थिति में और (A या B) दूसरी स्थिति में (और बाद में कुछ भी)"
+- **पैरामीटर**
+
+1. `ऑब्जेक्ट` - फ़िल्टर विकल्प:
+
+- `fromBlock`: `मात्रा|टैग` - (वैकल्पिक, डिफ़ॉल्ट: `"latest"`) पूर्णांक ब्लॉक नंबर, या अंतिम प्रस्तावित ब्लॉक के लिए `"latest"`, नवीनतम सुरक्षित ब्लॉक के लिए `"safe"`, नवीनतम अंतिम ब्लॉक के लिए `"finalized"`, या `"pending"`, `"earliest"` अभी तक किसी ब्लॉक में नहीं लेन-देन के लिए।
+- `toBlock`: `मात्रा|टैग` - (वैकल्पिक, डिफ़ॉल्ट: `"latest"`) पूर्णांक ब्लॉक नंबर, या अंतिम प्रस्तावित ब्लॉक के लिए `"latest"`, नवीनतम सुरक्षित ब्लॉक के लिए `"safe"`, नवीनतम अंतिम ब्लॉक के लिए `"finalized"`, या `"pending"`, `"earliest"` अभी तक किसी ब्लॉक में नहीं लेन-देन के लिए।
+- `address`: `डेटा|सारणी`, 20 बाइट्स - (वैकल्पिक) अनुबंध पता या पतों की एक सूची जहां से लॉग उत्पन्न होने चाहिए।
+- `topics`: `डेटा की सारणी`, - (वैकल्पिक) 32 बाइट्स `डेटा` विषयों की सारणी। विषय क्रम-निर्भर हैं। प्रत्येक विषय "या" विकल्पों के साथ डेटा की एक सरणी भी हो सकती है।
+
+```js
+params: [
+ {
+ fromBlock: "0x1",
+ toBlock: "0x2",
+ address: "0x8888f1f195afa192cfee860698584c030f4c9db1",
+ topics: [
+ "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
+ null,
+ [
+ "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
+ "0x0000000000000000000000000aff3454fce5edbc8cca8697c15331677e6ebccc",
+ ],
+ ],
+ },
+]
+```
+
+**रिटर्न**
+`मात्रा` - एक फ़िल्टर आईडी।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_newFilter\",\"params\":[{\"topics\":[\"0x12341234\"]}],\"id\":73}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x1\" // 1
+}
+```
+
+### eth_newBlockFilter {#eth_newblockfilter}
+
+नोड में एक फ़िल्टर बनाता है, ताकि जब कोई नया ब्लॉक आए तो सूचित किया जा सके।
+यह जांचने के लिए कि स्टेट बदला है या नहीं, [eth_getFilterChanges](#eth_getfilterchanges) को कॉल करें।
+
+**पैरामीटर**
+कोई नहीं
+
+**रिटर्न**
+`मात्रा` - एक फ़िल्टर आईडी।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_newBlockFilter\",\"params\":[],\"id\":73}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x1\" // 1
+}
+```
+
+### eth_newPendingTransactionFilter {#eth_newpendingtransactionfilter}
+
+नोड में एक फ़िल्टर बनाता है, ताकि जब नए लंबित लेन-देन आएं तो सूचित किया जा सके।
+यह जांचने के लिए कि स्टेट बदला है या नहीं, [eth_getFilterChanges](#eth_getfilterchanges) को कॉल करें।
+
+**पैरामीटर**
+कोई नहीं
+
+**रिटर्न**
+`मात्रा` - एक फ़िल्टर आईडी।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_newPendingTransactionFilter\",\"params\":[],\"id\":73}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": \"0x1\" // 1
+}
+```
+
+### eth_uninstallFilter {#eth_uninstallfilter}
+
+दी गई आईडी के साथ एक फ़िल्टर को अनइंस्टॉल करता है। जब घड़ी की अब आवश्यकता न हो तो हमेशा कॉल किया जाना चाहिए।
+इसके अतिरिक्त, जब कुछ समय के लिए [eth_getFilterChanges](#eth_getfilterchanges) के साथ अनुरोध नहीं किया जाता है तो फ़िल्टर टाइमआउट हो जाते हैं।
+
+**पैरामीटर**
+
+1. `मात्रा` - फ़िल्टर आईडी।
+
+```js
+params: [
+ "0xb", // 11
+]
+```
+
+**रिटर्न**
+`बूलियन` - यदि फ़िल्टर सफलतापूर्वक अनइंस्टॉल किया गया था तो `true`, अन्यथा `false`।
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_uninstallFilter\",\"params\":[\"0xb\"],\"id\":73}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\": \"2.0\",
+ \"result\": true
+}
+```
+
+### eth_getFilterChanges {#eth_getfilterchanges}
+
+एक फ़िल्टर के लिए पोलिंग विधि, जो अंतिम पोल के बाद हुए लॉग की एक सरणी लौटाती है।
+
+**पैरामीटर**
+
+1. `मात्रा` - फ़िल्टर आईडी।
+
+```js
+params: [
+ "0x16", // 22
+]
+```
+
+**रिटर्न**
+`सारणी` - लॉग ऑब्जेक्ट्स की सारणी, या एक खाली सारणी यदि अंतिम पोल के बाद कुछ भी नहीं बदला है।
+
+- `eth_newBlockFilter` के साथ बनाए गए फ़िल्टर के लिए, रिटर्न ब्लॉक हैश (`DATA`, 32 बाइट्स) होते हैं, उदाहरण के लिए, `["0x3454645634534..."]`।
+
+- `eth_newPendingTransactionFilter` के साथ बनाए गए फ़िल्टर के लिए, रिटर्न लेनदेन हैश (`DATA`, 32 बाइट्स) होते हैं, उदाहरण के लिए, `["0x6345343454645..."]`।
+
+- `eth_newFilter` के साथ बनाए गए फ़िल्टर के लिए लॉग निम्नलिखित मापदंडों के साथ ऑब्जेक्ट हैं:
+ - `removed`: `टैग` - `true` जब लॉग हटा दिया गया था, एक चेन पुनर्गठन के कारण। यदि यह एक वैध लॉग है तो `false`।
+ - `logIndex`: `मात्रा` - ब्लॉक में लॉग इंडेक्स स्थिति का पूर्णांक। जब यह लंबित लॉग हो तो `null`।
+ - `transactionIndex`: `मात्रा` - लेन-देन सूचकांक स्थिति लॉग का पूर्णांक जहां से बनाया गया था। जब यह लंबित लॉग हो तो `null`।
+ - `transactionHash`: `डेटा`, 32 बाइट्स - उन लेन-देन का हैश जिनसे यह लॉग बनाया गया था। जब यह लंबित लॉग हो तो `null`।
+ - `blockHash`: `डेटा`, 32 बाइट्स - उस ब्लॉक का हैश जहां यह लॉग था। लंबित होने पर `null`। जब यह लंबित लॉग हो तो `null`।
+ - `blockNumber`: `मात्रा` - वह ब्लॉक नंबर जहां यह लॉग था। लंबित होने पर `null`। जब यह लंबित लॉग हो तो `null`।
+ - `address`: `डेटा`, 20 बाइट्स - वह पता जहां से यह लॉग उत्पन्न हुआ।
+ - `data`: `DATA` - चर-लंबाई वाला गैर-अनुक्रमित लॉग डेटा। (_solidity_ में: शून्य या अधिक 32 बाइट्स के गैर-अनुक्रमित लॉग आर्ग्यूमेंट्स।)
+ - `topics`: `डेटा की सारणी` - 0 से 4 32 बाइट्स `डेटा` की सारणी अनुक्रमित लॉग तर्कों की। (_solidity_ में: पहला विषय इवेंट के हस्ताक्षर का _हैश_ है (उदाहरण के लिए, `Deposit(address,bytes32,uint256)`), सिवाय इसके कि आपने `anonymous` स्पेसिफायर के साथ इवेंट की घोषणा की हो।)
+
+- **उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getFilterChanges\",\"params\":[\"0x16\"],\"id\":73}'
+// परिणाम
+{
+ \"id\":1,
+ \"jsonrpc\":\"2.0\",
+ \"result\": [{
+ \"logIndex\": \"0x1\", // 1
+ \"blockNumber\":\"0x1b4\", // 436
+ \"blockHash\": \"0x8216c5785ac562ff41e2dcfdf5785ac562ff41e2dcfdf829c5a142f1fccd7d\",
+ \"transactionHash\": \"0xdf829c5a142f1fccd7d8216c5785ac562ff41e2dcfdf5785ac562ff41e2dcf\",
+ \"transactionIndex\": \"0x0\", // 0
+ \"address\": \"0x16c5785ac562ff41e2dcfdf829c5a142f1fccd7d\",
+ \"data\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",
+ \"topics\": [\"0x59ebeb90bc63057b6515673c3ecf9438e5058bca0f92585014eced636878c9a5\"]
+ },{
+ ...
+ }]
+}
+```
+
+### eth_getFilterLogs {#eth_getfilterlogs}
+
+दी गई आईडी के साथ फ़िल्टर से मेल खाने वाले सभी लॉग की एक सरणी लौटाता है।
+
+**पैरामीटर**
+
+1. `मात्रा` - फ़िल्टर आईडी।
+
+```js
+params: [
+ "0x16", // 22
+]
+```
+
+**रिटर्न**
+[eth_getFilterChanges](#eth_getfilterchanges) देखें
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getFilterLogs\",\"params\":[\"0x16\"],\"id\":74}'
+```
+
+परिणाम के लिए [eth_getFilterChanges](#eth_getfilterchanges) देखें
+
+### eth_getLogs {#eth_getlogs}
+
+दिए गए फ़िल्टर ऑब्जेक्ट से मेल खाने वाले सभी लॉग की एक सरणी लौटाता है।
+
+**पैरामीटर**
+
+1. `ऑब्जेक्ट` - फ़िल्टर विकल्प:
+
+- `fromBlock`: `मात्रा|टैग` - (वैकल्पिक, डिफ़ॉल्ट: `"latest"`) पूर्णांक ब्लॉक नंबर, या अंतिम प्रस्तावित ब्लॉक के लिए `"latest"`, नवीनतम सुरक्षित ब्लॉक के लिए `"safe"`, नवीनतम अंतिम ब्लॉक के लिए `"finalized"`, या `"pending"`, `"earliest"` अभी तक किसी ब्लॉक में नहीं लेन-देन के लिए।
+- `toBlock`: `मात्रा|टैग` - (वैकल्पिक, डिफ़ॉल्ट: `"latest"`) पूर्णांक ब्लॉक नंबर, या अंतिम प्रस्तावित ब्लॉक के लिए `"latest"`, नवीनतम सुरक्षित ब्लॉक के लिए `"safe"`, नवीनतम अंतिम ब्लॉक के लिए `"finalized"`, या `"pending"`, `"earliest"` अभी तक किसी ब्लॉक में नहीं लेन-देन के लिए।
+- `address`: `डेटा|सारणी`, 20 बाइट्स - (वैकल्पिक) अनुबंध पता या पतों की एक सूची जहां से लॉग उत्पन्न होने चाहिए।
+- `topics`: `डेटा की सारणी`, - (वैकल्पिक) 32 बाइट्स `डेटा` विषयों की सारणी। विषय क्रम-निर्भर हैं। प्रत्येक विषय "या" विकल्पों के साथ डेटा की एक सरणी भी हो सकती है।
+- `blockHash`: `डेटा`, 32 बाइट्स - (वैकल्पिक, **भविष्य**) EIP-234 के जुड़ने के साथ, `blockHash` एक नया फ़िल्टर विकल्प होगा जो लौटाए गए लॉग को 32-बाइट हैश `blockHash` वाले एकल ब्लॉक तक सीमित करता है। `blockHash` का उपयोग करना `fromBlock` = `toBlock` = हैश `blockHash` वाले ब्लॉक नंबर के बराबर है। यदि `blockHash` फ़िल्टर मानदंड में मौजूद है, तो न तो `fromBlock` और न ही `toBlock` की अनुमति है।
+
+```js
+params: [
+ {
+ topics: [
+ "0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b",
+ ],
+ },
+]
+```
+
+**रिटर्न**
+[eth_getFilterChanges](#eth_getfilterchanges) देखें
+
+**उदाहरण**
+
+```js
+// अनुरोध
+curl -X POST --data '{\"jsonrpc\":\"2.0\",\"method\":\"eth_getLogs\",\"params\":[{\"topics\":[\"0x000000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b\"]}],\"id\":74}'
+```
+
+परिणाम के लिए [eth_getFilterChanges](#eth_getfilterchanges) देखें
+
+## उपयोग का उदाहरण {#usage-example}
+
+### JSON_RPC का उपयोग करके अनुबंध को तैनात करना {#deploying-contract}
+
+इस अनुभाग में केवल RPC इंटरफ़ेस का उपयोग करके अनुबंध को कैसे तैनात किया जाए, इसका एक प्रदर्शन शामिल है। अनुबंधों को तैनात करने के लिए वैकल्पिक मार्ग हैं जहां इस जटिलता को दूर किया जाता है - उदाहरण के लिए, RPC इंटरफ़ेस के शीर्ष पर बनी लाइब्रेरी का उपयोग करना जैसे [web3.js](https://web3js.readthedocs.io/) और [web3.py](https://github.com/ethereum/web3.py)। ये सारग्रहण आम तौर पर समझने में आसान और कम त्रुटि-प्रवण होते हैं, लेकिन यह समझना अभी भी सहायक है कि पर्दे के पीछे क्या हो रहा है।
+
+निम्नलिखित एक सीधा-सादा स्मार्ट अनुबंध है जिसे `Multiply7` कहा जाता है जिसे एक एथेरियम नोड पर JSON-RPC इंटरफ़ेस का उपयोग करके तैनात किया जाएगा। यह ट्यूटोरियल मानता है कि पाठक पहले से ही एक Geth नोड चला रहा है। नोड और क्लाइंट के बारे में अधिक जानकारी [यहां](/developers/docs/nodes-and-clients/run-a-node) उपलब्ध है। गैर-Geth क्लाइंट के लिए HTTP JSON-RPC कैसे शुरू करें, यह देखने के लिए कृपया व्यक्तिगत [क्लाइंट](/developers/docs/nodes-and-clients/) दस्तावेज़ीकरण देखें। अधिकांश क्लाइंट `localhost:8545` पर सेवा देने के लिए डिफ़ॉल्ट होते हैं।
+
+```javascript
+contract Multiply7 {
+ event Print(uint);
+ function multiply(uint input) returns (uint) {
+ Print(input * 7);
+ return input * 7;
+ }
+}
+```
+
+सबसे पहली बात यह सुनिश्चित करना है कि HTTP RPC इंटरफ़ेस सक्षम है। इसका मतलब है कि हम स्टार्टअप पर Geth को `--http` फ्लैग प्रदान करते हैं। इस उदाहरण में हम एक निजी विकास श्रृंखला पर Geth नोड का उपयोग करते हैं। इस दृष्टिकोण का उपयोग करके हमें वास्तविक नेटवर्क पर ईथर की आवश्यकता नहीं है।
+
+```bash
+geth --http --dev console 2>>geth.log
+```
+
+यह `http://localhost:8545` पर HTTP RPC इंटरफ़ेस शुरू करेगा।
+
+हम यह सत्यापित कर सकते हैं कि इंटरफ़ेस [curl](https://curl.se) का उपयोग करके कॉइनबेस पता (खातों की सरणी से पहला पता प्राप्त करके) और शेष राशि प्राप्त करके चल रहा है। कृपया ध्यान दें कि इन उदाहरणों में डेटा आपके स्थानीय नोड पर भिन्न होगा। यदि आप इन आदेशों को आज़माना चाहते हैं, तो दूसरे कर्ल अनुरोध में अनुरोध पैरामीटर को पहले से लौटाए गए परिणाम से बदलें।
+
+```bash
+curl --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[], "id":1}' -H "Content-Type: application/json" localhost:8545
+{"id":1,"jsonrpc":"2.0","result":["0x9b1d35635cc34752ca54713bb99d38614f63c955"]}
+
+curl --data '{"jsonrpc":"2.0","method":"eth_getBalance", "params": ["0x9b1d35635cc34752ca54713bb99d38614f63c955", "latest"], "id":2}' -H "Content-Type: application/json" localhost:8545
+{"id":2,"jsonrpc":"2.0","result":"0x1639e49bba16280000"}
+```
+
+चूंकि संख्याएं हेक्स एन्कोडेड होती हैं, इसलिए शेष राशि को हेक्स स्ट्रिंग के रूप में वेई में लौटाया जाता है। यदि हम शेष राशि को ईथर में एक संख्या के रूप में चाहते हैं तो हम Geth कंसोल से web3 का उपयोग कर सकते हैं।
+
+```javascript
+web3.fromWei("0x1639e49bba16280000", "ether")
+// "410"
+```
+
+अब जब हमारी निजी विकास श्रृंखला पर कुछ ईथर है, तो हम अनुबंध को तैनात कर सकते हैं। पहला कदम Multiply7 अनुबंध को बाइट कोड में संकलित करना है जिसे EVM को भेजा जा सकता है। सॉलिडिटी कंपाइलर solc को स्थापित करने के लिए, [सॉलिडिटी दस्तावेज़ीकरण](https://docs.soliditylang.org/en/latest/installing-solidity.html) का पालन करें। (आप [हमारे उदाहरण के लिए उपयोग किए गए कंपाइलर के संस्करण](https://github.com/ethereum/solidity/releases/tag/v0.4.20) से मेल खाने के लिए एक पुराने `solc` रिलीज़ का उपयोग करना चाह सकते हैं।)
+
+अगला कदम Multiply7 अनुबंध को बाइट कोड में संकलित करना है जिसे EVM में भेजा जा सकता है।
+
+```bash
+echo 'pragma solidity ^0.4.16; contract Multiply7 { event Print(uint); function multiply(uint input) public returns (uint) { Print(input * 7); return input * 7; } }' | solc --bin
+
+======= :Multiply7 =======
+Binary:
+6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029
+```
+
+अब जब हमारे पास संकलित कोड है तो हमें यह निर्धारित करने की आवश्यकता है कि इसे तैनात करने में कितनी गैस लगती है। RPC इंटरफ़ेस में एक `eth_estimateGas` विधि है जो हमें एक अनुमान देगी।
+
+```bash
+curl --data '{\"jsonrpc\":\"2.0\",\"method\": \"eth_estimateGas\", \"params\": [{\"from\": \"0x9b1d35635cc34752ca54713bb99d38614f63c955\", \"data\": \"0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029\"}], \"id\": 5}' -H "Content-Type: application/json" localhost:8545
+{\"jsonrpc\":\"2.0\",\"id\":5,\"result\":\"0x1c31e\"}
+```
+
+और अंत में अनुबंध को तैनात करें।
+
+```bash
+curl --data '{\"jsonrpc\":\"2.0\",\"method\": \"eth_sendTransaction\", \"params\": [{\"from\": \"0x9b1d35635cc34752ca54713bb99d38614f63c955\", \"gas\": \"0x1c31e\", \"data\": \"0x6060604052341561000f57600080fd5b60eb8061001d6000396000f300606060405260043610603f576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063c6888fa1146044575b600080fd5b3415604e57600080fd5b606260048080359060200190919050506078565b6040518082815260200191505060405180910390f35b60007f24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da600783026040518082815260200191505060405180910390a16007820290509190505600a165627a7a7230582040383f19d9f65246752244189b02f56e8d0980ed44e7a56c0b200458caad20bb0029\"}], \"id\": 6}' -H "Content-Type: application/json" localhost:8545
+{\"id\":6,\"jsonrpc\":\"2.0\",\"result\":\"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf\"}
+```
+
+लेन-देन नोड द्वारा स्वीकार किया जाता है और एक लेन-देन हैश लौटाया जाता है। इस हैश का उपयोग लेन-देन को ट्रैक करने के लिए किया जा सकता है। अगला कदम यह निर्धारित करना है कि हमारा अनुबंध कहां तैनात है। प्रत्येक निष्पादित लेन-देन एक रसीद बनाएगा। इस रसीद में लेन-देन के बारे में विभिन्न जानकारी होती है जैसे कि लेन-देन किस ब्लॉक में शामिल था और EVM द्वारा कितनी गैस का उपयोग किया गया था। यदि कोई लेन-देन अनुबंध बनाता है तो उसमें अनुबंध का पता भी होगा। हम `eth_getTransactionReceipt` RPC विधि से रसीद प्राप्त कर सकते हैं।
+
+```bash
+curl --data '{\"jsonrpc\":\"2.0\",\"method\": \"eth_getTransactionReceipt\", \"params\": [\"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf\"], \"id\": 7}' -H "Content-Type: application/json" localhost:8545
+{\"jsonrpc\":\"2.0\",\"id\":7,\"result\":{\"blockHash\":\"0x77b1a4f6872b9066312de3744f60020cbd8102af68b1f6512a05b7619d527a4f\",\"blockNumber\":\"0x1\",\"contractAddress\":\"0x4d03d617d700cf81935d7f797f4e2ae719648262\",\"cumulativeGasUsed\":\"0x1c31e\",\"from\":\"0x9b1d35635cc34752ca54713bb99d38614f63c955\",\"gasUsed\":\"0x1c31e\",\"logs\":[],\"logsBloom\":\"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\"status\":\"0x1\",\"to\":null,\"transactionHash\":\"0xe1f3095770633ab2b18081658bad475439f6a08c902d0915903bafff06e6febf\",\"transactionIndex\":\"0x0\"}}
+```
+
+हमारा अनुबंध `0x4d03d617d700cf81935d7f797f4e2ae719648262` पर बनाया गया था। रसीद के बजाय एक शून्य परिणाम का मतलब है कि लेन-देन अभी तक एक ब्लॉक में शामिल नहीं किया गया है। एक पल प्रतीक्षा करें और जांचें कि क्या आपका सहमति क्लाइंट चल रहा है और इसे पुनः प्रयास करें।
+
+#### स्मार्ट अनुबंधों के साथ सहभागिता {#interacting-with-smart-contract}
+
+इस उदाहरण में हम अनुबंध की `multiply` विधि को `eth_sendTransaction` का उपयोग करके एक लेन-देन भेजेंगे।
+
+`eth_sendTransaction` को कई तर्कों की आवश्यकता होती है, विशेष रूप से `from`, `to` और `data`। `From` हमारे खाते का सार्वजनिक पता है, और `to` अनुबंध का पता है। `data` तर्क में एक पेलोड होता है जो यह परिभाषित करता है कि किस विधि को कॉल किया जाना चाहिए और किन तर्कों के साथ। यहीं पर [ABI (एप्लिकेशन बाइनरी इंटरफ़ेस)](https://docs.soliditylang.org/en/latest/abi-spec.html) काम आता है। ABI एक JSON फ़ाइल है जो यह परिभाषित करती है कि EVM के लिए डेटा को कैसे परिभाषित और एन्कोड किया जाए।
+
+पेलोड के बाइट्स यह परिभाषित करते हैं कि अनुबंध में किस विधि को कॉल किया गया है। यह फ़ंक्शन नाम और उसके तर्क प्रकारों पर केccak हैश से पहले 4 बाइट्स है, हेक्स एन्कोडेड। मल्टीप्लाई फ़ंक्शन एक uint स्वीकार करता है जो uint256 के लिए एक उपनाम है। यह हमें छोड़ देता है:
+
+```javascript
+web3.sha3("multiply(uint256)").substring(0, 10)
+// "0xc6888fa1"
+```
+
+अगला कदम तर्कों को एन्कोड करना है। केवल एक uint256 है, मान लीजिए, मान 6 है। ABI में एक अनुभाग है जो यह निर्दिष्ट करता है कि uint256 प्रकारों को कैसे एन्कोड किया जाए।
+
+`int: enc(X)` X का बिग-एंडियन टू का पूरक एन्कोडिंग है, जो ऋणात्मक X के लिए 0xff के साथ और धनात्मक X के लिए शून्य बाइट्स के साथ उच्च-क्रम (बाएं) तरफ गद्देदार है ताकि लंबाई 32 बाइट्स का एक गुणक हो।
+
+यह `0000000000000000000000000000000000000000000000000000000000000006` को एन्कोड करता है।
+
+फ़ंक्शन चयनकर्ता और एन्कोडेड तर्क को मिलाकर हमारा डेटा `0xc6888fa10000000000000000000000000000000000000000000000000000000000000006` होगा।
+
+इसे अब नोड पर भेजा जा सकता है:
+
+```bash
+curl --data '{\"jsonrpc\":\"2.0\",\"method\": \"eth_sendTransaction\", \"params\": [{\"from\": \"0xeb85a5557e5bdc18ee1934a89d8bb402398ee26a\", \"to\": \"0x6ff93b4b46b41c0c3c9baee01c255d3b4675963d\", \"data\": \"0xc6888fa10000000000000000000000000000000000000000000000000000000000000006\"}], \"id\": 8}' -H "Content-Type: application/json" localhost:8545
+{\"id\":8,\"jsonrpc\":\"2.0\",\"result\":\"0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74\"}
+```
+
+चूंकि एक लेन-देन भेजा गया था, एक लेन-देन हैश लौटाया गया था। रसीद प्राप्त करने पर मिलता है:
+
+```javascript
+{
+ blockHash: "0xbf0a347307b8c63dd8c1d3d7cbdc0b463e6e7c9bf0a35be40393588242f01d55",
+ blockNumber: 268,
+ contractAddress: null,
+ cumulativeGasUsed: 22631,
+ gasUsed: 22631,
+ logs: [{
+ address: "0x6ff93b4b46b41c0c3c9baee01c255d3b4675963d",
+ blockHash: "0xbf0a347307b8c63dd8c1d3d7cbdc0b463e6e7c9bf0a35be40393588242f01d55",
+ blockNumber: 268,
+ data: "0x000000000000000000000000000000000000000000000000000000000000002a",
+ logIndex: 0,
+ topics: ["0x24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da"],
+ transactionHash: "0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74",
+ transactionIndex: 0
+ }],
+ transactionHash: "0x759cf065cbc22e9d779748dc53763854e5376eea07409e590c990eafc0869d74",
+ transactionIndex: 0
+}
+```
+
+रसीद में एक लॉग होता है। यह लॉग EVM द्वारा लेन-देन निष्पादन पर उत्पन्न किया गया था और रसीद में शामिल किया गया था। `multiply` फ़ंक्शन से पता चलता है कि `Print` इवेंट इनपुट गुणा 7 के साथ उठाया गया था। चूंकि `Print` इवेंट के लिए तर्क एक uint256 था, हम इसे ABI नियमों के अनुसार डीकोड कर सकते हैं जो हमें अपेक्षित दशमलव 42 के साथ छोड़ देगा। डेटा के अलावा यह ध्यान देने योग्य है कि विषयों का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि किस इवेंट ने लॉग बनाया है:
+
+```javascript
+web3.sha3("Print(uint256)")
+// "24abdb5865df5079dcc5ac590ff6f01d5c16edbc5fab4e195d9febd1114503da"
+```
+
+यह JSON-RPC के प्रत्यक्ष उपयोग का प्रदर्शन करते हुए, कुछ सबसे सामान्य कार्यों का एक संक्षिप्त परिचय था।
+
+## संबंधित विषय {#related-topics}
+
+- [JSON-RPC विनिर्देश](http://www.jsonrpc.org/specification)
+- [नोड्स और क्लाइंट्स](/developers/docs/nodes-and-clients/)
+- [जावास्क्रिप्ट API](/developers/docs/apis/javascript/)
+- [बैकएंड API](/developers/docs/apis/backend/)
+- [निष्पादन क्लाइंट](/developers/docs/nodes-and-clients/#execution-clients)
diff --git a/public/content/translations/hi/developers/docs/blocks/index.md b/public/content/translations/hi/developers/docs/blocks/index.md
new file mode 100644
index 00000000000..1fc3d1c2248
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/blocks/index.md
@@ -0,0 +1,153 @@
+---
+title: "ब्लॉक"
+description: "एथेरियम ब्लॉकचेन में ब्लॉक का अवलोकन – उनकी डेटा संरचना, उनकी आवश्यकता क्यों है, और वे कैसे बने हैं।"
+lang: hi
+---
+
+ब्लॉकचेन में पिछले ब्लॉक के हैश के साथ लेनदेन के बैच हैं। यह ब्लॉक को एक साथ (एक चेन में) जोड़ता है, क्योंकि हैश क्रिप्टोग्राफ़िक रूप से ब्लॉक डेटा से प्राप्त होते हैं। यह धोखाधड़ी को रोकता है, क्योंकि इतिहास में किसी भी ब्लॉक में एक बदलाव निम्नलिखित सभी ब्लॉकों को अमान्य कर देगा, क्योंकि बाद के सभी हैश बदल जाएंगे और ब्लॉकचेन चलाने वाला हर कोई नोटिस करेगा।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+ब्लॉक एक बहुत ही शुरुआती-अनुकूल विषय है। लेकिन इस पृष्ठ को बेहतर ढंग से समझने में आपकी सहायता के लिए, हम अनुशंसा करते हैं कि आप पहले [खातों](/developers/docs/accounts/), [लेन-देन](/developers/docs/transactions/) और हमारे [एथेरियम का परिचय](/developers/docs/intro-to-ethereum/) को पढ़ें।
+
+## ब्लॉक क्यों? {#why-blocks}
+
+यह सुनिश्चित करने के लिए कि एथेरियम नेटवर्क पर सभी प्रतिभागी एक सिंक्रनाइज़ स्थिति बनाए रखें और लेनदेन के सटीक इतिहास पर सहमत हों, हम लेनदेन को ब्लॉक में बैच करते हैं। इसका मतलब है कि दर्जनों (या सैकड़ों) लेनदेन एक ही बार में प्रतिबद्ध, सहमत और सिंक्रनाइज़ किए जाते हैं।
+
+
+_आरेख [एथेरियम EVM सचित्र](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf) से अनुकूलित है_
+
+कमिट को अंतराल देकर, हम सभी नेटवर्क प्रतिभागियों को आम सहमति पर आने के लिए पर्याप्त समय देते हैं: भले ही लेनदेन अनुरोध प्रति सेकंड दर्जनों बार होते हैं, ब्लॉक केवल हर बारह सेकंड में एक बार एथेरियम पर बनाए जाते हैं और प्रतिबद्ध होते हैं।
+
+## ब्लॉक कैसे काम करते हैं {#how-blocks-work}
+
+लेनदेन के इतिहास को सुरक्षित करने के लिए, ब्लॉक को सख्ती से आदेश दिया जाता है (बनाए गए हर नए ब्लॉक में उसके मूल ब्लॉक का संदर्भ होता है), और ब्लॉक के अंदर लेनदेन को भी सख्ती से आदेश दिया जाता है। बहुत कम मामलों को छोड़कर, किसी भी समय, नेटवर्क पर सभी प्रतिभागी ब्लॉक की सटीक संख्या और इतिहास पर सहमत होते हैं, और वर्तमान लाइव लेनदेन अनुरोधों को अगले ब्लॉक में बैच करने के लिए काम कर रहे हैं।
+
+एक बार जब नेटवर्क पर रैंडम तरीके से चयनित सत्यापनकर्ता द्वारा एक ब्लॉक को एक साथ रखा जाता है, तो इसे बाकी नेटवर्क में प्रचारित किया जाता है; सभी नोड्स इस ब्लॉक को अपने ब्लॉकचेन के आखिर में जोड़ते हैं, और अगला ब्लॉक बनाने के लिए एक नया सत्यापनकर्ता चुना जाता है। सटीक ब्लॉक-असेंबली प्रक्रिया और प्रतिबद्धता/सर्वसम्मति प्रक्रिया वर्तमान में एथेरियम के "हिस्सेदारी का सबूत" प्रोटोकॉल द्वारा निर्दिष्ट किया गया है।
+
+## प्रूफ-ऑफ-स्टेक प्रोटोकॉल {#proof-of-stake-protocol}
+
+प्रूफ-ऑफ-स्टेक का निम्नलिखित अर्थ है:
+
+- मान्य नोड्स को बुरे व्यवहार के खिलाफ संपार्श्विक के रूप में जमा अनुबंध में 32 ETH को दांव पर लगाना पड़ता है। यह नेटवर्क की सुरक्षा में मदद करता है, क्योंकि साबित होने वाली दुर्भावनापूर्ण गतिविधि से कुछ या सभी हिस्सेदारी नष्ट हो जाती है।
+- हर स्लॉट में (बारह सेकंड के अलावा) एक सत्यापनकर्ता को ब्लॉक प्रस्तावक के रूप में रैंडम तरीके से चुना जाता है। वे लेनदेन को एक साथ बंडल करते हैं, उन्हें निष्पादित करते हैं और एक नया 'स्टेट' निर्धारित करते हैं। वे इस जानकारी को एक ब्लॉक में शामिल करते हैं और इसे अन्य सत्यापनकर्ताओं को पास करते हैं।
+- अन्य सत्यापनकर्ता जो नए ब्लॉक के बारे में सुनते हैं, यह सुनिश्चित करने के लिए लेनदेन को फिर से निष्पादित करते हैं कि वे वैश्विक स्थिति में प्रस्तावित बदलाव से सहमत हैं। यह मानते हुए कि ब्लॉक मान्य है, वे इसे अपने डेटाबेस में जोड़ते हैं।
+- अगर कोई सत्यापनकर्ता एक ही स्लॉट के लिए दो परस्पर विरोधी ब्लॉकों के बारे में सुनता है, तो वे अपने फ़ॉर्क-पसंद एल्गोरिथ्म का उपयोग सबसे अधिक दांव पर लगे ETH द्वारा समर्थित एक को चुनने के लिए करते हैं।
+
+[प्रूफ-ऑफ-स्टेक पर और अधिक](/developers/docs/consensus-mechanisms/pos)
+
+## एक ब्लॉक में क्या है? {#block-anatomy}
+
+एक ब्लॉक के भीतर बहुत सारी जानकारी शामिल है। उच्चतम लेवल पर एक ब्लॉक में निम्नलिखित फ़ील्ड होते हैं:
+
+| फ़ील्ड | वर्णन |
+| :--------------- | :----------------------------------------------------------------------- |
+| `स्लॉट्स` | ब्लॉक किस स्लॉट से संबंधित है |
+| `proposer_index` | ब्लॉक का प्रस्ताव करने वाले सत्यापनकर्ता की आईडी |
+| `parent_root` | पहले वाले ब्लॉक का हैश |
+| `state_root` | स्टेट ऑब्जेक्ट का रूट हैश |
+| `body` | एक ऑब्जेक्ट जिसमें कई फ़ील्ड होते हैं, जैसा कि नीचे परिभाषित किया गया है |
+
+ब्लॉक `body` में अपने खुद के कई फ़ील्ड होते हैं:
+
+| फ़ील्ड | वर्णन |
+| :------------------- | :------------------------------------------------------------------------ |
+| `randao_reveal` | अगले ब्लॉक प्रोपोज़र का चयन करने के लिए उपयोग किया जाने वाला मान |
+| `eth1_data` | जमा अनुबंध के बारे में जानकारी |
+| `graffiti` | ब्लॉक टैग करने के लिए उपयोग किया जाने वाला मनमाना डेटा |
+| `proposer_slashings` | स्लैश किए जाने वाले सत्यापनकर्ताओं की सूची |
+| `attester_slashings` | स्लैश किये या हटाए जाने वाले सत्यापकों की सूची |
+| `सत्यापन` | पिछले स्लॉट के लिए किए गए सत्यापनों की सूची |
+| `deposits` | जमा अनुबंध में नई जमाओं की सूची |
+| `voluntary_exits` | नेटवर्क से बाहर निकलने वाले सत्यापनकर्ताओं की सूची |
+| `sync_aggregate` | लाइट क्लाइंट्स की सेवा के लिए उपयोग किए जाने वाले सत्यापनकर्ताओं का सबसेट |
+| `execution_payload` | निष्पादन ग्राहक से पारित लेनदेन |
+
+`attestations` फ़ील्ड में ब्लॉक में मौजूद सभी सत्यापनों की एक सूची होती है। सत्यापन का अपना डेटा प्रकार होता है जिसमें डेटा के कई हिस्से होते हैं। हर सत्यापन में शामिल हैं:
+
+| फ़ील्ड | वर्णन |
+| :----------------- | :---------------------------------------------------------------- |
+| `aggregation_bits` | एक सूची जिसमें सत्यापनकर्ताओं ने इस सत्यापन में भाग लिया |
+| `data` | एक से ज़्यादा उपक्षेत्रों वाला कंटेनर |
+| `हस्ताक्षर` | `data` भाग के विरुद्ध सत्यापनकर्ताओं के एक सेट का समग्र हस्ताक्षर |
+
+`attestation` में `data` फ़ील्ड में निम्न शामिल हैं:
+
+| फ़ील्ड | वर्णन |
+| :------------------ | :-------------------------------------------------- |
+| `स्लॉट्स` | सत्यापन किस स्लॉट से संबंधित है |
+| `इंडेक्स` | सत्यापनकर्ताओं को सत्यापित करने के लिए सूचकांक |
+| `beacon_block_root` | चेन के हेड के रूप में देखे गए बीकन ब्लॉक का रूट हैश |
+| `स्रोत` | पिछली उचित चौकी |
+| `target` | नया इपॉक बाउंड्री ब्लॉक |
+
+`execution_payload` में लेनदेन निष्पादित करने से वैश्विक स्थिति अपडेट होती है। सभी क्लाइंट यह सुनिश्चित करने के लिए `execution_payload` में लेनदेन को फिर से निष्पादित करते हैं कि नई स्थिति नए ब्लॉक `state_root` फ़ील्ड में मौजूद स्थिति से मेल खाती है। इस प्रकार क्लाइंट बता सकते हैं कि उनके ब्लॉकचेन में जोड़ने के लिए एक नया ब्लॉक मान्य और सुरक्षित है। `execution payload` स्वयं कई फ़ील्ड वाला एक ऑब्जेक्ट है। एक `execution_payload_header` भी है जिसमें निष्पादन संबंधी डेटा के बारे में महत्वपूर्ण सारांश के तौर पर जानकारी है। ये डेटा संरचनाएं निम्नानुसार व्यवस्थित हैं:
+
+`execution_payload_header` में निम्न फ़ील्ड हैं:
+
+| फ़ील्ड | वर्णन |
+| :------------------ | :---------------------------------------------------------------- |
+| `parent_hash` | पैरेंट ब्लॉक का हैश |
+| `fee_recipient` | निम्न को लेनदेन शुल्क का भुगतान करने के लिए खाते पता |
+| `state_root` | रूट हैश इस ब्लॉक में बदलाव लागू करने के बाद वैश्विक स्थिति के लिए |
+| `receipts_root` | लेनदेन रसिप्ट ट्राई का हैश |
+| `logs_bloom` | डेटा संरचना जिसमें ईवेंट लॉग शामिल हैं |
+| `prev_randao` | सत्यापनकर्ता के रैंडम चयन में उपयोग किया जाने वाला मान |
+| `block_number` | वर्तमान ब्लॉक की संख्या |
+| `gas_limit` | इस ब्लॉक में अधिकतम गैस की अनुमति है |
+| `gas_used` | इस ब्लॉक में उपयोग की जाने वाली गैस की असल मात्रा |
+| `timestamp` | ब्लॉक का समय |
+| `extra_data` | रॉ बाइट्स के रूप में मनमाना अतिरिक्त डेटा |
+| `base_fee_per_gas` | आधार शुल्क मूल्य |
+| `block_hash` | निष्पादन ब्लॉक का हैश |
+| `transactions_root` | पेलोड में लेनदेन का रूट हैश |
+| `withdrawal_root` | पेलोड में निकासी का रूट हैश |
+
+`execution_payload` में ही निम्नलिखित शामिल हैं (ध्यान दें कि यह हेडर के समान है, सिवाय इसके कि लेनदेन के रूट हैश के बजाय इसमें लेनदेन की असल सूची और निकासी की जानकारी शामिल है):
+
+| फ़ील्ड | वर्णन |
+| :----------------- | :---------------------------------------------------------------- |
+| `parent_hash` | पैरेंट ब्लॉक का हैश |
+| `fee_recipient` | निम्न को लेनदेन शुल्क का भुगतान करने के लिए खाते पता |
+| `state_root` | रूट हैश इस ब्लॉक में बदलाव लागू करने के बाद वैश्विक स्थिति के लिए |
+| `receipts_root` | लेनदेन रसिप्ट ट्राई का हैश |
+| `logs_bloom` | डेटा संरचना जिसमें ईवेंट लॉग शामिल हैं |
+| `prev_randao` | सत्यापनकर्ता के रैंडम चयन में उपयोग किया जाने वाला मान |
+| `block_number` | वर्तमान ब्लॉक की संख्या |
+| `gas_limit` | इस ब्लॉक में अधिकतम गैस की अनुमति है |
+| `gas_used` | इस ब्लॉक में उपयोग की जाने वाली गैस की असल मात्रा |
+| `timestamp` | ब्लॉक का समय |
+| `extra_data` | रॉ बाइट्स के रूप में मनमाना अतिरिक्त डेटा |
+| `base_fee_per_gas` | आधार शुल्क मूल्य |
+| `block_hash` | निष्पादन ब्लॉक का हैश |
+| `ट्रांसक्शन्स` | निष्पादित किए जाने वाले लेनदेन की सूची |
+| `withdrawals` | निकासी वस्तुओं की सूची |
+
+`withdrawals` वाली सूची में निम्नलिखित तरीके से संरचित `withdrawal` वस्तुएं शामिल हैं:
+
+| फ़ील्ड | वर्णन |
+| :--------------- | :--------------------------------- |
+| `address` | खाते का पता जो वापस ले लिया गया है |
+| `amount` | निकाली गई राशि |
+| `इंडेक्स` | निकासी सूचकांक मूल्य |
+| `validatorIndex` | सत्यापनकर्ता सूचकांक मूल्य |
+
+## ब्लॉक समय {#block-time}
+
+ब्लॉक समय ब्लॉक को अलग करने वाले समय को दर्शाता है। एथेरियम में, समय को बारह सेकंड इकाइयों में विभाजित किया जाता है जिन्हें 'स्लॉट' कहा जाता है। हर स्लॉट में एक ब्लॉक का प्रस्ताव करने के लिए एक एकल सत्यापनकर्ता का चयन किया जाता है। यह मानते हुए कि सभी सत्यापनकर्ता ऑनलाइन और पूरी तरह कार्यात्मक हैं, हर स्लॉट में एक ब्लॉक होगा, जिसका मतलब है कि ब्लॉक का समय 12s है। हालांकि, कभी-कभी ब्लॉक का प्रस्ताव करने के लिए बुलाए जाने पर सत्यापनकर्ता ऑफ़लाइन हो सकते हैं, जिसका मतलब है कि स्लॉट कभी-कभी खाली हो सकते हैं।
+
+यह कार्यान्वयन काम का सबूत पर आधारित प्रणालियों से भिन्न होता है जहां ब्लॉक समय संभाव्य होते हैं और प्रोटोकॉल की लक्षित माईनिंग कठिनाई से ट्यून होती हैं। एथेरियम का [औसत ब्लॉक समय](https://etherscan.io/chart/blocktime) इसका एक आदर्श उदाहरण है जिससे नए 12s ब्लॉक समय की स्थिरता के आधार पर प्रूफ-ऑफ-वर्क से प्रूफ-ऑफ-स्टेक में ट्रांज़िशन का स्पष्ट रूप से अनुमान लगाया जा सकता है।
+
+## ब्लॉक का आकार {#block-size}
+
+एक अंतिम महत्वपूर्ण नोट यह है कि ब्लॉक खुद आकार के हिसाब से सेट होते हैं। हर ब्लॉक का लक्ष्य आकार 30 मिलियन गैस है, लेकिन नेटवर्क मांगों के अनुसार ब्लॉकों का आकार 60 मिलियन गैस (2x लक्ष्य ब्लॉक साइज़) की ब्लॉक सीमा तक बढ़ेगा या घटेगा। ब्लॉक गैस सीमा को पिछले ब्लॉक की गैस सीमा से 1/1024 के कारक द्वारा ऊपर या नीचे समायोजित किया जा सकता है। इस वजह से, सत्यापनकर्ता आम सहमति के माध्यम से ब्लॉक गैस सीमा को बदल सकते हैं। ब्लॉक में सभी ट्रांजेक्शन द्वारा खर्च की गई गैस की कुल राशि ब्लॉक में गैस सीमा से कम होनी चाहिए। यह महत्वपूर्ण है, क्योंकि यह सुनिश्चित करता है कि ब्लॉक मनमाने ढंग से बड़े नहीं हो सकते। अगर ब्लॉक मनमाने ढंग से बड़े हो सकते हैं, तो कम परफ़ॉर्मेंस करने वाले फ़ुल नोड्स धीरे-धीरे जदग और गति संबंधी आवश्यकताओं के कारण नेटवर्क के साथ बने रहने में सक्षम होना बंद कर देंगे। ब्लॉक जितना बड़ा होगा, अगले स्लॉट के लिए समय पर उन्हें प्रोसेस करने के लिए आवश्यक कंप्यूटिंग क्षमता उतनी ही अधिक होगी। यह एक केंद्रीकृत बल है, जिसका ब्लॉक आकार को सीमित करके प्रतिरोध किया जाता है।
+
+## आगे की रीडिंग {#further-reading}
+
+_क्या आप किसी सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की हो? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
+
+## संबंधित विषय {#related-topics}
+
+- [लेन-देन](/developers/docs/transactions/)
+- [गैस](/developers/docs/gas/)
+- [हिस्सेदारी का सबूत](/developers/docs/consensus-mechanisms/pos)
diff --git a/public/content/translations/hi/developers/docs/bridges/index.md b/public/content/translations/hi/developers/docs/bridges/index.md
new file mode 100644
index 00000000000..c1ea4080a4c
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/bridges/index.md
@@ -0,0 +1,138 @@
+---
+title: "ब्रिजेज़"
+description: "डेवलपर्स के लिए ब्रिजिंग का ओवरव्यू"
+lang: hi
+---
+
+L1 ब्लॉकचेन और L2 [स्केलिंग](/developers/docs/scaling/) समाधानों के प्रसार के साथ, और क्रॉस-चेन जाने वाले विकेंद्रीकृत अनुप्रयोगों की लगातार बढ़ती संख्या के साथ, चेनों के बीच संचार और संपत्ति की आवाजाही की आवश्यकता नेटवर्क के बुनियादी ढांचे का एक अनिवार्य हिस्सा बन गई है। इसे संभव बनाने में मदद के लिए विभिन्न प्रकार के पुल मौजूद हैं।
+
+## ब्रिजेज़ की आवश्यकता {#need-for-bridges}
+
+ब्लॉकचेन नेटवर्क को जोड़ने के लिए ब्रिजेज़ मौजूद हैं। वे ब्लॉकचेन के बीच कनेक्टिविटी और इंटरऑपरेबिलिटी को सक्षम करते हैं।
+
+ब्लॉकचेन मौन वातावरण में मौजूद हैं, जिसका अर्थ है कि ब्लॉकचेन के लिए स्वाभाविक रूप से अन्य ब्लॉकचेन के साथ व्यापार और संवाद करने का कोई तरीका नहीं है। नतीजतन, जबकि एक पारिस्थितिकी तंत्र के भीतर महत्वपूर्ण गतिविधि और नवाचार हो सकता है, यह अन्य पारिस्थितिक तंत्रों के साथ कनेक्टिविटी और इंटरऑपरेबिलिटी की कमी से सीमित है।
+
+ब्रिजेज़ अलग-अलग ब्लॉकचेन वातावरण को एक दूसरे से जुड़ने का एक तरीका प्रदान करते हैं। वे ब्लॉकचेन के बीच एक परिवहन मार्ग स्थापित करते हैं जहां टोकन, संदेश, मनमाना डेटा, और यहां तक कि [स्मार्ट अनुबंध](/developers/docs/smart-contracts/) कॉल को एक चेन से दूसरे चेन में स्थानांतरित किया जा सकता है।
+
+## ब्रिजेज़ के लाभ {#benefits-of-bridges}
+
+सीधे शब्दों में कहें, ब्रिजेज़ ब्लॉकचेन नेटवर्क को डेटा का आदान-प्रदान करने और उनके बीच संपत्ति को स्थानांतरित करने की अनुमति देकर कई उपयोग के मामलों को अनलॉक करते हैं।
+
+ब्लॉकचेन में अद्वितीय ताकत, कमजोरियां और अनुप्रयोगों के निर्माण के दृष्टिकोण (जैसे गति, थ्रूपुट, महंगाई, आदि) हैं। ब्रिजेज़ एक दूसरे के नवाचारों का लाभ उठाने के लिए ब्लॉकचेन को सक्षम करके समग्र क्रिप्टो पारिस्थितिकी तंत्र के विकास में मदद करते हैं।
+
+डेवलपर्स के लिए, ब्रिजेज़ निम्नलिखित सक्षम करते हैं:
+
+- जंजीरों में किसी भी डेटा, सूचना और संपत्ति का हस्तांतरण।
+- नई सुविधाओं को अनलॉक करना और प्रोटोकॉल के लिए मामलों का उपयोग करना क्योंकि ब्रिजेज़ प्रोटोकॉल की पेशकश के लिए डिज़ाइन स्थान का विस्तार करते हैं। उदाहरण के लिए, मूल रूप से एथेरियम मेननेट पर तैनात उपज खेती के लिए एक प्रोटोकॉल सभी ईवीएम-संगत श्रृंखलाओं में तरलता पूल की पेशकश कर सकता है।
+- विभिन्न ब्लॉकचेन की ताकत का लाभ उठाने का अवसर। उदाहरण के लिए, डेवलपर्स रोलअप में अपने डैप्स को तैनात करके विभिन्न L2 समाधानों द्वारा दी जाने वाली कम फीस से लाभ उठा सकते हैं, और साइडचेन और उपयोगकर्ता उनके पार ब्रिज कर सकते हैं।
+- नए उत्पादों के निर्माण के लिए विभिन्न ब्लॉकचेन पारिस्थितिक तंत्र के डेवलपर्स के बीच सहयोग।
+- उपयोगकर्ताओं और समुदायों को विभिन्न पारिस्थितिक तंत्रों से उनके डीएपी तक आकर्षित करना।
+
+## ब्रिजेज़ कैसे काम करते हैं? {#how-do-bridges-work}
+
+हालांकि कई तरह के [ब्रिज डिज़ाइन](https://li.fi/knowledge-hub/blockchain-bridges-and-classification/) होते हैं, संपत्तियों के क्रॉस-चेन ट्रांसफ़र को सुविधाजनक बनाने के तीन तरीके सबसे प्रमुख हैं:
+
+- **लॉक और मिंट –** स्रोत चेन पर संपत्तियों को लॉक करें और गंतव्य चेन पर संपत्तियों को मिंट करें।
+- **बर्न और मिंट –** स्रोत चेन पर संपत्तियों को बर्न करें और गंतव्य चेन पर संपत्तियों को मिंट करें।
+- **एटॉमिक स्वैप –** स्रोत चेन पर मौजूद संपत्तियों को किसी दूसरी पार्टी के साथ गंतव्य चेन की संपत्तियों के लिए स्वैप करें।
+
+## ब्रिज के प्रकार {#bridge-types}
+
+ब्रिजेज़ को आमतौर पर निम्नलिखित बाल्टियों में से एक में वर्गीकृत किया जा सकता है:
+
+- **नेटिव ब्रिजेज़ –** ये ब्रिजेज़ आमतौर पर किसी विशेष ब्लॉकचेन पर लिक्विडिटी को बूटस्ट्रैप करने के लिए बनाए जाते हैं, जिससे यूज़र्स के लिए इकोसिस्टम में फंड ले जाना आसान हो जाता है। उदाहरण के लिए, [Arbitrum Bridge](https://bridge.arbitrum.io/) यूज़र्स के लिए Ethereum मेननेट से Arbitrum तक ब्रिज करना सुविधाजनक बनाने के लिए बनाया गया है। इस तरह के अन्य ब्रिजेज़ में Polygon PoS Bridge, [Optimism Gateway](https://app.optimism.io/bridge), आदि शामिल हैं।
+- **वैलिडेटर या ओरेकल आधारित ब्रिजेज़ –** ये ब्रिजेज़ क्रॉस-चेन ट्रांसफ़र को मान्य करने के लिए बाहरी सत्यापनकर्ता सेट या ओरेकल पर निर्भर करते हैं। उदाहरण: मल्टीचेन और एक्रॉस.
+- **सामान्यीकृत संदेश पासिंग ब्रिजेज़ –** ये ब्रिजेज़ संपत्तियों के साथ-साथ संदेशों और मनमाने डेटा को चेनों पर ट्रांसफ़र कर सकते हैं। उदाहरण: एक्सलर, लेयरज़ीरो और नोमैड।
+- **लिक्विडिटी नेटवर्क –** ये ब्रिजेज़ मुख्य रूप से एटॉमिक स्वैप के माध्यम से एक चेन से दूसरे चेन में संपत्ति ट्रांसफ़र करने पर ध्यान केंद्रित करते हैं। आम तौर पर, वे क्रॉस-चेन संदेश पासिंग का समर्थन नहीं करते हैं। उदाहरण: Connext और Hop.
+
+## विचार करने योग्य ट्रेड-ऑफ़ {#trade-offs}
+
+पुलों के साथ, कोई सही समाधान नहीं हैं। बल्कि, एक उद्देश्य को पूरा करने के लिए केवल व्यापार-बंद किए जाते हैं। डेवलपर्स और उपयोगकर्ता निम्नलिखित कारकों के आधार पर पुलों का मूल्यांकन कर सकते हैं:
+
+- **सुरक्षा –** सिस्टम को कौन सत्यापित करता है? बाहरी सत्यापनकर्ताओं द्वारा सुरक्षित पुल आमतौर पर उन पुलों की तुलना में कम सुरक्षित होते हैं जो ब्लॉकचेन के सत्यापनकर्ताओं द्वारा स्थानीय या मूल रूप से सुरक्षित होते हैं।
+- **सुविधा –** एक ट्रांज़ैक्शन पूरा होने में कितना समय लगता है, और एक यूज़र को कितने ट्रांज़ैक्शन पर हस्ताक्षर करने की आवश्यकता होती है? एक डेवलपर के लिए, एक पुल को एकीकृत करने में कितना समय लगता है, और प्रक्रिया कितनी जटिल है?
+- **कनेक्टिविटी –** एक ब्रिज किन अलग-अलग डेस्टिनेशन चेनों से जुड़ सकता है (यानी, रोलअप, साइडचेन, अन्य लेयर 1 ब्लॉकचेन, आदि), और एक नए ब्लॉकचेन को इंटीग्रेट करना कितना मुश्किल है?
+- **अधिक जटिल डेटा पास करने की क्षमता –** क्या कोई ब्रिज चेनों के बीच संदेशों और अधिक जटिल मनमाने डेटा के ट्रांसफ़र को सक्षम कर सकता है, या यह केवल क्रॉस-चेन संपत्ति ट्रांसफ़र का समर्थन करता है?
+- **लागत-प्रभावशीलता –** एक ब्रिज के माध्यम से चेनों में संपत्ति ट्रांसफ़र करने में कितना खर्च होता है? आमतौर पर, पुल गैस लागत और विशिष्ट मार्गों की तरलता के आधार पर एक निश्चित या परिवर्तनीय शुल्क लेते हैं। इसकी सुरक्षा सुनिश्चित करने के लिए आवश्यक पूंजी के आधार पर पुल की लागत-प्रभावशीलता का मूल्यांकन करना भी महत्वपूर्ण है।
+
+उच्च स्तर पर, पुलों को विश्वसनीय और भरोसेमंद के रूप में वर्गीकृत किया जा सकता है।
+
+- **ट्रस्टेड –** ट्रस्टेड ब्रिजेज़ बाहरी रूप से सत्यापित होते हैं। वे श्रृंखलाओं में डेटा भेजने के लिए सत्यापनकर्ताओं के बाहरी सेट (मल्टी-सिग, मल्टी-पार्टी कम्प्यूटेशन सिस्टम, ओरेकल नेटवर्क के साथ फेडरेशन) का उपयोग करते हैं। नतीजतन, वे महान कनेक्टिविटी की पेशकश कर सकते हैं और जंजीरों में गुजरने वाले पूरी तरह से सामान्यीकृत संदेश को सक्षम कर सकते हैं। वे गति और लागत-प्रभावशीलता के साथ भी अच्छा प्रदर्शन करते हैं। यह सुरक्षा की कीमत पर आता है, क्योंकि उपयोगकर्ताओं को पुल की सुरक्षा पर निर्भर रहना पड़ता है।
+- **ट्रस्टलेस –** ये ब्रिजेज़ संदेशों और टोकन को ट्रांसफ़र करने के लिए उन ब्लॉकचेन पर निर्भर करते हैं जिनसे वे जुड़ रहे हैं और उनके सत्यापनकर्ताओं पर। वे 'भरोसेमंद' हैं क्योंकि वे नई विश्वास मान्यताओं (ब्लॉकचेन के अलावा) को नहीं जोड़ते हैं। नतीजतन, भरोसेमंद पुलों को विश्वसनीय पुलों की तुलना में अधिक सुरक्षित माना जाता है।
+
+अन्य कारकों के आधार पर भरोसेमंद पुलों का मूल्यांकन करने के लिए, हमें उन्हें सामान्यीकृत संदेश पासिंग पुलों और तरलता नेटवर्क में तोड़ना होगा।
+
+- **सामान्यीकृत संदेश पासिंग ब्रिजेज़ –** ये ब्रिजेज़ सुरक्षा और चेनों में अधिक जटिल डेटा ट्रांसफ़र करने की क्षमता में उत्कृष्ट होते हैं। आमतौर पर, वे लागत-प्रभावशीलता के साथ भी अच्छे होते हैं। हालांकि, ये ताकत आम तौर पर हल्के ग्राहक पुलों (पूर्व: आईबीसी) के लिए कनेक्टिविटी की लागत पर आती है और आशावादी पुलों (पूर्व: खानाबदोश) के लिए गति कमियां जो धोखाधड़ी के सबूत का उपयोग करती हैं।
+- **लिक्विडिटी नेटवर्क –** ये ब्रिजेज़ संपत्ति ट्रांसफ़र करने के लिए एटॉमिक स्वैप का उपयोग करते हैं और स्थानीय रूप से सत्यापित सिस्टम हैं (यानी, वे ट्रांज़ैक्शन को सत्यापित करने के लिए अंतर्निहित ब्लॉकचेन के सत्यापनकर्ताओं का उपयोग करते हैं)। नतीजतन, वे सुरक्षा और गति के साथ उत्कृष्टता प्राप्त करते हैं। इसके अलावा, उन्हें तुलनात्मक रूप से लागत प्रभावी माना जाता है और अच्छी कनेक्टिविटी प्रदान करते हैं। हालाँकि, प्रमुख ट्रेडऑफ़ अधिक जटिल डेटा पास करने में उनकी असमर्थता है - क्योंकि वे क्रॉस-चेन संदेश पासिंग का समर्थन नहीं करते हैं।
+
+## ब्रिजेज़ के साथ जोखिम {#risk-with-bridges}
+
+[DeFi में शीर्ष तीन सबसे बड़े हैक](https://rekt.news/leaderboard/) ब्रिजेज़ की वजह से हुए हैं और वे अभी भी विकास के शुरुआती चरण में हैं। किसी भी पुल का उपयोग करने से निम्नलिखित जोखिम होते हैं:
+
+- **स्मार्ट अनुबंध जोखिम –** हालांकि कई ब्रिजेज़ ने सफलतापूर्वक ऑडिट पास कर लिए हैं, संपत्तियों को हैक के संपर्क में लाने के लिए स्मार्ट अनुबंध में सिर्फ एक खामी ही काफी है (उदाहरण: [Solana का Wormhole Bridge](https://rekt.news/wormhole-rekt/))।
+- **प्रणालीगत वित्तीय जोखिम –** कई ब्रिजेज़ एक नई चेन पर मूल संपत्ति के कैनोनिकल संस्करणों को मिंट करने के लिए रैप्ड संपत्तियों का उपयोग करते हैं। यह पारिस्थितिकी तंत्र को प्रणालीगत जोखिम के लिए उजागर करता है, जैसा कि हमने टोकन के लिपटे संस्करणों का शोषण देखा है।
+- **काउंटरपार्टी जोखिम –** कुछ ब्रिजेज़ एक ट्रस्टेड डिज़ाइन का उपयोग करते हैं, जिसमें यूज़र्स को इस धारणा पर भरोसा करना पड़ता है कि सत्यापनकर्ता यूज़र्स के फंड को चुराने के लिए मिलीभगत नहीं करेंगे। उपयोगकर्ताओं को इन तृतीय-पक्ष अभिनेताओं पर भरोसा करने की आवश्यकता उन्हें गलीचा खींचने, सेंसरशिप और अन्य दुर्भावनापूर्ण गतिविधियों जैसे जोखिमों के लिए उजागर करती है।
+- **खुले मुद्दे –** यह देखते हुए कि ब्रिजेज़ विकास के शुरुआती चरण में हैं, इस बात से संबंधित कई अनुत्तरित प्रश्न हैं कि ब्रिजेज़ विभिन्न बाजार स्थितियों में कैसा प्रदर्शन करेंगे, जैसे कि नेटवर्क कंजेशन के समय और नेटवर्क-स्तरीय हमलों या स्टेट रोलबैक जैसी अप्रत्याशित घटनाओं के दौरान। यह अनिश्चितता कुछ जोखिम पैदा करती है, जिनमें से डिग्री अभी भी अज्ञात है।
+
+## डैप्स पुलों का उपयोग कैसे कर सकते हैं? {#how-can-dapps-use-bridges}
+
+यहां कुछ व्यावहारिक अनुप्रयोग दिए गए हैं जो डेवलपर्स पुलों के बारे में विचार कर सकते हैं और अपनी डैप क्रॉस-चेन ले सकते हैं:
+
+### ब्रिजेज़ को इंटीग्रेट करना {#integrating-bridges}
+
+डेवलपर्स के लिए, पुलों के लिए समर्थन जोड़ने के कई तरीके हैं:
+
+1. **अपना खुद का ब्रिज बनाना –** एक सुरक्षित और विश्वसनीय ब्रिज बनाना आसान नहीं है, खासकर यदि आप अधिक ट्रस्ट-मिनिमाइज़्ड मार्ग अपनाते हैं। इसके अलावा, इसके लिए स्केलेबिलिटी और इंटरऑपरेबिलिटी अध्ययन से संबंधित वर्षों के अनुभव और तकनीकी विशेषज्ञता की आवश्यकता होती है। इसके अतिरिक्त, इसे एक पुल बनाए रखने और इसे संभव बनाने के लिए पर्याप्त तरलता को आकर्षित करने के लिए एक व्यावहारिक टीम की आवश्यकता होगी।
+
+2. **यूज़र्स को कई ब्रिज विकल्प दिखाना –** कई [डैप्स](/developers/docs/dapps/) के लिए यूज़र्स को उनके साथ इंटरैक्ट करने के लिए अपने नेटिव टोकन की आवश्यकता होती है। उपयोगकर्ताओं को अपने टोकन तक पहुंचने में सक्षम बनाने के लिए, वे अपनी वेबसाइट पर विभिन्न ब्रिज विकल्प प्रदान करते हैं। हालाँकि, यह विधि समस्या का एक त्वरित समाधान है क्योंकि यह उपयोगकर्ता को डैप इंटरफ़ेस से दूर ले जाती है और फिर भी उन्हें अन्य डैप्स और पुलों के साथ इंटरैक्ट करने की आवश्यकता होती है। गलतियाँ करने की बढ़ती गुंजाइश के साथ यह एक बोझिल ऑनबोर्डिंग अनुभव है।
+
+3. **एक ब्रिज को इंटीग्रेट करना –** इस समाधान में डैप को यूज़र्स को बाहरी ब्रिज और DEX इंटरफ़ेस पर भेजने की आवश्यकता नहीं होती है। यह डैप्स को उपयोगकर्ता ऑनबोर्डिंग अनुभव को बेहतर बनाने की अनुमति देता है। हालाँकि, इस दृष्टिकोण की अपनी सीमाएँ हैं:
+
+ - पुलों का आकलन और रखरखाव कठिन और समय लेने वाला है।
+ - एक पुल का चयन विफलता और निर्भरता का एक बिंदु बनाता है।
+ - डैप पुल की क्षमताओं द्वारा सीमित है।
+ - अकेले पुल पर्याप्त नहीं हो सकते हैं। क्रॉस-चेन स्वैप जैसी अधिक कार्यक्षमता प्रदान करने के लिए डैप्स को DEX की आवश्यकता हो सकती है।
+
+4. **कई ब्रिजेज़ को इंटीग्रेट करना –** यह समाधान एक ब्रिज को इंटीग्रेट करने से जुड़ी कई समस्याओं का समाधान करता है। हालाँकि, इसकी सीमाएँ भी हैं, क्योंकि कई पुलों को एकीकृत करना संसाधन-खपत है और डेवलपर्स के लिए तकनीकी और संचार ओवरहेड्स बनाता है - क्रिप्टो में सबसे दुर्लभ संसाधन।
+
+5. **एक ब्रिज एग्रीगेटर को इंटीग्रेट करना –** डैप्स के लिए एक और विकल्प एक ब्रिज एग्रीगेशन समाधान को इंटीग्रेट करना है जो उन्हें कई ब्रिजेज़ तक पहुंच प्रदान करता है। ब्रिज एग्रीगेटर सभी पुलों की ताकत विरासत में लेते हैं और इस प्रकार किसी एक पुल की क्षमताओं तक सीमित नहीं होते हैं। विशेष रूप से, पुल एग्रीगेटर आमतौर पर पुल एकीकरण को बनाए रखते हैं, जो पुल एकीकरण के तकनीकी और परिचालन पहलुओं के शीर्ष पर रहने की परेशानी से डीएपी को बचाता है।
+
+कहा जा रहा है कि, ब्रिज एग्रीगेटर्स की भी अपनी सीमाएं हैं। उदाहरण के लिए, जबकि वे अधिक पुल विकल्प प्रदान कर सकते हैं, एग्रीगेटर के प्लेटफॉर्म पर पेश किए गए पुलों के अलावा कई और पुल आमतौर पर बाजार में उपलब्ध होते हैं। इसके अलावा, पुलों की तरह, पुल एग्रीगेटर भी स्मार्ट अनुबंध और प्रौद्योगिकी जोखिमों (अधिक स्मार्ट अनुबंध = अधिक जोखिम) के संपर्क में हैं।
+
+यदि कोई डैप किसी पुल या एग्रीगेटर को एकीकृत करने के मार्ग से नीचे जाता है, तो एकीकरण कितना गहरा होना चाहिए, इसके आधार पर अलग-अलग विकल्प हैं। उदाहरण के लिए, यदि यह उपयोगकर्ता ऑनबोर्डिंग अनुभव को बेहतर बनाने के लिए केवल फ्रंट-एंड एकीकरण है, तो एक डैप विजेट को एकीकृत करेगा। हालांकि, अगर एकीकरण गहरी क्रॉस-चेन रणनीतियों जैसे स्टेकिंग, उपज खेती आदि का पता लगाने के लिए है, तो डीएपी एसडीके या एपीआई को एकीकृत करता है।
+
+### कई चेनों पर डैप डिप्लॉय करना {#deploying-a-dapp-on-multiple-chains}
+
+कई चेनों पर डैप डिप्लॉय करने के लिए, डेवलपर्स [Alchemy](https://www.alchemy.com/), [Hardhat](https://hardhat.org/), [Moralis](https://moralis.io/), आदि जैसे डेवलपमेंट प्लेटफ़ॉर्म का उपयोग कर सकते हैं। आमतौर पर, ये प्लेटफ़ॉर्म कंपोज़ेबल प्लगइन्स के साथ आते हैं जो डैप्स को क्रॉस-चेन जाने में सक्षम कर सकते हैं। उदाहरण के लिए, डेवलपर्स [hardhat-deploy प्लगइन](https://github.com/wighawag/hardhat-deploy) द्वारा ऑफ़र किए गए डिटरमिनिस्टिक डिप्लॉयमेंट प्रॉक्सी का उपयोग कर सकते हैं।
+
+#### उदाहरण
+
+- [क्रॉस-चेन डैप्स कैसे बनाएं](https://moralis.io/how-to-build-cross-chain-dapps/)
+- [क्रॉस-चेन NFT मार्केटप्लेस बनाना](https://youtu.be/WZWCzsB1xUE)
+- [Moralis: क्रॉस-चेन NFT डैप्स बनाना](https://www.youtube.com/watch?v=ehv70kE1QYo)
+
+### चेनों पर अनुबंध गतिविधि की निगरानी {#monitoring-contract-activity-across-chains}
+
+श्रृंखलाओं में अनुबंध गतिविधि की निगरानी के लिए, डेवलपर्स वास्तविक समय में स्मार्ट अनुबंधों का निरीक्षण करने के लिए टेंडरली जैसे सबग्राफ और डेवलपर प्लेटफार्मों का उपयोग कर सकते हैं। ऐसे प्लेटफ़ॉर्म में ऐसे टूल भी होते हैं जो क्रॉस-चेन गतिविधियों के लिए बेहतर डेटा निगरानी कार्यक्षमता प्रदान करते हैं, जैसे [अनुबंधों द्वारा उत्सर्जित इवेंट](https://docs.soliditylang.org/en/v0.8.14/contracts.html?highlight=events#events) की जाँच करना, आदि।
+
+#### उपकरण
+
+- [The Graph](https://thegraph.com/en/)
+- [Tenderly](https://tenderly.co/)
+
+## आगे की रीडिंग {#further-reading}
+
+- [ब्लॉकचेन ब्रिजेज़](/bridges/) – ethereum.org
+- [L2Beat ब्रिज जोखिम फ़्रेमवर्क](https://l2beat.com/bridges/summary)
+- [ब्लॉकचेन ब्रिजेज़: क्रिप्टोनैटवर्क के नेटवर्क बनाना](https://medium.com/1kxnetwork/blockchain-bridges-5db6afac44f8) - 8 सितंबर, 2021 – दिमित्री बेरेनज़ोन
+- [द इंटरऑपरेबिलिटी ट्राइलेमा](https://blog.connext.network/the-interoperability-trilemma-657c2cf69f17) - 1 अक्टूबर, 2021 – अर्जुन भूपतानी
+- [क्लस्टर: ट्रस्टेड और ट्रस्ट-मिनिमाइज़्ड ब्रिजेज़ मल्टी-चेन परिदृश्य को कैसे आकार देते हैं](https://blog.celestia.org/clusters/) - 4 अक्टूबर, 2021 – मुस्तफा अल-बसम
+- [LI.FI: ब्रिजेज़ के साथ, विश्वास एक स्पेक्ट्रम है](https://blog.li.fi/li-fi-with-bridges-trust-is-a-spectrum-354cd5a1a6d8) - 28 अप्रैल, 2022 – अर्जुन चंद
+- [रोलअप इंटरऑपरेबिलिटी समाधानों की स्थिति](https://web.archive.org/web/20250428015516/https://research.2077.xyz/the-state-of-rollup-interoperability) - 20 जून, 2024 – एलेक्स हुक
+- [सुरक्षित क्रॉस-चेन इंटरऑपरेबिलिटी के लिए साझा सुरक्षा का उपयोग: लैग्रेंज स्टेट कमेटियां और उससे आगे](https://web.archive.org/web/20250125035123/https://research.2077.xyz/harnessing-shared-security-for-secure-blockchain-interoperability) - 12 जून, 2024 – इमैनुएल अवोसिका
+
+इसके अतिरिक्त, यहां [James Prestwich](https://twitter.com/_prestwich) की कुछ व्यावहारिक प्रस्तुतियां हैं जो ब्रिजेज़ की गहरी समझ विकसित करने में मदद कर सकती हैं:
+
+- [ब्रिजेज़ बनाना, दीवारों वाले बगीचे नहीं](https://youtu.be/ZQJWMiX4hT0)
+- [ब्रिजेज़ को समझना](https://youtu.be/b0mC-ZqN8Oo)
+- [ब्रिजेज़ क्यों जल रहे हैं?](https://youtu.be/c7cm2kd20j8)
diff --git a/public/content/translations/hi/developers/docs/consensus-mechanisms/index.md b/public/content/translations/hi/developers/docs/consensus-mechanisms/index.md
index 676f05b1920..d88717b7872 100644
--- a/public/content/translations/hi/developers/docs/consensus-mechanisms/index.md
+++ b/public/content/translations/hi/developers/docs/consensus-mechanisms/index.md
@@ -1,14 +1,14 @@
---
-title: आम सहमति तंत्र
-description: वितरित प्रणालियों में सर्वसम्मति प्रोटोकॉल की व्याख्या और एथेरियम में उनकी भूमिका।
+title: "आम सहमति तंत्र"
+description: "वितरित प्रणालियों में सर्वसम्मति प्रोटोकॉल की व्याख्या और एथेरियम में उनकी भूमिका।"
lang: hi
---
'आम सहमति तंत्र' शब्द का उपयोग अक्सर बोलचाल की भाषा में 'हिस्सेदारी का सबूत', 'काम का सबूत' या 'प्राधिकार-का-सबूत' प्रोटोकॉल को संदर्भित करने के लिए किया जाता है। हालांकि, ये आम सहमति तंत्र में केवल घटक हैं, जो [सिबिल हमलों](/glossary/#sybil-attack) से बचाते हैं। सर्वसम्मति तंत्र विचारों, प्रोटोकॉल और प्रोत्साहनों का पूरा ढेर है जो एक ब्लॉकचेन की स्थिति पर सहमत होने के लिए नोड्स के वितरित सेट को सक्षम बनाता है।
-## आवश्यक शर्तें {#prerequisites}
+## पूर्वापेक्षाएं {#prerequisites}
-इस पेज को बेहतर ढंग से समझने के लिए, हम अनुशंसा करते हैं कि आप पहले हमारे [एथेरियम का परिचय](/developers/docs/intro-to-ethereum/) पढ़ें।
+इस पेज को बेहतर ढंग से समझने के लिए, हम अनुशंसा करते हैं कि आप पहले हमारा [एथेरियम का परिचय](/developers/docs/intro-to-ethereum/) पढ़ें।
## सर्वसम्मति क्या है? {#what-is-consensus}
@@ -28,13 +28,13 @@ lang: hi
ये घटक मिलकर आम सहमति तंत्र बनाते हैं।
-## सर्वसम्मति तंत्र के प्रकार {#types-of-consensus-mechanisms}
+## आम सहमति तंत्र के प्रकार {#types-of-consensus-mechanisms}
### काम का सबूत आधारित {#proof-of-work}
-बिटकॉइन की तरह, एथेरियम ने एक बार **काम का सबूत (PoW)** आधारित आम सहमति प्रोटोकॉल का उपयोग किया था।
+Bitcoin की तरह, Ethereum ने एक बार **काम का सबूत (PoW)** आधारित आम सहमति प्रोटोकॉल का उपयोग किया था।
-#### ब्लॉक निर्माण {#pow-block-creation}
+#### ब्लोक निर्माण {#pow-block-creation}
माईनर संसाधित लेनदेन से भरे नए ब्लॉक बनाने के लिए प्रतिस्पर्धा करते हैं। विजेता बाकी नेटवर्क के साथ नए ब्लॉक को साझा करता है और कुछ ताजा माईनिंग ETH अर्जित करता है। दौड़ कंप्यूटर द्वारा जीती जाती है जो गणित की पहेली को सबसे तेजी से हल करने में सक्षम है। यह वर्तमान ब्लॉक और पहले गए ब्लॉक के बीच क्रिप्टोग्राफिक लिंक उत्पन्न करता है। इस पहेली को हल करना "काम का सबूत" में काम है। कैनोनिकल चेन तब एक कांटा-विकल्प नियम द्वारा निर्धारित की जाती है जो उन ब्लॉकों के सेट का चयन करती है जिनके पास उन्हें माईन करने के लिए सबसे अधिक काम किया गया है।
@@ -42,13 +42,13 @@ lang: hi
नेटवर्क को इस तथ्य से सुरक्षित रखा जाता है कि श्रृंखला को धोखा देने के लिए आपको नेटवर्क की 51% कंप्यूटिंग शक्ति की आवश्यकता होगी। इसके लिए उपकरण और ऊर्जा में इतने बड़े निवेश की आवश्यकता होगी; आपको लाभ से अधिक खर्च करने की संभावना है।
-[काम का सबूत](/developers/docs/consensus-mechanisms/pow/) के बारे में अधिक जानकारी
+[काम का सबूत](/developers/docs/consensus-mechanisms/pow/)
### हिस्सेदारी का सबूत आधारित {#proof-of-stake}
-एथेरियम अब **हिस्सेदारी का सबूत (PoS)** आधारित आम सहमति प्रोटोकॉल का उपयोग करता है।
+Ethereum अब **हिस्सेदारी का सबूत (PoS)** आधारित आम सहमति प्रोटोकॉल का उपयोग करता है।
-#### ब्लॉक निर्माण {#pos-block-creation}
+#### ब्लोक निर्माण {#pos-block-creation}
सत्यापनकर्ता ब्लॉक बनाते हैं। ब्लॉक प्रस्तावक होने के लिए प्रत्येक स्लॉट में एक सत्यापनकर्ता को रेंडम रूप से चुना जाता है। उनके सहमति ग्राहक अपने युग्मित निष्पादन ग्राहक से 'निष्पादन पेलोड' के रूप में लेनदेन के एक बंडल का अनुरोध करते हैं। वे इसे एक ब्लॉक बनाने के लिए सर्वसम्मति डेटा में शामिल करते हैं, जिसे वे एथेरियम नेटवर्क पर अन्य नोड्स को भेजते हैं। इस ब्लॉक उत्पादन को ETH में पुरस्कृत किया जाता है। दुर्लभ मामलों में जब एक ही स्लॉट के लिए कई संभावित ब्लॉक मौजूद होते हैं, या नोड्स अलग-अलग समय पर ब्लॉक के बारे में सुनते हैं, तो कांटा विकल्प एल्गोरिथम उस ब्लॉक को चुनता है जो साक्षी के सबसे बड़े वजन के साथ चेन बनाता है (जहां भार उनके ETH बैलेंस द्वारा स्केल किए गए सत्यापनकर्ताओं की संख्या है)।
@@ -56,9 +56,9 @@ lang: hi
एक हिस्सेदारी का सबूत सिस्टम क्रिप्टो-आर्थिक रूप से सुरक्षित है क्योंकि श्रृंखला पर नियंत्रण करने का प्रयास करने वाले हमलावर को ETH की भारी मात्रा को नष्ट करना होगा। पुरस्कारों की एक प्रणाली व्यक्तिगत हितधारकों को ईमानदारी से व्यवहार करने के लिए प्रोत्साहित करती है, और दंड स्टेकर्स को दुर्भावनापूर्ण रूप से कार्य करने से हतोत्साहित करता है।
-[हिस्सेदारी का सबूत](/developers/docs/consensus-mechanisms/pos/) के बारे में अधिक जानकारी
+[हिस्सेदारी का सबूत](/developers/docs/consensus-mechanisms/pos/)
-### एक दृश्य गाइड {#types-of-consensus-video}
+### एक विज़ुअल गाइड {#types-of-consensus-video}
एथेरियम पर उपयोग किए जाने वाले विभिन्न प्रकार के सर्वसम्मति तंत्रों पर अधिक देखें:
@@ -68,25 +68,25 @@ lang: hi
'काम का सबूत' और 'हिस्सेदारी का सबूत' अकेले आम सहमति प्रोटोकॉल नहीं हैं, लेकिन उन्हें अक्सर सादगी के लिए इस तरह संदर्भित किया जाता है। वे वास्तव में सिबिल प्रतिरोध तंत्र और ब्लॉक लेखक चयनकर्ता हैं; वे यह तय करने का एक तरीका हैं कि नवीनतम ब्लॉक का लेखक कौन है। एक अन्य महत्वपूर्ण घटक चेन चयन (उर्फ कांटा विकल्प) एल्गोरिथम है जो नोड्स को उन परिदृश्यों में चेन के शीर्ष पर एक एकल सही ब्लॉक चुनने में सक्षम बनाता है जहां एक ही स्थिति में कई ब्लॉक मौजूद हैं।
-**सिबिल प्रतिरोध** मापता है कि सिबिल हमले के खिलाफ एक प्रोटोकॉल कैसे किराया करता है। इस प्रकार के हमले का प्रतिरोध एक विकेंद्रीकृत ब्लॉकचेन के लिए आवश्यक है और माईनर्स और सत्यापनकर्ताओं को लगाए गए संसाधनों के आधार पर समान रूप से पुरस्कृत करने में सक्षम बनाता है। काम का सबूत और हिस्सेदारी का सबूत यूज़र को बहुत अधिक ऊर्जा खर्च करके या बहुत अधिक संपार्श्विक लगाकर इससे बचाते हैं। ये सुरक्षा सिबिल हमलों के लिए एक आर्थिक निवारक है।
+**सिबिल प्रतिरोध** यह मापता है कि कोई प्रोटोकॉल सिबिल हमले के विरुद्ध कैसा प्रदर्शन करता है। इस प्रकार के हमले का प्रतिरोध एक विकेंद्रीकृत ब्लॉकचेन के लिए आवश्यक है और माईनर्स और सत्यापनकर्ताओं को लगाए गए संसाधनों के आधार पर समान रूप से पुरस्कृत करने में सक्षम बनाता है। काम का सबूत और हिस्सेदारी का सबूत यूज़र को बहुत अधिक ऊर्जा खर्च करके या बहुत अधिक संपार्श्विक लगाकर इससे बचाते हैं। ये सुरक्षा सिबिल हमलों के लिए एक आर्थिक निवारक है।
-एक **चेन चयन नियम** का उपयोग यह तय करने के लिए किया जाता है कि कौन सी श्रृंखला "सही" श्रृंखला है। बिटकॉइन "सबसे लंबी श्रृंखला" नियम का उपयोग करता है, जिसका अर्थ है कि जो भी ब्लॉकचेन सबसे लंबा होगा वह बाकी नोड्स वैध के रूप में स्वीकार करेगा और साथ काम करेगा। 'काम का सबूत' चेन के लिए, सबसे लंबी चेन की कुल संचयी 'काम का सबूत' कठिनाई से निर्धारित होती है। एथेरियम सबसे लंबी चेन नियम का भी उपयोग करता था; हालांकि अब, जब एथेरियम 'हिस्सेदारी का सबूत' पर चलता है, तो उसने एक अपडेटेड कांटा-विकल्प एल्गोरिथम को अपनाया जो चेन के 'भार' को मापता है। वजन सत्यापनकर्ता वोटों का संचित योग है, जो सत्यापनकर्ता स्टेक-ईथर बैलेंस द्वारा भारित है।
+एक **श्रृंखला चयन नियम** का उपयोग यह तय करने के लिए किया जाता है कि कौन सी श्रृंखला "सही" श्रृंखला है। बिटकॉइन "सबसे लंबी श्रृंखला" नियम का उपयोग करता है, जिसका अर्थ है कि जो भी ब्लॉकचेन सबसे लंबा होगा वह बाकी नोड्स वैध के रूप में स्वीकार करेगा और साथ काम करेगा। 'काम का सबूत' चेन के लिए, सबसे लंबी चेन की कुल संचयी 'काम का सबूत' कठिनाई से निर्धारित होती है। एथेरियम सबसे लंबी चेन नियम का भी उपयोग करता था; हालांकि अब, जब एथेरियम 'हिस्सेदारी का सबूत' पर चलता है, तो उसने एक अपडेटेड कांटा-विकल्प एल्गोरिथम को अपनाया जो चेन के 'भार' को मापता है। वजन सत्यापनकर्ता वोटों का संचित योग है, जो सत्यापनकर्ता स्टेक-ईथर बैलेंस द्वारा भारित है।
-एथेरियम एक आम सहमति तंत्र का उपयोग करता है जिसे [गैस्पर](/developers/docs/consensus-mechanisms/pos/gasper/) के रूप में जाना जाता है जो [कैस्पर FFG 'हिस्सेदारी का सबूत'](https://arxiv.org/abs/1710.09437) को [GHOST कांटा-विकल्प नियम](https://arxiv.org/abs/2003.03052) के साथ जोड़ता है।
+Ethereum [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/) नामक एक आम सहमति तंत्र का उपयोग करता है जो [Casper FFG proof-of-stake](https://arxiv.org/abs/1710.09437) को [GHOST fork-choice rule](https://arxiv.org/abs/2003.03052) के साथ जोड़ता है।
-## अग्रिम पठन {#further-reading}
+## आगे की रीडिंग {#further-reading}
-- [ब्लॉकचेन सर्वसम्मति एल्गोरिथम क्या है?](https://academy.binance.com/en/articles/what-is-a-blockchain-consensus-algorithm)
-- [नाकामोटो सर्वसम्मति क्या है? शुरुआती गाइड को पूरा करें](https://blockonomi.com/nakamoto-consensus/)
-- [कैस्पर कैसे काम करता है?](https://medium.com/unitychain/intro-to-casper-ffg-9ed944d98b2d)
-- ['काम का सबूत' ब्लॉकचेन की सुरक्षा और प्रदर्शन पर](https://eprint.iacr.org/2016/555.pdf)
-- [बीजान्टिन गलती](https://en.wikipedia.org/wiki/Byzantine_fault)
+- [ब्लॉकचेन सहमति एल्गोरिथम क्या है?](https://academy.binance.com/en/articles/what-is-a-blockchain-consensus-algorithm)
+- [नाकामोतो सहमति क्या है? शुरुआती लोगों के लिए संपूर्ण गाइड](https://blockonomi.com/nakamoto-consensus/)
+- [Casper कैसे काम करता है?](https://medium.com/unitychain/intro-to-casper-ffg-9ed944d98b2d)
+- [काम का सबूत ब्लॉकचेन की सुरक्षा और प्रदर्शन पर](https://eprint.iacr.org/2016/555.pdf)
+- [बाइजेंटाइन फॉल्ट](https://en.wikipedia.org/wiki/Byzantine_fault)
-_एक सामुदायिक संसाधन के बारे में जानें जिसने आपकी मदद की? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
+_कोई ऐसा सामुदायिक संसाधन जानते हैं जिसने आपकी मदद की हो?_ इस पृष्ठ को संपादित करें और इसे जोड़ें!_
## संबंधित विषय {#related-topics}
-- [काम का प्रमाण](/developers/docs/consensus-mechanisms/pow/)
+- [काम का सबूत](/developers/docs/consensus-mechanisms/pow/)
- [माइनिंग](/developers/docs/consensus-mechanisms/pow/mining/)
-- [स्टेक-का-प्रमाण](/developers/docs/consensus-mechanisms/pos/)
-- [प्रूफ-ऑफ-अथॉरिटी](/developers/docs/consensus-mechanisms/poa/)
+- [हिस्सेदारी का सबूत](/developers/docs/consensus-mechanisms/pos/)
+- [अधिकार का सबूत](/developers/docs/consensus-mechanisms/poa/)
diff --git a/public/content/translations/hi/developers/docs/consensus-mechanisms/poa/index.md b/public/content/translations/hi/developers/docs/consensus-mechanisms/poa/index.md
index 4ebce434089..c45dfc129da 100644
--- a/public/content/translations/hi/developers/docs/consensus-mechanisms/poa/index.md
+++ b/public/content/translations/hi/developers/docs/consensus-mechanisms/poa/index.md
@@ -1,6 +1,6 @@
---
-title: प्राधिकार का सबूत (PoA)
-description: प्राधिकार का सबूत सर्वसम्मति प्रोटोकॉल और ब्लॉकचेन पारिस्थितिकी तंत्र में इसकी भूमिका का स्पष्टीकरण।
+title: "प्राधिकार का सबूत (PoA)"
+description: "प्राधिकार का सबूत सर्वसम्मति प्रोटोकॉल और ब्लॉकचेन पारिस्थितिकी तंत्र में इसकी भूमिका का स्पष्टीकरण।"
lang: hi
---
@@ -16,7 +16,7 @@ lang: hi
प्राधिकार के सबूत के लिए [जेनेसिस ब्लॉक](/शब्दावली/#जेनेसिस-ब्लॉक) में सेट किए गए अधिकृत हस्ताक्षरकर्ताओं के एक सेट पर भरोसा करने की आवश्यकता होती है। आजकल के अधिकांश कार्यान्वयन में, सभी अधिकृत हस्ताक्षरकर्ता श्रृंखला की कंसेंसस निर्धारित करने में समान शक्ति और अधिकार रखते हैं। प्रतिष्ठा दांव लगाने के पीछे का विचार यह है कि प्रत्येक अधिकृत सत्यापनकर्ता अपने ग्राहक को जानें (KYC) जैसी चीजों के माध्यम से सभी के लिए अच्छी तरह से जाना जाता है, या एक प्रसिद्ध संगठन एकमात्र सत्यापनकर्ता होने के कारण—इस तरह यदि कोई सत्यापनकर्ता कुछ भी गलत करता है, तो उनकी पहचान ज्ञात है।
-PoA के कई कार्यान्वयन हैं, लेकिन मानक एथेरियम कार्यान्वयन **क्लिक** है, जो [EIP-225](https://eips.ethereum.org/EIPS/eip-225) को लागू करता है। क्लिक, डेवलपर-फ्रेंडली तथा लागू करने में आसान मानदंड है, जो सभी क्लाइंट सिंक्रनाइज़ेशन प्रकारों को सपोर्ट करता है। अन्य कार्यान्वयन में [IBFT 2.0] (https://besu.hyperledger.org/private-networks/concepts/poa) और [Aura] (https://openethereum.github.io/Chain-specification) शामिल हैं।
+PoA के कई कार्यान्वयन हैं, लेकिन मानक एथेरियम कार्यान्वयन **क्लिक** है, जो [EIP-225](https://eips.ethereum.org/EIPS/eip-225) को लागू करता है। क्लिक, डेवलपर-फ्रेंडली तथा लागू करने में आसान मानदंड है, जो सभी क्लाइंट सिंक्रनाइज़ेशन प्रकारों को सपोर्ट करता है। अन्य कार्यान्वयन में [IBFT 2.0](https://besu.hyperledger.org/private-networks/concepts/poa) और [Aura](https://openethereum.github.io/Chain-specification) शामिल हैं।
## यह कैसे काम करता है {#how-it-works}
@@ -58,11 +58,11 @@ PoA नेटवर्क में, जब N अधिकृत हस्ता
## आगे की रीडिंग {#further-reading}
-- [EIP-225] (https://eips.ethereum.org/EIPS/eip-225) _क्लिक स्टैंडर्ड_
-- [प्राधिकरण अध्ययन का प्रमाण] (https://github.com/cryptoeconomics-study/website/blob/master/docs/sync/2.4-lecture.md) _क्रिप्टोइकॉनॉमिक्स_
+- [EIP-225](https://eips.ethereum.org/EIPS/eip-225) _क्लिक स्टैंडर्ड_
+- [प्राधिकरण अध्ययन का प्रमाण](https://github.com/cryptoeconomics-study/website/blob/master/docs/sync/2.4-lecture.md) _क्रिप्टोइकॉनॉमिक्स_
- [अधिकार का प्रमाण क्या है](https://forum.openzeppelin.com/t/proof-of-authority/3577) _OpenZeppelin_
-- [प्राधिकरण का प्रमाण समझाया गया] (https://academy.binance.com/en/articles/proof-of-authority-explained) _binance_
-- [ब्लॉकचेन में PoA] (https://medium.com/techskill-brew/proof-of-authority-or-poa-in-blockchain-part-11-blockchain-series-be15b3321cba)
+- [प्राधिकरण का प्रमाण समझाया गया](https://academy.binance.com/en/articles/proof-of-authority-explained) _binance_
+- [ब्लॉकचेन में PoA](https://medium.com/techskill-brew/proof-of-authority-or-poa-in-blockchain-part-11-blockchain-series-be15b3321cba)
- [क्लिक समझाया](https://medium.com/@Destiner/clique-cross-client-proof-of-authority-algorithm-for-ethereum-8b2a135201d)
- [अप्रचलित PoA, ऑरा स्पेशिफिकेशन](https://openethereum.github.io/Chain-specification)
- [IBFT 2.0, एक और PoA कार्यान्वयन](https://besu.hyperledger.org/private-networks/concepts/poa)
@@ -77,3 +77,4 @@ PoA नेटवर्क में, जब N अधिकृत हस्ता
- [काम का सबूत](/developers/docs/consensus-mechanisms/pow/)
- [हिस्सेदारी का सबूत](/developers/docs/consensus-mechanisms/pos/)
+
diff --git a/public/content/translations/hi/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md b/public/content/translations/hi/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md
new file mode 100644
index 00000000000..5cde1d018ea
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/consensus-mechanisms/pos/attack-and-defense/index.md
@@ -0,0 +1,166 @@
+---
+title: "एथेरियम हिस्सेदारी का सबूत अटैक और डिफेंस"
+description: "हिस्सेदारी का सबूत एथेरियम पर ज्ञात हमले के तरीकों के बारे में जानें और जानें कि इन्हें कैसे रोका जाता है।"
+lang: hi
+---
+
+चोर और ठग लगातार एथेरियम के क्लाइंट सॉफ़्टवेयर पर हमला करने के अवसर ढूंढते रहते हैं। यह पेज एथेरियम की सहमति परत पर ज्ञात हमले के वेक्टरों को रेखांकित करता है और रेखांकित करता है कि उन हमलों का बचाव कैसे किया जा सकता है। इस पेज पर दी गई जानकारी को [एक लंबे प्रारूप वाले संस्करण](https://mirror.xyz/jmcook.eth/YqHargbVWVNRQqQpVpzrqEQ8IqwNUJDIpwRP7SS5FXs) से लिया गया है।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+[प्रूफ़-ऑफ़-स्टेक](/developers/docs/consensus-mechanisms/pos/) का कुछ बुनियादी ज्ञान होना ज़रूरी है। साथ ही, एथेरियम की [प्रोत्साहन परत](/developers/docs/consensus-mechanisms/pos/rewards-and-penalties) और फोर्क-चॉइस एल्गोरिथ्म, [LMD-GHOST](/developers/docs/consensus-mechanisms/pos/gasper) की बुनियादी समझ होना भी मददगार होगा।
+
+## साइबर हमलावर क्या चाहते हैं? {#what-do-attackers-want}
+
+एक आम गलत धारणा यह है कि एक सफल हमलावर नया ईथर उत्पन्न कर सकता है, या मनमाने खातों से ईथर को निकाल सकता है। इनमें से कोई भी संभव नहीं है, क्योंकि सभी लेनदेन नेटवर्क पर सभी निष्पादन ग्राहकों द्वारा निष्पादित किए जाते हैं। उन्हें वैधता की बुनियादी शर्तों को पूरा करना होगा (जैसे, लेनदेन पर प्रेषक की प्राइवेट की से हस्ताक्षर किए गए हैं, प्रेषक के पास पर्याप्त बैलेंस है, आदि) अन्यथा वे बस रिवर्ट हो जाते हैं। परिणाम के तीन वर्ग हैं, जिन्हें कोई हमलावर वास्तविक रूप से लक्ष्य कर सकता है: पुनर्गठन, दोहरी अन्तिम स्थिति या अन्तिम स्थिति विलंब।
+
+**“पुनर्गठन”** (reorg) ब्लॉकों का एक नए क्रम में फेरबदल है, शायद कैनोनिकल चेन में ब्लॉकों के कुछ जोड़ या घटाव के साथ। दुर्भावनापूर्ण पुनर्गठन, यह सुनिश्चित कर सकता है कि विशिष्ट ब्लॉकों को शामिल करना है या बाहर रखना है, जिससे फ़्रंट-रनिंग और बैक-रनिंग लेनदेन (MEV) द्वारा दोहरे-खर्च या मूल्य निष्कर्षण की अनुमति मिलती है। री-ऑर्ग्स का उपयोग कुछ लेनदेन को कैनोनिकल चेन में शामिल होने से रोकने के लिए भी किया जा सकता है-जो सेंसरशिप का एक रूप है। अत्यंत चरम रूप से रीऑर्ग का रूप "अन्तिम स्थिति उलटना" है, जिसमें पहले से ही अनुमोदित ब्लॉक हटा दिए जाते हैं या उनकी जगह ले ली जाती है। यह तभी संभव है, जब हमलावर द्वारा कुल स्टेक किए गए ईथर का ⅓ से अधिक नष्ट किया जाए - यह गारंटी "आर्थिक अन्तिम स्थिति" के रूप में जानी जाती है - इसके बारे में अधिक जानकारी बाद में दी जाएगी।
+
+**दोहरी फाइनैलिटी** एक असंभावित लेकिन गंभीर स्थिति है, जहां दो फोर्क एक साथ फाइनलाइज़ करने में सक्षम होते हैं, जिससे चेन में एक स्थायी विभाजन पैदा होता है। यह सैद्धांतिक रूप से ऐसे हमलावर के लिए संभव है, जो कुल स्टेक किए गए ईथर का 34% जोखिम उठाने को तैयार हो। समुदाय को ऑफ-चेन समन्वय करने और यह तय करने के लिए मजबूर किया जाएगा कि किस चेन का पालन करना है, जिसके लिए सामाजिक परत में मजबूती की आवश्यकता होगी।
+
+एक **फाइनैलिटी में देरी** का हमला नेटवर्क को चेन के सेक्शन को फाइनलाइज़ करने के लिए आवश्यक शर्तों तक पहुंचने से रोकता है। अन्तिम स्थिति के बिना, एथेरियम पर आधारित वित्तीय ऐप्लिकेशन पर भरोसा करना मुश्किल है। अन्तिम स्थिति विलंब हमले का उद्देश्य, संभवतः सीधे लाभ प्राप्त करने के बजाय, एथेरियम को विघटित करना होता है, जब तक कि हमलावर के पास कुछ रणनीतिक शॉर्ट पोज़िशन न हों।
+
+सामाजिक परत पर हमला करने का उद्देश्य, एथेरियम में लोगों के विश्वास को कमज़ोर करना, ईथर का मूल्य घटाना, अपनाने की दर कम करना, या एथेरियम समुदाय को कमज़ोर करना हो सकता है, ताकि बैंड से बाहर के समन्वय को और कठिन बनाया जा सके।
+
+यह स्थापित करने के बाद कि कोई विरोधी एथेरियम पर हमला क्यों कर सकता है, निम्नलिखित सेक्शन इस बात की जांच करते हैं कि वे इसे _कैसे_ कर सकते हैं।
+
+## हमले के तरीके {#methods-of-attack}
+
+### परत 0 के हमले {#layer-0}
+
+सबसे पहले, वे व्यक्ति, जो एथेरियम में सक्रिय रूप से भाग नहीं ले रहे हैं (क्लाइंट सॉफ़्टवेयर चलाकर) सामाजिक परत (परत 0) को लक्ष्य बनाकर हमला कर सकते हैं। परत 0, एथेरियम की नींव है, और इसलिए यह हमलों के लिए एक संभावित सतह का प्रतिनिधित्व करती है, जिनके परिणाम पूरे स्टैक में फैल सकते हैं। कुछ उदाहरणों में ये शामिल हो सकते हैं:
+
+- गलत सूचना अभियान, एथेरियम के रोडमैप, डिवेलपर टीमों, ऐप्स आदि के प्रति समुदाय के विश्वास को खत्म कर सकता है। यह नेटवर्क की सुरक्षा में भाग लेने के लिए तैयार व्यक्तियों की संख्या घटा सकता है, जिसके परिणामस्वरूप विकेंद्रीकरण और क्रिप्टो-आर्थिक सुरक्षा दोनों का ह्रास होगा।
+
+- डिवेलपर समुदाय के खिलाफ लक्षित हमले और/या धमकी। यह डिवेलपर के स्वैच्छिक निकास की ओर ले जा सकता है, और एथेरियम की प्रगति को धीमा कर सकता है।
+
+- अति-उत्साही विनियमन को भी परत 0 पर हमला माना जा सकता है, क्योंकि यह भागीदारी और अपनाने को तेज़ी से हतोत्साहित कर सकता है।
+
+- जानकार लेकिन दुर्भावनापूर्ण काम करने वालों का डिवेलपर समुदाय में घुसपैठ करना, जिनका उद्देश्य अनावश्यक चर्चाओं के माध्यम से प्रगति को धीमा करना, महत्वपूर्ण निर्णयों में देरी करना, स्पैम बनाना आदि है।
+
+- एथेरियम ईकोसिस्टम के मुख्य लोगों के निर्णय लेने को प्रभावित करने के दी गई रिश्वतें।
+
+इन हमलों को जो बात विशेष रूप से खतरनाक बनाती है, वह यह है कई मामलों में बहुत कम पूंजी या तकनीकी जानकारी की आवश्यकता होती है। कोई परत 0 हमला, क्रिप्टो-आर्थिक हमले पर एक गुणक हो सकता है। उदाहरण के लिए, यदि सेंसरशिप या अन्तिम स्थिति परिवर्तन एक दुर्भावनापूर्ण बहुसंख्यक हितधारक द्वारा प्राप्त किया गया था, तो सामाजिक परत को कमज़ोर करने से एक सामुदायिक प्रतिक्रिया को समन्वयित करना अधिक कठिन हो सकता है।
+
+परत 0 हमलों से रक्षा करना शायद सरल नहीं है, लेकिन कुछ बुनियादी सिद्धांत स्थापित किए जा सकते हैं। एक सिद्धांत यह है कि एथेरियम के बारे में सार्वजनिक जानकारी के लिए एक उच्च संकेत शोर अनुपात बनाए रखा जाए, जो कि समुदाय के ईमानदार सदस्यों द्वारा निर्मित और ब्लॉग, discord सर्वर, एनोटेटेड स्पेसिफ़िकेशन, किताबों, पॉडकास्ट और Youtube के माध्यम से तैयार और प्रचारित किया जाए। यहां ethereum.org पर, हम सटीक जानकारी बनाए रखने और उसे जितनी ज़्यादा संभव हो सके, उतनी भाषाओं में अनुवादित करने की पूरी कोशिश करते हैं। किसी स्थान को उच्च गुणवत्ता वाली जानकारी और मीम्स से भरना, गलत सूचना के विरुद्ध एक प्रभावी बचाव है।
+
+सामाजिक परत हमलों के खिलाफ एक और महत्वपूर्ण सुरक्षा उपाय, एक स्पष्ट मिशन वक्तव्य और शासन प्रोटोकॉल है। एथेरियम ने स्मार्ट-कॉन्ट्रैक्ट परत 1 के बीच विकेंद्रीकरण और सुरक्षा के चैंपियन के रूप में अपनी पहचान बनाई है, जबकि स्केलेबिलिटी और स्थिरता को भी अत्यधिक महत्व दिया है। एथेरियम समुदाय में जो भी असहमतियां उभरती हैं, इन मूल सिद्धांतों से न्यूनतम स्तर पर ही समझौता किया जाता है। इन मूल सिद्धांतों के खिलाफ किसी भी कथा का मूल्यांकन करना और EIP (एथेरियम सुधार प्रस्ताव) प्रक्रिया में बार-बार समीक्षा के माध्यम से उन्हें जांचना, समुदाय को अच्छे और बुरे तत्वों में फर्क करने में मदद कर सकता है और बुरे इरादों वाले तत्वों को एथेरियम की भविष्य की दिशा को प्रभावित करने की सीमा को कम कर सकता है।
+
+अंततः, यह महत्वपूर्ण है कि एथेरियम समुदाय सभी प्रतिभागियों के लिए खुला और स्वागतयोग्य बना रहे। द्वारपालों और विशिष्टता वाला समुदाय विशेष रूप से सामाजिक हमले के प्रति संवेदनशील होता है, क्योंकि "हम और वे" कथाएं गढ़ना आसान होता है। जनजातीयता और विषाक्त अधिकतावाद, समुदाय को नुकसान पहुंचाते हैं और परत 0 सुरक्षा को कमज़ोर करते हैं। नेटवर्क की सुरक्षा में निहित हित वाले एथेरियन को अपने आचरण को ऑनलाइन और मीटस्पेस में एथेरियम की परत 0 की सुरक्षा में प्रत्यक्ष योगदानकर्ता के रूप में देखना चाहिए।
+
+### प्रोटोकॉल पर हमला {#attacking-the-protocol}
+
+एथेरियम के क्लाइंट सॉफ़्टवेयर को कोई भी चला सकता है। किसी क्लाइंट में कोई सत्यापनकर्ता जोड़ने के लिए, किसी यूज़र को जमा अनुबंध में 32 ईथर स्टेक करने की आवश्यकता होती है। कोई सत्यापनकर्ता किसी यूज़र को, नए ब्लॉकों को प्रस्तावित और प्रमाणित करके, एथेरियम की नेटवर्क सुरक्षा में सक्रिय रूप से भाग लेने की अनुमति देता है। सत्यापनकर्ता के पास अब एक आवाज़ होती है, जिसका उपयोग वे ब्लॉकचेन की भविष्य की सामग्री को प्रभावित करने के लिए कर सकते हैं - वे ईमानदारी से ऐसा कर सकते हैं और पुरस्कारों के माध्यम से ईथर के अपने संग्रह को बढ़ा सकते हैं या वे अपने स्टेक को जोखिम में डालते हुए, अपने लाभ के लिए प्रक्रिया में हेरफेर करने की कोशिश कर सकते हैं। हमला करने का एक तरीका यह है कि कुल स्टेक का एक बड़ा अनुपात जमा किया जाए और फिर इसका उपयोग ईमानदार सत्यापनकर्ताओं को मतदान से बाहर करने के लिए किया जाए। हमलावर द्वारा नियंत्रित स्टेक का अनुपात जितना अधिक होगा, उनकी मतदान शक्ति उतनी ही अधिक होगी, विशेष रूप से कुछ आर्थिक मील के पत्थरों पर जिनका हम बाद में पता लगाएंगे। हालांकि, अधिकांश हमलावर पर्याप्त ईथर इकट्ठा नहीं कर पाएंगे, ताकि वे इस तरीके से हमला कर सकें, इसलिए उन्हें ईमानदार बहुसंख्यकों को एक निश्चित तरीके से कार्य करने के लिए प्रेरित करने हेतु सूक्ष्म तकनीकों का उपयोग करना पड़ता है।
+
+मूल रूप से, सभी छोटे-स्टेक के हमले दो प्रकार की सत्यापनकर्ता की गलत गतिविधियों पर सूक्ष्म भिन्नताएँ होती हैं: कम गतिविधि (सही समय पर प्रमाणित/प्रस्तावित नहीं करना या देर से करना) या अधिक गतिविधि (एक स्लॉट में बहुत बार प्रस्तावित/प्रमाणित करना)। इन क्रियाओं को उनके सबसे सामान्य रूप में कांटा-विकल्प एल्गोरिथम और प्रोत्साहन परत द्वारा आसानी से संभाला जा सकता है, लेकिन सिस्टम को हमलावर के पक्ष में हेरफेर करने के लिए चालाक तरीके होते हैं।
+
+### ETH की छोटी मात्रा का उपयोग करके हमले {#attacks-by-small-stakeholders}
+
+#### पुनर्गठन (reorgs) {#reorgs}
+
+कई शोध पत्रों ने एथेरियम पर होने वाले हमलों की व्याख्या की है, जिनमें कुल स्टेक किए गए ईथर के केवल एक छोटे हिस्से से पुनर्गठन या अन्तिम स्थिति में विलंब हासिल किया जाता है। ये हमले आमतौर पर इस बात पर निर्भर करते हैं कि हमलावर कुछ जानकारी को अन्य सत्यापनकर्ताओं से छिपाकर रखता है और फिर उसे किसी विशेष तरीके से और/या किसी सही मौके पर जारी करता है। इनका उद्देश्य आमतौर पर कुछ ईमानदार ब्लॉक को कैनोनिकल चेन से हटाना होता है। [Neuder et al 2020](https://arxiv.org/pdf/2102.02247.pdf) ने दिखाया कि कैसे एक हमलावर वैलिडेटर किसी खास स्लॉट `n+1` के लिए एक ब्लॉक (`B`) बना सकता है और उसकी पुष्टि कर सकता है, लेकिन उसे नेटवर्क पर दूसरे नोड्स में प्रसारित करने से बच सकता है। इसके बजाय, वे उस प्रमाणित ब्लॉक को अगले स्लॉट `n+2` तक रोके रखते हैं। एक ईमानदार वैलिडेटर स्लॉट `n+2` के लिए एक ब्लॉक (`C`) प्रस्तावित करता है। लगभग एक साथ, हमलावर अपने रोके गए ब्लॉक (`B`) और उसके लिए अपनी रोकी गई पुष्टि जारी कर सकता है, और स्लॉट `n+2` के लिए अपने वोटों के साथ `B` को चेन का हेड होने की पुष्टि भी कर सकता है, जिससे प्रभावी रूप से ईमानदार ब्लॉक `C` के अस्तित्व को नकारा जा सकता है। जब ईमानदार ब्लॉक `D` जारी किया जाता है, तो फोर्क चॉइस एल्गोरिथ्म देखता है कि `C` पर `D` के बनने की तुलना में `B` के ऊपर `D` का बनना भारी है। इसलिए हमलावर 1-ब्लॉक एक्स-एंटे पुनर्गठन का उपयोग करके कैनोनिकल चेन से स्लॉट `n+2` में ईमानदार ब्लॉक `C` को हटाने में कामयाब रहा है। स्टेक के [34% हिस्से वाले एक हमलावर](https://www.youtube.com/watch?v=6vzXwwk12ZE) के इस हमले में सफल होने की बहुत अच्छी संभावना है, जैसा कि [इस नोट](https://notes.ethereum.org/plgVdz-ORe-fGjK06BZ_3A#Fork-choice-by-block-slot-pair) में बताया गया है। सिद्धांत में, हालांकि, इस हमले का प्रयास छोटे स्टेक के साथ भी किया जा सकता है। [Neuder et al 2020](https://arxiv.org/pdf/2102.02247.pdf) ने इस हमले को 30% स्टेक के साथ काम करने के रूप में वर्णित किया, लेकिन बाद में इसे [कुल स्टेक के 2%](https://arxiv.org/pdf/2009.04987.pdf) के साथ और फिर से [एकल वैलिडेटर](https://arxiv.org/abs/2110.10086#) के लिए बैलेंसिंग तकनीकों का उपयोग करके व्यवहार्य दिखाया गया, जिनकी हम अगले सेक्शन में जांच करेंगे।
+
+
+
+ऊपर वर्णित एक-ब्लॉक पुनर्गठन हमले का एक वैचारिक आरेख (यहां से ग्रहण किया गया https://notes.ethereum.org/plgVdz-ORe-fGjK06BZ_3A#Fork-choice-by-block-slot-pair)
+
+एक अधिक परिष्कृत हमला, ईमानदार सत्यापनकर्ता सेट को ऐसे अलग-अलग समूहों में विभाजित कर सकता है, चेन के शीर्ष के बारे में जिनका अलग-अलग दृष्टिकोण होता है। इसे **बैलेंसिंग अटैक** के रूप में जाना जाता है। हमलावर अपने ब्लॉक को प्रस्तावित करने के मौके इंतज़ार करते हैं, और जब वह मौका आता है, तो वे भ्रमित करते हैं और दो ब्लॉक प्रस्तावित करते हैं। वे एक ब्लॉक को ईमानदार सत्यापनकर्ता सेट के आधे हिस्से को भेजते हैं और दूसरे ब्लॉक को दूसरे आधे हिस्से को भेजते हैं। कांटा-विकल्प एल्गोरिथम द्वारा भ्रमों का पता लगाया जाता है और ब्लॉक प्रस्तावक को स्लैश किया जाता है और नेटवर्क से बाहर कर दिया जाता है, लेकिन दोनों ब्लॉक अभी भी मौज़ूद रहते हैं और प्रत्येक कांटे को लगभग आधे सत्यापनकर्ता सेट द्वारा प्रमाणित किया जाता है। इस बीच, शेष दुर्भावनापूर्ण सत्यापनकर्ता, अपने प्रमाणीकरण को रोकते हैं। फिर, जब कांटा-विकल्प एल्गोरिथम क्रियान्वित होता है, तो एक या दूसरे कांटे के पक्ष में सत्यापनों को चुनिंदा रूप से पर्याप्त सत्यापनकर्ताओं को जारी करके, वे सत्यापनों के संचित भार को एक या दूसरे कांटे के पक्ष में झुका देते हैं। यह अनिश्चितकाल तक जारी रह सकता है, जिसमें हमलावर सत्यापनकर्ता, पूरे दो कांटों में सत्यापनकर्ताओं का समान विभाजन बनाए रखते हैं। चूंकि कोई भी कांटा 2/3 सुपरमेजॉरिटी हासिल नहीं कर सकता, इसलिए नेटवर्क को अंतिम रूप नहीं मिलेगा।
+
+**बाउंसिंग हमले** भी समान होते हैं। हमलावर सत्यापनकर्ताओं द्वारा वोटों को फिर से रोका जाता है। दो कांटों के बीच समान विभाजन बनाए रखने के लिए, वोटों को जारी करने के बजाय, वे अवसर के अनुसार अपने वोटों का उपयोग करके जांच बिंदुओं को वैध बनाते हैं, जो कांटा A और कांटा B के बीच बदलते रहते हैं। दो कांटों के बीच वैधता का यह उलटफेर, औचित्यपूर्ण स्रोत और लक्ष्य जांचबिंदुओं के जोड़े को बनने से रोकता है, जिन्हें किसी भी चेन पर अंतिम रूप दिया जा सकता है, जिससे अंतिम स्थिति रुक जाती है।
+
+
- काम के सबूत को अब अप्रचलित कर दिया गया है। एथेरियम अब अपने कंसेंसस मैकेनिज्म के हिस्से के रूप में प्रूफ-ऑफ-वर्क का उपयोग नहीं करता है। इसके बजाय, यह हिस्सेदारी के सबूत का उपयोग करता है। [हिस्सेदारी के सबूत](/developers/docs/consensus-mechanisms/pos/) और [स्टेकिंग](/staking/) पर और अधिक पढ़ें।
+ काम के सबूत को अब अप्रचलित कर दिया गया है। एथेरियम अब अपने कंसेंसस मैकेनिज्म के हिस्से के रूप में प्रूफ-ऑफ-वर्क का उपयोग नहीं करता है। इसके बजाय, यह हिस्सेदारी के सबूत का उपयोग करता है। [प्रूफ-ऑफ-स्टेक](/developers/docs/consensus-mechanisms/pos/) और [स्टेकिंग](/staking/) पर और पढ़ें।
-## आवश्यक शर्तें {#prerequisites}
+## पूर्वापेक्षाएं {#prerequisites}
-इस पृष्ठ को बेहतर ढंग से समझने के लिए, हम अनुशंसा करते हैं कि आप पहले [लेनदेन](/developers/docs/transactions/), [ब्लॉक](/developers/docs/blocks/) और [कंसेंसस मैकेनिज्म](/developers/docs/consensus-mechanisms/) पढें।
+इस पृष्ठ को बेहतर ढंग से समझने के लिए, हम अनुशंसा करते हैं कि आप पहले [लेनदेन](/developers/docs/transactions/), [blocks](/developers/docs/blocks/), और [आम सहमति तंत्र](/developers/docs/consensus-mechanisms/) को पढ़ लें।
## काम का सबूत (PoW) क्या है? {#what-is-pow}
-नाकामोटो कंसेंसस, जो प्रूफ-ऑफ-वर्क का उपयोग करती है, वह मैकेनिज्म है जिसने एक बार विकेन्द्रीकृत एथेरियम नेटवर्क को खाता शेष राशि और लेनदेन के क्रम जैसी चीजों पर कंसेंसस (यानी सभी नोड्स सहमत हैं) की अनुमति दी थी। इसने यूज़र को अपने सिक्कों को "दोहरा खर्च" करने से रोका और यह सुनिश्चित किया कि एथेरियम श्रृंखला पर हमला करना या हेरफेर करना काफी मुश्किल था। ये सुरक्षा गुण अब [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/) नामक कंसेंसस मैकेनिज्म का उपयोग करने के बजाय प्रूफ-ऑफ-स्टेक से आते हैं।
+नाकामोतो सहमति, जो प्रूफ-ऑफ-वर्क का उपयोग करती है, वह तंत्र है जिसने एक बार विकेंद्रीकृत एथेरियम नेटवर्क को खाते की शेष राशि और लेनदेन के क्रम जैसी चीज़ों पर सहमति (यानी सभी नोड सहमत हैं) बनाने में मदद की। इसने यूज़र को अपने सिक्कों को "दोहरा खर्च" करने से रोका और यह सुनिश्चित किया कि एथेरियम श्रृंखला पर हमला करना या हेरफेर करना काफी मुश्किल था। अब ये सुरक्षा गुण प्रूफ-ऑफ-स्टेक से आते हैं, जो [Gasper](/developers/docs/consensus-mechanisms/pos/gasper/) नामक सहमति तंत्र का उपयोग करता है।
-## काम का सबूत और माइनिंग {#pow-and-mining}
+## प्रूफ-ऑफ-वर्क और माइनिंग {#pow-and-mining}
प्रूफ-ऑफ-वर्क अंतर्निहित एल्गोरिथम है जो प्रूफ-ऑफ-वर्क ब्लॉकचेन पर माइनर्स द्वारा किए जाने वाले कार्य के लिए कठिनाई और नियम निर्धारित करता है। माईनिंग "काम" ही है। यह श्रृंखला में वैध ब्लॉक जोड़ने का कार्य है। यह महत्वपूर्ण है क्योंकि श्रृंखला की लंबाई नेटवर्क को ब्लॉकचेन के सही फोर्क का पालन करने में मदद करती है। जितना अधिक "काम" किया जाता है, श्रृंखला उतनी ही लंबी होती है, और ब्लॉक संख्या जितनी अधिक होती है, नेटवर्क चीजों की वर्तमान स्थिति का उतना ही निश्चित हो सकता है।
-[माईनिंग करने के बारे में अधिक जानकारी](/developers/docs/consensus-mechanisms/pow/mining/)
+[माइनिंग के बारे में और जानें](/developers/docs/consensus-mechanisms/pow/mining/)
## एथेरियम के प्रूफ-ऑफ-वर्क ने कैसे काम किया? {#how-it-works}
एथेरियम लेनदेन को ब्लॉकों में संसाधित किया जाता है। वर्तमान में अप्रचलित प्रूफ-ऑफ-वर्क एथेरियम में, प्रत्येक ब्लॉक में शामिल हैं:
- ब्लॉक कठिनाई – उदाहरण के लिए: 3,324,092,183,262,715
-- mixHash - उदाहरण के लिए: `0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`
-- नॉन्स - उदाहरण के लिए: `0xd3ee432b4fb3d26b`
+- mixHash – उदाहरण के लिए: `0x44bca881b07a6a09f83b130798072441705d9a665c5ac8bdf2f39a3cdf3bee29`
+- nonce – उदाहरण के लिए: `0xd3ee432b4fb3d26b`
यह ब्लॉक डेटा सीधे काम के सबूत से संबंधित थे।
-### काम के सबूत में काम {#the-work}
+### प्रूफ-ऑफ-वर्क में कार्य {#the-work}
प्रूफ-ऑफ-वर्क प्रोटोकॉल, एताश को एक ब्लॉक के लिए नॉन्स के लिए माइनर्स को परीक्षण और त्रुटि की गहन परीक्षा से गुजरना पड़ता है। केवल एक वैध नॉन्स के साथ ब्लॉक श्रृंखला में जोड़ा जा सकता है।
@@ -49,7 +49,7 @@ lang: hi
हैशिंग धोखाधड़ी को पहचानना आसान बनाता है। लेकिन एक प्रक्रिया के रूप में काम का सबूत भी श्रृंखला पर हमला करने के लिए एक बड़ा निवारक था।
-### काम का सबूत और सुरक्षा {#security}
+### प्रूफ-ऑफ-वर्क और सुरक्षा {#security}
माइनर्स को मुख्य एथेरियम श्रृंखला पर यह काम करने के लिए प्रोत्साहित किया गया था। माइनर्स के एक सबसेट के लिए अपनी श्रृंखला शुरू करने के लिए बहुत कम इंसेटिव मिलता था—यह सिस्टम को कमजोर करता है। ब्लॉकचेन, सत्य के स्रोत के रूप में सिंगल स्थिति होने पर भरोसा करते हैं।
@@ -57,33 +57,33 @@ lang: hi
लगातार दुर्भावनापूर्ण लेकिन वैध ब्लॉक बनाने के लिए, एक दुर्भावनापूर्ण माईनर को बाकी सभी को हराने के लिए नेटवर्क माईनिंग पॉवर के 51% से अधिक की आवश्यकता होगी। "काम" की उस राशि के लिए बहुत महंगी कंप्यूटिंग शक्ति की आवश्यकता होती है और खर्च की गई ऊर्जा भी एक हमले में किए गए लाभ से अधिक हो सकती है।
-### प्रूफ-ऑफ-वर्क इकोनॉमिक्स {#economics}
+### प्रूफ-ऑफ-वर्क अर्थशास्त्र {#economics}
प्रूफ-ऑफ-वर्क प्रणाली में नई मुद्रा जारी करने और माइनर्स को काम करने के लिए इंसेटिव प्रदान करने के लिए भी जिम्मेदार था।
-[कॉन्स्टेंटिनोपल अपग्रेड](/ethereum-forks/#constantinople) के बाद से, सफलतापूर्वक एक ब्लॉक बनाने वाले माइनर्स को दो ताजा माईनिंग ETH और लेनदेन शुल्क के हिस्से से पुरस्कृत किया गया। ओमर ब्लॉकों ने 1.75 ETH की भी भरपाई की। ओमर ब्लॉक एक माईनर द्वारा व्यावहारिक रूप से उसी समय बनाए गए वैध ब्लॉक थे जब एक अन्य माईनर ने कैनोनिकल ब्लॉक बनाया था, जो अंततः निर्धारित किया गया था कि किस श्रृंखला को पहले के शीर्ष पर बनाया गया था। ओमर ब्लॉक आमतौर पर नेटवर्क विलंबता के कारण हुआ।
+[कॉन्स्टेंटिनोपल अपग्रेड](/ethereum-forks/#constantinople) के बाद से, जो माइनर्स सफलतापूर्वक एक ब्लॉक बनाते थे, उन्हें दो नए मिंट किए गए ETH और लेनदेन शुल्क का एक हिस्सा इनाम में दिया जाता था। ओमर ब्लॉकों ने 1.75 ETH की भी भरपाई की। ओमर ब्लॉक एक माईनर द्वारा व्यावहारिक रूप से उसी समय बनाए गए वैध ब्लॉक थे जब एक अन्य माईनर ने कैनोनिकल ब्लॉक बनाया था, जो अंततः निर्धारित किया गया था कि किस श्रृंखला को पहले के शीर्ष पर बनाया गया था। ओमर ब्लॉक आमतौर पर नेटवर्क विलंबता के कारण हुआ।
-## अन्तिम स्थिति {#finality}
+## अंतिमता {#finality}
एथेरियम पर लेन-देन की "अंतिमता" तब होती है जब यह एक ब्लॉक का हिस्सा होता है जिसे बदल नहीं सकता है।
क्योंकि माइनर्स ने विकेंद्रीकृत तरीके से काम किया, एक ही समय में दो वैध ब्लॉकों को माइन किया जा सकता था। यह एक अस्थायी फोर्क बनाता है। आखिरकार, बाद के ब्लॉकों का माईनिंग करने और इसमें जोड़े जाने के बाद इनमें से एक श्रृंखला स्वीकृत श्रृंखला बन गई, जिससे यह लंबा हो गया।
-चीजों को और जटिल बनाने के लिए, अस्थायी फोर्क पर खारिज किए गए लेनदेन को स्वीकृत श्रृंखला में शामिल नहीं किया जा सकता है। इसका मतलब है कि यह उलट हो सकता है। तो अंतिमता उस समय को संदर्भित करती है जब आपको लेनदेन को अपरिवर्तनीय मानने से पहले इंतजार करना चाहिए। पिछले प्रूफ-ऑफ-वर्क एथेरियम के तहत, एक विशिष्ट ब्लॉक `N` के शीर्ष पर जितने अधिक ब्लॉक माईन किए गए थे, उतना अधिक उच्च विश्वास होगा कि `N` में लेनदेन सफल होंगे और वापस नहीं किए जाएंगे। अब, प्रूफ-ऑफ-स्टेक के साथ, अंतिम रूप देना एक ब्लॉक की संभाव्य संपत्ति के बजाय एक स्पष्ट है।
+चीजों को और जटिल बनाने के लिए, अस्थायी फोर्क पर खारिज किए गए लेनदेन को स्वीकृत श्रृंखला में शामिल नहीं किया जा सकता है। इसका मतलब है कि यह उलट हो सकता है। तो अंतिमता उस समय को संदर्भित करती है जब आपको लेनदेन को अपरिवर्तनीय मानने से पहले इंतजार करना चाहिए। पिछले प्रूफ-ऑफ-वर्क एथेरियम के तहत, एक विशिष्ट ब्लॉक `N` के शीर्ष पर जितने अधिक ब्लॉक माइन किए गए, यह विश्वास उतना ही अधिक था कि `N` में लेनदेन सफल थे और उन्हें पलटा नहीं जाएगा। अब, प्रूफ-ऑफ-स्टेक के साथ, अंतिम रूप देना एक ब्लॉक की संभाव्य संपत्ति के बजाय एक स्पष्ट है।
-## काम के सबूत का ऊर्जा-उपयोग {#energy}
+## प्रूफ-ऑफ-वर्क में ऊर्जा की खपत {#energy}
-काम के सबूत की एक प्रमुख कमजोरी, नेटवर्क को सुरक्षित रखने के लिए आवश्यक ऊर्जा उत्पादन की मात्रा है। सुरक्षा और विकेंद्रीकरण बनाए रखने के लिए, काम के सबूत पर एथेरियम ने बड़ी मात्रा में ऊर्जा की खपत की। हिस्सेदारी के सबूत पर स्विच करने से कुछ समय पहले, एथेरियम माईनर सामूहिक रूप से लगभग 70 TWh/yr (लगभग चेक गणराज्य के समान - [digiconomist](https://digiconomist.net/) 18-जुलाई-2022 के अनुसार) का उपभोग कर रहे थे।
+काम के सबूत की एक प्रमुख कमजोरी, नेटवर्क को सुरक्षित रखने के लिए आवश्यक ऊर्जा उत्पादन की मात्रा है। सुरक्षा और विकेंद्रीकरण बनाए रखने के लिए, काम के सबूत पर एथेरियम ने बड़ी मात्रा में ऊर्जा की खपत की। प्रूफ-ऑफ-स्टेक पर स्विच करने से कुछ समय पहले, एथेरियम माइनर्स सामूहिक रूप से लगभग 70 TWh/yr की खपत कर रहे थे (लगभग चेक गणराज्य के बराबर - 18-जुलाई-2022 को [digiconomist](https://digiconomist.net/) के अनुसार)।
## लाभ और हानि {#pros-and-cons}
-| पेशेवरों | विपक्ष |
-| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-| काम के सबूत तटस्थ है। आरंभ करने के लिए आपको ETH की आवश्यकता नहीं है और ब्लॉक पुरस्कार आपको 0ETH से सकारात्मक संतुलन तक जाने की अनुमति देते हैं। [हिस्सेदारी के सबूत](/developers/docs/consensus-mechanisms/pos/) के साथ आपको शुरू करने के लिए ETH की आवश्यकता है। | काम का सबूत इतनी ऊर्जा का उपयोग करता है कि यह पर्यावरण के लिए बुरा है। |
-| काम का सबूत एक आजमाया हुआ के है जिसने Bitcoin और एथेरियम को कई वर्षों तक सुरक्षित और विकेंद्रीकृत रखा है। | यदि आप माइन करना चाहते हैं, तो आपको ऐसे विशेष उपकरणों की आवश्यकता है जो शुरू करने के लिए एक बड़ा निवेश है। |
-| हिस्सेदारी के सबूत की तुलना में इसे लागू करना अपेक्षाकृत आसान है। | बढ़ती गणना की आवश्यकता के कारण, माईनिंग पूल संभावित रूप से माईनिंग खेल पर हावी हो सकते हैं, जिससे केंद्रीकरण और सुरक्षा जोखिम हो सकते हैं। |
+| पेशेवरों | विपक्ष |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| काम के सबूत तटस्थ है। आरंभ करने के लिए आपको ETH की आवश्यकता नहीं है और ब्लॉक पुरस्कार आपको 0ETH से सकारात्मक संतुलन तक जाने की अनुमति देते हैं। [प्रूफ-ऑफ-स्टेक](/developers/docs/consensus-mechanisms/pos/) के साथ शुरुआत करने के लिए आपको ETH की आवश्यकता होती है। | काम का सबूत इतनी ऊर्जा का उपयोग करता है कि यह पर्यावरण के लिए बुरा है। |
+| काम का सबूत एक आजमाया हुआ के है जिसने Bitcoin और एथेरियम को कई वर्षों तक सुरक्षित और विकेंद्रीकृत रखा है। | यदि आप माइन करना चाहते हैं, तो आपको ऐसे विशेष उपकरणों की आवश्यकता है जो शुरू करने के लिए एक बड़ा निवेश है। |
+| हिस्सेदारी के सबूत की तुलना में इसे लागू करना अपेक्षाकृत आसान है। | बढ़ती गणना की आवश्यकता के कारण, माईनिंग पूल संभावित रूप से माईनिंग खेल पर हावी हो सकते हैं, जिससे केंद्रीकरण और सुरक्षा जोखिम हो सकते हैं। |
-## हिस्सेदारी के सबूत की तुलना में {#compared-to-pos}
+## प्रूफ-ऑफ-स्टेक की तुलना में {#compared-to-pos}
उच्च स्तर पर, प्रूफ-ऑफ-स्टेक का प्रूफ-ऑफ-वर्क के समान अंतिम लक्ष्य होता है: विकेन्द्रीकृत नेटवर्क को सुरक्षित रूप से आम सहमति तक पहुंचने में मदद करना। लेकिन इसमें प्रक्रिया और कर्मियों में कुछ अंतर हैं:
@@ -92,23 +92,23 @@ lang: hi
- सत्यापनकर्ता ब्लॉक बनाने के लिए प्रतिस्पर्धा नहीं करते हैं, इसके बजाय उन्हें एक एल्गोरिथम द्वारा रैंडम रूप से चुना जाता है।
- अंतिमता स्पष्ट है: कुछ चेकपॉइंट पर, यदि 2/3 सत्यापनकर्ता ब्लॉक की स्थिति पर सहमत होते हैं तो इसे अंतिम माना जाता है। सत्यापनकर्ताओं को इस पर अपनी पूरी हिस्सेदारी स्टेक पर लगानी चाहिए, इसलिए यदि वे लाइन से टकराने की कोशिश करते हैं, तो वे अपनी पूरी हिस्सेदारी खो देंगे।
-[हिस्सेदारी के सबूत के बारे में अधिक जानकारी](/developers/docs/consensus-mechanisms/pos/)
+[प्रूफ-ऑफ-स्टेक के बारे में और जानें](/developers/docs/consensus-mechanisms/pos/)
## क्या आप एक दृश्य शिक्षार्थी हैं? {#visual-learner}
xᵐ mod P ≡ 1
-इन निर्धारणों को देखते हुए, हमारे पास है:
+इससे बचने के लिए, संख्या सिद्धांत से परिणाम की अपील की जाती है। एक [_सेफ प्राइम_](https://en.wikipedia.org/wiki/Safe_prime) को एक ऐसे प्राइम `P` के रूप में परिभाषित किया गया है, जिसके लिए `(P-1)/2` भी एक प्राइम है। [गुणक समूह](https://en.wikipedia.org/wiki/Multiplicative_group_of_integers_modulo_n) `ℤ/nℤ` के किसी सदस्य `x` का _क्रम_ (order) वह न्यूनतम `m` होता है जिसके लिए xᵐ mod P ≡ 1
+इन परिभाषाओं को देखते हुए, हमें यह मिलता है:
-> ऑब्जर्वेशन 1. माना कि एक सेफ प्राइम `P` के लिए `x` गुणक समूह `ℤ/Pℤ` का सदस्य है। यदि `x mod P ≠ 1 mod P` और `x mod P ≠ P-1 mod P` है, तो `x` का क्रम या तो `P-1` या `(P-1)/2` है।
+> ऑब्जर्वेशन 1. मान लें कि एक सेफ प्राइम `P` के लिए `x`, गुणक समूह `ℤ/Pℤ` का सदस्य है। यदि `x mod P ≠ 1 mod P` और `x mod P ≠ P-1 mod P` है, तो `x` का क्रम या तो `P-1` या `(P-1)/2` है।
-_प्रमाण_। चूँकि `P` एक सेफ प्राइम है, तो \[लैग्रेंज प्रमेय\] \[लैग्रेंज\] द्वारा सिद्ध होता है कि `x` का क्रम या तो `1`, `2`, `(P-1)/2`, या `P-1` है।
+_प्रमाण_। चूंकि `P` एक सेफ प्राइम है, तो [लैग्रेंज के प्रमेय][lagrange] के अनुसार `x` का क्रम या तो `1`, `2`, `(P-1)/2`, या `P-1` है।
-`x` का क्रम `1` नहीं हो सकता है, क्योंकि फर्मेट के लिटिल प्रमेय द्वारा सिद्ध होता है:
+`x` का क्रम `1` नहीं हो सकता, क्योंकि फर्मेट के छोटे प्रमेय के अनुसार:
xP-1 mod P ≡ 1
-अतः `x`, `Z/nZ` की गुणक पहचान होनी चाहिए, जो अद्वितीय है। चूँकि हमने मान लिया है कि `x ≠ 1` धारणा द्वारा, यह संभव नहीं है।
+अतः `x` को `ℤ/nℤ` की गुणक पहचान होना चाहिए, जो अद्वितीय है। चूंकि हमने यह मान लिया है कि `x ≠ 1`, यह संभव नहीं है।
-`x` का क्रम `2` नहीं हो सकता जब तक कि `x = P-1` न हो, क्योंकि यह उल्लंघन करेगा कि `P` अभाज्य है।
+`x` का क्रम `2` नहीं हो सकता जब तक कि `x = P-1` न हो, क्योंकि यह इस बात का उल्लंघन करेगा कि `P` प्राइम है।
-उपरोक्त प्रस्ताव से, हम पहचान सकते हैं कि पुनरावृत्त `(picker * init) % P` की चक्र लंबाई कम से कम `(P-1)/2` होगी। ऐसा इसलिए है क्योंकि हमने `P` को लगभग दो की उच्च शक्ति के बराबर एक सेफ़ प्राइम के रूप में चुना है, और `init` अंतराल `[2,2**256+1]` में है। `P` के परिमाण को देखते हुए, हमें मॉड्यूलर घातांक से चक्र की उम्मीद कभी नहीं करनी चाहिए।
+उपरोक्त प्रस्ताव से, हम यह पहचान सकते हैं कि `(picker * init) % P` को दोहराने पर चक्र की लंबाई कम से कम `(P-1)/2` होगी। ऐसा इसलिए है क्योंकि हमने `P` को दो की उच्च घात के लगभग बराबर एक सेफ प्राइम के रूप में चुना है, और `init` अंतराल `[2,2**256+1]` में है। `P` के परिमाण को देखते हुए, हमें मॉड्यूलर एक्सपोनेंशिएशन से कभी भी एक चक्र की उम्मीद नहीं करनी चाहिए।
-जब हम DAG (`init` लेबल वाला वेरिएबल) में पहला सेल असाइन कर रहे होते हैं, तो हम `pow(sha3(seed) + 2, 3, P)` की गणना करते हैं। पहली नज़र में, यह गारंटी नहीं देता है कि परिणाम न तो `1` है और न ही `P-1` है। हालांकि, चूंकि `P-1` एक सेफ़ प्राइम है, इसलिए हमारे पास निम्नलिखित अतिरिक्त आश्वासन हैं, जो अवलोकन 1 का एक परिणाम है:
+जब हम DAG में पहला सेल निर्दिष्ट कर रहे होते हैं (जिसे `init` वैरिएबल से लेबल किया गया है), हम `pow(sha3(seed) + 2, 3, P)` की गणना करते हैं। पहली नज़र में, यह इस बात की गारंटी नहीं देता है कि परिणाम न तो `1` है और न ही `P-1`। हालांकि, चूंकि `P-1` एक सेफ प्राइम है, हमारे पास निम्नलिखित अतिरिक्त आश्वासन है, जो अवलोकन 1 का एक उप-प्रमेय है:
-> ऑब्जर्वेशन 2. माना कि सेफ़ प्राइम `P` के लिए `x` गुणक समूह `ℤ/Pℤ` का सदस्य है, और मान लीजिए `w` एक प्राकृत संख्या है। यदि `x mod P ≠ 1 mod P` और `x mod P ≠ P-1 mod P`, साथ ही `w mod P ≠ P-1 mod P` और `w mod P ≠ 0 mod P` है, तो `xw mod P ≠ 1 mod P` और `xw mod P ≠ P-1 mod P`
+> ऑब्जर्वेशन 2. मान लें कि एक सेफ प्राइम `P` के लिए `x` गुणक समूह `ℤ/Pℤ` का एक सदस्य है, और मान लें कि `w` एक प्राकृत संख्या है। यदि `x mod P ≠ 1 mod P` और `x mod P ≠ P-1 mod P` है, साथ ही `w mod P ≠ P-1 mod P` और `w mod P ≠ 0 mod P` है, तो `xʷ mod P ≠ 1 mod P` और `xʷ mod P ≠ P-1 mod P`
-### एक हैश फ़ंक्शन के रूप में मॉड्यूलर घातांक {#modular-exponentiation}
+### एक हैश फ़ंक्शन के रूप में मॉड्यूलर एक्सपोनेंशिएशन {#modular-exponentiation}
`P` और `w` के कुछ मानों के लिए, फ़ंक्शन `pow(x, w, P)` में कई टकराव हो सकते हैं। उदाहरण के लिए, `pow(x,9,19)` केवल `{1,18}` मान लेता है।
-चूंकि `P` प्राइम है, तो मॉड्यूलर घातांक हैशिंग फ़ंक्शन के लिए एक उपयुक्त `w` को निम्नलिखित परिणाम का उपयोग करके चुना जा सकता है:
+यह देखते हुए कि `P` प्राइम है, मॉड्यूलर एक्सपोनेंशिएशन हैशिंग फ़ंक्शन के लिए एक उपयुक्त `w` निम्नलिखित परिणाम का उपयोग करके चुना जा सकता है:
-> ऑब्जर्वेशन 3. मान लीजिए `P` एक प्राइम है; `w` और `P-1` अपेक्षाकृत प्राइम हैं यदि और केवल यदि `a` और `b` `ℤ/Pℤ`में:
->
->
-> 'aw mod P ≡ bw mod P' if और only if 'a mod P ≡ b mod P'
->
+> ऑब्जर्वेशन 3. मान लें `P` एक प्राइम है; `w` और `P-1` सह-अभाज्य हैं यदि और केवल यदि `ℤ/Pℤ` में सभी `a` और `b` के लिए:`aʷ mod P ≡ bʷ mod P` यदि और केवल यदि `a mod P ≡ b mod P`
-इस प्रकार, चूंकि `P` प्राइम है और `w` `P-1` के लिए अपेक्षाकृत प्राइम है, हमें ज्ञात होता है कि `|{pow(x, w, P) : x ∈ ℤ}| = P`, जिसका अर्थ है कि हैशिंग फ़ंक्शन में न्यूनतम टक्कर दर संभव है।
+इस प्रकार, यह देखते हुए कि `P` प्राइम है और `w`, `P-1` के साथ सह-अभाज्य है, हमें मिलता है कि `|{pow(x, w, P) : x ∈ ℤ}| = P`, जिसका अर्थ है कि हैशिंग फ़ंक्शन की कॉलिज़न दर न्यूनतम संभव है।
-विशेष मामले में कि `P` एक सेफ़ प्राइम है जैसा कि हमने चुना है, तो `P-1` में केवल कारक 1, 2, `(P-1)/2` `P-1`। चूँकि `P` > 7, हम जानते हैं कि `P-1` के लिए 3 अपेक्षाकृत प्राइम है, इसलिए `w = 3` उपरोक्त प्रस्ताव को संतुष्ट करता है।
+उस विशेष मामले में जहां `P` एक सेफ प्राइम है जैसा कि हमने चुना है, तो `P-1` के केवल 1, 2, `(P-1)/2` और `P-1` गुणनखंड होते हैं। चूँकि `P` > 7, हम जानते हैं कि 3, `P-1` के साथ सह-अभाज्य है, इसलिए `w=3` उपरोक्त प्रस्ताव को संतुष्ट करता है।
-## अधिक कुशल कैश-आधारित मूल्यांकन एल्गोरिथम {#cache-based-evaluation}
+## अधिक कुशल कैश-आधारित मूल्यांकन एल्गोरिदम {#cache-based-evaluation}
```python
def quick_calc(params, seed, p):
diff --git a/public/content/translations/hi/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md b/public/content/translations/hi/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
index cc458f4e90f..cfe2d7b666d 100644
--- a/public/content/translations/hi/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
+++ b/public/content/translations/hi/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash/index.md
@@ -1,6 +1,6 @@
---
-title: एथाश
-description: एथाश एल्गोरिथम पर एक विस्तृत नज़र।
+title: "एथाश"
+description: "एथाश एल्गोरिथम पर एक विस्तृत नज़र।"
lang: hi
---
@@ -8,12 +8,12 @@ lang: hi
- एथाश एथेरियम का प्रूफ-ऑफ-वर्क माइनिंग एल्गोरिथम था। प्रूफ-ऑफ-वर्क को अब **पूरी तरह से बंद कर दिया गया है** और एथेरियम अब इसके बजाय [प्रूफ-ऑफ-स्टेक](/developers/docs/consensus-mechanisms/pos/) का उपयोग करके सुरक्षित है। [द मर्ज](/roadmap/merge/), [हिस्सेदारी के सबूत](/developers/docs/consensus-mechanisms/pos/) और [स्टेकिंग](/staking/) पर अधिक। यह पृष्ठ ऐतिहासिक रुचि के लिए है!
+ एथाश एथेरियम का प्रूफ-ऑफ-वर्क माइनिंग एल्गोरिथम था। काम का सबूत अब **पूरी तरह से बंद कर दिया गया है** और एथेरियम अब इसके बजाय [हिस्सेदारी के सबूत](/developers/docs/consensus-mechanisms/pos/) का उपयोग करके सुरक्षित है। [मर्ज](/roadmap/merge/), [हिस्सेदारी के सबूत](/developers/docs/consensus-mechanisms/pos/) और [स्टेकिंग](/staking/) पर और पढ़ें। यह पृष्ठ ऐतिहासिक रुचि के लिए है!
-एथाश [डैगर-हाशिमोटो](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto) एल्गोरिथम का एक संशोधित संस्करण है। एथाश प्रूफ-ऑफ-वर्क [मेमोरी हार्ड](https://wikipedia.org/wiki/Memory-hard_function) है, जिससे एल्गोरिथम ASIC प्रतिरोधी बनाने की अपेक्षा की गई थी। एथाश ASIC को अंततः विकसित किया गया था लेकिन GPU माईनिंग तब तक एक व्यवहार्य विकल्प था जब तक कि प्रूफ-ऑफ-वर्क बंद नहीं किया गया था। एथाश का उपयोग अभी भी अन्य गैर-एथेरियम प्रूफ-ऑफ-वर्क नेटवर्क पर अन्य सिक्कों को माइन करने के लिए किया जाता है।
+एथाश [डैगर-हाशिमोटो](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto) एल्गोरिथम का एक संशोधित संस्करण है। एथाश काम का सबूत [मेमोरी हार्ड](https://wikipedia.org/wiki/Memory-hard_function) है, जिससे एल्गोरिथम को ASIC प्रतिरोधी माना जाता था। एथाश ASIC को अंततः विकसित किया गया था लेकिन GPU माईनिंग तब तक एक व्यवहार्य विकल्प था जब तक कि प्रूफ-ऑफ-वर्क बंद नहीं किया गया था। एथाश का उपयोग अभी भी अन्य गैर-एथेरियम प्रूफ-ऑफ-वर्क नेटवर्क पर अन्य सिक्कों को माइन करने के लिए किया जाता है।
## एथाश कैसे काम करता है? {#how-does-ethash-work}
@@ -23,7 +23,7 @@ lang: hi
1. एक **सीड** मौजूद है जिसे उस बिंदु तक ब्लॉक हेडर के माध्यम से स्कैन करके प्रत्येक ब्लॉक के लिए गणना की जा सकती है।
2. सीड से, कोई **16 MB स्यूडोरैंडम कैश** की गणना कर सकता है। लाइट क्लाइंट कैश स्टोर करते हैं।
-3. कैश से, हम एक **1 GB डेटासेट** उत्पन्न कर सकते हैं, इस विशेषता के साथ कि डेटासेट में प्रत्येक आइटम कैश से केवल कुछ ही वस्तुओं पर निर्भर करता है। पूर्ण क्लाइंट और माईनर डेटासेट को संग्रहीत करते हैं। डेटासेट समय के साथ रैखिक रूप से बढ़ता है।
+3. कैश से, हम **1 GB डेटासेट** उत्पन्न कर सकते हैं, इस विशेषता के साथ कि डेटासेट में प्रत्येक आइटम कैश से केवल कुछ ही वस्तुओं पर निर्भर करता है। पूर्ण क्लाइंट और माईनर डेटासेट को संग्रहीत करते हैं। डेटासेट समय के साथ रैखिक रूप से बढ़ता है।
4. माईनिंग में डेटासेट के रैंडम स्लाइस को पकड़ना और उन्हें एक साथ हैश करना शामिल है। डेटासेट के विशिष्ट भागों को पुन: उत्पन्न करने के लिए कैश का उपयोग करके कम मेमोरी के साथ सत्यापन किया जा सकता है, इसलिए आपको केवल कैश को स्टोर करने की आवश्यकता है।
बड़े डेटासेट को हर 30000 ब्लॉक में एक बार अपडेट किया जाता है, इसलिए एक माईनर के प्रयास का अधिकांश हिस्सा डेटासेट को पढ़ना होगा, इसमें बदलाव नहीं करना होगा।
@@ -33,27 +33,27 @@ lang: hi
हम निम्नलिखित परिभाषाओं को नियोजित करते हैं:
```
-WORD_BYTES = 4 # bytes in word
-DATASET_BYTES_INIT = 2**30 # bytes in dataset at genesis
-DATASET_BYTES_GROWTH = 2**23 # dataset growth per epoch
-CACHE_BYTES_INIT = 2**24 # bytes in cache at genesis
-CACHE_BYTES_GROWTH = 2**17 # cache growth per epoch
-CACHE_MULTIPLIER=1024 # Size of the DAG relative to the cache
-EPOCH_LENGTH = 30000 # blocks per epoch
-MIX_BYTES = 128 # width of mix
-HASH_BYTES = 64 # hash length in bytes
-DATASET_PARENTS = 256 # number of parents of each dataset element
-CACHE_ROUNDS = 3 # number of rounds in cache production
-ACCESSES = 64 # number of accesses in hashimoto loop
+WORD_BYTES = 4 # शब्द में बाइट्स
+DATASET_BYTES_INIT = 2**30 # जेनेसिस पर डेटासेट में बाइट्स
+DATASET_BYTES_GROWTH = 2**23 # प्रति युग डेटासेट वृद्धि
+CACHE_BYTES_INIT = 2**24 # जेनेसिस पर कैश में बाइट्स
+CACHE_BYTES_GROWTH = 2**17 # प्रति युग कैश वृद्धि
+CACHE_MULTIPLIER=1024 # कैश के सापेक्ष DAG का आकार
+EPOCH_LENGTH = 30000 # प्रति युग ब्लॉक
+MIX_BYTES = 128 # मिक्स की चौड़ाई
+HASH_BYTES = 64 # बाइट्स में हैश की लंबाई
+DATASET_PARENTS = 256 # प्रत्येक डेटासेट तत्व के पैरेंट्स की संख्या
+CACHE_ROUNDS = 3 # कैश उत्पादन में राउंड की संख्या
+ACCESSES = 64 # हाशिमोटो लूप में एक्सेस की संख्या
```
### 'SHA3' का उपयोग {#sha3}
-एथेरियम का विकास SHA3 मानक के विकास के साथ हुआ, और मानक प्रक्रिया ने अंतिम हैश एल्गोरिथम के पैडिंग में देर से बदलाव किया, ताकि एथेरियम sha3_256 और "sha3_512" हैश मानक sha3 हैश नहीं हैं, लेकिन एक प्रकार जिसे अक्सर संदर्भित किया जाता है अन्य संदर्भों में "Keccak-256" और "Keccak-512" के रूप में। चर्चा देखें, उदाहरण के लिए [यहां](https://eips.ethereum.org/EIPS/eip-1803), [यहां](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use), या [यहां](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057)।
+एथेरियम का विकास SHA3 मानक के विकास के साथ हुआ, और मानक प्रक्रिया ने अंतिम हैश एल्गोरिथम के पैडिंग में देर से बदलाव किया, ताकि एथेरियम sha3_256 और "sha3_512" हैश मानक sha3 हैश नहीं हैं, लेकिन एक प्रकार जिसे अक्सर संदर्भित किया जाता है अन्य संदर्भों में "Keccak-256" और "Keccak-512" के रूप में। चर्चा देखें, उदा., [यहां](https://eips.ethereum.org/EIPS/eip-1803), [यहां](http://ethereum.stackexchange.com/questions/550/which-cryptographic-hash-function-does-ethereum-use), या [यहां](http://bitcoin.stackexchange.com/questions/42055/what-is-the-approach-to-calculate-an-ethereum-address-from-a-256-bit-private-key/42057#42057)।
कृपया इसे ध्यान में रखें क्योंकि नीचे दिए गए एल्गोरिथ्म के विवरण में "sha3" हैश को संदर्भित किया गया है।
-## पैरामीटर {#parameters}
+## पैरामीटर्स {#parameters}
एथाश के कैश और डेटासेट के पैरामीटर ब्लॉक नंबर पर निर्भर करते हैं। कैश आकार और डेटासेट आकार दोनों रैखिक रूप से बढ़ते हैं; हालांकि, हम हमेशा चक्रीय व्यवहार के लिए आकस्मिक नियमितताओं के जोखिम को कम करने के लिए रैखिक रूप से बढ़ती सीमा से नीचे उच्चतम प्राइम लेते हैं।
@@ -75,7 +75,7 @@ def get_full_size(block_number):
डेटासेट और कैश आकार मूल्यों की तालिकाएं परिशिष्ट में प्रदान की गई हैं।
-## कैश जनरेशन {#cache-generation}
+## कैश उत्पादन {#cache-generation}
अब, हम कैश बनाने के लिए फ़ंक्शन निर्दिष्ट करते हैं:
@@ -83,12 +83,12 @@ def get_full_size(block_number):
def mkcache(cache_size, seed):
n = cache_size // HASH_BYTES
- # Sequentially produce the initial dataset
+ # क्रमिक रूप से प्रारंभिक डेटासेट का उत्पादन करें
o = [sha3_512(seed)]
for i in range(1, n):
o.append(sha3_512(o[-1]))
- # Use a low-round version of randmemohash
+ # रैंडमेमोहेश के कम-राउंड संस्करण का उपयोग करें
for _ in range(CACHE_ROUNDS):
for i in range(n):
v = o[i][0] % n
@@ -97,11 +97,11 @@ def mkcache(cache_size, seed):
return o
```
-कैश उत्पादन प्रक्रिया में पहले क्रमिक रूप से 32 MB मेमोरी भरना शामिल है, फिर सर्जियो डेमियन लर्नर के _RandMemoHash_ एल्गोरिथम के दो पास [_स्ट्रिक्ट मेमोरी हार्ड हैशिंग फ़ंक्शंस_ (2014) से करते](http://www.hashcash.org/papers/memohash.pdf) हैं। आउटपुट 524288 64-बाइट मानों का एक सेट है।
+कैश उत्पादन प्रक्रिया में पहले क्रमिक रूप से 32 MB मेमोरी भरना, फिर [_स्ट्रिक्ट मेमोरी हार्ड हैशिंग फंक्शंस_ (2014)](http://www.hashcash.org/papers/memohash.pdf) से सर्जियो डेमियन लर्नर के _RandMemoHash_ एल्गोरिथम के दो पास करना शामिल है। आउटपुट 524288 64-बाइट मानों का एक सेट है।
-## डेटा एकत्रीकरण फ़ंक्शन {#date-aggregation-function}
+## डेटा एग्रीगेशन फ़ंक्शन {#date-aggregation-function}
-हम XOR के लिए एक गैर-सहयोगी विकल्प के रूप में कुछ मामलों में [FNV हैश](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) से प्रेरित एल्गोरिथम का उपयोग करते हैं। ध्यान दें कि हम FNV-1 स्पेक के विपरीत पूर्ण 32-बिट इनपुट के साथ प्राइम को गुणा करते हैं, जो बदले में प्राइम को एक बाइट (ऑक्टेट) से गुणा करता है।
+हम कुछ मामलों में XOR के गैर-सहयोगी विकल्प के रूप में [FNV हैश](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function) से प्रेरित एल्गोरिथम का उपयोग करते हैं। ध्यान दें कि हम FNV-1 स्पेक के विपरीत पूर्ण 32-बिट इनपुट के साथ प्राइम को गुणा करते हैं, जो बदले में प्राइम को एक बाइट (ऑक्टेट) से गुणा करता है।
```python
FNV_PRIME = 0x01000193
@@ -110,7 +110,7 @@ def fnv(v1, v2):
return ((v1 * FNV_PRIME) ^ v2) % 2**32
```
-कृपया ध्यान दें, यहां तक कि पीला पेपर fnv को v1*(FNV_PRIME ^ v2) के रूप में निर्दिष्ट करता है, सभी वर्तमान कार्यान्वयन लगातार उपरोक्त निर्धारण का उपयोग करते हैं।
+कृपया ध्यान दें, यहां तक कि पीला पेपर fnv को v1\*(FNV_PRIME ^ v2) के रूप में निर्दिष्ट करता है, सभी वर्तमान कार्यान्वयन लगातार उपरोक्त निर्धारण का उपयोग करते हैं।
## पूर्ण डेटासेट गणना {#full-dataset-calculation}
@@ -120,11 +120,11 @@ def fnv(v1, v2):
def calc_dataset_item(cache, i):
n = len(cache)
r = HASH_BYTES // WORD_BYTES
- # initialize the mix
+ # मिक्स को इनिशियलाइज़ करें
mix = copy.copy(cache[i % n])
mix[0] ^= i
mix = sha3_512(mix)
- # fnv it with a lot of random cache nodes based on i
+ # i के आधार पर बहुत से रैंडम कैश नोड्स के साथ इसे fnv करें
for j in range(DATASET_PARENTS):
cache_index = fnv(i ^ j, mix[j % r])
mix = map(fnv, mix, cache[cache_index % n])
@@ -138,29 +138,29 @@ def calc_dataset(full_size, cache):
return [calc_dataset_item(cache, i) for i in range(full_size // HASH_BYTES)]
```
-## मेन लूप {#main-loop}
+## मुख्य लूप {#main-loop}
-अब, हम मुख्य "हाशिमोटो" जैसे लूप को निर्दिष्ट करते हैं, जहां हम किसी विशेष हेडर और नॉन्स के लिए अपना अंतिम मूल्य उत्पन्न करने के लिए पूर्ण डेटासेट से डेटा एकत्र करते हैं। नीचे दिए गए कोड में, `header` एक _ट्रन्केटेड_ ब्लॉक हेडर के RLP प्रतिनिधित्व के SHA3-256 _हैश_ का प्रतिनिधित्व करता है, जो कि फ़ील्ड **mixHash** और **नॉन्स** के अतिरिक्त किसी अन्य हेडर का है। `nonce` बड़े-एंडियन क्रम में 64 बिट अहस्ताक्षरित पूर्णांक के आठ बाइट्स हैं। तो `nonce[::-1]` उस मान का आठ-बाइट लिटिल-एंडियन प्रतिनिधित्व है:
+अब, हम मुख्य "हाशिमोटो" जैसे लूप को निर्दिष्ट करते हैं, जहां हम किसी विशेष हेडर और नॉन्स के लिए अपना अंतिम मूल्य उत्पन्न करने के लिए पूर्ण डेटासेट से डेटा एकत्र करते हैं। नीचे दिए गए कोड में, `header` एक _काटे गए_ ब्लॉक हेडर के RLP प्रतिनिधित्व के SHA3-256 _हैश_ का प्रतिनिधित्व करता है, यानी, एक ऐसा हेडर जो **mixHash** और **nonce** फ़ील्ड को बाहर करता है। `nonce` बिग-एंडियन क्रम में 64 बिट अहस्ताक्षरित पूर्णांक के आठ बाइट्स हैं। तो `nonce[::-1]` उस मान का आठ-बाइट लिटिल-एंडियन प्रतिनिधित्व है:
```python
def hashimoto(header, nonce, full_size, dataset_lookup):
n = full_size / HASH_BYTES
w = MIX_BYTES // WORD_BYTES
mixhashes = MIX_BYTES / HASH_BYTES
- # combine header+nonce into a 64 byte seed
+ # header+nonce को 64 बाइट सीड में मिलाएं
s = sha3_512(header + nonce[::-1])
- # start the mix with replicated s
+ # s की प्रतिकृति के साथ मिक्स शुरू करें
mix = []
for _ in range(MIX_BYTES / HASH_BYTES):
mix.extend(s)
- # mix in random dataset nodes
+ # रैंडम डेटासेट नोड्स में मिलाएं
for i in range(ACCESSES):
p = fnv(i ^ s[0], mix[i % w]) % (n // mixhashes) * mixhashes
newdata = []
for j in range(MIX_BYTES / HASH_BYTES):
newdata.extend(dataset_lookup(p + j))
mix = map(fnv, mix, newdata)
- # compress mix
+ # मिक्स को कंप्रेस करें
cmix = []
for i in range(0, len(mix), 4):
cmix.append(fnv(fnv(fnv(mix[i], mix[i+1]), mix[i+2]), mix[i+3]))
@@ -176,9 +176,9 @@ def hashimoto_full(full_size, dataset, header, nonce):
return hashimoto(header, nonce, full_size, lambda x: dataset[x])
```
-अनिवार्य रूप से, हम एक "मिक्स" 128 बाइट्स चौड़ा बनाए रखते हैं, और बार-बार क्रमिक रूप से पूर्ण डेटासेट से 128 बाइट्स प्राप्त करते हैं और इसे युग्मन के साथ संयोजित करने के लिए `fnv` फ़ंक्शन का उपयोग करते हैं। अनुक्रमिक पहुंच के 128 बाइट्स का उपयोग किया जाता है ताकि एल्गोरिथम का प्रत्येक दौर हमेशा RAM से एक पूर्ण पृष्ठ प्राप्त करे, अनुवाद लुकसाइड बफर मिस को कम करता है जिसे ASIC प्राथमिक रूप से अनदेखा कर पाएगा।
+अनिवार्य रूप से, हम एक "मिक्स" 128 बाइट्स चौड़ा बनाए रखते हैं, और बार-बार क्रमिक रूप से पूर्ण डेटासेट से 128 बाइट्स प्राप्त करते हैं और इसे मिक्स के साथ संयोजित करने के लिए `fnv` फ़ंक्शन का उपयोग करते हैं। अनुक्रमिक पहुंच के 128 बाइट्स का उपयोग किया जाता है ताकि एल्गोरिथम का प्रत्येक दौर हमेशा RAM से एक पूर्ण पृष्ठ प्राप्त करे, अनुवाद लुकसाइड बफर मिस को कम करता है जिसे ASIC प्राथमिक रूप से अनदेखा कर पाएगा।
-यदि इस एल्गोरिथम का आउटपुट वांछित लक्ष्य से नीचे है, तो नॉन्स मान्य है। ध्यान दें कि अंत में `sha3_256` का अतिरिक्त एप्लिकेशन यह सुनिश्चित करता है कि एक मध्यवर्ती नॉन्स मौजूद है जिसे यह साबित करने के लिए प्रदान किया जा सकता है कि कम से कम थोड़ी मात्रा में काम किया गया था; इस त्वरित बाहरी PoW सत्यापन का उपयोग DDoS विरोधी उद्देश्यों के लिए किया जा सकता है। यह सांख्यिकीय आश्वासन प्रदान करने का भी कार्य करता है कि परिणाम एक निष्पक्ष, 256-बिट संख्या है।
+यदि इस एल्गोरिथम का आउटपुट वांछित लक्ष्य से नीचे है, तो नॉन्स मान्य है। ध्यान दें कि अंत में `sha3_256` का अतिरिक्त एप्लिकेशन यह सुनिश्चित करता है कि एक मध्यवर्ती नॉन्स मौजूद है जिसे यह साबित करने के लिए प्रदान किया जा सकता है कि कम से कम थोड़ी मात्रा में काम किया गया था; इस त्वरित बाहरी काम के सबूत सत्यापन का उपयोग एंटी-DDoS उद्देश्यों के लिए किया जा सकता है। यह सांख्यिकीय आश्वासन प्रदान करने का भी कार्य करता है कि परिणाम एक निष्पक्ष, 256-बिट संख्या है।
## माइनिंग {#mining}
@@ -186,7 +186,7 @@ def hashimoto_full(full_size, dataset, header, nonce):
```python
def mine(full_size, dataset, header, difficulty):
- # zero-pad target to compare with hash on the same digit
+ # समान अंक पर हैश के साथ तुलना करने के लिए टारगेट को ज़ीरो-पैड करें
target = zpad(encode_int(2**256 // difficulty), 64)[::-1]
from random import randint
nonce = randint(0, 2**64)
@@ -195,7 +195,7 @@ def mine(full_size, dataset, header, difficulty):
return nonce
```
-## सीड हैश को निर्धारित करना {#seed-hash}
+## सीड हैश को परिभाषित करना {#seed-hash}
सीड हैश की गणना करने के लिए जिसका उपयोग किसी दिए गए ब्लॉक के शीर्ष पर माईनिंग के लिए किया जाएगा, हम निम्नलिखित एल्गोरिथम का उपयोग करते हैं:
@@ -209,9 +209,9 @@ def mine(full_size, dataset, header, difficulty):
ध्यान दें कि सुगम माईनिंग और सत्यापन के लिए, हम एक अलग थ्रेड में भविष्य के सीडहैश और डेटासेट की पूर्व-गणना करने की सलाह देते हैं।
-## अग्रिम पठन {#further-reading}
+## आगे की रीडिंग {#further-reading}
-_एक सामुदायिक संसाधन के बारे में जानें, जिसने आपकी मदद की? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
+_क्या आप किसी ऐसे सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की हो?_ _इस पेज को संपादित करें और इसे जोड़ें!_
## परिशिष्ट {#appendix}
@@ -220,7 +220,7 @@ _एक सामुदायिक संसाधन के बारे म
```python
import sha3, copy
-# Assumes little endian bit ordering (same as Intel architectures)
+# लिटिल-एंडियन बिट ऑर्डरिंग मानता है (इंटेल आर्किटेक्चर के समान)
def decode_int(s):
return int(s[::-1].encode('hex'), 16) if s else 0
@@ -248,7 +248,7 @@ def serialize_cache(ds):
serialize_dataset = serialize_cache
-# sha3 hash function, outputs 64 bytes
+# sha3 हैश फ़ंक्शन, 64 बाइट्स का आउटपुट देता है
def sha3_512(x):
return hash_words(lambda v: sha3.sha3_512(v).digest(), 64, x)
@@ -993,7 +993,7 @@ cache_sizes = [
265287488, 265418432, 265550528, 265681216, 265813312, 265943488,
266075968, 266206144, 266337728, 266468032, 266600384, 266731072,
266862272, 266993344, 267124288, 267255616, 267386432, 267516992,
-267648704, 267777728, 267910592, 268040512, 268172096, 268302784,
+267648704, 26777728, 267910592, 268040512, 268172096, 268302784,
268435264, 268566208, 268696256, 268828096, 268959296, 269090368,
269221312, 269352256, 269482688, 269614784, 269745856, 269876416,
270007616, 270139328, 270270272, 270401216, 270531904, 270663616,
diff --git a/public/content/translations/hi/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md b/public/content/translations/hi/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
index d18d8cb40b2..b2d06c99af5 100644
--- a/public/content/translations/hi/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
+++ b/public/content/translations/hi/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/index.md
@@ -1,6 +1,6 @@
---
-title: माईनिंग एल्गोरिथम
-description: एथेरियम माईनिंग के लिए उपयोग किए जाने वाले एल्गोरिदम पर एक विस्तृत नज़र।
+title: "माईनिंग एल्गोरिथम"
+description: "एथेरियम माईनिंग के लिए उपयोग किए जाने वाले एल्गोरिदम पर एक विस्तृत नज़र।"
lang: hi
---
@@ -15,28 +15,28 @@ lang: hi
एथेरियम माईनिंग ने एक एल्गोरिथम का इस्तेमाल किया जिसे एताश के नाम से जाना जाता है। एल्गोरिथम का मूल विचार यह है कि एक माईनर ब्रूट फोर्स गणना का उपयोग करके एक नॉन्स इनपुट खोजने की कोशिश करता है ताकि परिणामी हैश गणना की गई कठिनाई द्वारा निर्धारित सीमा से छोटा हो। इस डिफिकल्टी लेवल को गतिशील रूप से समायोजित किया जा सकता है, जिससे ब्लॉक उत्पादन नियमित अंतराल पर हो सकता है।
-## आवश्यक शर्तें {#prerequisites}
+## पूर्वापेक्षाएं {#prerequisites}
-इस पृष्ठ को बेहतर ढंग से समझने के लिए, हम अनुशंसा करते हैं कि आप पहले [प्रूफ-ऑफ-वर्क कंसेंसस](/developers/docs/consensus-mechanisms/pow) और [माईनिंग](/developers/docs/consensus-mechanisms/pow/mining) पर पढ़ें।
+इस पेज को बेहतर ढंग से समझने के लिए, हम आपको पहले [प्रूफ-ऑफ-वर्क सहमति](/developers/docs/consensus-mechanisms/pow) और [माईनिंग](/developers/docs/consensus-mechanisms/pow/mining) के बारे में पढ़ने की सलाह देते हैं।
-## डैगर हाशिमोटो {#dagger-hashimoto}
+## डैगर हैशिमोटो {#dagger-hashimoto}
डैगर हाशिमोटो एथेरियम माईनिंग के लिए एक अग्रदूत अनुसंधान एल्गोरिथम था जिसे एथाश ने हटा दिया था। यह दो अलग-अलग एल्गोरिदम का एक समामेलन था: डैगर और हाशिमोटो। यह केवल एक शोध कार्यान्वयन था और एथेरियम मेननेट लॉन्च होने के समय तक एथाश द्वारा प्रतिस्थापित किया गया था।
-[डैगर](http://www.hashcash.org/papers/dagger.html) में एक [निर्देशित एसाइक्लिक ग्राफ की पीढ़ी शामिल](https://en.wikipedia.org/wiki/Directed_acyclic_graph) होती है, जिसके रैंडम स्लाइस एक साथ हैश हो जाते हैं। मुख्य सिद्धांत यह है कि प्रत्येक नॉन्स को केवल एक बड़े कुल डेटा ट्री के एक छोटे से हिस्से की आवश्यकता होती है। प्रत्येक नॉन्स के लिए सबट्री की पुनर्गणना माईनिंग के लिए निषेधात्मक है - इसलिए ट्री को स्टोर करने की आवश्यकता है - लेकिन एक सिंगल नॉन्स के योग्य सत्यापन के लिए ठीक है। डैगर को Scrypt जैसे मौजूदा एल्गोरिदम के विकल्प के रूप में डिज़ाइन किया गया था, जो मेमोरी-हार्ड हैं लेकिन यह सत्यापित करना मुश्किल है कि उनकी मेमोरी-कठोरता वास्तव में सुरक्षित स्तरों तक बढ़ जाती है। हालांकि, डैगर साझा मेमोरी हार्डवेयर एक्सिलरेशन के लिए कमजोर था और अनुसंधान के दौरान कुछ अन्य एवेन्यु के लिए इसे त्याग दिया गया था।
+[डैगर](http://www.hashcash.org/papers/dagger.html) में एक [डायरेक्टेड एसाइक्लिक ग्राफ़](https://en.wikipedia.org/wiki/Directed_acyclic_graph) का निर्माण शामिल है, जिसके रैंडम स्लाइस को एक साथ हैश किया जाता है। मुख्य सिद्धांत यह है कि प्रत्येक नॉन्स को केवल एक बड़े कुल डेटा ट्री के एक छोटे से हिस्से की आवश्यकता होती है। प्रत्येक नॉन्स के लिए सबट्री की पुनर्गणना माईनिंग के लिए निषेधात्मक है - इसलिए ट्री को स्टोर करने की आवश्यकता है - लेकिन एक सिंगल नॉन्स के योग्य सत्यापन के लिए ठीक है। डैगर को Scrypt जैसे मौजूदा एल्गोरिदम के विकल्प के रूप में डिज़ाइन किया गया था, जो मेमोरी-हार्ड हैं लेकिन यह सत्यापित करना मुश्किल है कि उनकी मेमोरी-कठोरता वास्तव में सुरक्षित स्तरों तक बढ़ जाती है। हालांकि, डैगर साझा मेमोरी हार्डवेयर एक्सिलरेशन के लिए कमजोर था और अनुसंधान के दौरान कुछ अन्य एवेन्यु के लिए इसे त्याग दिया गया था।
-[हाशिमोटो](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) एक एल्गोरिथम है जो I/O बाउंड होने से ASIC-प्रतिरोध जोड़ता है (यानी मेमोरी रीड माईनिंग प्रक्रिया में सीमित कारक हैं)। सिद्धांत यह है कि गणना की तुलना में RAM अधिक उपलब्ध है; अरबों डॉलर के शोध ने पहले से ही विभिन्न उपयोग के मामलों के लिए RAM को अनुकूलित करने की जांच की है, जिसमें अक्सर नियर-रैंडम एक्सेस पैटर्न शामिल होते हैं (इसलिए “रैंडम एक्सेस मेमोरी”)। नतीजतन, मौजूदा RAM एल्गोरिथम के मूल्यांकन के लिए इष्टतम के करीब होने की संभावना है। हाशिमोटो डेटा के स्रोत के रूप में ब्लॉकचेन का उपयोग करता है, साथ ही साथ उपरोक्त (1) और (3) को संतुष्ट करता है।
+[हाशिमोटो](http://diyhpl.us/%7Ebryan/papers2/bitcoin/meh/hashimoto.pdf) एक एल्गोरिथम है जो I/O बाउंड होने से ASIC-प्रतिरोध जोड़ता है (यानी, मेमोरी रीड माईनिंग प्रक्रिया में सीमित कारक हैं)। सिद्धांत यह है कि गणना की तुलना में RAM अधिक उपलब्ध है; अरबों डॉलर के शोध ने पहले से ही विभिन्न उपयोग के मामलों के लिए RAM को अनुकूलित करने की जांच की है, जिसमें अक्सर नियर-रैंडम एक्सेस पैटर्न शामिल होते हैं (इसलिए “रैंडम एक्सेस मेमोरी”)। नतीजतन, मौजूदा RAM एल्गोरिथम के मूल्यांकन के लिए इष्टतम के करीब होने की संभावना है। हाशिमोटो डेटा के स्रोत के रूप में ब्लॉकचेन का उपयोग करता है, साथ ही साथ उपरोक्त (1) और (3) को संतुष्ट करता है।
-डैगर-हाशिमोटो ने डैगर और हाशिमोटो एल्गोरिथम के संशोधित संस्करणों का उपयोग किया। डैगर हाशिमोटो और हाशिमोटो के बीच अंतर यह है कि, डेटा स्रोत के रूप में ब्लॉकचेन का उपयोग करने के बजाय, डैगर हाशिमोटो एक कस्टम-जनरेटेड डेटा सेट का उपयोग करता है, जो प्रत्येक N ब्लॉक के ब्लॉक डेटा के आधार पर अपडेट होता है। डेटा सेट, डैगर एल्गोरिथम का उपयोग करके उत्पन्न होता है, जिससे प्रकाश ग्राहक सत्यापन एल्गोरिथम के लिए प्रत्येक नॉन्स के लिए विशिष्ट सबसेट की कुशलतापूर्वक गणना करने की सुविधा मिलती है। डैगर हाशिमोटो और डैगर के बीच का अंतर यह है कि, मूल डैगर के विपरीत, ब्लॉक को क्वेरी करने के लिए उपयोग किया जाने वाला डेटासेट अर्ध-स्थायी है, केवल कभी-कभी अंतराल पर अपडेट किया जा रहा है (उदाहरण के लिए प्रति सप्ताह एक बार)। इसका मतलब यह है कि डेटासेट उत्पन्न करने के प्रयास का हिस्सा शून्य के करीब है, इसलिए साझा मेमोरी स्पीडअप के बारे में सर्जियो लर्नर के तर्क नगण्य हो जाते हैं।
+डैगर-हाशिमोटो ने डैगर और हाशिमोटो एल्गोरिथम के संशोधित संस्करणों का उपयोग किया। डैगर हाशिमोटो और हाशिमोटो के बीच अंतर यह है कि, डेटा स्रोत के रूप में ब्लॉकचेन का उपयोग करने के बजाय, डैगर हाशिमोटो एक कस्टम-जनरेटेड डेटा सेट का उपयोग करता है, जो प्रत्येक N ब्लॉक के ब्लॉक डेटा के आधार पर अपडेट होता है। डेटा सेट, डैगर एल्गोरिथम का उपयोग करके उत्पन्न होता है, जिससे प्रकाश ग्राहक सत्यापन एल्गोरिथम के लिए प्रत्येक नॉन्स के लिए विशिष्ट सबसेट की कुशलतापूर्वक गणना करने की सुविधा मिलती है। डैगर हाशिमोटो और डैगर के बीच अंतर यह है कि, मूल डैगर के विपरीत, ब्लॉक को क्वेरी करने के लिए उपयोग किया जाने वाला डेटासेट अर्ध-स्थायी है, जिसे केवल सामयिक अंतराल पर अपडेट किया जाता है (जैसे, सप्ताह में एक बार)। इसका मतलब यह है कि डेटासेट उत्पन्न करने के प्रयास का हिस्सा शून्य के करीब है, इसलिए साझा मेमोरी स्पीडअप के बारे में सर्जियो लर्नर के तर्क नगण्य हो जाते हैं।
-[डैगर-हाशिमोटो](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto) पर अधिक।
+[डैगर-हाशिमोटो](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/dagger-hashimoto) के बारे में और अधिक।
## एथाश {#ethash}
-एथाश माईनिंग एल्गोरिथम था जो वास्तव में वास्तविक एथेरियम मेननेट पर वर्तमान में अप्रचलित प्रूफ-ऑफ-वर्क आर्किटेक्चर के तहत उपयोग किया गया था। एल्गोरिथम के महत्वपूर्ण रूप से अद्यतन होने के बाद एथाश प्रभावी रूप से डैगर-हाशिमोटो के एक विशिष्ट संस्करण को दिया गया एक नया नाम था, जबकि अब भी यह अपने पूर्ववर्ती के मूल सिद्धांतों को विरासत में प्राप्त करता है। एथेरियम मेननेट ने केवल एक बार एथाश का उपयोग किया - जो डैगर हाशिमोटो माईनिंग एल्गोरिथम का एक अनुसंधान और विकास संस्करण था जिसे एथेरियम मेननेट पर माईनिंग शुरू होने से पहले हटा दिया गया था।
+एथाश माईनिंग एल्गोरिथम था जो वास्तव में वास्तविक एथेरियम मेननेट पर वर्तमान में अप्रचलित प्रूफ-ऑफ-वर्क आर्किटेक्चर के तहत उपयोग किया गया था। एल्गोरिथम के महत्वपूर्ण रूप से अद्यतन होने के बाद एथाश प्रभावी रूप से डैगर-हाशिमोटो के एक विशिष्ट संस्करण को दिया गया एक नया नाम था, जबकि अब भी यह अपने पूर्ववर्ती के मूल सिद्धांतों को विरासत में प्राप्त करता है। एथेरियम मेननेट ने हमेशा सिर्फ एथाश का इस्तेमाल किया - डैगर हाशिमोटो माईनिंग एल्गोरिथम का एक R&D वर्ज़न था, जिसे एथेरियम मेननेट पर माईनिंग शुरू होने से पहले बदल दिया गया था।
-[एथाश पर अधिक](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash)।
+[एथाश](/developers/docs/consensus-mechanisms/pow/mining/mining-algorithms/ethash) के बारे में और अधिक।
-## अग्रिम पठन {#further-reading}
+## आगे की रीडिंग {#further-reading}
-_एक सामुदायिक संसाधन के बारे में जानें, जिसने आपकी मदद की? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
+_क्या आप किसी ऐसे सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की हो?_ _इस पृष्ठ को संपादित करें और इसे जोड़ें!_
diff --git a/public/content/translations/hi/developers/docs/dapps/index.md b/public/content/translations/hi/developers/docs/dapps/index.md
new file mode 100644
index 00000000000..bcf56865fab
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/dapps/index.md
@@ -0,0 +1,96 @@
+---
+title: "डैप्स का तकनीकी परिचय"
+description:
+lang: hi
+---
+
+एक विकेन्द्रीकृत अनुप्रयोग (dapp) एक ऐसा अनुप्रयोग है जो एक विकेन्द्रीकृत नेटवर्क पर बनाया गया है जो एक [स्मार्ट अनुबंध](/developers/docs/smart-contracts/) और एक फ्रंटएंड यूजर इंटरफेस को जोड़ता है। एथेरियम पर, स्मार्ट अनुबंध आसान और पारदर्शी होते हैं – ओपन API की तरह – इसलिए आपका dapp किसी और द्वारा लिखे गए स्मार्ट अनुबंध को भी शामिल कर सकता है।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+डैप्स के बारे में जानने से पहले, आपको [ब्लॉकचेन की मूल बातें](/developers/docs/intro-to-ethereum/) समझनी चाहिए और एथेरियम नेटवर्क और यह कैसे विकेन्द्रीकृत है, इसके बारे में पढ़ना चाहिए।
+
+## डैप की परिभाषा {#definition-of-a-dapp}
+
+Dapp का बैकेंड कोड एक विकेंद्रीकृत पीयर-टू-पीयर नेटवर्क पर चलता है। इसकी तुलना उस ऐप से करें जहां बैकेंड कोड केंद्रीकृत सर्वर पर चलता है।
+
+एक dapp में अपने बैकएंड पर कॉल करने के लिए किसी भी भाषा (ऐप की तरह) में लिखा गया फ़्रंटएंड कोड और यूज़र इंटरफ़ेस हो सकता है। इसके अलावा, इसके फ्रंटएंड को [IPFS](https://ipfs.io/) जैसे विकेन्द्रीकृत भंडारण पर होस्ट किया जा सकता है।
+
+- **विकेंद्रीकृत** - डैप्स एथेरियम पर काम करते हैं, जो एक खुला सार्वजनिक विकेन्द्रीकृत प्लेटफ़ॉर्म है जहाँ किसी एक व्यक्ति या समूह का नियंत्रण नहीं होता है।
+- **नियतात्मक** - डैप्स उस परिवेश की परवाह किए बिना समान कार्य करते हैं जिसमें वे निष्पादित होते हैं।
+- **ट्यूरिंग कम्प्लीट** - डैप्स आवश्यक संसाधन दिए जाने पर कोई भी कार्रवाई कर सकते हैं।
+- **पृथक** - डैप्स को एथेरियम वर्चुअल मशीन के रूप में जाने जाने वाले वर्चुअल परिवेश में निष्पादित किया जाता है ताकि यदि स्मार्ट अनुबंध में कोई बग हो, तो यह ब्लॉकचेन नेटवर्क के सामान्य कामकाज में बाधा नहीं डालेगा।
+
+### स्मार्ट अनुबंधों पर {#on-smart-contracts}
+
+Dapps का परिचय देने के लिए, हमें स्मार्ट अनुबंध का परिचय देना होगा – जो कि एक बेहतर शब्द के अभाव में dapp का बैकएंड है। विस्तृत अवलोकन के लिए, हमारे [स्मार्ट अनुबंध](/developers/docs/smart-contracts/) सेक्शन पर जाएं।
+
+एक स्मार्ट अनुबंध कोड है जो एथेरियम ब्लॉकचेन पर मौजूद होता है और बिल्कुल वैसे ही चलता है जैसा कि प्रोग्राम किया गया हो। जब स्मार्ट अनुबंध नेटवर्क पर डिप्लॉय हो जाते हैं, तो आप उन्हें बदल नहीं सकते। Dapps विकेंद्रीकृत हो सकते हैं, क्योंकि वे किसी व्यक्ति या कंपनी द्वारा नहीं, बल्कि कॉन्ट्रैक्ट में लिखे गए तर्क द्वारा नियंत्रित होते हैं। इसका मतलब यह भी है कि आपको अपने कॉन्ट्रैक्ट्स को बहुत सावधानी से डिज़ाइन करना होगा और उनका पूरी तरह से परीक्षण करना होगा।
+
+## डैप विकास के लाभ {#benefits-of-dapp-development}
+
+- **शून्य डाउनटाइम** – एक बार जब स्मार्ट अनुबंध ब्लॉकचेन पर तैनात हो जाता है, तो पूरा नेटवर्क हमेशा उन क्लाइंट्स की सेवा करने में सक्षम होगा जो अनुबंध के साथ इंटरैक्ट करना चाहते हैं। इसलिए, दुर्भावनापूर्ण कर्ता व्यक्तिगत dapps पर लक्षित सेवा-से-इनकार हमले शुरू नहीं कर सकते।
+- **गोपनीयता** – आपको डैप को तैनात करने या उसके साथ इंटरैक्ट करने के लिए वास्तविक पहचान प्रदान करने की आवश्यकता नहीं है।
+- **सेंसरशिप का प्रतिरोध** – नेटवर्क पर कोई भी एक इकाई यूज़र्स को लेनदेन सबमिट करने, डैप्स तैनात करने या ब्लॉकचेन से डेटा पढ़ने से नहीं रोक सकती है।
+- **पूर्ण डेटा अखंडता** – क्रिप्टोग्राफ़िक प्रिमिटिव्स की बदौलत ब्लॉकचेन पर संग्रहीत डेटा अपरिवर्तनीय और निर्विवाद है। दुर्भावनापूर्ण कर्ता उन लेनदेनों या अन्य डेटा को नहीं बना सकते जो पहले ही सार्वजनिक हो चुके हैं।
+- **ट्रस्टलेस कंप्यूटेशन/सत्यापन योग्य व्यवहार** – स्मार्ट अनुबंधों का विश्लेषण किया जा सकता है और यह गारंटी है कि वे एक केंद्रीय प्राधिकरण पर भरोसा करने की आवश्यकता के बिना, अनुमानित तरीकों से निष्पादित होंगे। यह पारंपरिक मॉडल में सच नहीं है; उदाहरण के लिए, जब हम ऑनलाइन बैंकिंग सिस्टम का उपयोग करते हैं, तो हमें वित्तीय संस्थानों पर भरोसा करना पड़ता है कि वे हमारे वित्तीय डेटा का दुरुपयोग नहीं करेंगे, रिकॉर्ड में छेड़छाड़ नहीं करेंगे या हैक नहीं होंगे।
+
+## डैप विकास की कमियां {#drawbacks-of-dapp-development}
+
+- **रखरखाव** – डैप्स का रखरखाव करना अधिक कठिन हो सकता है क्योंकि ब्लॉकचेन पर प्रकाशित कोड और डेटा को संशोधित करना कठिन होता है। एक बार डिप्लॉय होने के बाद, डेवलपर्स के लिए अपने dapps (या डैप द्वारा संग्रहित अंतर्निहित डेटा) को अपडेट करना कठिन होता है, भले ही पुराने संस्करण में बग या सुरक्षा जोखिम पहचाने गए हों।
+- **प्रदर्शन ओवरहेड** – इसमें एक बहुत बड़ा प्रदर्शन ओवरहेड है, और स्केलिंग वास्तव में कठिन है। एथेरियम जिस स्तर की सुरक्षा, अखंडता, पारदर्शिता और विश्वसनीयता की उम्मीद रखता है, उसे प्राप्त करने के लिए, हर नोड हर लेनदेन को चलाता और सेव करता है। इसके अलावा, हिस्सेदारी का सबूत सहमति प्राप्त करने में भी समय लेता है।
+- **नेटवर्क कंजेशन** – जब कोई एक डैप बहुत अधिक कम्प्यूटेशनल संसाधनों का उपयोग करता है, तो पूरा नेटवर्क बैक अप हो जाता है। वर्तमान में, नेटवर्क केवल लगभग 10-15 लेनदेन प्रति सेकंड प्रोसेस कर सकता है; अगर लेनदेन इससे तेजी से भेजे जा रहे हैं, तो अपुष्ट लेनदेनों का पूल जल्दी ही बढ़ सकता है।
+- **यूज़र अनुभव** – यूज़र-अनुकूल अनुभवों को डिज़ाइन करना अधिक कठिन हो सकता है क्योंकि एक औसत एंड-यूज़र के लिए ब्लॉकचेन के साथ वास्तव में सुरक्षित तरीके से इंटरैक्ट करने के लिए आवश्यक टूल स्टैक सेट अप करना बहुत मुश्किल हो सकता है।
+- **केंद्रीकरण** – एथेरियम की आधार परत के शीर्ष पर बने यूज़र-अनुकूल और डेवलपर-अनुकूल समाधान वैसे भी केंद्रीकृत सेवाओं की तरह दिख सकते हैं। उदाहरण के लिए, ऐसी सेवाएं कुंजियों या अन्य संवेदनशील जानकारी को सर्वर-साइड पर संग्रहित कर सकती हैं, एक केंद्रीकृत सर्वर का उपयोग करके फ़्रंटएंड प्रदान कर सकती हैं, या ब्लॉकचेन पर लिखने से पहले एक केंद्रीकृत सर्वर पर महत्वपूर्ण व्यावसायिक तर्क चला सकती हैं। केंद्रीकरण पारंपरिक मॉडल पर ब्लॉकचेन के कई (अगर सभी नहीं तो) लाभों को समाप्त कर देता है।
+
+## क्या आप एक दृश्य शिक्षार्थी हैं? {#visual-learner}
+
+,
+ number3: u64
+ }
+
+ dummy = Dummy{
+
+ number1: 37,
+ number2: 55,
+ vector: vec![1,2,3,4],
+ number3: 22,
+ }
+
+ serialized = ssz.serialize(dummy)
+
+```
+
+`serialized` की निम्नलिखित संरचना होगी (यहाँ केवल 4 बिट्स तक पैडेड है, वास्तविकता में 32 बिट्स तक पैडेड है, और स्पष्टता के लिए `int` प्रतिनिधित्व रखा गया है):
+
+```
+[37, 0, 0, 0, 55, 0, 0, 0, 16, 0, 0, 0, 22, 0, 0, 0, 1, 2, 3, 4]
+------------ ----------- ----------- ----------- ----------
+ | | | | |
+ number1 number2 vector के लिए number3 vector का मान
+ ऑफ़सेट
+```
+
+स्पष्टता के लिए पंक्तियों में विभाजित:
+
+```
+[
+ 37, 0, 0, 0, # `number1` का लिटिल-एंडियन एन्कोडिंग।
+ 55, 0, 0, 0, # `number2` का लिटिल-एंडियन एन्कोडिंग।
+ 16, 0, 0, 0, # "ऑफ़सेट" जो इंगित करता है कि `vector` का मान कहाँ से शुरू होता है (लिटिल-एंडियन 16)।
+ 22, 0, 0, 0, # `number3` का लिटिल-एंडियन एन्कोडिंग।
+ 1, 2, 3, 4, # `vector` में वास्तविक मान।
+]
+```
+
+यह अभी भी एक सरलीकरण है - ऊपर की योजना में पूर्णांक और शून्य वास्तव में बाइटलिस्ट के रूप में संग्रहीत किए जाएंगे, इस तरह:
+
+```
+[
+ 10100101000000000000000000000000 # `number1` का लिटिल-एंडियन एन्कोडिंग
+ 10110111000000000000000000000000 # `number2` का लिटिल-एंडियन एन्कोडिंग।
+ 10010000000000000000000000000000 # "ऑफ़सेट" जो इंगित करता है कि `vector` का मान कहाँ से शुरू होता है (लिटिल-एंडियन 16)।
+ 10010110000000000000000000000000 # `number3` का लिटिल-एंडियन एन्कोडिंग।
+ 10000001100000101000001110000100 # `bytes` फ़ील्ड का वास्तविक मान।
+]
+```
+
+तो परिवर्तनीय-लंबाई वाले प्रकारों के लिए वास्तविक मान सीरियलाइज़्ड ऑब्जेक्ट के अंत में एक हीप में संग्रहीत किए जाते हैं, उनके ऑफ़सेट फ़ील्ड की क्रमित सूची में उनकी सही स्थिति में संग्रहीत होते हैं।
+
+कुछ विशेष मामले भी हैं जिनके लिए विशिष्ट उपचार की आवश्यकता होती है, जैसे कि `BitList` प्रकार जिसमें सीरियलाइज़ेशन के दौरान एक लंबाई कैप जोड़ने और डी-सीरियलाइज़ेशन के दौरान हटाने की आवश्यकता होती है। पूरा विवरण [SSZ स्पेक](https://github.com/ethereum/consensus-specs/blob/dev/ssz/simple-serialize.md) में उपलब्ध है।
+
+### डी-सीरियलाइज़ेशन {#deserialization}
+
+इस ऑब्जेक्ट को डी-सीरियलाइज़ करने के लिए स्कीमा की आवश्यकता होती है। स्कीमा सीरियलाइज़्ड डेटा के सटीक लेआउट को परिभाषित करता है ताकि प्रत्येक विशिष्ट तत्व को बाइट्स के ब्लॉब से किसी सार्थक ऑब्जेक्ट में डी-सीरियलाइज़ किया जा सके, जिसमें तत्वों का सही प्रकार, मान, आकार और स्थिति हो। यह स्कीमा ही है जो डी-सीरियलाइज़र को बताता है कि कौन से मान वास्तविक मान हैं और कौन से ऑफ़सेट हैं। जब किसी ऑब्जेक्ट को सीरियलाइज़ किया जाता है तो सभी फ़ील्ड नाम गायब हो जाते हैं, लेकिन स्कीमा के अनुसार डी-सीरियलाइज़ेशन पर पुनः स्थापित हो जाते हैं।
+
+इस पर एक इंटरैक्टिव व्याख्या के लिए [ssz.dev](https://www.ssz.dev/overview) देखें।
+
+## मर्कलाइज़ेशन {#merkleization}
+
+इस SSZ सीरियलाइज़्ड ऑब्जेक्ट को फिर मर्कलाइज़्ड किया जा सकता है - यानी उसी डेटा के मर्कल-ट्री प्रतिनिधित्व में बदल दिया जाता है। सबसे पहले, सीरियलाइज़्ड ऑब्जेक्ट में 32-बाइट चंक्स की संख्या निर्धारित की जाती है। ये ट्री के "लीव्स" हैं। लीव्स की कुल संख्या 2 की घात होनी चाहिए ताकि लीव्स को एक साथ हैश करने पर अंततः एक एकल हैश-ट्री-रूट उत्पन्न हो। यदि ऐसा स्वाभाविक रूप से नहीं होता है, तो शून्य के 32 बाइट्स वाले अतिरिक्त लीव्स जोड़े जाते हैं। आरेखीय रूप से:
+
+```
+ हैश ट्री रूट
+ / \
+ / \
+ / \
+ / \
+ लीव्स का हैश लीव्स का हैश
+ 1 और 2 3 और 4
+ / \ / \
+ / \ / \
+ / \ / \
+ leaf1 leaf2 leaf3 leaf4
+```
+
+ऐसे मामले भी हैं जहां ट्री के लीव्स स्वाभाविक रूप से उस तरह से समान रूप से वितरित नहीं होते हैं जैसे वे उपरोक्त उदाहरण में होते हैं। उदाहरण के लिए, लीफ 4 कई तत्वों वाला एक कंटेनर हो सकता है जिसके लिए मर्कल ट्री में अतिरिक्त "गहराई" जोड़ने की आवश्यकता होती है, जिससे एक असमान ट्री बनता है।
+
+इन ट्री तत्वों को लीफ X, नोड X आदि के रूप में संदर्भित करने के बजाय, हम उन्हें सामान्यीकृत सूचकांक दे सकते हैं, जिसकी शुरुआत रूट = 1 से होती है और प्रत्येक स्तर पर बाएं से दाएं गिनती होती है। यह ऊपर बताया गया सामान्यीकृत सूचकांक है। सीरियलाइज़्ड सूची में प्रत्येक तत्व का एक सामान्यीकृत सूचकांक `2**depth + idx` के बराबर होता है, जहां idx सीरियलाइज़्ड ऑब्जेक्ट में इसकी शून्य-अनुक्रमित स्थिति है और गहराई मर्कल ट्री में स्तरों की संख्या है, जिसे तत्वों (लीव्स) की संख्या के आधार-दो लघुगणक के रूप में निर्धारित किया जा सकता है।
+
+## सामान्यीकृत सूचकांक {#generalized-indices}
+
+एक सामान्यीकृत सूचकांक एक पूर्णांक है जो एक बाइनरी मर्कल ट्री में एक नोड का प्रतिनिधित्व करता है जहां प्रत्येक नोड में एक सामान्यीकृत सूचकांक `2 ** depth + पंक्ति में सूचकांक` होता है।
+
+```
+ 1 --गहराई = 0 2**0 + 0 = 1
+ 2 3 --गहराई = 1 2**1 + 0 = 2, 2**1+1 = 3
+ 4 5 6 7 --गहराई = 2 2**2 + 0 = 4, 2**2 + 1 = 5...
+
+```
+
+यह प्रतिनिधित्व मर्कल ट्री में डेटा के प्रत्येक टुकड़े के लिए एक नोड सूचकांक देता है।
+
+## मल्टीप्रूफ़्स {#multiproofs}
+
+एक विशिष्ट तत्व का प्रतिनिधित्व करने वाले सामान्यीकृत सूचकांकों की सूची प्रदान करने से हमें इसे हैश-ट्री-रूट के विरुद्ध सत्यापित करने की अनुमति मिलती है। यह रूट वास्तविकता का हमारा स्वीकृत संस्करण है। हमें प्रदान किया गया कोई भी डेटा उस वास्तविकता के विरुद्ध सत्यापित किया जा सकता है, इसे मर्कल ट्री में सही जगह पर डालकर (इसके सामान्यीकृत सूचकांक द्वारा निर्धारित) और यह देखकर कि रूट स्थिर रहता है। स्पेक [यहाँ](https://github.com/ethereum/consensus-specs/blob/dev/ssz/merkle-proofs.md#merkle-multiproofs) में ऐसे फ़ंक्शन हैं जो यह दिखाते हैं कि सामान्यीकृत सूचकांकों के एक विशेष सेट की सामग्री को सत्यापित करने के लिए आवश्यक नोड्स के न्यूनतम सेट की गणना कैसे करें।
+
+उदाहरण के लिए, नीचे दिए गए ट्री में इंडेक्स 9 में डेटा को सत्यापित करने के लिए, हमें इंडेक्स 8, 9, 5, 3, 1 पर डेटा के हैश की आवश्यकता है।
+(8,9) का हैश, हैश (4) के बराबर होना चाहिए, जो 5 के साथ हैश होकर 2 उत्पन्न करता है, जो 3 के साथ हैश होकर ट्री रूट 1 उत्पन्न करता है। यदि 9 के लिए गलत डेटा प्रदान किया गया होता, तो रूट बदल जाता - हम इसका पता लगा लेते और शाखा को सत्यापित करने में विफल रहते।
+
+```
+* = प्रूफ़ उत्पन्न करने के लिए आवश्यक डेटा
+
+ 1*
+ 2 3*
+ 4 5* 6 7
+8* 9* 10 11 12 13 14 15
+
+```
+
+## आगे की रीडिंग {#further-reading}
+
+- [एथेरियम को अपग्रेड करना: SSZ](https://eth2book.info/altair/part2/building_blocks/ssz)
+- [एथेरियम को अपग्रेड करना: मर्कलाइज़ेशन](https://eth2book.info/altair/part2/building_blocks/merkleization)
+- [SSZ कार्यान्वयन](https://github.com/ethereum/consensus-specs/issues/2138)
+- [SSZ कैलकुलेटर](https://simpleserialize.com/)
+- [SSZ.dev](https://www.ssz.dev/)
diff --git a/public/content/translations/hi/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md b/public/content/translations/hi/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
new file mode 100644
index 00000000000..a2b94d37e3f
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/data-structures-and-encoding/web3-secret-storage/index.md
@@ -0,0 +1,195 @@
+---
+title: "Web3 सिक्रेट स्टोरेज की परिभाषा"
+description: "वेब3 गुप्त भंडारण के लिए औपचारिक परिभाषा"
+lang: hi
+sidebarDepth: 2
+---
+
+एथेरियम पर अपने ऐप को काम करने के लिए, आप web3.js लाइब्रेरी द्वारा प्रदान किए गए वेब3 ऑब्जेक्ट का उपयोग कर सकते हैं। हुड के तहत यह आरपीसी कॉल के माध्यम से एक स्थानीय नोड से संचार करता है। [web3](https://github.com/ethereum/web3.js/) किसी भी एथेरियम नोड के साथ काम करता है जो एक RPC लेयर को उजागर करता है।
+
+`web3` में `eth` ऑब्जेक्ट शामिल है - web3.eth।
+
+```js
+var fs = require("fs")
+var recognizer = require("ethereum-keyfile-recognizer")
+
+fs.readFile("keyfile.json", (err, data) => {
+ var json = JSON.parse(data)
+ var result = recognizer(json)
+})
+
+/** परिणाम
+ * [ 'web3', 3 ] web3 (v3) कीफ़ाइल
+ * [ 'ethersale', undefined ] Ethersale कीफ़ाइल
+ * null अमान्य कीफ़ाइल
+ */
+```
+
+यह Web3 सीक्रेट स्टोरेज डेफ़िनिशन के **संस्करण 3** का दस्तावेज़ है।
+
+## परिभाषा {#definition}
+
+फ़ाइल की वास्तविक एन्कोडिंग और डिकोडिंग संस्करण 1 से काफी हद तक अपरिवर्तित रहती है, सिवाय इसके कि क्रिप्टो एल्गोरिथ्म अब AES-128-CBC (AES-128-CTR अब न्यूनतम आवश्यकता है) के लिए तय नहीं है। अधिकांश अर्थ/एल्गोरिदम संस्करण 1 के समान हैं, `mac` को छोड़कर, जिसे पूर्ण `ciphertext` के साथ व्युत्पन्न कुंजी के दूसरे-सबसे-बाएँ 16 बाइट्स के संयोजन के SHA3 (keccak-256) के रूप में दिया जाता है।
+
+गुप्त कुंजी फ़ाइलें सीधे `~/.web3/keystore` (यूनिक्स-जैसे सिस्टम के लिए) और `~/AppData/Web3/keystore` (विंडोज के लिए) में संग्रहीत की जाती हैं। उन्हें कुछ भी नाम दिया जा सकता है, लेकिन एक अच्छा कन्वेंशन `.json` है, जहाँ `` गुप्त कुंजी को दी गई 128-बिट UUID है (गुप्त कुंजी के पते के लिए एक गोपनीयता-संरक्षण प्रॉक्सी)।
+
+ऐसी सभी फाइलों में एक संबद्ध पासवर्ड होता है। किसी दी गई `.json` फ़ाइल की गुप्त कुंजी प्राप्त करने के लिए, पहले फ़ाइल की एन्क्रिप्शन कुंजी प्राप्त करें; यह फ़ाइल का पासवर्ड लेने और इसे `kdf` कुंजी द्वारा वर्णित एक कुंजी व्युत्पत्ति फ़ंक्शन के माध्यम से पारित करके किया जाता है। KDF फ़ंक्शन के लिए `KDF-निर्भर` स्थिर और डायनामिक पैरामीटर `kdfparams` कुंजी में वर्णित हैं।
+
+PBKDF2 को सभी न्यूनतम-अनुपालन कार्यान्वयन द्वारा समर्थित किया जाना चाहिए, हालांकि निरूपित:
+
+- `kdf`: `pbkdf2`
+
+For PBKDF2, the kdfparams include:
+
+- `prf`: `hmac-sha256` होना चाहिए (भविष्य में बढ़ाया जा सकता है);
+- `c`: पुनरावृत्तियों की संख्या;
+- `salt`: PBKDF को दिया गया साल्ट;
+- `dklen`: व्युत्पन्न कुंजी के लिए लंबाई। >= 32 होना चाहिए।
+
+एक बार फ़ाइल की कुंजी प्राप्त हो जाने के बाद, इसे मैक की व्युत्पत्ति के माध्यम से सत्यापित किया जाना चाहिए। MAC की गणना बाइट ऐरे के SHA3 (keccak-256) हैश के रूप में की जानी चाहिए, जो `ciphertext` कुंजी की सामग्री के साथ व्युत्पन्न कुंजी के दूसरे-सबसे-बाएँ 16 बाइट्स के संयोजन के रूप में बनती है, यानी:
+
+```js
+KECCAK(DK[16..31] ++ )
+```
+
+(जहाँ `++` संयोजन ऑपरेटर है)
+
+इस मान की तुलना `mac` कुंजी की सामग्री से की जानी चाहिए; यदि वे अलग हैं, तो एक वैकल्पिक पासवर्ड का अनुरोध किया जाना चाहिए (या ऑपरेशन रद्द कर दिया जाना चाहिए)।
+
+फ़ाइल की कुंजी सत्यापित हो जाने के बाद, सिफर टेक्स्ट (फ़ाइल में `ciphertext` कुंजी) को `cipher` कुंजी द्वारा निर्दिष्ट सममित एन्क्रिप्शन एल्गोरिदम का उपयोग करके और `cipherparams` कुंजी के माध्यम से पैरामीटर करके डिक्रिप्ट किया जा सकता है। यदि व्युत्पन्न कुंजी आकार और एल्गोरिथ्म का कुंजी आकार बेमेल है, तो व्युत्पन्न कुंजी के शून्य गद्देदार, सबसे दाएं बाइट्स का उपयोग एल्गोरिथ्म की कुंजी के रूप में किया जाना चाहिए।
+
+सभी न्यूनतम-अनुपालन कार्यान्वयन को AES-128-CTR एल्गोरिथम का समर्थन करना चाहिए, जिसे निम्न के माध्यम से दर्शाया गया है:
+
+- `cipher: aes-128-ctr`
+
+यह सिफर निम्नलिखित पैरामीटर लेता है, जिसे सिफरपरम कुंजी की कुंजी के रूप में दिया गया है:
+
+- `iv`: सिफर के लिए 128-बिट आरंभीकरण वेक्टर।
+
+सिफर के लिए कुंजी व्युत्पन्न कुंजी के सबसे बाएँ 16 बाइट्स है, यानी, `DK[0..15]`
+
+एक गुप्त कुंजी का निर्माण/एन्क्रिप्शन अनिवार्य रूप से इन निर्देशों के विपरीत होना चाहिए। सुनिश्चित करें कि `uuid`, `salt` और `iv` वास्तव में यादृच्छिक हैं।
+
+`version` फ़ील्ड के अलावा, जिसे संस्करण के "हार्ड" पहचानकर्ता के रूप में कार्य करना चाहिए, कार्यान्वयन प्रारूप में छोटे, गैर-ब्रेकिंग परिवर्तनों को ट्रैक करने के लिए `minorversion` का भी उपयोग कर सकते हैं।
+
+## टेस्ट वेक्टर्स {#test-vectors}
+
+विवरण
+
+- `पता`: `008aeeda4d805471df9b2a5b0f38a0c3bcba786b`
+- `ICAP`: `XE542A5PZHH8PYIZUBEJEO0MFWRAPPIL67`
+- `UUID`: `3198bc9c-6672-5ab3-d9954942343ae5b6`
+- `पासवर्ड`: `testpassword`
+- `गुप्त`: `7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d`
+
+### PBKDF2-SHA-256 {#PBKDF2-SHA-256}
+
+`AES-128-CTR` और `PBKDF2-SHA-256` का उपयोग करके टेस्ट वेक्टर:
+
+`~/.web3/keystore/3198bc9c-6672-5ab3-d9954942343ae5b6.json` की फ़ाइल सामग्री:
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-ctr",
+ "cipherparams": {
+ "iv": "6087dab2f9fdbbfaddc31a909735c1e6"
+ },
+ "ciphertext": "5318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46",
+ "kdf": "pbkdf2",
+ "kdfparams": {
+ "c": 262144,
+ "dklen": 32,
+ "prf": "hmac-sha256",
+ "salt": "ae3cd4e7013836a3df6bd7241b12db061dbe2c6785853cce422d148a624ce0bd"
+ },
+ "mac": "517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2"
+ },
+ "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6",
+ "version": 3
+}
+```
+
+**मध्यवर्ती**:
+
+`व्युत्पन्न कुंजी`: `f06d69cdc7da0faffb1008270bca38f5e31891a3a773950e6d0fea48a7188551`
+`MAC बॉडी`: `e31891a3a773950e6d0fea48a71885515318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46`
+`MAC`: `517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2`
+`सिफर कुंजी`: `f06d69cdc7da0faffb1008270bca38f5`
+
+### Scrypt {#scrypt}
+
+Test vector using AES-128-CTR and Scrypt:
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-ctr",
+ "cipherparams": {
+ "iv": "740770fce12ce862af21264dab25f1da"
+ },
+ "ciphertext": "dd8a1132cf57db67c038c6763afe2cbe6ea1949a86abc5843f8ca656ebbb1ea2",
+ "kdf": "scrypt",
+ "kdfparams": {
+ "dklen": 32,
+ "n": 262144,
+ "p": 1,
+ "r": 8,
+ "salt": "25710c2ccd7c610b24d068af83b959b7a0e5f40641f0c82daeb1345766191034"
+ },
+ "mac": "337aeb86505d2d0bb620effe57f18381377d67d76dac1090626aa5cd20886a7c"
+ },
+ "id": "3198bc9c-6672-5ab3-d995-4942343ae5b6",
+ "version": 3
+}
+```
+
+**मध्यवर्ती**:
+
+`व्युत्पन्न कुंजी`: `7446f59ecc301d2d79bc3302650d8a5cedc185ccbb4bf3ca1ebd2c163eaa6c2d`
+`MAC बॉडी`: `edc185ccbb4bf3ca1ebd2c163eaa6c2ddd8a1132cf57db67c038c6763afe2cbe6ea1949a86abc5843f8ca656ebbb1ea2`
+`MAC`: `337aeb86505d2d0bb620effe57f18381377d67d76dac1090626aa5cd20886a7c`
+`सिफर कुंजी`: `7446f59ecc301d2d79bc3302650d8a5c`
+
+## संस्करण 1 से परिवर्तन {#alterations-from-v2}
+
+यह संस्करण [यहाँ](https://github.com/ethereum/homestead-guide/blob/master/old-docs-for-reference/go-ethereum-wiki.rst/Passphrase-protected-key-store-spec.rst) प्रकाशित संस्करण 1 के साथ कई विसंगतियों को ठीक करता है। संक्षेप में ये हैं:
+
+- पूंजीकरण अनुचित और असंगत है (स्क्रीप्ट लोअरकेस, केडीएफ मिश्रित-केस, मैक अपरकेस)।
+- अनावश्यक को संबोधित करें और गोपनीयता से समझौता करें।
+- `Salt` स्वाभाविक रूप से कुंजी व्युत्पत्ति फ़ंक्शन का एक पैरामीटर है और इसके साथ संबद्ध होने का हकदार है, न कि सामान्य रूप से क्रिप्टो के साथ।
+- _SaltLen_ अनावश्यक (बस इसे Salt से प्राप्त करें)।
+- प्रमुख व्युत्पत्ति फ़ंक्शन दिया गया है, फिर भी क्रिप्टो एल्गोरिथ्म कठिन रूप से निर्दिष्ट है।
+- `Version` स्वाभाविक रूप से संख्यात्मक है फिर भी एक स्ट्रिंग है (स्ट्रक्चर्ड वर्जनिंग एक स्ट्रिंग के साथ संभव होगी, लेकिन इसे शायद ही कभी बदलते कॉन्फ़िगरेशन फ़ाइल प्रारूप के लिए दायरे से बाहर माना जा सकता है)।
+- `KDF` और `cipher` सैद्धांतिक रूप से सहोदर अवधारणाएं हैं फिर भी अलग-अलग व्यवस्थित हैं।
+- `MAC` की गणना डेटा के एक व्हाइटस्पेस एग्नोस्टिक भाग (!) के माध्यम से की जाती है।
+
+निम्न फ़ाइल देने के लिए प्रारूप में परिवर्तन किए गए हैं, कार्यात्मक रूप से पहले लिंक किए गए पृष्ठ पर दिए गए उदाहरण के बराबर:
+
+```json
+{
+ "crypto": {
+ "cipher": "aes-128-cbc",
+ "ciphertext": "07533e172414bfa50e99dba4a0ce603f654ebfa1ff46277c3e0c577fdc87f6bb4e4fe16c5a94ce6ce14cfa069821ef9b",
+ "cipherparams": {
+ "iv": "16d67ba0ce5a339ff2f07951253e6ba8"
+ },
+ "kdf": "scrypt",
+ "kdfparams": {
+ "dklen": 32,
+ "n": 262144,
+ "p": 1,
+ "r": 8,
+ "salt": "06870e5e6a24e183a5c807bd1c43afd86d573f7db303ff4853d135cd0fd3fe91"
+ },
+ "mac": "8ccded24da2e99a11d48cda146f9cc8213eb423e2ea0d8427f41c3be414424dd",
+ "version": 1
+ },
+ "id": "0498f19a-59db-4d54-ac95-33901b4f1870",
+ "version": 2
+}
+```
+
+## संस्करण 2 से परिवर्तन {#alterations-from-v2}
+
+संस्करण 2 कई बग के साथ एक प्रारंभिक C ++ कार्यान्वयन था। सभी आवश्यक चीजें इससे अपरिवर्तित रहती हैं।
diff --git a/public/content/translations/hi/developers/docs/design-and-ux/dex-design-best-practice/index.md b/public/content/translations/hi/developers/docs/design-and-ux/dex-design-best-practice/index.md
new file mode 100644
index 00000000000..c666aab26c2
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/design-and-ux/dex-design-best-practice/index.md
@@ -0,0 +1,220 @@
+---
+title: "विकेंद्रीकृत विनिमय (DEX) डिजाइन सर्वोत्तम अभ्यास"
+description: "टोकन स्वैप करने के लिए UX/UI निर्णयों की व्याख्या करने वाली एक मार्गदर्शिका।"
+lang: hi
+---
+
+2018 में Uniswap के लॉन्च के बाद से, दर्जनों विभिन्न श्रृंखलाओं में सैकड़ों विकेन्द्रीकृत एक्सचेंज लॉन्च किए गए हैं।
+इनमें से कई ने नए तत्व पेश किए या अपना खुद का ट्विस्ट जोड़ा, लेकिन इंटरफ़ेस आम तौर पर वही रहा है।
+
+इसका एक कारण [याकूब का नियम](https://lawsofux.com/jakobs-law/) है:
+
+> उपयोगकर्ता अपना अधिकांश समय अन्य साइटों पर बिताते हैं। इसका मतलब है कि उपयोगकर्ता आपकी साइट को उसी तरह काम करना पसंद करते हैं जैसे वे अन्य सभी साइटें जिन्हें वे पहले से जानते हैं।
+
+Uniswap, Pancakeswap, और Sushiswap जैसे शुरुआती इनोवेटर्स के लिए धन्यवाद, DeFi उपयोगकर्ताओं के पास एक सामूहिक विचार है कि DEX कैसा दिखता है।
+इस कारण से, "सर्वोत्तम अभ्यास" जैसा कुछ अब उभर रहा है। हम देखते हैं कि साइटों पर अधिक से अधिक डिज़ाइन निर्णयों को मानकीकृत किया जा रहा है। आप DEX के विकास को लाइव परीक्षण के एक विशाल उदाहरण के रूप में देख सकते हैं। जो चीजें काम करती थीं, वे रुकी हुई थीं, जो चीजें नहीं थीं, उन्हें फेंक दिया गया। व्यक्तित्व के लिए अभी भी जगह है, लेकिन कुछ मानक हैं जिनके अनुरूप DEX होना चाहिए।
+
+यह लेख इसका सारांश है:
+
+- क्या शामिल करें
+- इसे यथासंभव प्रयोग करने योग्य कैसे बनाएं
+- डिजाइन को अनुकूलित करने के मुख्य तरीके
+
+सभी उदाहरण वायरफ्रेम विशेष रूप से इस लेख के लिए बनाए गए थे, हालांकि वे सभी वास्तविक परियोजनाओं पर आधारित हैं।
+
+फिग्मा किट भी नीचे शामिल है - बेझिझक इसका उपयोग करें और अपने स्वयं के वायरफ्रेम को गति दें!
+
+## DEX की मूल शारीरिक रचना {#basic-anatomy-of-a-dex}
+
+UI में आम तौर पर तीन तत्व होते हैं:
+
+1. मुख्य रूप
+2. बटन
+3. विवरण पैनल
+
+! [जेनेरिक DEX UI, तीन मुख्य तत्व दिखा रहा है](./1.png)
+
+## Variations {#variations}
+
+यह इस लेख में एक सामान्य विषय होगा, लेकिन इन तत्वों को व्यवस्थित करने के कई अलग-अलग तरीके हैं। "विवरण पैनल" हो सकता है:
+
+- बटन के ऊपर
+- बटन के नीचे
+- एक अकॉर्डियन पैनल में छिपा हुआ
+- और/या "पूर्वावलोकन" मोडल पर
+
+N.B. एक "पूर्वावलोकन" मोडल वैकल्पिक है, लेकिन यदि आप मुख्य यूआई पर बहुत कम विवरण दिखा रहे हैं, तो यह आवश्यक हो जाता है।
+
+## मुख्य रूप की संरचना{#structure-of-the-main-form}
+
+यह वह बॉक्स है जहां आप वास्तव में चुनते हैं कि आप किस टोकन को स्वैप करना चाहते हैं। घटक में एक इनपुट फ़ील्ड और एक पंक्ति में एक छोटा बटन होता है।
+
+DEX आमतौर पर ऊपर एक पंक्ति में और नीचे एक पंक्ति में अतिरिक्त विवरण प्रदर्शित करते हैं, हालांकि इसे अलग तरह से कॉन्फ़िगर किया जा सकता है।
+
+! [इनपुट पंक्ति, ऊपर और नीचे एक विवरण पंक्ति के साथ](./2.png)
+
+## विविधताएं {#variations2}
+
+दो UI विविधताएँ यहाँ दिखाई गई हैं; बिना किसी सीमा के, एक बहुत ही खुला डिज़ाइन बनाना, और एक जहां इनपुट पंक्ति में एक सीमा होती है, जो उस तत्व पर ध्यान केंद्रित करती है।
+
+! [मुख्य रूप के दो UI रूपांतर](./3.png)
+
+यह मूल संरचना \*\* जानकारी के चार प्रमुख टुकड़े \*\* को डिजाइन में दिखाने की अनुमति देती है: प्रत्येक कोने में एक। यदि केवल एक शीर्ष/निचली पंक्ति है, तो केवल दो स्थान हैं।
+
+DeFi के विकास के दौरान, यहां कई अलग-अलग चीजों को शामिल किया गया है।
+
+## {#key-info-to-include} शामिल करने के लिए मुख्य जानकारी
+
+- वॉलेट में बैलेंस
+- अधिकतम बटन
+- फिएट समकक्ष
+- "प्राप्त" राशि पर मूल्य प्रभाव
+
+DeFi के शुरुआती दिनों में, फिएट समकक्ष अक्सर गायब रहता था। यदि आप किसी भी प्रकार का वेब3 प्रोजेक्ट बना रहे हैं, तो यह आवश्यक है कि एक फिएट समकक्ष दिखाया जाए। उपयोगकर्ता अभी भी स्थानीय मुद्राओं के संदर्भ में सोचते हैं, इसलिए वास्तविक दुनिया के मानसिक मॉडल से मेल खाने के लिए, इसे शामिल किया जाना चाहिए।
+
+दूसरे फ़ील्ड पर (वह जहां आप उस टोकन को चुनते हैं जिसे आप स्वैप कर रहे हैं) आप इनपुट राशि और अनुमानित आउटपुट मात्रा के बीच अंतर की गणना करके, फिएट मुद्रा राशि के बगल में मूल्य प्रभाव भी शामिल कर सकते हैं। यह शामिल करने के लिए काफी उपयोगी विवरण है।
+
+प्रतिशत बटन (जैसे, 25%, 50%, 75%) एक उपयोगी सुविधा हो सकते हैं, लेकिन वे अधिक जगह लेते हैं, अधिक कॉल टू एक्शन जोड़ते हैं, और अधिक मानसिक भार डालते हैं। प्रतिशत स्लाइडर्स के साथ भी। इनमें से कुछ UI निर्णय आपके ब्रांड और आपके उपयोगकर्ता प्रकार पर निर्भर करेंगे।
+
+अतिरिक्त विवरण मुख्य फॉर्म के नीचे दिखाए जा सकते हैं। चूंकि इस प्रकार की जानकारी ज्यादातर समर्थक उपयोगकर्ताओं के लिए है, इसलिए यह या तो समझ में आता है:
+
+- इसे यथासंभव कम से कम रखें, या;
+- इसे एक अकॉर्डियन पैनल में छुपाएं
+
+! [उस मुख्य रूप के कोनों में दिखाया गया विवरण](./4.png)
+
+## {#extra-info-to-include} शामिल करने के लिए अतिरिक्त जानकारी
+
+- टोकन मूल्य
+- गिरावट
+- न्यूनतम प्राप्त
+- अपेक्षित आउटपुट
+- मूल्य प्रभाव
+- गैस लागत अनुमान
+- अन्य शुल्क
+- आदेश रूटिंग
+
+यकीनन, इनमें से कुछ विवरण वैकल्पिक हो सकते हैं।
+
+ऑर्डर रूटिंग दिलचस्प है, लेकिन अधिकांश उपयोगकर्ताओं के लिए बहुत फर्क नहीं पड़ता है।
+
+कुछ अन्य विवरण बस एक ही चीज़ को अलग-अलग तरीकों से पुनः स्थापित कर रहे हैं। उदाहरण के लिए, "न्यूनतम प्राप्त" और "फिसलन" एक ही सिक्के के दो पहलू हैं। यदि आपके पास 1% पर फिसलन सेट है, तो न्यूनतम आप प्राप्त करने की उम्मीद कर सकते हैं = अपेक्षित आउटपुट -1%। कुछ UI अपेक्षित राशि, न्यूनतम राशि और फिसलन दिखाएंगे... जो उपयोगी है लेकिन संभवतः ओवरकिल है।
+
+अधिकांश उपयोगकर्ता वैसे भी डिफ़ॉल्ट फिसलन छोड़ देंगे।
+
+"मूल्य प्रभाव" अक्सर "टू" फ़ील्ड में फिएट समकक्ष के बगल में कोष्ठक में दिखाया जाता है। यह जोड़ने के लिए एक महान विवरण है, लेकिन अगर इसे यहां दिखाया गया है, तो क्या इसे वास्तव में नीचे फिर से दिखाने की आवश्यकता है? और फिर पूर्वावलोकन स्क्रीन पर?
+
+कई उपयोगकर्ता (विशेष रूप से छोटी मात्रा में स्वैप करने वाले) इन विवरणों की परवाह नहीं करेंगे; वे बस एक संख्या दर्ज करेंगे और स्वैप दबाएंगे।
+
+! [कुछ विवरण एक ही बात दिखाते हैं](./5.png)
+
+वास्तव में क्या विवरण दिखाए जाते हैं, यह आपके दर्शकों पर निर्भर करेगा और आप ऐप को क्या महसूस करना चाहते हैं।
+
+यदि आप विवरण पैनल में स्लिपेज सहिष्णुता शामिल करते हैं, तो आपको इसे सीधे यहां से संपादन योग्य बनाना चाहिए। यह "त्वरक" का एक अच्छा उदाहरण है; एक साफ-सुथरी UX ट्रिक जो ऐप की सामान्य उपयोगिता को प्रभावित किए बिना अनुभवी उपयोगकर्ताओं के प्रवाह को गति दे सकती है।
+
+! [विवरण पैनल से स्लिपेज को नियंत्रित किया जा सकता है](./6.png)
+
+एक स्क्रीन पर न केवल एक विशिष्ट जानकारी के बारे में, बल्कि पूरे प्रवाह के बारे में ध्यान से सोचना एक अच्छा विचार है:
+मुख्य रूप में नंबर दर्ज करना → विवरण स्कैन करना → पूर्वावलोकन स्क्रीन पर क्लिक करना (यदि आपके पास पूर्वावलोकन स्क्रीन है)।
+क्या विवरण पैनल हर समय दिखाई देना चाहिए, या उपयोगकर्ता को विस्तार करने के लिए इसे क्लिक करने की आवश्यकता है?
+क्या आपको पूर्वावलोकन स्क्रीन जोड़कर घर्षण पैदा करना चाहिए? यह उपयोगकर्ता को धीमा करने और अपने व्यापार पर विचार करने के लिए मजबूर करता है, जो उपयोगी हो सकता है। लेकिन क्या वे सभी समान जानकारी फिर से देखना चाहते हैं? इस बिंदु पर उनके लिए सबसे उपयोगी क्या है?
+
+## डिज़ाइन विकल्प {#design-options}
+
+जैसा कि उल्लेख किया गया है, इसमें से बहुत कुछ आपकी व्यक्तिगत शैली के लिए नीचे आता है
+आपका उपयोगकर्ता कौन है?
+आपका ब्रांड क्या है?
+क्या आप हर विवरण दिखाने वाला "समर्थक" इंटरफ़ेस चाहते हैं, या क्या आप न्यूनतम होना चाहते हैं?
+यहां तक कि अगर आप उन समर्थक उपयोगकर्ताओं के लिए लक्ष्य बना रहे हैं जो सभी जानकारी संभव चाहते हैं, तो भी आपको एलन कूपर के बुद्धिमान शब्दों को याद रखना चाहिए:
+
+> कोई फर्क नहीं पड़ता कि कितना सुंदर है, कोई फर्क नहीं पड़ता कि आपका इंटरफ़ेस कितना अच्छा है, यह बेहतर होगा यदि इसमें से कम थे।
+
+### संरचना {#structure}
+
+- बाईं ओर टोकन, या दाईं ओर टोकन
+- 2 पंक्तियाँ या 3
+- बटन के ऊपर या नीचे विवरण
+- विवरण विस्तारित, छोटा किया गया, या नहीं दिखाया गया
+
+### घटक शैली {#component-style}
+
+- खाली
+- उल्लिखित
+- भरा
+
+शुद्ध UX दृष्टिकोण से, UI शैली आपके विचार से कम मायने रखती है। दृश्य रुझान चक्रों में आते हैं और जाते हैं, और बहुत सारी वरीयता व्यक्तिपरक होती है।
+
+इसके लिए एक महसूस करने का सबसे आसान तरीका - और विभिन्न विभिन्न विन्यासों के बारे में सोचें - कुछ उदाहरणों पर एक नज़र डालना है और फिर स्वयं कुछ प्रयोग करना है।
+
+शामिल फिग्मा किट में खाली, उल्लिखित और भरे हुए घटक होते हैं।
+
+नीचे दिए गए उदाहरणों पर एक नज़र डालें कि आप इसे एक साथ रखने के विभिन्न तरीकों को देख सकते हैं:
+
+! [भरी हुई शैली में 3 पंक्तियाँ](./7.png)
+
+! [एक उल्लिखित शैली में 3 पंक्तियाँ](./8.png)
+
+! [खाली शैली में 2 पंक्तियाँ](./9.png)
+
+! [एक उल्लिखित शैली में 3 पंक्तियाँ, एक विवरण पैनल के साथ](./10.png)
+
+! [एक उल्लिखित शैली में इनपुट पंक्ति के साथ 3 पंक्तियाँ](./11.png)
+
+! [भरी हुई शैली में 2 पंक्तियाँ](./12.png)
+
+## लेकिन टोकन किस तरफ जाना चाहिए? {#but-which-side-should-the-token-go-on}
+
+लब्बोलुआब यह है कि यह शायद प्रयोज्य के लिए एक बड़ा फर्क नहीं पड़ता है। हालाँकि, कुछ बातों का ध्यान रखना चाहिए, जो आपको एक या दूसरे तरीके से प्रभावित कर सकती हैं।
+
+समय के साथ फैशन में बदलाव देखना थोड़ा दिलचस्प रहा है। Uniswap के पास शुरू में बाईं ओर टोकन था, लेकिन तब से इसे दाईं ओर ले जाया गया है। Sushiswap ने यह बदलाव एक डिज़ाइन अपग्रेड के दौरान भी किया। अधिकांश, लेकिन सभी नहीं, प्रोटोकॉल ने सूट का पालन किया है।
+
+वित्तीय परिपाटी में पारंपरिक रूप से संख्या से पहले मुद्रा का प्रतीक लगाया जाता है, जैसे, $50, €50, £50, लेकिन हम _कहते हैं_ 50 डॉलर, 50 यूरो, 50 पाउंड।
+
+सामान्य उपयोगकर्ता के लिए - विशेष रूप से कोई व्यक्ति जो बाएं से दाएं, ऊपर से नीचे पढ़ता है - दाईं ओर टोकन शायद अधिक स्वाभाविक लगता है।
+
+! [बाईं ओर टोकन के साथ एक यूआई](./13.png)
+
+टोकन को बाईं ओर रखना और दाईं ओर सभी संख्याएं सुखद सममित दिखती हैं, जो एक प्लस है, लेकिन इस लेआउट का एक और नकारात्मक पहलू है।
+
+निकटता का नियम बताता है कि जो वस्तुएं एक साथ करीब हैं, उन्हें संबंधित माना जाता है। तदनुसार, हम संबंधित वस्तुओं को एक दूसरे के बगल में रखना चाहते हैं। टोकन बैलेंस सीधे टोकन से संबंधित है, और जब भी कोई नया टोकन चुना जाता है तो बदल जाएगा। इसलिए टोकन बैलेंस के लिए टोकन सेलेक्ट बटन के बगल में होना थोड़ा अधिक समझ में आता है। इसे टोकन के नीचे ले जाया जा सकता है, लेकिन यह लेआउट की समरूपता को तोड़ता है।
+
+अंततः, दोनों विकल्पों के लिए प्लस और माइनस हैं, लेकिन यह दिलचस्प है कि प्रवृत्ति दाईं ओर टोकन की ओर कैसे दिखाई देती है।
+
+## बटन व्यवहार{#button-behavior}
+
+Don’t have a separate button for Approve. साथ ही, स्वीकृति के लिए अलग से क्लिक न करें. उपयोगकर्ता स्वैप करना चाहता है, इसलिए बस बटन पर "स्वैप" कहें और पहले चरण के रूप में अनुमोदन शुरू करें। एक मोडल एक स्टेपर, या एक साधारण "tx 1 of 2 - अनुमोदन" अधिसूचना के साथ प्रगति दिखा सकता है।
+
+! [अनुमोदन और स्वैप के लिए अलग बटन के साथ एक यूआई](./14.png)
+
+! [एक बटन वाला UI जो अनुमोदन कहता है](./15.png)
+
+### प्रासंगिक सहायता के रूप में बटन {#button-as-contextual-help}
+
+बटन अलर्ट के रूप में डबल ड्यूटी कर सकता है!
+
+यह वास्तव में Web3 के बाहर एक काफी असामान्य डिज़ाइन पैटर्न है, लेकिन इसके भीतर मानक बन गया है। यह एक अच्छा नवाचार है क्योंकि यह स्पेस बचाता है, और ध्यान केंद्रित रखता है।
+
+यदि मुख्य क्रिया - स्वैप - किसी त्रुटि के कारण अनुपलब्ध है, तो कारण बटन के साथ समझाया जा सकता है, उदाहरण के लिए:
+
+- नेटवर्क स्विच करें
+- वॉलेट कनेक्ट करें
+- विभिन्न त्रुटियां
+
+बटन को \*\* कार्रवाई के लिए मैप किया जा सकता है \*\* जिसे प्रदर्शन करने की आवश्यकता है। उदाहरण के लिए, यदि उपयोगकर्ता स्वैप नहीं कर सकता क्योंकि वे गलत नेटवर्क पर हैं, तो बटन को "एथेरियम पर स्विच करें" कहना चाहिए, और जब उपयोगकर्ता बटन पर क्लिक करता है, तो उसे नेटवर्क को एथेरियम में स्विच करना चाहिए। यह उपयोगकर्ता प्रवाह को काफी गति देता है।
+
+! [मुख्य सीटीए से शुरू की जा रही प्रमुख कार्रवाइयां](./16.png)
+
+! [मुख्य CTA में दिखाया गया त्रुटि संदेश](./17.png)
+
+## इस figma फ़ाइल {#build-your-own-with-this-figma-file} के साथ अपना खुद का निर्माण करें
+
+कई प्रोटोकॉल की कड़ी मेहनत के लिए धन्यवाद, DEX डिजाइन में बहुत सुधार हुआ है। हम जानते हैं कि उपयोगकर्ता को किस जानकारी की आवश्यकता है, हमें इसे कैसे दिखाना चाहिए, और प्रवाह को यथासंभव सहज कैसे बनाया जाए।
+उम्मीद है कि यह लेख यूएक्स सिद्धांतों का एक ठोस अवलोकन प्रदान करता है।
+
+यदि आप प्रयोग करना चाहते हैं, तो कृपया बेझिझक Figma wireframe किट का उपयोग करें। इसे यथासंभव सरल रखा जाता है, लेकिन विभिन्न तरीकों से मूल संरचना बनाने के लिए पर्याप्त लचीलापन है।
+
+[फिग्मा वायरफ्रेम किट](https://www.figma.com/community/file/1393606680816807382/dex-wireframes-kit)
+
+DeFi का विकास जारी रहेगा, और सुधार की हमेशा गुंजाइश रहती है।
+
+शुभकामनाएँ!
diff --git a/public/content/translations/hi/developers/docs/design-and-ux/heuristics-for-web3/index.md b/public/content/translations/hi/developers/docs/design-and-ux/heuristics-for-web3/index.md
new file mode 100644
index 00000000000..812e557d50e
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/design-and-ux/heuristics-for-web3/index.md
@@ -0,0 +1,138 @@
+---
+title: "Web3 इंटरफ़ेस डिज़ाइन के लिए 7 ह्यूरिस्टिक्स"
+description: "Web3 की उपयोगिता में सुधार के सिद्धांत"
+lang: hi
+---
+
+प्रयोज्य ह्यूरिस्टिक्स व्यापक "अंगूठे के नियम" हैं जिनका उपयोग आप अपनी साइट की उपयोगिता को मापने के लिए कर सकते हैं।
+यहाँ दिए गए 7 ह्यूरिस्टिक्स विशेष रूप से Web3 के लिए तैयार किए गए हैं और इनका उपयोग जैकब नीलसन के [इंटरैक्शन डिज़ाइन के लिए 10 सामान्य सिद्धांत](https://www.nngroup.com/articles/ten-usability-heuristics/) के साथ किया जाना चाहिए।
+
+## Web3 के लिए सात प्रयोज्य हेरिस्टिक्स {#seven-usability-heuristics-for-web3}
+
+1. प्रतिक्रिया कार्रवाई का अनुसरण करती है
+2. सुरक्षा और विश्वास
+3. सबसे महत्वपूर्ण जानकारी स्पष्ट है
+4. समझने योग्य शब्दावली
+5. क्रियाएं यथासंभव छोटी हैं
+6. नेटवर्क कनेक्शन दृश्यमान और लचीले होते हैं
+7. ऐप से नियंत्रण, वॉलेट से नहीं
+
+## परिभाषाएं और उदाहरण {#definitions-and-examples}
+
+### १. प्रतिक्रिया कार्रवाई का अनुसरण करती है{#feedback-follows-action}
+
+\*\* यह स्पष्ट होना चाहिए जब कुछ हुआ है, या हो रहा है।
+
+उपयोगकर्ता अपने पिछले चरणों के परिणाम के आधार पर अपने अगले चरणों पर निर्णय लेते हैं। इसलिए यह आवश्यक है कि वे सिस्टम की स्थिति के बारे में सूचित रहें। यह वेब3 में विशेष रूप से महत्वपूर्ण है क्योंकि ब्लॉकचेन के लिए लेनदेन करने में कभी-कभी कम समय लग सकता है। यदि प्रतीक्षा करने के लिए उन्हें सूचित करने वाली कोई प्रतिक्रिया नहीं है, तो उपयोगकर्ता अनिश्चित हैं कि क्या कुछ हुआ है।
+
+**Tips:**
+
+- उपयोगकर्ता को संदेश, सूचनाओं और अन्य अलर्ट के माध्यम से सूचित करें।
+- प्रतीक्षा समय को स्पष्ट रूप से संप्रेषित करें।
+- यदि कोई कार्रवाई कुछ सेकंड से अधिक समय लेने वाली है, तो उपयोगकर्ता को टाइमर या एनीमेशन के साथ आश्वस्त करें ताकि उन्हें ऐसा महसूस हो सके कि कुछ हो रहा है।
+- अगर किसी प्रक्रिया के कई चरण हैं, तो हर चरण दिखाएँ.
+
+**उदाहरण:**
+लेन-देन में शामिल प्रत्येक चरण को दिखाने से उपयोगकर्ताओं को यह जानने में मदद मिलती है कि वे प्रक्रिया में कहां हैं। उपयुक्त आइकन उपयोगकर्ता को उनके कार्यों की स्थिति बताते हैं।
+
+! [टोकन स्वैप करते समय उपयोगकर्ता को प्रत्येक चरण के बारे में सूचित करना](./Image1.png)
+
+### 2. सुरक्षा और विश्वास {#security-and-trust-are-backed-in} में बेक किए गए हैं
+
+सुरक्षा को प्राथमिकता दी जानी चाहिए, और उपयोगकर्ता के लिए इस पर जोर दिया जाना चाहिए।
+लोग अपने डेटा की बहुत परवाह करते हैं। सुरक्षा अक्सर उपयोगकर्ताओं के लिए एक प्राथमिक चिंता का विषय है, इसलिए इसे डिजाइन के सभी स्तरों पर माना जाना चाहिए। आपको हमेशा अपने उपयोगकर्ताओं का विश्वास अर्जित करने की कोशिश करनी चाहिए, लेकिन जिस तरह से आप ऐसा करते हैं उसका मतलब अलग-अलग ऐप्स पर अलग-अलग चीजें हो सकता है। यह एक बाद का विचार नहीं होना चाहिए, लेकिन पूरे सचेत रूप से डिजाइन किया जाना चाहिए। सामाजिक चैनलों और दस्तावेज़ीकरण, साथ ही अंतिम UI सहित उपयोगकर्ता अनुभव में विश्वास बनाएँ। विकेंद्रीकरण के स्तर, ट्रेजरी मल्टी-सिग स्थिति, और क्या टीम को डॉक्स किया गया है, जैसी चीजें सभी उपयोगकर्ताओं के विश्वास को प्रभावित करती हैं
+
+**Tips:**
+
+- अपने ऑडिट को गर्व से सूचीबद्ध करें
+- कई ऑडिट प्राप्त करें
+- अपने द्वारा डिज़ाइन की गई सभी सुरक्षा सुविधाओं का विज्ञापन करें
+- अंतर्निहित एकीकरण सहित संभावित जोखिमों को हाइलाइट करें
+- रणनीतियों की जटिलता का संचार करें
+- गैर-UI समस्याओं पर विचार करें जो आपके उपयोगकर्ताओं की सुरक्षा की धारणा को प्रभावित कर सकती हैं
+
+**उदाहरण:**
+पाद लेख में अपने ऑडिट शामिल करें, एक प्रमुख आकार में।
+
+
+
+### 3. सबसे महत्वपूर्ण जानकारी स्पष्ट है {#the-most-important-info-is-obvious}
+
+जटिल सिस्टम के लिए, केवल सबसे प्रासंगिक डेटा दिखाएं। निर्धारित करें कि सबसे महत्वपूर्ण क्या है, और इसके प्रदर्शन को प्राथमिकता दें।
+बहुत अधिक जानकारी भारी होती है और उपयोगकर्ता आमतौर पर निर्णय लेते समय जानकारी के एक टुकड़े पर लंगर डालते हैं। DeFi में, यह संभवतः यील्ड ऐप्स पर APR और लेंडिंग ऐप्स पर LTV होगा।
+
+**Tips:**
+
+- उपयोगकर्ता अनुसंधान सबसे महत्वपूर्ण मीट्रिक को उजागर करेगा
+- मुख्य जानकारी को बड़ा बनाएं, और अन्य विवरण छोटे और विनीत
+- लोग पढ़ते नहीं हैं, वे स्कैन करते हैं; सुनिश्चित करें कि आपका डिज़ाइन स्कैन करने योग्य है
+
+**उदाहरण:** स्कैन करते समय पूर्ण रंग में बड़े टोकन ढूंढना आसान होता है। APR एपीआर बड़ा है और एक उच्चारण रंग में हाइलाइट किया गया है।
+
+! [टोकन और एपीआर ढूंढना आसान है](./Image3.png)
+
+### 4. ! [टोकन और एपीआर ढूंढना आसान है](./Image3. png)
+
+शब्दावली समझने योग्य और उपयुक्त होनी चाहिए।
+तकनीकी शब्दजाल एक बहुत बड़ा अवरोधक हो सकता है, क्योंकि इसके लिए पूरी तरह से नए मानसिक मॉडल के निर्माण की आवश्यकता होती है। उपयोगकर्ता डिजाइन को उन शब्दों, वाक्यांशों और अवधारणाओं से संबंधित करने में असमर्थ हैं जिन्हें वे पहले से जानते हैं। सब कुछ भ्रामक और अपरिचित लगता है, और इससे पहले कि वे इसका उपयोग करने का प्रयास कर सकें, सीखने की अवस्था बहुत तेज है। एक उपयोगकर्ता कुछ पैसे बचाने के लिए DeFi से संपर्क कर सकता है, और वे जो पाते हैं वह है: खनन, खेती, दांव, उत्सर्जन, रिश्वत, वॉल्ट, लॉकर, veTokens, निहित, युग, विकेन्द्रीकृत एल्गोरिदम, प्रोटोकॉल-स्वामित्व वाली तरलता...
+सरल शब्दों का उपयोग करने का प्रयास करें जो लोगों के व्यापक समूह द्वारा समझा जाएगा। केवल अपने प्रोजेक्ट के लिए बिल्कुल नए शब्दों का आविष्कार न करें।
+
+**Tips:**
+
+- सरल और सुसंगत शब्दावली का प्रयोग करें
+- जितना हो सके मौजूदा भाषा का इस्तेमाल करें
+- अपनी खुद की शर्तों के साथ मत आओ
+- सम्मेलनों का पालन करें जैसे वे दिखाई देते हैं
+- जितना संभव हो उपयोगकर्ताओं को शिक्षित करें
+
+**उदाहरण:**
+"आपका पुरस्कार" एक व्यापक रूप से समझा जाने वाला, तटस्थ, शब्द है; इस परियोजना के लिए एक नया शब्द नहीं बनाया गया है। पुरस्कारों को वास्तविक दुनिया के मानसिक मॉडल से मेल खाने के लिए USD में दर्शाया जाता है, भले ही पुरस्कार स्वयं किसी अन्य टोकन में हों।
+
+! [टोकन पुरस्कार, अमेरिका में प्रदर्शित डॉलर](./Image4.png)
+
+### 5. क्रियाएं यथासंभव कम हैं {#actions-are-as-short-as-possible}
+
+उप क्रियाओं को समूहीकृत करके उपयोगकर्ता की बातचीत को गति दें।
+यह स्मार्ट अनुबंध स्तर, साथ ही यूआई पर किया जा सकता है। उपयोगकर्ता को सिस्टम के एक हिस्से से दूसरे हिस्से में जाने की ज़रूरत नहीं होनी चाहिए - या सिस्टम को पूरी तरह से छोड़ दें - एक सामान्य क्रिया को पूरा करने के लिए।
+
+**Tips:**
+
+- जहां संभव हो अन्य कार्यों के साथ "अनुमोदन" को मिलाएं
+- हस्ताक्षर करने के चरणों को यथासंभव एक साथ बंडल करें
+
+**उदाहरण:** "तरलता जोड़ें" और "हिस्सेदारी" का संयोजन एक त्वरक का एक सरल उदाहरण है जो उपयोगकर्ता को समय और गैस दोनों बचाता है।
+
+! [मोडल जमा और हिस्सेदारी कार्यों को संयोजित करने के लिए एक स्विच दिखा रहा है](./Image5.png)
+
+### 6. नेटवर्क कनेक्शन दृश्यमान और लचीले होते हैं {#network-connections-are-visible-and-flexible}
+
+उपयोगकर्ता को सूचित करें कि वे किस नेटवर्क से जुड़े हैं, और नेटवर्क बदलने के लिए स्पष्ट शॉर्टकट प्रदान करें।
+यह मल्टीचैन ऐप्स पर विशेष रूप से महत्वपूर्ण है। ऐप के मुख्य कार्य अभी भी डिस्कनेक्ट या गैर-समर्थित नेटवर्क से कनेक्ट होने पर दिखाई देने चाहिए।
+
+**Tips:**
+
+- डिस्कनेक्ट होने पर जितना संभव हो उतना ऐप दिखाएं
+- दिखाएँ कि उपयोगकर्ता वर्तमान में किस नेटवर्क से कनेक्टेड है
+- नेटवर्क बदलने के लिए उपयोगकर्ता को वॉलेट में न जाने दें
+- यदि ऐप को उपयोगकर्ता को नेटवर्क स्विच करने की आवश्यकता है, तो मुख्य कॉल से कार्रवाई का संकेत दें
+- यदि ऐप में कई नेटवर्क के लिए बाजार या वॉल्ट हैं, तो स्पष्ट रूप से बताएं कि उपयोगकर्ता वर्तमान में किस सेट को देख रहा है
+
+**उदाहरण:** उपयोगकर्ता को दिखाएं कि वे किस नेटवर्क से जुड़े हैं, और उन्हें ऐपबार में इसे बदलने की अनुमति दें।
+
+! [ड्रॉपडाउन बटन कनेक्टेड नेटवर्क दिखा रहा है](./Image6.png)
+
+### 7. ऐप से नियंत्रण, वॉलेट से नहीं {#control-from-the-app-not-the-wallet}
+
+यूआई को उपयोगकर्ता को वह सब कुछ बताना चाहिए जो उन्हें जानना चाहिए और उन्हें जो कुछ भी करने की आवश्यकता है उस पर उन्हें नियंत्रण देना चाहिए।
+Web3 में, आपके द्वारा UI में की जाने वाली कार्रवाइयाँ हैं, और आपके द्वारा वॉलेट में की जाने वाली कार्रवाइयाँ हैं। आम तौर पर, आप यूआई में एक कार्रवाई शुरू करते हैं, और फिर वॉलेट में इसकी पुष्टि करते हैं। यदि इन दो किस्में को सावधानीपूर्वक एकीकृत नहीं किया जाता है तो उपयोगकर्ता असहज महसूस कर सकते हैं।
+
+**Tips:**
+
+- UI में प्रतिक्रिया के माध्यम से सिस्टम स्थिति का संचार करें
+- उनके इतिहास का रिकॉर्ड रखें
+- पुराने लेनदेन के लिए ब्लॉक एक्सप्लोरर के लिंक प्रदान करें
+- नेटवर्क बदलने के लिए शॉर्टकट प्रदान करें।
+
+**उदाहरण:** एक सूक्ष्म कंटेनर उपयोगकर्ता को दिखाता है कि उनके बटुए में कौन से प्रासंगिक टोकन हैं, और मुख्य सीटीए नेटवर्क को बदलने के लिए एक शॉर्टकट प्रदान करता है।
+
+! [मुख्य सीटीए उपयोगकर्ता को नेटवर्क स्विच करने के लिए प्रेरित कर रहा है](./Image7.png)
diff --git a/public/content/translations/hi/developers/docs/design-and-ux/index.md b/public/content/translations/hi/developers/docs/design-and-ux/index.md
new file mode 100644
index 00000000000..c427d13b9da
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/design-and-ux/index.md
@@ -0,0 +1,86 @@
+---
+title: "वेब3 में डिज़ाइन और UX"
+description: "वेब3 स्पेस और एथेरियम में UX डिजाइन और अनुसंधान का परिचय"
+lang: hi
+---
+
+क्या आप एथेरियम के साथ डिजाइन करने के लिए नए हैं? यह आपके लिए सही जगह है। एथेरियम समुदाय ने आपको वेब3 डिज़ाइन और शोध की मूल बातें से परिचित कराने के लिए संसाधन लिखे हैं। आप उन मुख्य अवधारणाओं के बारे में जानेंगे जो आपके परिचित अन्य ऐप डिज़ाइनों से भिन्न हो सकती हैं।
+
+पहले वेब3 की अधिक बुनियादी समझ की आवश्यकता है? [**लर्न हब**](/learn/) को देखें।
+
+## उपयोगकर्ता अनुसंधान से शुरू करें {#start-with-user-research}
+
+प्रभावी डिजाइन नेत्रहीन आकर्षक उपयोगकर्ता इंटरफेस बनाने से परे है। इसमें उपयोगकर्ता की जरूरतों, उद्देश्यों और ड्राइविंग कारकों की गहरी समझ हासिल करना शामिल है। इसलिए, हम सभी डिजाइनरों को एक डिजाइन प्रक्रिया अपनाने की पुरजोर सलाह देते हैं, जैसे कि [**डबल डायमंड प्रक्रिया**](https://en.wikipedia.org/wiki/Double_Diamond_\(design_process_model\)), यह सुनिश्चित करने के लिए कि उनका काम जानबूझकर और सप्रयोजन हो।
+
+- [Web3 को और अधिक UX शोधकर्ताओं और डिजाइनरों की आवश्यकता है](https://blog.akasha.org/akasha-conversations-9-web3-needs-more-ux-researchers-and-designers) - वर्तमान डिजाइन परिपक्वता का एक अवलोकन
+- [web3 में UX अनुसंधान के लिए एक सरल गाइड](https://uxplanet.org/a-complete-guide-to-ux-research-for-web-3-0-products-d6bead20ebb1) - अनुसंधान कैसे करें इसके लिए सरल गाइड
+- [Web3 में UX निर्णयों तक कैसे पहुंचें](https://archive.devcon.org/archive/watch/6/data-empathy-how-to-approach-ux-decisions-in-web3/) - मात्रात्मक और गुणात्मक अनुसंधान और दोनों के बीच के अंतरों का एक संक्षिप्त अवलोकन (वीडियो, 6 मिनट)
+- [web3 में एक ux शोधकर्ता होना](https://medium.com/@georgia.rakusen/what-its-like-being-a-user-researcher-in-web3-6a4bcc096849) - web3 में UX शोधकर्ता होने का क्या मतलब है, इस पर एक व्यक्तिगत दृष्टिकोण
+
+## web3 में अनुसंधान अध्ययन {#research-in-web3}
+
+यह वेब3 में किए गए उपयोगकर्ता अनुसंधान की एक क्यूरेटेड सूची है जो डिजाइन और उत्पाद निर्णयों में मदद कर सकती है या स्वयं के अध्ययन का संचालन करने के लिए प्रेरणा के रूप में काम कर सकती है।
+
+| फोकस का क्षेत्र | नाम |
+| :-------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| क्रिप्टो ऑनबोर्डिंग | [The Reown Pulse 2024: क्रिप्टो उपभोक्ता भावना और उपयोग](https://reown.com/blog/unveiling-walletconnects-consumer-crypto-report) |
+| क्रिप्टो ऑनबोर्डिंग | [CRADL: क्रिप्टोकरेंसी में UX](https://docs.google.com/presentation/d/1s2OPSH5sMJzxRYaJSSRTe8W2iIoZx0PseIV-WeZWD1s/edit?usp=sharing) |
+| क्रिप्टो ऑनबोर्डिंग | [CRADL: क्रिप्टोकरेंसी में ऑनबोर्डिंग](https://docs.google.com/presentation/d/1R9nFuzA-R6SxaGCKhoMbE4Vxe0JxQSTiHXind3LVq_w/edit?usp=sharing) |
+| क्रिप्टो ऑनबोर्डिंग | [Bitcoin UX रिपोर्ट](https://github.com/patestevao/BitcoinUX-report/blob/master/report.md) |
+| क्रिप्टो ऑनबोर्डिंग | [ConSensys: दुनिया भर में Web3 की धारणा की स्थिति 2023](https://consensys.io/insight-report/web3-and-crypto-global-survey-2023) |
+| क्रिप्टो ऑनबोर्डिंग | [NEAR: अपनाने की दिशा में यात्रा में तेजी लाना](https://drive.google.com/file/d/1VuaQP4QSaQxR5ddQKTMGI0b0rWdP7uGn/view) |
+| स्टेकिंग | [OpenUX: Rocket Pool नोड ऑपरेटर UX](https://storage.googleapis.com/rocketpool/RocketPool-NodeOperator-UX-Report-Jan-2024.pdf) |
+| स्टेकिंग | [स्टेकिंग: मुख्य रुझान, निष्कर्ष और भविष्यवाणियां - Eth Staker](https://lookerstudio.google.com/u/0/reporting/cafcee00-e1af-4148-bae8-442a88ac75fa/page/p_ja2srdhh2c?s=hmbTWDh9hJo) |
+| स्टेकिंग | [मल्टी ऐप स्टेकिंग](https://github.com/threshold-network/UX-User-Research/blob/main/Multi-App%20Staking%20\(MAS\)/iterative-user-study/MAS%20Iterative%20User%20Study.pdf) |
+| डीएओ | [2022 डीएओ अनुसंधान अपडेट: डीएओ बिल्डर्स को क्या चाहिए?](https://blog.aragon.org/2022-dao-research-update/) |
+| DeFi | [कवरेज पूल](https://github.com/threshold-network/UX-User-Research/tree/main/Keep%20Coverage%20Pool) |
+| DeFi | [ConSensys: DeFi उपयोगकर्ता अनुसंधान रिपोर्ट 2022](https://cdn2.hubspot.net/hubfs/4795067/ConsenSys%20Codefi-Defi%20User%20ResearchReport.pdf) |
+| मेटावर्स | [मेटावर्स: उपयोगकर्ता अनुसंधान रिपोर्ट](https://www.politico.com/f/?id=00000187-7685-d820-a7e7-7e85d1420000) |
+| मेटावर्स | [सफारी पर जाना: मेटावर्स में उपयोगकर्ताओं पर शोध करना](https://archive.devcon.org/archive/watch/6/going-on-safari-researching-users-in-the-metaverse/?tab=YouTube) (वीडियो, 27 मिनट) |
+
+## web3 के लिए डिज़ाइन {#design-for-web3}
+
+- [Web3 UX डिज़ाइन हैंडबुक](https://web3ux.design/) - Web3 ऐप्स डिजाइन करने के लिए व्यावहारिक गाइड
+- [Web3 डिज़ाइन सिद्धांत](https://medium.com/@lyricalpolymath/web3-design-principles-f21db2f240c1) - ब्लॉकचेन आधारित डैप्स के लिए UX नियमों की एक रूपरेखा
+- [ब्लॉकचेन डिज़ाइन सिद्धांत](https://medium.com/design-ibm/blockchain-design-principles-599c5c067b6e) - IBM में ब्लॉकचेन डिजाइन टीम द्वारा सीखे गए सबक
+- [Neueux.com](https://neueux.com/apps) - विविध फ़िल्टरिंग विकल्पों के साथ उपयोगकर्ता प्रवाह की UI लाइब्रेरी
+- [Web3 का उपयोगिता संकट: आपको क्या जानना चाहिए!](https://www.youtube.com/watch?v=oBSXT_6YDzg) - डेवलपर केंद्रित प्रोजेक्ट निर्माण के नुकसान पर एक पैनल चर्चा (वीडियो, 34 मिनट)
+
+## शुरुआत करना {#getting-started}
+
+- [Web3 के लिए स्वानुभविक](/developers/docs/design-and-ux/heuristics-for-web3/) - Web3 इंटरफ़ेस डिज़ाइन के लिए 7 स्वानुभविक
+- [DEX डिज़ाइन की सर्वोत्तम प्रथाएं](/developers/docs/design-and-ux/dex-design-best-practice/) - विकेंद्रीकृत एक्सचेंज डिज़ाइन करने के लिए एक गाइड
+
+## Web3 डिज़ाइन केस स्टडीज़ {#design-case-studies}
+
+- [Deep Work Studio](https://www.deepwork.studio/case-studies)
+- [OpenSea पर एक NFT बेचना](https://builtformars.com/case-studies/opensea)
+- [वॉलेट UX टियरडाउन: वॉलेट को कैसे बदलना होगा](https://www.youtube.com/watch?v=oTpuxYj8JWI&ab_channel=ETHDenver) (वीडियो, 20 मिनट)
+
+## डिज़ाइन बाउंटीज़ {#bounties}
+
+- [Dework](https://app.dework.xyz/bounties)
+- [Buildbox हैकथॉन](https://app.buidlbox.io/)
+- [ETHGlobal हैकथॉन](https://ethglobal.com/)
+
+## डिज़ाइन डीएओ और समुदाय {#design-daos-and-communities}
+
+पेशेवर समुदाय-संचालित संगठनों में शामिल हों या अन्य सदस्यों के साथ डिजाइन और अनुसंधान से संबंधित विषयों और रुझानों पर चर्चा करने के लिए डिजाइन समूहों में शामिल हों।
+
+- [Vectordao.com](https://vectordao.com/)
+- [Deepwork.studio](https://www.deepwork.studio/)
+- [We3.co](https://we3.co/)
+- [Openux.xyz](https://openux.xyz/)
+
+## डिज़ाइन सिस्टम और अन्य डिज़ाइन संसाधन {#design-systems-and-resources}
+
+- [Optimism डिज़ाइन](https://www.figma.com/@optimism) (Figma)
+- [Ethereum.org डिज़ाइन सिस्टम](https://www.figma.com/@ethdotorg) (Figma)
+- [Finity, Polygon द्वारा एक डिज़ाइन सिस्टम](https://www.figma.com/community/file/1073921725197233598/finity-design-system) (Figma)
+- [Kleros डिज़ाइन सिस्टम](https://www.figma.com/community/file/999852250110186964/kleros-design-system) (Figma)
+- [Safe डिज़ाइन सिस्टम](https://www.figma.com/community/file/1337417127407098506/safe-design-system) (Figma)
+- [ENS डिज़ाइन सिस्टम](https://thorin.ens.domains/)
+- [Mirror डिज़ाइन सिस्टम](https://degen-xyz.vercel.app/)
+
+**इस पृष्ठ पर सूचीबद्ध लेख और परियोजनाएं आधिकारिक समर्थन नहीं हैं**, और केवल सूचनात्मक उद्देश्यों के लिए प्रदान की गई हैं।
+हम अपनी [सूचीकरण नीति](/contributing/design/adding-design-resources) में मानदंडों के आधार पर इस पृष्ठ पर लिंक जोड़ते हैं। यदि आप चाहते हैं कि हम कोई प्रोजेक्ट/लेख जोड़ें, तो इस पृष्ठ को [GitHub](https://github.com/ethereum/ethereum-org-website/blob/dev/public/content/developers/docs/design-and-ux/index.md) पर संपादित करें।
diff --git a/public/content/translations/hi/developers/docs/development-networks/index.md b/public/content/translations/hi/developers/docs/development-networks/index.md
new file mode 100644
index 00000000000..05a4b414f2c
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/development-networks/index.md
@@ -0,0 +1,71 @@
+---
+title: "विकास नेटवर्क"
+description: "एथेरियम अनुप्रयोगों के निर्माण में सहायता के लिए विकास नेटवर्क और उपलब्ध उपकरणों का अवलोकन।"
+lang: hi
+---
+
+स्मार्ट कॉन्ट्रैक्ट्स के साथ एथेरियम एप्लिकेशन बनाते समय, आप इसे स्थानीय नेटवर्क पर चलाना चाहेंगे ताकि यह देखा जा सके कि इसे तैनात करने से पहले यह कैसे काम करता है।
+
+वेब विकास के लिए आप अपने कंप्यूटर पर एक स्थानीय सर्वर कैसे चला सकते हैं, इसी तरह, आप अपने डीएपी का परीक्षण करने के लिए स्थानीय ब्लॉकचेन इंस्टेंस बनाने के लिए एक विकास नेटवर्क का उपयोग कर सकते हैं। ये एथेरियम विकास नेटवर्क ऐसी सुविधाएँ प्रदान करते हैं जो सार्वजनिक टेस्टनेट की तुलना में बहुत तेज़ पुनरावृत्ति की अनुमति देती हैं (उदाहरण के लिए आपको टेस्टनेट नल से ईटीएच प्राप्त करने से निपटने की आवश्यकता नहीं है)।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+डेवलपमेंट नेटवर्क में जाने से पहले आपको [इथेरियम स्टैक की मूल बातें](/developers/docs/ethereum-stack/) और [एथेरियम नेटवर्क](/developers/docs/networks/) को समझना चाहिए।
+
+## एक विकास नेटवर्क क्या है? {#what-is-a-development-network}
+
+विकास नेटवर्क अनिवार्य रूप से एथेरियम क्लाइंट (एथेरियम के कार्यान्वयन) हैं जो विशेष रूप से स्थानीय विकास के लिए डिज़ाइन किए गए हैं।
+
+**स्थानीय रूप से एक मानक एथेरियम नोड क्यों न चलाएं?**
+
+आप _एक [नोड चला सकते हैं](/developers/docs/nodes-and-clients/#running-your-own-node) लेकिन चूंकि डेवलपमेंट नेटवर्क विशेष रूप से डेवलपमेंट के लिए बनाए गए हैं, वे अक्सर इस तरह की सुविधाजनक सुविधाओं के साथ आते हैं:
+
+- अपने स्थानीय ब्लॉकचेन को डेटा के साथ निर्धारक रूप से सीड करना (उदाहरण के लिए, ETH बैलेंस वाले खाते)
+- तुरंत प्राप्त होने वाले प्रत्येक लेनदेन के साथ ब्लॉक का उत्पादन, क्रम में और बिना किसी देरी के
+- एन्हांस्ड डिबगिंग और लॉगिंग कार्यक्षमता
+
+## उपलब्ध उपकरण {#available-projects}
+
+**ध्यान दें**: अधिकांश [डेवलपमेंट फ्रेमवर्क](/developers/docs/frameworks/) में एक अंतर्निहित डेवलपमेंट नेटवर्क शामिल होता है। हमारा सुझाव है कि आप [अपने स्थानीय डेवलपमेंट परिवेश को सेट करने](/developers/local-environment/) के लिए एक फ्रेमवर्क से शुरुआत करें।
+
+### Hardhat नेटवर्क {#hardhat-network}
+
+विकास के लिए डिज़ाइन किया गया एक स्थानीय एथेरियम नेटवर्क। यह आपको अपने अनुबंधों को तैनात करने, अपने परीक्षण चलाने और अपने कोड को डीबग करने की अनुमति देता है।
+
+Hardhat Network Hardhat के साथ बिल्ट-इन आता है, जो पेशेवरों के लिए एक Ethereum डेवलपमेंट एनवायरनमेंट है।
+
+- [वेबसाइट](https://hardhat.org/)
+- [GitHub](https://github.com/NomicFoundation/hardhat)
+
+### स्थानीय बीकन चेन्स {#local-beacon-chains}
+
+कुछ आम सहमति ग्राहकों के पास परीक्षण उद्देश्यों के लिए स्थानीय बीकन श्रृंखलाओं को कताई के लिए अंतर्निहित उपकरण हैं। लाइटहाउस, निंबस और लॉडस्टार के लिए निर्देश उपलब्ध हैं:
+
+- [Lodestar का उपयोग करके स्थानीय टेस्टनेट](https://chainsafe.github.io/lodestar/contribution/advanced-topics/setting-up-a-testnet#post-merge-local-testnet/)
+- [Lighthouse का उपयोग करके स्थानीय टेस्टनेट](https://lighthouse-book.sigmaprime.io/setup.html#local-testnets)
+
+### सार्वजनिक एथेरियम टेस्ट-चेन {#public-beacon-testchains}
+
+एथेरियम के दो अनुरक्षित सार्वजनिक परीक्षण कार्यान्वयन भी हैं: सेपोलिया और हुडी। लंबी अवधि के समर्थन वाला अनुशंसित टेस्टनेट हुडी है, जिस पर कोई भी सत्यापन करने के लिए स्वतंत्र है। सेपोलिया एक अनुमति प्राप्त सत्यापनकर्ता सेट का उपयोग करता है, जिसका अर्थ है कि इस टेस्टनेट पर नए सत्यापनकर्ताओं के लिए कोई सामान्य पहुंच नहीं है।
+
+- [Hoodi स्टेकिंग लॉन्चपैड](https://hoodi.launchpad.ethereum.org/)
+
+### Kurtosis एथेरियम पैकेज {#kurtosis}
+
+कुर्टोसिस मल्टी-कंटेनर परीक्षण वातावरण के लिए एक बिल्ड सिस्टम है जो डेवलपर्स को ब्लॉकचेन नेटवर्क के प्रतिलिपि प्रस्तुत करने योग्य उदाहरणों को स्थानीय रूप से स्पिन करने में सक्षम बनाता है।
+
+एथेरियम कुर्टोसिस पैकेज का उपयोग डॉकर या कुबेरनेट्स पर एक पैरामीटराइज़बल, अत्यधिक स्केलेबल और निजी एथेरियम टेस्टनेट को जल्दी से तत्काल करने के लिए किया जा सकता है। पैकेज सभी प्रमुख निष्पादन परत (EL) और आम सहमति परत (CL) क्लाइंट का समर्थन करता है। Kurtosis एथेरियम कोर बुनियादी ढांचे से संबंधित सत्यापन और परीक्षण वर्कफ़्लोज़ में उपयोग किए जाने वाले प्रतिनिधि नेटवर्क के लिए सभी स्थानीय पोर्ट मैपिंग और सेवा कनेक्शन को इनायत से संभालता है।
+
+- [एथेरियम नेटवर्क पैकेज](https://github.com/kurtosis-tech/ethereum-package)
+- [वेबसाइट](https://www.kurtosis.com/)
+- [GitHub](https://github.com/kurtosis-tech/kurtosis)
+- [प्रलेखन](https://docs.kurtosis.com/)
+
+## आगे की रीडिंग {#further-reading}
+
+_क्या आप किसी सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की हो? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
+
+## संबंधित विषय {#related-topics}
+
+- [डेवलपमेंट फ्रेमवर्क](/developers/docs/frameworks/)
+- [एक स्थानीय डेवलपमेंट परिवेश सेट करें](/developers/local-environment/)
diff --git a/public/content/translations/hi/developers/docs/ethereum-stack/index.md b/public/content/translations/hi/developers/docs/ethereum-stack/index.md
new file mode 100644
index 00000000000..034be47a258
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/ethereum-stack/index.md
@@ -0,0 +1,60 @@
+---
+title: "एथेरियम स्टैक का परिचय"
+description: "एथेरियम स्टैक की विभिन्न परतों का पूर्वाभ्यास और वे एक साथ कैसे फिट होते हैं।"
+lang: hi
+---
+
+किसी भी सॉफ्टवेयर स्टैक की तरह, पूरा "एथेरियम स्टैक" आपके लक्ष्यों के आधार पर प्रोजेक्ट से प्रोजेक्ट में अलग-अलग होगा।
+
+हालाँकि, एथेरियम के मुख्य घटक हैं जो एक मानसिक मॉडल प्रदान करने में मदद करते हैं कि सॉफ़्टवेयर एप्लिकेशन एथेरियम ब्लॉकचेन के साथ कैसे इंटरैक्ट करते हैं। स्टैक की परतों को समझने से आपको उन विभिन्न तरीकों को समझने में मदद मिलेगी जिनसे एथेरियम को सॉफ्टवेयर प्रोजेक्ट्स में एकीकृत किया जा सकता है।
+
+## स्तर 1: एथेरियम वर्चुअल मशीन {#ethereum-virtual-machine}
+
+[एथेरियम वर्चुअल मशीन (EVM)](/developers/docs/evm/) एथेरियम पर स्मार्ट अनुबंधों के लिए रनटाइम वातावरण है। एथेरियम ब्लॉकचेन पर सभी स्मार्ट अनुबंध और स्टेट परिवर्तन [लेन-देन](/developers/docs/transactions/) द्वारा निष्पादित किए जाते हैं। ईवीएम एथेरियम नेटवर्क पर सभी लेनदेन प्रसंस्करण को संभालता है।
+
+किसी भी वर्चुअल मशीन की तरह, ईवीएम निष्पादन कोड और निष्पादन मशीन (एक एथेरियम नोड) के बीच अमूर्तता का एक स्तर बनाता है। वर्तमान में ईवीएम दुनिया भर में वितरित हजारों नोड्स पर चल रही है।
+
+हुड के तहत, ईवीएम विशिष्ट कार्यों को निष्पादित करने के लिए ऑपकोड निर्देशों के एक सेट का उपयोग करता है। ये (140 अद्वितीय) ऑपकोड EVM को [ट्यूरिंग-कंप्लीट](https://en.wikipedia.org/wiki/Turing_completeness) होने की अनुमति देते हैं, जिसका मतलब है कि पर्याप्त संसाधन दिए जाने पर EVM लगभग किसी भी चीज़ की गणना करने में सक्षम है।
+
+एक डैप डेवलपर के रूप में, आपको मौजूद ईवीएम के अलावा इसके बारे में ज्यादा जानने की जरूरत नहीं है और यह बिना डाउनटाइम के एथेरियम पर सभी एप्लिकेशन को मज़बूती से शक्ति देता है।
+
+## स्तर 2: स्मार्ट अनुबंध {#smart-contracts}
+
+[स्मार्ट अनुबंध](/developers/docs/smart-contracts/) निष्पादन योग्य प्रोग्राम हैं जो एथेरियम ब्लॉकचेन पर चलते हैं।
+
+स्मार्ट अनुबंध विशिष्ट [प्रोग्रामिंग भाषाओं](/developers/docs/smart-contracts/languages/) का उपयोग करके लिखे जाते हैं जो EVM बाइटकोड (निम्न-स्तरीय मशीन निर्देश जिन्हें ऑपकोड कहा जाता है) में कंपाइल होते हैं।
+
+न केवल स्मार्ट कॉन्ट्रैक्ट ओपन सोर्स लाइब्रेरी के रूप में काम करते हैं, वे अनिवार्य रूप से ओपन एपीआई सेवाएं हैं जो हमेशा चल रही हैं और उन्हें नीचे नहीं ले जाया जा सकता है। स्मार्ट अनुबंध सार्वजनिक फ़ंक्शन प्रदान करते हैं, जिनसे उपयोगकर्ता और एप्लिकेशन ([डैप्स](/developers/docs/dapps/)) बिना अनुमति की आवश्यकता के इंटरैक्ट कर सकते हैं। कोई भी एप्लिकेशन कार्यक्षमता की रचना करने के लिए परिनियोजित स्मार्ट अनुबंधों के साथ एकीकृत हो सकता है, जैसे [डेटा फ़ीड](/developers/docs/oracles/) जोड़ना या टोकन स्वैप का समर्थन करना। इसके अतिरिक्त, कोई भी अपने एप्लिकेशन की जरूरतों को पूरा करने के लिए कस्टम कार्यक्षमता जोड़ने के लिए एथेरियम में नए स्मार्ट कॉन्ट्रैक्ट तैनात कर सकता है।
+
+एक डैप डेवलपर के रूप में, आपको स्मार्ट कॉन्ट्रैक्ट तभी लिखने होंगे जब आप एथेरियम ब्लॉकचेन पर कस्टम कार्यक्षमता जोड़ना चाहते हैं। आप पा सकते हैं कि आप केवल मौजूदा स्मार्ट अनुबंधों के साथ एकीकृत करके अपनी परियोजना की अधिकांश या सभी जरूरतों को प्राप्त कर सकते हैं, उदाहरण के लिए यदि आप स्थिर स्टॉक में भुगतान का समर्थन करना चाहते हैं या टोकन के विकेन्द्रीकृत विनिमय को सक्षम करना चाहते हैं।
+
+## स्तर 3: एथेरियम नोड्स {#ethereum-nodes}
+
+किसी एप्लिकेशन को एथेरियम ब्लॉकचेन के साथ इंटरैक्ट करने के लिए, उसे एक [एथेरियम नोड](/developers/docs/nodes-and-clients/) से कनेक्ट होना चाहिए। नोड से कनेक्ट करने से आप ब्लॉकचेन डेटा पढ़ सकते हैं और/या नेटवर्क पर लेनदेन भेज सकते हैं।
+
+एथेरियम नोड्स सॉफ्टवेयर चलाने वाले कंप्यूटर हैं - एक एथेरियम क्लाइंट। एक ग्राहक Ethereum का एक कार्यान्वयन है जो प्रत्येक ब्लॉक में सभी लेनदेन की पुष्टि करता है, नेटवर्क को सुरक्षित रखता है और डेटा को सटीक रखता है। **एथेरियम नोड्स ही एथेरियम ब्लॉकचेन हैं**। वे सामूहिक रूप से एथेरियम ब्लॉकचेन की स्थिति को संग्रहीत करते हैं और ब्लॉकचेन राज्य को उत्परिवर्तित करने के लिए लेनदेन पर आम सहमति तक पहुंचते हैं।
+
+अपने एप्लिकेशन को एक एथेरियम नोड से ([JSON-RPC API](/developers/docs/apis/json-rpc/) के माध्यम से) कनेक्ट करके, आपका एप्लिकेशन ब्लॉकचेन से डेटा पढ़ सकता है (जैसे उपयोगकर्ता के खाते की शेष राशि) और साथ ही नेटवर्क पर नए लेन-देन प्रसारित कर सकता है (जैसे उपयोगकर्ता खातों के बीच ETH स्थानांतरित करना या स्मार्ट अनुबंधों के फ़ंक्शन निष्पादित करना)।
+
+## स्तर 4: एथेरियम क्लाइंट API {#ethereum-client-apis}
+
+कई सुविधा पुस्तकालय (एथेरियम के ओपन सोर्स समुदाय द्वारा निर्मित और अनुरक्षित) आपके एप्लिकेशन को एथेरियम ब्लॉकचेन से जुड़ने और संवाद करने की अनुमति देते हैं।
+
+यदि आपका उपयोगकर्ता-सामना करने वाला एप्लिकेशन एक वेब ऐप है, तो आप सीधे अपने फ्रंटएंड में एक [जावास्क्रिप्ट API](/developers/docs/apis/javascript/) `npm install` करना चुन सकते हैं। या शायद आप इस कार्यक्षमता को सर्वर-साइड, एक [पाइथन](/developers/docs/programming-languages/python/) या [जावा](/developers/docs/programming-languages/java/) API का उपयोग करके लागू करना चुनेंगे।
+
+हालांकि ये एपीआई स्टैक का एक आवश्यक टुकड़ा नहीं हैं, वे एथेरियम नोड के साथ सीधे बातचीत करने की जटिलता को दूर करते हैं। वे यूटिलिटी फ़ंक्शन (जैसे, ETH को Gwei में बदलना) भी प्रदान करते हैं, ताकि एक डेवलपर के रूप में आप एथेरियम क्लाइंट की जटिलताओं से निपटने में कम समय और अपने एप्लिकेशन के लिए विशिष्ट कार्यक्षमता पर अधिक समय केंद्रित कर सकें।
+
+## स्तर 5: अंतिम-उपयोगकर्ता एप्लिकेशन {#end-user-applications}
+
+स्टैक के शीर्ष स्तर पर उपयोगकर्ता-सामना करने वाले एप्लिकेशन हैं। ये मानक एप्लिकेशन हैं जिनका आप नियमित रूप से उपयोग करते हैं और आज निर्माण करते हैं: मुख्य रूप से वेब और मोबाइल ऐप।
+
+जिस तरह से आप इन उपयोगकर्ता इंटरफेस को विकसित करते हैं वह अनिवार्य रूप से अपरिवर्तित रहता है। अक्सर उपयोगकर्ताओं को यह जानने की आवश्यकता नहीं होगी कि वे जिस एप्लिकेशन का उपयोग कर रहे हैं वह ब्लॉकचेन का उपयोग करके बनाया गया है।
+
+## अपना स्टैक चुनने के लिए तैयार हैं? {#ready-to-choose-your-stack}
+अपने एथेरियम एप्लिकेशन के लिए [एक स्थानीय विकास वातावरण सेट अप करने](/developers/local-environment/) के लिए हमारी मार्गदर्शिका देखें।
+
+## आगे की रीडिंग {#further-reading}
+
+- [वेब 3.0 एप्लिकेशन की वास्तुकला](https://www.preethikasireddy.com/post/the-architecture-of-a-web-3-0-application) - _प्रीति कासिरेड्डी_
+
+_क्या आप किसी सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की हो? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
diff --git a/public/content/translations/hi/developers/docs/evm/index.md b/public/content/translations/hi/developers/docs/evm/index.md
new file mode 100644
index 00000000000..bdaa8a3d18f
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/evm/index.md
@@ -0,0 +1,88 @@
+---
+title: "एथेरियम वर्चुअल मशीन (EVM)"
+description: "एथेरियम वर्चुअल मशीन का परिचय और यह स्थिति, लेनदेन और स्मार्ट अनुबंधों से कैसे संबंधित है।"
+lang: hi
+---
+
+एथेरियम वर्चुअल मशीन (EVM) एक विकेन्द्रीकृत आभासी वातावरण है जो सभी एथेरियम नोड्स में लगातार और सुरक्षित रूप से कोड निष्पादित करता है। नोड्स स्मार्ट अनुबंधों को निष्पादित करने के लिए EVM चलाते हैं, और [परिचालनों](/developers/docs/evm/opcodes/) के लिए आवश्यक कम्प्यूटेशनल प्रयास को मापने के लिए "[गैस](/developers/docs/gas/)" का उपयोग करते हैं, जिससे कुशल संसाधन आवंटन और नेटवर्क सुरक्षा सुनिश्चित होती है।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+EVM को समझने के लिए कंप्यूटर विज्ञान में [बाइट्स](https://wikipedia.org/wiki/Byte), [मेमोरी](https://wikipedia.org/wiki/Computer_memory), और [स्टैक](https://wikipedia.org/wiki/Stack_\(abstract_data_type\)) जैसी सामान्य शब्दावली से कुछ बुनियादी परिचित होना आवश्यक है। [हैश फ़ंक्शन](https://wikipedia.org/wiki/Cryptographic_hash_function) और [मर्कल ट्री](https://wikipedia.org/wiki/Merkle_tree) जैसी क्रिप्टोग्राफी/ब्लॉकचेन अवधारणाओं के साथ सहज होना भी सहायक होगा।
+
+## लेजर से स्टेट मशीन तक {#from-ledger-to-state-machine}
+
+'वितरित लेजर' के सादृश्य का उपयोग अक्सर बिटकॉइन जैसे ब्लॉकचेन का वर्णन करने के लिए किया जाता है, जो क्रिप्टोग्राफी के मूलभूत उपकरणों का उपयोग करके विकेन्द्रीकृत मुद्रा को सक्षम करता है। लेजर गतिविधि का एक रिकॉर्ड रखता है जिसे नियमों के एक सेट का पालन करना चाहिए जो यह नियंत्रित करता है कि कोई व्यक्ति लेजर को संशोधित करने के लिए क्या कर सकता है और क्या नहीं कर सकता है। उदाहरण के लिए, एक बिटकॉइन पता पहले से प्राप्त बिटकॉइन से ज्यादा खर्च नहीं कर सकता। ये नियम बिटकॉइन और कई अन्य ब्लॉकचेन पर सभी लेनदेन को रेखांकित करते हैं।
+
+हालांकि एथेरियम की अपनी मूल क्रिप्टोकरेंसी (ईथर) है जो लगभग उन्हीं सहज नियमों का पालन करती है, यह एक बहुत अधिक शक्तिशाली फ़ंक्शन भी सक्षम करता है: [स्मार्ट अनुबंध](/developers/docs/smart-contracts/)। इस अधिक जटिल विशेषता के लिए, एक अधिक परिष्कृत सादृश्य की आवश्यकता है। एक वितरित खाता बही के बजाय, एथेरियम एक वितरित [स्टेट मशीन](https://wikipedia.org/wiki/Finite-state_machine) है। एथेरियम की स्थिति एक बड़ी डेटा संरचना है जो न केवल सभी खाते और शेष राशि रखती है, बल्कि एक _मशीन स्टेट_ भी, जो नियमों के पूर्व-परिभाषित सेट के अनुसार ब्लॉक से ब्लॉक में बदल सकती है, और जो मनमाना मशीन कोड निष्पादित कर सकती है। स्थिति को ब्लॉक से ब्लॉक में बदलने के विशिष्ट नियमों को EVM द्वारा परिभाषित किया गया है।
+
+
+_आरेख [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf) से अनुकूलित है_
+
+## एथेरियम स्टेट ट्रांज़िशन फ़ंक्शन {#the-ethereum-state-transition-function}
+
+EVM एक गणितीय फंक्शन के रूप में व्यवहार करता है: इनपुट को देखते हुए, यह एक नियतात्मक आउटपुट उत्पन्न करता है। इसलिए एथेरियम को **स्टेट ट्रांज़िशन फ़ंक्शन** के रूप में अधिक औपचारिक रूप से वर्णित करना काफी सहायक है:
+
+```
+Y(S, T)= S'
+```
+
+एक पुरानी वैध स्टेट `(S)` और वैध लेन-देन के एक नए सेट `(T)` को देखते हुए, एथेरियम स्टेट ट्रांज़िशन फ़ंक्शन `Y(S, T)` एक नई वैध आउटपुट स्टेट `S'` उत्पन्न करता है।
+
+### स्टेट {#state}
+
+एथेरियम के संदर्भ में, स्टेट एक विशाल डेटा संरचना है जिसे [संशोधित मर्कल पैट्रीशिया ट्राई](/developers/docs/data-structures-and-encoding/patricia-merkle-trie/) कहा जाता है, जो सभी [खातों](/developers/docs/accounts/) को हैश द्वारा लिंक रखती है और जिसे ब्लॉकचेन पर संग्रहीत एकल रूट हैश तक घटाया जा सकता है।
+
+### लेनदेन {#transactions}
+
+लेनदेन खातों से क्रिप्टोग्राफ़िक रूप से हस्ताक्षरित निर्देश हैं। लेनदेन दो प्रकार के होते हैं: वे जिनके परिणामस्वरूप संदेश कॉल आती हैं और वे जिनके परिणामस्वरूप अनुबंध निर्माण होता है।
+
+अनुबंध बनाने के परिणामस्वरूप संकलित [स्मार्ट अनुबंध](/developers/docs/smart-contracts/anatomy/) बाइटकोड वाला एक नया अनुबंध खाता बनता है। जब भी कोई अन्य खाता उस अनुबंध पर संदेश कॉल करता है, तो वह अपने बाइटकोड को निष्पादित करता है।
+
+## EVM निर्देश {#evm-instructions}
+
+EVM 1024 आइटम की गहराई के साथ एक [स्टैक मशीन](https://wikipedia.org/wiki/Stack_machine) के रूप में निष्पादित होता है। प्रत्येक आइटम एक 256-बिट शब्द है, जिसे 256-बिट क्रिप्टोग्राफी (जैसे Keccak-256 हैश या secp256k1 हस्ताक्षर) के साथ उपयोग में आसानी के लिए चुना गया था।
+
+निष्पादन के दौरान, EVM एक क्षणिक _मेमोरी_ (वर्ड-एड्रेसेड बाइट ऐरे के रूप में) बनाए रखता है, जो लेन-देन के बीच बनी नहीं रहती है।
+
+### क्षणिक भंडारण
+
+क्षणिक भंडारण एक प्रति-लेनदेन कुंजी-मान स्टोर है जिसे `TSTORE` और `TLOAD` ऑपकोड के माध्यम से एक्सेस किया जाता है। यह एक ही लेन-देन के दौरान सभी आंतरिक कॉलों में बना रहता है लेकिन लेन-देन के अंत में साफ़ हो जाता है। मेमोरी के विपरीत, क्षणिक भंडारण को निष्पादन फ्रेम के बजाय EVM स्टेट के हिस्से के रूप में मॉडल किया गया है, फिर भी यह वैश्विक स्टेट के लिए प्रतिबद्ध नहीं है। क्षणिक भंडारण एक लेन-देन के दौरान आंतरिक कॉलों में गैस-कुशल अस्थायी स्टेट साझा करने में सक्षम बनाता है।
+
+### स्टोरेज
+
+अनुबंधों में एक मर्कल पैट्रीशिया _स्टोरेज_ ट्राई (एक वर्ड-एड्रेसेबल वर्ड ऐरे के रूप में) होता है, जो संबंधित खाते से जुड़ा होता है और वैश्विक स्टेट का हिस्सा होता है। यह स्थायी भंडारण क्षणिक भंडारण से भिन्न है, जो केवल एक ही लेन-देन की अवधि के लिए उपलब्ध है और खाते के स्थायी भंडारण ट्राई का हिस्सा नहीं बनता है।
+
+### ऑपकोड
+
+संकलित स्मार्ट अनुबंध बाइटकोड कई EVM [ऑपकोड](/developers/docs/evm/opcodes) के रूप में निष्पादित होता है, जो `XOR`, `AND`, `ADD`, `SUB`, आदि जैसे मानक स्टैक संचालन करते हैं। EVM कई ब्लॉकचेन-विशिष्ट स्टैक संचालन भी लागू करता है, जैसे `ADDRESS`, `BALANCE`, `BLOCKHASH`, आदि। ऑपकोड सेट में `TSTORE` और `TLOAD` भी शामिल हैं, जो क्षणिक भंडारण तक पहुँच प्रदान करते हैं।
+
+
+_आरेख [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf) से अनुकूलित हैं_
+
+## EVM कार्यान्वयन {#evm-implementations}
+
+EVM के सभी कार्यान्वयन को एथेरियम येलोपेपर में वर्णित विनिर्देश का पालन करना चाहिए।
+
+एथेरियम के दस साल के इतिहास में, EVM में कई संशोधन हुए हैं, और विभिन्न प्रोग्रामिंग भाषाओं में EVM के कई कार्यान्वयन हैं।
+
+[एथेरियम निष्पादन क्लाइंट्स](/developers/docs/nodes-and-clients/#execution-clients) में एक EVM कार्यान्वयन शामिल है। इसके अतिरिक्त, कई स्टैंडअलोन कार्यान्वयन हैं, जिनमें शामिल हैं:
+
+- [Py-EVM](https://github.com/ethereum/py-evm) - _Python_
+- [evmone](https://github.com/ethereum/evmone) - _C++_
+- [ethereumjs-vm](https://github.com/ethereumjs/ethereumjs-vm) - _JavaScript_
+- [revm](https://github.com/bluealloy/revm) - _Rust_
+
+## अतिरिक्त पठन {#further-reading}
+
+- [एथेरियम यलोपेपर](https://ethereum.github.io/yellowpaper/paper.pdf)
+- [जेलोपेपर उर्फ KEVM: K में EVM के शब्दार्थ](https://jellopaper.org/)
+- [द बेजपेपर](https://github.com/chronaeon/beigepaper)
+- [एथेरियम वर्चुअल मशीन ऑपकोड](https://www.ethervm.io/)
+- [एथेरियम वर्चुअल मशीन ऑपकोड इंटरैक्टिव रेफरेंस](https://www.evm.codes/)
+- [Solidity के डॉक्यूमेंटेशन में एक संक्षिप्त परिचय](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#index-6)
+- [मास्टरिंग एथेरियम - द एथेरियम वर्चुअल मशीन](https://github.com/ethereumbook/ethereumbook/blob/openedition/13evm.asciidoc)
+
+## संबंधित विषय {#related-topics}
+
+- [गैस](/developers/docs/gas/)
diff --git a/public/content/translations/hi/developers/docs/evm/opcodes/index.md b/public/content/translations/hi/developers/docs/evm/opcodes/index.md
new file mode 100644
index 00000000000..265a9436f6c
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/evm/opcodes/index.md
@@ -0,0 +1,177 @@
+---
+title: "EVM के लिए ओपकोड्स"
+description: "एथेरियम वर्चुअल मशीन के लिए सभी उपलब्ध ओपकोड्स की एक सूची।"
+lang: hi
+---
+
+## सारांश {#overview}
+
+यह [wolflo/evm-opcodes](https://github.com/wolflo/evm-opcodes) पर EVM संदर्भ पृष्ठ का एक अद्यतन संस्करण है।
+इसे [Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf), [Jello Paper](https://jellopaper.org/evm/), और [geth](https://github.com/ethereum/go-ethereum) कार्यान्वयन से भी लिया गया है।
+यह एक सुलभ संदर्भ होने का इरादा है, लेकिन यह विशेष रूप से कठोर नहीं है।
+यदि आप शुद्धता के बारे में निश्चित होना चाहते हैं और हर किनारे के मामले से अवगत होना चाहते हैं, तो जेलो पेपर या क्लाइंट कार्यान्वयन का उपयोग करना उचित है।
+
+एक इंटरैक्टिव संदर्भ खोज रहे हैं? [evm.codes](https://www.evm.codes/) देखें।
+
+गतिशील गैस लागत वाले संचालन के लिए, [gas.md](https://github.com/wolflo/evm-opcodes/blob/main/gas.md) देखें।
+
+💡 त्वरित टिप: पूरी लाइनें देखने के लिए, डेस्कटॉप पर क्षैतिज रूप से स्क्रॉल करने के लिए `[shift] + scroll` का उपयोग करें।
+
+| स्टैक | नाम | गैस | प्रारंभिक स्टैक | परिणामी स्टैक | Mem / स्टोरेज | नोट्स | |
+| :---: | :------------- | :---------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- |
+| 00 | STOP | 0 | | | | निष्पादन रोकें | |
+| 01 | ADD | 3 | `a, b` | `a + b` | | (u)int256 जोड़ मॉड्यूलो 2\*\*256 | |
+| 02 | MUL | 5 | `a, b` | `a * b` | | (u)int256 गुणा मॉड्यूलो 2\*\*256 | |
+| 03 | SUB | 3 | `a, b` | `a - b` | | (u)int256 घटाव मॉड्यूलो 2\*\*256 | |
+| 04 | DIV | 5 | `a, b` | `a // b` | | uint256 विभाजन | |
+| 05 | SDIV | 5 | `a, b` | `a // b` | | int256 विभाजन | |
+| 06 | MOD | 5 | `a, b` | `a % b` | | uint256 मापांक | |
+| 07 | SMOD | 5 | `a, b` | `a % b` | | int256 मापांक | |
+| 08 | ADDMOD | 8 | `a, b, N` | `(a + b) % N` | | (u)int256 जोड़ मॉड्यूलो N | |
+| 09 | MULMOD | 8 | `a, b, N` | `(a * b) % N` | | (u)int256 गुणा मॉड्यूलो N | |
+| 0A | EXP | [A1](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a1-exp) | `a, b` | `a ** b` | | uint256 घातांक मॉड्यूलो 2\*\*256 | |
+| 0B | SIGNEXTEND | 5 | `b, x` | `SIGNEXTEND(x, b)` | | `x` को `(b+1)` बाइट से 32 बाइट तक [साइन एक्सटेंड](https://wikipedia.org/wiki/Sign_extension) करें | |
+| 0C-0F | _अमान्य_ | | | | | | |
+| 10 | LT | 3 | `a, b` | `a < b` | | uint256 से कम | |
+| 11 | GT | 3 | `a, b` | `a > b` | | uint256 से अधिक | |
+| 12 | SLT | 3 | `a, b` | `a < b` | | int256 से कम | |
+| 13 | SGT | 3 | `a, b` | `a > b` | | int256 से अधिक | |
+| 14 | EQ | 3 | `a, b` | `a == b` | | (u)int256 समानता | |
+| 15 | ISZERO | 3 | `a` | `a == 0` | | (u)int256 iszero | |
+| 16 | AND | 3 | `a, b` | `a && b` | | बिटवाइज़ AND | |
+| 17 | OR | 3 | `a, b` | `a \\|\\| b` | | बिटवाइज़ OR | |
+| 18 | XOR | 3 | `a, b` | `a ^ b` | | बिटवाइज़ XOR | |
+| 19 | NOT | 3 | `a` | `~a` | | बिटवाइज़ NOT | |
+| 1A | BYTE | 3 | `i, x` | `(x >> (248 - i * 8)) && 0xFF` | | (u)int256 `x` का `i`-वाँ बाइट, बाईं ओर से | |
+| 1B | SHL | 3 | `shift, val` | `val << shift` | | शिफ्ट लेफ्ट | |
+| 1C | SHR | 3 | `shift, val` | `val >> shift` | | लॉजिकल शिफ्ट राइट | |
+| 1D | SAR | 3 | `shift, val` | `val >> shift` | | अरिथमैटिक शिफ्ट राइट | |
+| 1E-1F | _अमान्य_ | | | | | | |
+| 20 | KECCAK256 | [A2](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a2-sha3) | `ost, len` | `keccak256(mem[ost:ost+len-1])` | | keccak256 | |
+| 21-2F | _अमान्य_ | | | | | | |
+| 30 | ADDRESS | 2 | `.` | `address(this)` | | निष्पादित हो रहे अनुबंध का पता | |
+| 31 | BALANCE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `addr.balance` | | बैलेंस, wei में | |
+| 32 | ORIGIN | 2 | `.` | `tx.origin` | | tx शुरू करने वाला पता | |
+| 33 | CALLER | 2 | `.` | `msg.sender` | | msg प्रेषक का पता | |
+| 34 | CALLVALUE | 2 | `.` | `msg.value` | | msg मान, wei में | |
+| 35 | CALLDATALOAD | 3 | `idx` | `msg.data[idx:idx+32]` | | इंडेक्स `idx` पर msg डेटा से शब्द पढ़ें | |
+| 36 | CALLDATASIZE | 2 | `.` | `len(msg.data)` | | msg डेटा की लंबाई, बाइट्स में | |
+| 37 | CALLDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := msg.data[ost:ost+len-1] | msg डेटा कॉपी करें | |
+| 38 | CODESIZE | 2 | `.` | `len(this.code)` | | निष्पादित हो रहे अनुबंध के कोड की लंबाई, बाइट्स में | |
+| 39 | CODECOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | | mem[dstOst:dstOst+len-1] := this.code[ost:ost+len-1] | निष्पादित हो रहे अनुबंध का बाइटकोड कॉपी करें |
+| 3A | GASPRICE | 2 | `.` | `tx.gasprice` | | tx की गैस कीमत, प्रति यूनिट गैस wei में [\*\*](https://eips.ethereum.org/EIPS/eip-1559#gasprice) | |
+| 3B | EXTCODESIZE | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `len(addr.code)` | | addr पर कोड का आकार, बाइट्स में | |
+| 3C | EXTCODECOPY | [A4](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a4-extcodecopy) | `addr, dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := addr.code[ost:ost+len-1] | `addr` से कोड कॉपी करें | |
+| 3D | RETURNDATASIZE | 2 | `.` | `size` | | पिछली बाहरी कॉल से लौटे डेटा का आकार, बाइट्स में | |
+| 3E | RETURNDATACOPY | [A3](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a3-copy-operations) | `dstOst, ost, len` | `.` | mem[dstOst:dstOst+len-1] := returndata[ost:ost+len-1] | पिछली बाहरी कॉल से लौटाए गए डेटा को कॉपी करें | |
+| 3F | EXTCODEHASH | [A5](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a5-balance-extcodesize-extcodehash) | `addr` | `हैश` | | हैश = addr.exists ? keccak256(addr.code) : 0 | |
+| 40 | BLOCKHASH | 20 | `blockNum` | `blockHash(blockNum)` | | | |
+| 41 | COINBASE | 2 | `.` | `block.coinbase` | | वर्तमान ब्लोक के प्रस्तावक का पता | |
+| 42 | TIMESTAMP | 2 | `.` | `block.timestamp` | | वर्तमान ब्लॉक का टाइमस्टैम्प | |
+| 43 | NUMBER | 2 | `.` | `block.number` | | वर्तमान ब्लॉक की संख्या | |
+| 44 | PREVRANDAO | 2 | `.` | `randomness beacon` | | रैंडमनेस बीकन | |
+| 45 | GASLIMIT | 2 | `.` | `block.gaslimit` | | वर्तमान ब्लॉक की गैस सीमा | |
+| 46 | CHAINID | 2 | `.` | `chain_id` | | वर्तमान [चेन आईडी](https://eips.ethereum.org/EIPS/eip-155) को स्टैक पर पुश करें | |
+| 47 | SELFBALANCE | 5 | `.` | `address(this).balance` | | निष्पादित हो रहे अनुबंध का बैलेंस, wei में | |
+| 48 | BASEFEE | 2 | `.` | `block.basefee` | | वर्तमान ब्लॉक का आधार शुल्क | |
+| 49 | BLOBHASH | 3 | `idx` | `tx.blob_versioned_hashes[idx]` | | [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) | |
+| 4A | BLOBBASEFEE | 2 | `.` | `block.blobbasefee` | | वर्तमान ब्लॉक का ब्लॉब आधार शुल्क ([EIP-7516](https://eips.ethereum.org/EIPS/eip-7516)) | |
+| 4B-4F | _अमान्य_ | | | | | | |
+| 50 | POP | 2 | `_anon` | `.` | | स्टैक के ऊपर से आइटम हटाएं और उसे छोड़ दें | |
+| 51 | MLOAD | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost` | `mem[ost:ost+32]` | | ऑफ़सेट `ost` पर मेमोरी से शब्द पढ़ें | |
+| 52 | MSTORE | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost:ost+32] := val | मेमोरी में एक शब्द लिखें | |
+| 53 | MSTORE8 | 3[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, val` | `.` | mem[ost] := val && 0xFF | मेमोरी में एक बाइट लिखें | |
+| 54 | SLOAD | [A6](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a6-sload) | `key` | `storage[key]` | | भंडारण से शब्द पढ़ें | |
+| 55 | SSTORE | [A7](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a7-sstore) | `key, val` | `.` | storage[key] := val | भंडारण में शब्द लिखें | |
+| 56 | JUMP | 8 | `dst` | `.` | | `$pc := dst` यह चिह्नित करें कि `pc` केवल तभी असाइन किया जाता है जब `dst` एक वैध जंपडेस्ट हो | |
+| 57 | JUMPI | 10 | `dst, condition` | `.` | | `$pc := condition ?` `dst : $pc + 1` | |
+| 58 | PC | 2 | `.` | `$pc` | | प्रोग्राम काउंटर | |
+| 59 | MSIZE | 2 | `.` | `len(mem)` | | वर्तमान निष्पादन संदर्भ में मेमोरी का आकार, बाइट्स में | |
+| 5A | GAS | 2 | `.` | `gasRemaining` | | | |
+| 5B | JUMPDEST | 1 | | | वैध जंप गंतव्य को चिह्नित करें | एक वैध जंप गंतव्य, उदाहरण के लिए एक जंप गंतव्य जो पुश डेटा के अंदर नहीं है | |
+| 5C | TLOAD | 100 | `key` | `tstorage[key]` | | ट्रांजिएंट स्टोरेज से शब्द पढ़ें ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) | |
+| 5D | TSTORE | 100 | `key, val` | `.` | tstorage[key] := val | ट्रांजिएंट स्टोरेज में शब्द लिखें ([EIP-1153](https://eips.ethereum.org/EIPS/eip-1153)) | |
+| 5E | MCOPY | 3+3\*words+[A0](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `dstOst, ost, len` | `.` | mem[dstOst] := mem[ost:ost+len] | मेमोरी को एक क्षेत्र से दूसरे क्षेत्र में कॉपी करें ([EIP-5656](https://eips.ethereum.org/EIPS/eip-5656)) | |
+| 5F | PUSH0 | 2 | `.` | `uint8` | | स्थिर मान 0 को स्टैक पर पुश करें | |
+| 60 | PUSH1 | 3 | `.` | `uint8` | | 1-बाइट मान को स्टैक पर पुश करें | |
+| 61 | PUSH2 | 3 | `.` | `uint16` | | 2-बाइट मान को स्टैक पर पुश करें | |
+| 62 | PUSH3 | 3 | `.` | `uint24` | | 3-बाइट मान को स्टैक पर पुश करें | |
+| 63 | PUSH4 | 3 | `.` | `uint32` | | 4-बाइट मान को स्टैक पर पुश करें | |
+| 64 | PUSH5 | 3 | `.` | `uint40` | | 5-बाइट मान को स्टैक पर पुश करें | |
+| 65 | PUSH6 | 3 | `.` | `uint48` | | 6-बाइट मान को स्टैक पर पुश करें | |
+| 66 | PUSH7 | 3 | `.` | `uint56` | | 7-बाइट मान को स्टैक पर पुश करें | |
+| 67 | PUSH8 | 3 | `.` | `uint64` | | 8-बाइट मान को स्टैक पर पुश करें | |
+| 68 | PUSH9 | 3 | `.` | `uint72` | | 9-बाइट मान को स्टैक पर पुश करें | |
+| 69 | PUSH10 | 3 | `.` | `uint80` | | 10-बाइट मान को स्टैक पर पुश करें | |
+| 6A | PUSH11 | 3 | `.` | `uint88` | | 11-बाइट मान को स्टैक पर पुश करें | |
+| 6B | PUSH12 | 3 | `.` | `uint96` | | 12-बाइट मान को स्टैक पर पुश करें | |
+| 6C | PUSH13 | 3 | `.` | `uint104` | | 13-बाइट मान को स्टैक पर पुश करें | |
+| 6D | PUSH14 | 3 | `.` | `uint112` | | 14-बाइट मान को स्टैक पर पुश करें | |
+| 6E | PUSH15 | 3 | `.` | `uint120` | | 15-बाइट मान को स्टैक पर पुश करें | |
+| 6F | PUSH16 | 3 | `.` | `uint128` | | 16-बाइट मान को स्टैक पर पुश करें | |
+| 70 | PUSH17 | 3 | `.` | `uint136` | | 17-बाइट मान को स्टैक पर पुश करें | |
+| 71 | PUSH18 | 3 | `.` | `uint144` | | 18-बाइट मान को स्टैक पर पुश करें | |
+| 72 | PUSH19 | 3 | `.` | `uint152` | | 19-बाइट मान को स्टैक पर पुश करें | |
+| 73 | PUSH20 | 3 | `.` | `uint160` | | 20-बाइट मान को स्टैक पर पुश करें | |
+| 74 | PUSH21 | 3 | `.` | `uint168` | | 21-बाइट मान को स्टैक पर पुश करें | |
+| 75 | PUSH22 | 3 | `.` | `uint176` | | 22-बाइट मान को स्टैक पर पुश करें | |
+| 76 | PUSH23 | 3 | `.` | `uint184` | | 23-बाइट मान को स्टैक पर पुश करें | |
+| 77 | PUSH24 | 3 | `.` | `uint192` | | 24-बाइट मान को स्टैक पर पुश करें | |
+| 78 | PUSH25 | 3 | `.` | `uint200` | | 25-बाइट मान को स्टैक पर पुश करें | |
+| 79 | PUSH26 | 3 | `.` | `uint208` | | 26-बाइट मान को स्टैक पर पुश करें | |
+| 7A | PUSH27 | 3 | `.` | `uint216` | | 27-बाइट मान को स्टैक पर पुश करें | |
+| 7B | PUSH28 | 3 | `.` | `uint224` | | 28-बाइट मान को स्टैक पर पुश करें | |
+| 7C | PUSH29 | 3 | `.` | `uint232` | | 29-बाइट मान को स्टैक पर पुश करें | |
+| 7D | PUSH30 | 3 | `.` | `uint240` | | 30-बाइट मान को स्टैक पर पुश करें | |
+| 7E | PUSH31 | 3 | `.` | `uint248` | | 31-बाइट मान को स्टैक पर पुश करें | |
+| 7F | PUSH32 | 3 | `.` | `uint256` | | 32-बाइट मान को स्टैक पर पुश करें | |
+| 80 | DUP1 | 3 | `a` | `a, a` | | स्टैक पर पहले मान का क्लोन बनाएँ | |
+| 81 | DUP2 | 3 | `_, a` | `a, _, a` | | स्टैक पर दूसरे मान का क्लोन बनाएँ | |
+| 82 | DUP3 | 3 | `_, _, a` | `a, _, _, a` | | स्टैक पर तीसरे मान का क्लोन बनाएँ | |
+| 83 | DUP4 | 3 | `_, _, _, a` | `a, _, _, _, a` | | स्टैक पर चौथे मान का क्लोन बनाएँ | |
+| 84 | DUP5 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 5वें मान का क्लोन बनाएँ | |
+| 85 | DUP6 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 6वें मान का क्लोन बनाएँ | |
+| 86 | DUP7 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 7वें मान का क्लोन बनाएँ | |
+| 87 | DUP8 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 8वें मान का क्लोन बनाएँ | |
+| 88 | DUP9 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 9वें मान का क्लोन बनाएँ | |
+| 89 | DUP10 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 10वें मान का क्लोन बनाएँ | |
+| 8A | DUP11 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 11वें मान का क्लोन बनाएँ | |
+| 8B | DUP12 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 12वें मान का क्लोन बनाएँ | |
+| 8C | DUP13 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 13वें मान का क्लोन बनाएँ | |
+| 8D | DUP14 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 14वें मान का क्लोन बनाएँ | |
+| 8E | DUP15 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 15वें मान का क्लोन बनाएँ | |
+| 8F | DUP16 | 3 | `..., a` | `a, ..., a` | | स्टैक पर 16वें मान का क्लोन बनाएँ | |
+| 90 | SWAP1 | 3 | `a, b` | `b, a` | | | |
+| 91 | SWAP2 | 3 | `a, _, b` | `b, _, a` | | | |
+| 92 | SWAP3 | 3 | `a, _, _, b` | `b, _, _, a` | | | |
+| 93 | SWAP4 | 3 | `a, _, _, _, b` | `b, _, _, _, a` | | | |
+| 94 | SWAP5 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 95 | SWAP6 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 96 | SWAP7 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 97 | SWAP8 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 98 | SWAP9 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 99 | SWAP10 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9A | SWAP11 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9B | SWAP12 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9C | SWAP13 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9D | SWAP14 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9E | SWAP15 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| 9F | SWAP16 | 3 | `a, ..., b` | `b, ..., a` | | | |
+| A0 | LOG0 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len` | `.` | | LOG0(memory[ost:ost+len-1]) | |
+| A1 | LOG1 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0` | `.` | | LOG1(memory[ost:ost+len-1], topic0) | |
+| A2 | LOG2 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1` | `.` | | LOG2(memory[ost:ost+len-1], topic0, topic1) | |
+| A3 | LOG3 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2` | `.` | | LOG3(memory[ost:ost+len-1], topic0, topic1, topic2) | |
+| A4 | LOG4 | [A8](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a8-log-operations) | `ost, len, topic0, topic1, topic2, topic3` | `.` | | LOG4(memory[ost:ost+len-1], topic0, topic1, topic2, topic3) | |
+| A5-EF | _अमान्य_ | | | | | | |
+| F0 | CREATE | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len` | `addr` | | addr = keccak256(rlp([address(this), this.nonce])) | |
+| F1 | CALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | gas, addr, val, argOst, argLen, retOst, retLen | `success` | mem[retOst:retOst+retLen-1] := returndata | | |
+| F2 | CALLCODE | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, val, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] = returndata | DELEGATECALL के समान, लेकिन मूल msg.sender और msg.value का प्रचार नहीं करता है | |
+| F3 | RETURN | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | return mem[ost:ost+len-1] | |
+| F4 | DELEGATECALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] := returndata | | |
+| F5 | CREATE2 | [A9](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a9-create-operations) | `val, ost, len, salt` | `addr` | | addr = keccak256(0xff ++ address(this) ++ salt ++ keccak256(mem[ost:ost+len-1]))[12:] | |
+| F6-F9 | _अमान्य_ | | | | | | |
+| FA | STATICCALL | [AA](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-call-operations) | `gas, addr, argOst, argLen, retOst, retLen` | `success` | mem[retOst:retOst+retLen-1] := returndata | | |
+| FB-FC | _अमान्य_ | | | | | | |
+| FD | REVERT | 0[\*](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#a0-1-memory-expansion) | `ost, len` | `.` | | revert(mem[ost:ost+len-1]) | |
+| FE | INVALID | [AF](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#af-invalid) | | | नामित अमान्य ऑपकोड - [EIP-141](https://eips.ethereum.org/EIPS/eip-141) | | |
+| FF | SELFDESTRUCT | [AB](https://github.com/wolflo/evm-opcodes/blob/main/gas.md#ab-selfdestruct) | `addr` | `.` | | `addr` पर सभी ETH भेजता है; यदि उसी लेनदेन में निष्पादित किया जाता है जिसमें एक अनुबंध बनाया गया था, तो यह अनुबंध को नष्ट कर देता है | |
diff --git a/public/content/translations/hi/developers/docs/frameworks/index.md b/public/content/translations/hi/developers/docs/frameworks/index.md
new file mode 100644
index 00000000000..f2da0ec49fe
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/frameworks/index.md
@@ -0,0 +1,156 @@
+---
+title: "Dapp डेवलपमेंट फ़्रेमवर्क"
+description: "फ़्रेमवर्क के लाभों का अन्वेषण करें और उपलब्ध विकल्पों की तुलना करें।"
+lang: hi
+---
+
+## फ्रेमवर्क का परिचय {#introduction-to-frameworks}
+
+एक पूर्ण विकसित dapp बनाने की आवश्यकता है
+टैकनोलजी के विभिन्न टुकड़े। सॉफ्टवेयर फ़्रेमवर्क में कई आवश्यक शामिल हैं ताकि
+सुविधाओं या आसान प्लगइन सिस्टम प्रदान करने वाले टूल को चुनने के लिए जो आप चाहते हैं ।
+
+फ़्रेमवर्क बहुत सारी आउट-ऑफ़-द-बॉक्स कार्यक्षमता के साथ आते हैं,
+उदाहरण के लिए:
+
+- एक स्थानीय ब्लॉकचेन उदाहरण को स्पिन करने के लिए विशेष रूप से प्रदर्शित होता है।
+- आपके स्मार्ट अनुबंध को संकलित करने और परीक्षण करने के लिए उपयोगिताएँ।
+- अपने उपयोगकर्ता-उन्मुख एप्लिकेशन को एक ही प्रोजेक्ट/रिपॉजिटरी के भीतर बनाने
+ के लिए क्लाइंट डेवलपमेंट ऐड-ऑन।
+- Ethereum नेटवर्क से कनेक्ट करने और अनुबंधों को डिप्लॉय करने
+ के लिए कॉन्फ़िगरेशन, चाहे वह स्थानीय रूप से चल रहे इंस्टेंस के लिए हो, या Ethereum के
+ सार्वजनिक नेटवर्कों में से एक के लिए हो।
+- विकेंद्रीकृत ऐप वितरण - IPFS जैसे स्टोरेज
+ विकल्पों के साथ एकीकरण।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+फ्रेमवर्क में जाने से पहले, हम अनुशंसा करते हैं कि आप पहले हमारे [डैप्स](/developers/docs/dapps/) और [Ethereum स्टैक](/developers/docs/ethereum-stack/) का परिचय पढ़ें।
+
+## उपलब्ध फ्रेमवर्क {#available-frameworks}
+
+**Foundry** - **_Foundry, Ethereum एप्लिकेशन डेवलपमेंट के लिए एक अत्यंत तेज, पोर्टेबल और मॉड्यूलर टूलकिट है_**
+
+- [Foundry इंस्टॉल करें](https://book.getfoundry.sh/)
+- [Foundry बुक](https://book.getfoundry.sh/)
+- [टेलीग्राम पर Foundry कम्युनिटी चैट](https://t.me/foundry_support)
+- [Awesome Foundry](https://github.com/crisgarner/awesome-foundry)
+
+**Hardhat -** **_पेशेवरों के लिए Ethereum डेवलपमेंट वातावरण।_**
+
+- [hardhat.org](https://hardhat.org)
+- [GitHub](https://github.com/nomiclabs/hardhat)
+
+**Ape -** **_Pythonistas, डेटा साइंटिस्ट और सुरक्षा पेशेवरों के लिए स्मार्ट अनुबंध डेवलपमेंट टूल।_**
+
+- [प्रलेखन](https://docs.apeworx.io/ape/stable/)
+- [GitHub](https://github.com/ApeWorX/ape)
+
+**Web3j -** **_JVM पर ब्लॉकचेन एप्लिकेशन विकसित करने का एक प्लेटफॉर्म।_**
+
+- [होमपेज](https://www.web3labs.com/web3j-sdk)
+- [प्रलेखन](https://docs.web3j.io)
+- [GitHub](https://github.com/web3j/web3j)
+
+**ethers-kt -** **_EVM-आधारित ब्लॉकचेन के लिए एसिंक, उच्च-प्रदर्शन Kotlin/Java/Android लाइब्रेरी।_**
+
+- [GitHub](https://github.com/Kr1ptal/ethers-kt)
+- [उदाहरण](https://github.com/Kr1ptal/ethers-kt/tree/master/examples)
+- [Discord](https://discord.gg/rx35NzQGSb)
+
+**Create Eth App -** **_एक कमांड से Ethereum-संचालित ऐप्स बनाएँ। चुनने के लिए UI फ्रेमवर्क और DeFi टेम्प्लेट की एक विस्तृत पेशकश के साथ आता है।_**
+
+- [GitHub](https://github.com/paulrberg/create-eth-app)
+- [टेम्प्लेट्स](https://github.com/PaulRBerg/create-eth-app/tree/develop/templates)
+
+**Scaffold-Eth -** **_Ethers.js + Hardhat + वेब3 के लिए React कंपोनेंट और हुक: स्मार्ट अनुबंधों द्वारा संचालित विकेंद्रीकृत एप्लिकेशन बनाने के लिए आपको जो कुछ भी चाहिए।_**
+
+- [GitHub](https://github.com/scaffold-eth/scaffold-eth-2)
+
+**Tenderly -** **_वेब3 डेवलपमेंट प्लेटफॉर्म जो ब्लॉकचेन डेवलपर को स्मार्ट अनुबंध बनाने, टेस्ट करने, डीबग करने, मॉनिटर करने और संचालित करने और डैप UX को बेहतर बनाने में सक्षम बनाता है।_**
+
+- [वेबसाइट](https://tenderly.co/)
+- [प्रलेखन](https://docs.tenderly.co/)
+
+**The Graph -** **_ब्लॉकचेन डेटा को कुशलतापूर्वक क्वेरी करने के लिए The Graph।_**
+
+- [वेबसाइट](https://thegraph.com/)
+- [ट्यूटोरियल](/developers/tutorials/the-graph-fixing-web3-data-querying/)
+
+**Alchemy -** **_Ethereum डेवलपमेंट प्लेटफॉर्म।_**
+
+- [alchemy.com](https://www.alchemy.com/)
+- [GitHub](https://github.com/alchemyplatform)
+- [Discord](https://discord.com/invite/alchemyplatform)
+
+**NodeReal -** **_Ethereum डेवलपमेंट प्लेटफॉर्म।_**
+
+- [Nodereal.io](https://nodereal.io/)
+- [GitHub](https://github.com/node-real)
+- [Discord](https://discord.gg/V5k5gsuE)
+
+**thirdweb SDK -** **_हमारे शक्तिशाली SDKs और CLI का उपयोग करके अपने स्मार्ट अनुबंधों के साथ इंटरैक्ट कर सकने वाले वेब3 एप्लिकेशन बनाएँ।_**
+
+- [प्रलेखन](https://portal.thirdweb.com/sdk/)
+- [GitHub](https://github.com/thirdweb-dev/)
+
+**Chainstack -** **_वेब3 (Ethereum और अन्य) डेवलपमेंट प्लेटफॉर्म।_**
+
+- [chainstack.com](https://www.chainstack.com/)
+- [GitHub](https://github.com/chainstack)
+- [Discord](https://discord.gg/BSb5zfp9AT)
+
+**Crossmint -** **_एंटरप्राइज-ग्रेड वेब3 डेवलपमेंट प्लेटफॉर्म, जो आपको सभी प्रमुख EVM चेन्स (और अन्य) पर NFT एप्लिकेशन बनाने की अनुमति देता है।_**
+
+- [वेबसाइट](https://www.crossmint.com)
+- [प्रलेखन](https://docs.crossmint.com)
+- [Discord](https://discord.com/invite/crossmint)
+
+**Brownie -** **_Python-आधारित डेवलपमेंट वातावरण और टेस्टिंग फ्रेमवर्क।_**
+
+- [प्रलेखन](https://eth-brownie.readthedocs.io/en/latest/)
+- [GitHub](https://github.com/eth-brownie/brownie)
+- **Brownie का रखरखाव वर्तमान में नहीं किया जा रहा है**
+
+**OpenZeppelin SDK -** **_द अल्टीमेट स्मार्ट अनुबंध टूलकिट: आपको स्मार्ट अनुबंधों को डेवलप करने, कंपाइल करने, अपग्रेड करने, डिप्लॉय करने और उनके साथ इंटरैक्ट करने में मदद करने के लिए टूल का एक सूट।_**
+
+- [OpenZeppelin Defender SDK](https://docs.openzeppelin.com/defender/sdk)
+- [GitHub](https://github.com/OpenZeppelin/openzeppelin-sdk)
+- [कम्युनिटी फोरम](https://forum.openzeppelin.com/c/support/17)
+- **OpenZeppelin SDK का डेवलपमेंट समाप्त हो गया है**
+
+**Catapulta -** **_मल्टी-चेन स्मार्ट अनुबंध डिप्लॉयमेंट टूल, ब्लॉक एक्सप्लोरर में वेरिफ़िकेशन को स्वचालित करता है, डिप्लॉय किए गए स्मार्ट अनुबंधों का ट्रैक रखता है और डिप्लॉयमेंट रिपोर्ट शेयर करता है, Foundry और Hardhat प्रोजेक्ट्स के लिए प्लग-एंड-प्ले।_**
+
+- [वेबसाइट](https://catapulta.sh/)
+- [प्रलेखन](https://catapulta.sh/docs)
+- [Github](https://github.com/catapulta-sh)
+
+**GoldRush (Covalent द्वारा संचालित) -** **_GoldRush डेवलपर, विश्लेषकों और उद्यमों के लिए सबसे व्यापक ब्लॉकचेन डेटा API सुइट प्रदान करता है। चाहे आप DeFi डैशबोर्ड, एक वॉलेट, एक ट्रेडिंग बॉट, एक AI एजेंट या एक अनुपालन प्लेटफॉर्म बना रहे हों, डेटा API आपको आवश्यक ऑन-चेन डेटा के लिए तेज, सटीक और डेवलपर-अनुकूल एक्सेस प्रदान करते हैं_**
+
+- [वेबसाइट](https://goldrush.dev/)
+- [प्रलेखन](https://goldrush.dev/docs/chains/ethereum)
+- [GitHub](https://github.com/covalenthq)
+- [Discord](https://www.covalenthq.com/discord/)
+
+**Wake -** **_अनुबंधों के परीक्षण, फ़ज़िंग, परिनियोजन, भेद्यता स्कैनिंग और कोड नेविगेशन के लिए ऑल-इन-वन Python फ्रेमवर्क।_**
+
+- [होमपेज](https://getwake.io/)
+- [प्रलेखन](https://ackeeblockchain.com/wake/docs/latest/)
+- [GitHub](https://github.com/Ackee-Blockchain/wake)
+- [VS Code एक्सटेंशन](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity)
+
+**Veramo -** **_ओपन सोर्स, मॉड्यूलर और एग्नोस्टिक फ्रेमवर्क जो विकेंद्रीकृत एप्लिकेशन डेवलपर के लिए अपने एप्लिकेशन में विकेंद्रीकृत पहचान और सत्यापन योग्य क्रेडेंशियल बनाना आसान बनाता है।_**
+
+- [होमपेज](https://veramo.io/)
+- [प्रलेखन](https://veramo.io/docs/basics/introduction)
+- [GitHub](https://github.com/uport-project/veramo)
+- [Discord](https://discord.com/invite/FRRBdjemHV)
+- [NPM पैकेज](https://www.npmjs.com/package/@veramo/core)
+
+## आगे की रीडिंग {#further-reading}
+
+_क्या आप किसी सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की हो? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
+
+## संबंधित विषय {#related-topics}
+
+- [एक स्थानीय डेवलपमेंट परिवेश सेट करें](/developers/local-environment/)
diff --git a/public/content/translations/hi/developers/docs/gas/index.md b/public/content/translations/hi/developers/docs/gas/index.md
new file mode 100644
index 00000000000..c8fdc66444f
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/gas/index.md
@@ -0,0 +1,149 @@
+---
+title: "गैस और शुल्क"
+metaTitle: "एथेरियम गैस और शुल्क: तकनीकी अवलोकन"
+description: "एथेरियम गैस शुल्क, उनकी गणना कैसे की जाती है, और नेटवर्क सुरक्षा और लेनदेन प्रसंस्करण में उनकी भूमिका के बारे में जानें।"
+lang: hi
+---
+
+एथेरियम नेटवर्क के लिए गैस आवश्यक है। यह ईंधन है जो इसे संचालित करने की अनुमति देता है, उसी तरह जैसे कार को चलाने के लिए गैसोलीन की आवश्यकता होती है।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+इस पृष्ठ को बेहतर ढंग से समझने के लिए, हम आपको पहले [लेनदेन](/developers/docs/transactions/) और [EVM](/developers/docs/evm/) के बारे में पढ़ने की सलाह देते हैं।
+
+## गैस क्या है? {#what-is-gas}
+
+गैस उस इकाई को दर्शाता है जो एथेरियम नेटवर्क पर खास संचालन को निष्पादित करने के लिए आवश्यक कम्प्यूटेशनल कोशिशों की मात्रा को मापता है।
+
+चूंकि हर एथेरियम लेनदेन को निष्पादित करने के लिए कम्प्यूटेशनल संसाधनों की आवश्यकता होती है, इसलिए उन संसाधनों को यह सुनिश्चित करने के लिए भुगतान करना पड़ता है कि एथेरियम स्पैम के प्रति संवेदनशील नहीं है और हमेशा चलने वाले कम्प्यूटेशनल लूप में फंस नहीं सकता। गणना के लिए भुगतान गैस शुल्क के रूप में किया जाता है।
+
+गैस शुल्क **किसी ऑपरेशन को करने के लिए उपयोग की जाने वाली गैस की मात्रा है, जिसे प्रति यूनिट गैस की लागत से गुणा किया जाता है**। शुल्क का भुगतान इस बात की परवाह किए बिना किया जाता है कि लेनदेन सफल होता है या विफल होता है।
+
+\n_चित्र [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf) से अनुकूलित है_
+
+गैस शुल्क का भुगतान एथेरियम की मूल मुद्रा, ईथर (ETH) में करना होगा। गैस की कीमतें आमतौर पर ग्वेई में उद्धृत की जाती हैं, जो ETH का एक संप्रदाय है। हर ग्वेई एक ETH (0.000000001 ETH या 10-9 ETH) के एक अरबवें हिस्से के बराबर है।
+
+उदाहरण के लिए, यह कहने के बजाय कि आपकी गैस की कीमत 0.000000001 ईथर है, आप कह सकते हैं कि आपकी गैस की कीमत 1 ग्वेई है।
+
+'ग्वेई' शब्द 'giga-wei' का छोटा रूप है, जिसका अर्थ है 'बिलियन वेई'। एक ग्वेई एक अरब वेई के बराबर है। Wei स्वयं ([b-money](https://www.investopedia.com/terms/b/bmoney.asp) के निर्माता [Wei Dai](https://wikipedia.org/wiki/Wei_Dai) के नाम पर) ETH की सबसे छोटी इकाई है।
+
+## गैस शुल्क की गणना कैसे की जाती है? {#how-are-gas-fees-calculated}
+
+आप लेनदेन जमा करते समय गैस की मात्रा तय कर सकते हैं जिसका आप भुगतान करना चाहते हैं। एक निश्चित मात्रा में गैस का ऑफ़र देकर, आप अपने लेनदेन को अगले ब्लॉक में शामिल करने के लिए बोली लगा रहे हैं। अगर आप बहुत कम का ऑफ़र देते हैं, तो सत्यापनकर्ताओं को शामिल करने के लिए आपके लेनदेन को चुनने की संभावना कम होती है, जिसका अर्थ है कि आपका लेनदेन देर से निष्पादित हो सकता है या बिल्कुल नहीं। अगर आप बहुत अधिक का ऑफ़र देते हैं, तो आप कुछ ETH बर्बाद कर सकते हैं। तो, आप कैसे बता सकते हैं कि कितना भुगतान करना है?
+
+आपके द्वारा भुगतान की जाने वाली कुल गैस दो घटकों में विभाजित है: `आधार शुल्क` और `प्राथमिकता शुल्क` (टिप)।
+
+`आधार शुल्क` प्रोटोकॉल द्वारा निर्धारित किया जाता है—आपको अपने लेनदेन को वैध माने जाने के लिए कम से कम इस राशि का भुगतान करना होगा। `priority fee` एक टिप है जिसे आप अपने लेनदेन को सत्यापनकर्ताओं के लिए आकर्षक बनाने के लिए आधार शुल्क में जोड़ते हैं ताकि वे इसे अगले ब्लॉक में शामिल करने के लिए चुनें।
+
+एक लेनदेन जो केवल `आधार शुल्क` का भुगतान करता है वह तकनीकी रूप से मान्य है, लेकिन इसके शामिल होने की संभावना नहीं है, क्योंकि यह सत्यापनकर्ताओं को किसी अन्य लेनदेन के बजाय इसे चुनने के लिए कोई प्रोत्साहन प्रदान नहीं करता है। 'सही' `priority` शुल्क आपके लेनदेन भेजने के समय नेटवर्क उपयोग द्वारा निर्धारित किया जाता है—यदि बहुत अधिक मांग है तो आपको अपना `priority` शुल्क अधिक निर्धारित करना पड़ सकता है, लेकिन जब मांग कम होती है, तो आप कम भुगतान कर सकते हैं।
+
+उदाहरण के लिए, मान लें कि जॉर्डन को टेलर को 1 ETH का भुगतान करना है। एक ETH ट्रांसफ़र के लिए 21,000 यूनिट गैस की आवश्यकता होती है, और आधार शुल्क 10 ग्वेई है। जॉर्डन में 2 ग्वेई की टिप शामिल है।
+
+कुल शुल्क अब इसके बराबर होगा:
+
+`इस्तेमाल होने वाली गैस की इकाइयां * (आधार शुल्क + प्राथमिकता शुल्क)`
+
+जहां `आधार शुल्क` प्रोटोकॉल द्वारा निर्धारित एक मान है और `प्राथमिकता शुल्क` उपयोगकर्ता द्वारा सत्यापनकर्ता को टिप के रूप में निर्धारित एक मान है।
+
+उदा., `21,000 * (10 + 2) = 252,000 gwei` (0.000252 ETH).
+
+जब जॉर्डन पैसे भेजता है, तो जॉर्डन के खाते से 1.000252 ETH काट लिया जाएगा। टेलर को 1.0000 ETH का श्रेय दिया जाएगा। सत्यापनकर्ता को 0.000042 ETH की टिप प्राप्त होती है। 0.00021 ETH का `आधार शुल्क` बर्न कर दिया जाता है।
+
+### आधार शुल्क {#base-fee}
+
+प्रत्येक ब्लॉक में एक आधार शुल्क होता है जो आरक्षित मूल्य के रूप में काम करता है। किसी ब्लॉक में शामिल किए जाने के लिए पात्र होने के लिए प्रति गैस प्रस्तावित मूल्य कम से कम आधार शुल्क के बराबर होना चाहिए। आधार शुल्क की गणना वर्तमान ब्लॉक से स्वतंत्र रूप से की जाती है और इसके बजाय यह इसके पहले के ब्लॉकों द्वारा निर्धारित किया जाता है, जिससे उपयोगकर्ताओं के लिए लेनदेन शुल्क अधिक अनुमानित हो जाता है। जब ब्लॉक बनाया जाता है, तो यह **आधार शुल्क \"बर्न\" कर दिया जाता है**, इसे सर्कुलेशन से हटा दिया जाता है।
+
+आधार शुल्क की गणना एक सूत्र द्वारा की जाती है जो पिछले ब्लॉक के आकार (सभी लेनदेन के लिए उपयोग की जाने वाली गैस की मात्रा) की तुलना लक्ष्य आकार (गैस सीमा का आधा) से करता है। यदि लक्ष्य ब्लॉक आकार लक्ष्य से ऊपर या नीचे है, तो आधार शुल्क क्रमशः प्रति ब्लॉक अधिकतम 12.5% तक बढ़ेगा या घटेगा। यह घातीय बढ़ोतरी ब्लॉक आकार के लिए अनिश्चित काल तक उच्च रहने के लिए आर्थिक रूप से गैर-व्यवहार्य बनाती है।
+
+| ब्लॉक नंबर | शामिल गैस | शुल्क में बढ़ोतरी | वर्तमान आधार शुल्क |
+| ---------- | --------: | --------------------: | --------------------------: |
+| 1 | 18M | 0% | 100 ग्वेई |
+| 2 | 36M | 0% | 100 ग्वेई |
+| 3 | 36M | 12.5% | 112.5 ग्वेई |
+| 4 | 36M | 12.5% | 126.6 ग्वेई |
+| 5 | 36M | 12.5% | 142.4 ग्वेई |
+| 6 | 36M | 12.5% | 160.2 ग्वेई |
+| 7 | 36M | 12.5% | 180.2 ग्वेई |
+| 8 | 36M | 12.5% | 202.7 ग्वेई |
+
+ऊपर दी गई तालिका में, गैस सीमा के रूप में 36 मिलियन का उपयोग करके एक उदाहरण प्रदर्शित किया गया है। इस उदाहरण के बाद, ब्लॉक नंबर 9 पर एक लेनदेन बनाने के लिए, एक वॉलेट उपयोगकर्ता को निश्चितता के साथ बताएगा कि अगले ब्लॉक में जोड़ा जाने वाला **अधिकतम आधार शुल्क** `वर्तमान आधार शुल्क * 112.5%` या `202.7 gwei * 112.5% = 228.1 gwei` है।
+
+यह भी ध्यान रखना महत्वपूर्ण है कि यह संभावना नहीं है कि हम पूर्ण ब्लॉक के विस्तारित स्पाइक्स देखेंगे, क्योंकि जिस गति से आधार शुल्क एक पूरे ब्लॉक से पहले बढ़ता है।
+
+| ब्लॉक नंबर | शामिल गैस | शुल्क में बढ़ोतरी | वर्तमान आधार शुल्क |
+| --------------------------------------------------- | --------------------------------------------------: | --------------------: | --------------------------------------------------: |
+| 30 | 36M | 12.5% | 2705.6 ग्वेई |
+| ... | ... | 12.5% | ... |
+| 50 | 36M | 12.5% | 28531.3 ग्वेई |
+| ... | ... | 12.5% | ... |
+| 100 | 36M | 12.5% | 10302608.6 ग्वेई |
+
+### प्राथमिकता शुल्क (टिप्स) {#priority-fee}
+
+प्राथमिकता शुल्क (टिप) सत्यापनकर्ताओं को एक ब्लॉक में लेनदेन की संख्या को अधिकतम करने के लिए प्रोत्साहित करता है, जो केवल ब्लॉक गैस सीमा द्वारा विवश है। टिप्स के बिना, एक तर्कसंगत सत्यापनकर्ता किसी भी प्रत्यक्ष निष्पादन परत या सहमति परत दंड के बिना कम—या शून्य—लेनदेन शामिल कर सकता है, क्योंकि स्टेकिंग पुरस्कार इस बात से स्वतंत्र हैं कि एक ब्लॉक में कितने लेनदेन हैं। इसके अतिरिक्त, टिप्स उपयोगकर्ताओं को एक ही ब्लॉक के भीतर प्राथमिकता के लिए दूसरों से अधिक बोली लगाने की अनुमति देते हैं, जो प्रभावी रूप से तात्कालिकता का संकेत देता है।
+
+### अधिकतम शुल्क {#maxfee}
+
+नेटवर्क पर लेनदेन निष्पादित करने के लिए, उपयोगकर्ता एक अधिकतम सीमा तय कर सकते हैं जिसका वे अपने लेनदेन को निष्पादित करने के लिए भुगतान करने को तैयार हैं। इस वैकल्पिक पैरामीटर को `maxFeePerGas` के रूप में जाना जाता है। लेनदेन को निष्पादित करने के लिए, अधिकतम शुल्क आधार शुल्क और टिप के योग से अधिक होना चाहिए। लेनदेन प्रेषक को अधिकतम शुल्क और आधार शुल्क और टिप के योग के बीच का अंतर वापस कर दिया जाता है।
+
+### ब्लॉक का आकार {#block-size}
+
+प्रत्येक ब्लॉक का लक्ष्य आकार वर्तमान गैस सीमा का आधा होता है, लेकिन नेटवर्क की मांग के अनुसार ब्लॉकों का आकार बढ़ेगा या घटेगा, जब तक कि ब्लॉक सीमा (लक्ष्य ब्लॉक आकार का 2 गुना) तक नहीं पहुंच जाता। प्रोटोकॉल _tâtonnement_ की प्रक्रिया के माध्यम से लक्ष्य पर एक संतुलन औसत ब्लॉक आकार प्राप्त करता है। इसका मतलब है कि अगर ब्लॉक का आकार लक्ष्य ब्लॉक साइज़ से अधिक है, तो प्रोटोकॉल निम्नलिखित ब्लॉक के लिए आधार शुल्क बढ़ाएगा। इसी तरह, प्रोटोकॉल आधार शुल्क में तब कमी करेगा, जब ब्लॉक साइज़ लक्ष्य ब्लॉक आकार से कम हो।
+
+जिस राशि से आधार शुल्क समायोजित किया जाता है वह इस बात के समानुपाती होता है कि वर्तमान ब्लॉक साइज़ लक्ष्य से कितना दूर है। यह एक रैखिक गणना है जो एक खाली ब्लॉक के लिए -12.5% से, लक्ष्य आकार पर 0% से लेकर, गैस सीमा तक पहुंचने वाले ब्लॉक के लिए +12.5% तक है। सत्यापनकर्ता सिग्नलिंग के आधार पर, साथ ही नेटवर्क अपग्रेड के माध्यम से समय के साथ गैस की सीमा में उतार-चढ़ाव हो सकता है। आप [यहां समय के साथ गैस सीमा में होने वाले बदलावों को देख सकते हैं](https://eth.blockscout.com/stats/averageGasLimit?interval=threeMonths)।
+
+[ब्लॉकों पर अधिक जानकारी](/developers/docs/blocks/)
+
+### व्यवहार में गैस शुल्क की गणना {#calculating-fees-in-practice}
+
+आप स्पष्ट रूप से बता सकते हैं कि आप अपने लेनदेन को निष्पादित करने के लिए कितना भुगतान करने को तैयार हैं। हालांकि, ज़्यादातर वॉलेट प्रदाता अपने उपयोगकर्ताओं पर बोझ की मात्रा को कम करने के लिए स्वचालित रूप से एक सुझाए गए लेनदेन शुल्क (आधार शुल्क + अनुशंसित प्राथमिकता शुल्क) निर्धारित करेंगे।
+
+## गैस शुल्क क्यों मौजूद हैं? {#why-do-gas-fees-exist}
+
+संक्षेप में, गैस शुल्क एथेरियम नेटवर्क को सुरक्षित रखने में मदद करता है। नेटवर्क पर निष्पादित हर गणना के लिए शुल्क की आवश्यकता करके, हम खराब कर्ताओं को नेटवर्क को स्पैम करने से रोकते हैं। कोड में आकस्मिक या शत्रुतापूर्ण अनंत लूप या अन्य कम्प्यूटेशनल अपव्यय से बचने के लिए, हर लेनदेन को कोड निष्पादन के कितने कम्प्यूटेशनल चरणों का उपयोग करने की सीमा तय करने की आवश्यकता होती है। गणना की मूलभूत इकाई "गैस" है।
+
+हालांकि एक लेनदेन में एक सीमा शामिल होती है, लेनदेन में उपयोग नहीं की गई कोई भी गैस उपयोगकर्ता को वापस कर दी जाती है (उदा., `अधिकतम शुल्क - (आधार शुल्क + टिप)` वापस कर दिया जाता है)।
+
+\n_चित्र [Ethereum EVM illustrated](https://takenobu-hs.github.io/downloads/ethereum_evm_illustrated.pdf) से अनुकूलित है_
+
+## गैस की सीमा क्या है? {#what-is-gas-limit}
+
+गैस सीमा उस गैस की अधिकतम मात्रा को संदर्भित करती है जिसे आप लेनदेन पर उपभोग करने के इच्छुक हैं। [स्मार्ट अनुबंधों](/developers/docs/smart-contracts/) से जुड़े अधिक जटिल लेनदेन के लिए अधिक कम्प्यूटेशनल कार्य की आवश्यकता होती है, इसलिए उन्हें एक साधारण भुगतान की तुलना में उच्च गैस सीमा की आवश्यकता होती है। एक मानक ETH संबंधी ट्रांसफ़र के लिए 21,000 यूनिट गैस की गैस सीमा की आवश्यकता होती है।
+
+उदाहरण के लिए, अगर आप एक साधारण ETH संबंधी ट्रांसफ़र के लिए 50,000 की गैस सीमा रखते हैं, तो EVM 21,000 की खपत करेगा, और आपको शेष 29,000 वापस मिल जाएगा। हालांकि, यदि आप बहुत कम गैस निर्दिष्ट करते हैं, उदाहरण के लिए, एक साधारण ETH हस्तांतरण के लिए 20,000 की गैस सीमा, तो लेनदेन सत्यापन चरण के दौरान विफल हो जाएगा। इसे एक ब्लॉक में शामिल किए जाने से पहले अस्वीकार कर दिया जाएगा, और कोई गैस खर्च नहीं होगी। दूसरी ओर, यदि निष्पादन के दौरान एक लेनदेन में गैस खत्म हो जाती है (उदाहरण के लिए, एक स्मार्ट अनुबंध आधे रास्ते में ही सारी गैस का उपयोग कर लेता है), तो EVM किसी भी बदलाव को वापस कर देगा, लेकिन प्रदान की गई सभी गैस अभी भी किए गए काम के लिए खर्च की जाएगी।
+
+## गैस का शुल्क इतना अधिक क्यों हो सकता है? {#why-can-gas-fees-get-so-high}
+
+उच्च गैस शुल्क एथेरियम की लोकप्रियता के कारण हैं। अगर बहुत अधिक मांग है, तो उपयोगकर्ताओं को अन्य उपयोगकर्ताओं के लेनदेन को आज़माने और बाहर निकालने के लिए टिप की ज़्यादा राशि की पेशकश करनी चाहिए। एक उच्च टिप यह अधिक संभावना बना सकती है कि आपका लेनदेन अगले ब्लॉक में आ जाएगा। इसके अलावा, अधिक जटिल स्मार्ट कॉन्ट्रैक्ट ऐप अपने कार्यों का समर्थन करने के लिए बहुत सारे ऑपरेशन कर सकते हैं, जिससे वे बहुत अधिक गैस का उपभोग कर सकते हैं।
+
+## गैस लागत को कम करने की पहल {#initiatives-to-reduce-gas-costs}
+
+एथेरियम [स्केलेबिलिटी अपग्रेड](/roadmap/) को अंततः गैस शुल्क के कुछ मुद्दों का समाधान करना चाहिए, जो बदले में, प्लेटफॉर्म को प्रति सेकंड हजारों लेनदेन संसाधित करने और विश्व स्तर पर स्केल करने में सक्षम करेगा।
+
+लेयर 2 स्केलिंग गैस लागत, उपयोगकर्ता अनुभव और मापनीयता में सुधार करने के लिए एक प्राथमिक पहल है।
+
+[लेयर 2 स्केलिंग पर अधिक जानकारी](/developers/docs/scaling/#layer-2-scaling)
+
+## गैस शुल्क की निगरानी {#monitoring-gas-fees}
+
+अगर आप गैस की कीमतों की निगरानी करना चाहते हैं, तो आप अपने ETH को कम में भेज सकते हैं, आप कई अलग-अलग उपकरणों का उपयोग कर सकते हैं, जैसे:
+
+- [Etherscan](https://etherscan.io/gastracker) _लेनदेन गैस मूल्य अनुमानक_
+- [Blockscout](https://eth.blockscout.com/gas-tracker) _ओपन सोर्स लेनदेन गैस मूल्य अनुमानक_
+- [ETH Gas Tracker](https://www.ethgastracker.com/) _लेनदेन शुल्क कम करने और पैसे बचाने के लिए एथेरियम और L2 गैस की कीमतों की निगरानी और उन्हें ट्रैक करें_
+- [Blocknative ETH Gas Estimator](https://chrome.google.com/webstore/detail/blocknative-eth-gas-estim/ablbagjepecncofimgjmdpnhnfjiecfm) _गैस का अनुमान लगाने वाला Chrome एक्सटेंशन जो टाइप 0 लीगेसी लेनदेन और टाइप 2 EIP-1559 लेनदेन दोनों का समर्थन करता है।_
+- [Cryptoneur Gas Fees Calculator](https://www.cryptoneur.xyz/gas-fees-calculator) _Mainnet, Arbitrum, और Polygon पर विभिन्न प्रकार के लेनदेन के लिए अपनी स्थानीय मुद्रा में गैस शुल्क की गणना करें।_
+
+## संबंधित उपकरण {#related-tools}
+
+- [Blocknative's Gas Platform](https://www.blocknative.com/gas) _Blocknative के वैश्विक मेमपूल डेटा प्लेटफॉर्म द्वारा संचालित गैस अनुमान API_
+- [Gas Network](https://gas.network) ऑन-चेन गैस ऑरेकल। 35+ चेनों के लिए समर्थन।
+
+## आगे की रीडिंग {#further-reading}
+
+- [एथेरियम गैस की व्याख्या](https://defiprime.com/gas)
+- [आपके स्मार्ट अनुबंधों की गैस खपत को कम करना](https://medium.com/coinmonks/8-ways-of-reducing-the-gas-consumption-of-your-smart-contracts-9a506b339c0a)
+- [डेवलपर्स के लिए गैस अनुकूलन रणनीतियाँ](https://www.alchemy.com/overviews/solidity-gas-optimization)
+- [EIP-1559 दस्तावेज़](https://eips.ethereum.org/EIPS/eip-1559)।
+- [टिम बीको के EIP-1559 संसाधन](https://hackmd.io/@timbeiko/1559-resources)
+- [EIP-1559: तंत्र को मीम्स से अलग करना](https://web.archive.org/web/20241126205908/https://research.2077.xyz/eip-1559-separating-mechanisms-from-memes)
diff --git a/public/content/translations/hi/developers/docs/ides/index.md b/public/content/translations/hi/developers/docs/ides/index.md
new file mode 100644
index 00000000000..9432713435a
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/ides/index.md
@@ -0,0 +1,64 @@
+---
+title: "एकीकृत विकास वातावरण (IDE)"
+description: "रीमिक्स, VS कोड और लोकप्रिय प्लगइन्स सहित एथेरियम विकास के लिए वेब-आधारित और डेस्कटॉप IDEs के बारे में जानें।"
+lang: hi
+---
+
+जब एक [एकीकृत विकास वातावरण (IDE)](https://wikipedia.org/wiki/Integrated_development_environment) स्थापित करने की बात आती है, तो एथेरियम पर एप्लिकेशन प्रोग्रामिंग करना किसी भी अन्य सॉफ्टवेयर प्रोजेक्ट की प्रोग्रामिंग के समान है। चुनने के लिए कई विकल्प हैं, इसलिए दिन के अंत में, आईडीई या कोड संपादक चुनें जो आपकी प्राथमिकताओं के लिए सबसे उपयुक्त हो। सबसे अधिक संभावना है कि आपके एथेरियम विकास के लिए सबसे अच्छा आईडीई विकल्प आईडीई है जिसे आप पहले से ही पारंपरिक सॉफ्टवेयर विकास के लिए उपयोग करते हैं।
+
+## वेब-आधारित IDEs {#web-based-ides}
+
+यदि आप [एक स्थानीय विकास वातावरण स्थापित करने](/developers/local-environment/) से पहले कोड के साथ छेड़छाड़ करना चाहते हैं, तो ये वेब ऐप एथेरियम स्मार्ट अनुबंध विकास के लिए कस्टम-निर्मित हैं।
+
+**[Remix](https://remix.ethereum.org/)** - **_अंतर्निहित स्थैतिक विश्लेषण, और एक परीक्षण ब्लॉकचेन वर्चुअल मशीन के साथ वेब-आधारित IDE_**
+
+- [डॉक्स](https://remix-ide.readthedocs.io/en/latest/#)
+- [Gitter](https://gitter.im/ethereum/remix)
+
+**[ChainIDE](https://chainide.com/)** - **_एक क्लाउड-आधारित मल्टी-चेन IDE_**
+
+- [डॉक्स](https://chainide.gitbook.io/chainide-english-1/)
+- [सहायता फ़ोरम](https://forum.chainide.com/)
+
+**[Replit (Solidity Starter - Beta)](https://replit.com/@replit/Solidity-starter-beta)** - **_हॉट रीलोडिंग, त्रुटि जाँच और प्रथम श्रेणी के टेस्टनेट समर्थन के साथ एथेरियम के लिए एक अनुकूलन योग्य विकास वातावरण_**
+
+- [डॉक्स](https://docs.replit.com/)
+
+**[Tenderly Sandbox](https://sandbox.tenderly.co/)** - **_एक तेज़ प्रोटोटाइपिंग वातावरण जहाँ आप Solidity और JavaScript का उपयोग करके ब्राउज़र में स्मार्ट अनुबंध लिख, निष्पादित और डीबग कर सकते हैं_**
+
+**[EthFiddle](https://ethfiddle.com/)** - **_वेब-आधारित IDE जो आपको अपना स्मार्ट अनुबंध लिखने, संकलित करने और डीबग करने की सुविधा देता है_**
+
+- [Gitter](https://gitter.im/loomnetwork/ethfiddle)
+
+## डेस्कटॉप IDEs {#desktop-ides}
+
+अधिकांश स्थापित आईडीई ने एथेरियम विकास अनुभव को बढ़ाने के लिए प्लगइन्स का निर्माण किया है। कम से कम, वे [स्मार्ट अनुबंध भाषाओं](/developers/docs/smart-contracts/languages/) के लिए सिंटैक्स हाइलाइटिंग प्रदान करते हैं।
+
+**Visual Studio Code -** **_आधिकारिक एथेरियम समर्थन वाला पेशेवर क्रॉस-प्लेटफ़ॉर्म IDE_**
+
+- [Visual Studio Code](https://code.visualstudio.com/)
+- [कोड नमूने](https://github.com/Azure-Samples/blockchain/blob/master/blockchain-workbench/application-and-smart-contract-samples/readme.md)
+- [GitHub](https://github.com/microsoft/vscode)
+
+**JetBrains IDEs (IntelliJ IDEA, आदि)** -\*\* **_सॉफ्टवेयर डेवलपर्स और टीमों के लिए आवश्यक उपकरण_**
+
+- [JetBrains](https://www.jetbrains.com/)
+- [GitHub](https://github.com/JetBrains)
+- [IntelliJ Solidity](https://github.com/intellij-solidity/intellij-solidity/)
+
+**Remix Desktop -** **_अपने स्थानीय मशीन पर Remix IDE का अनुभव करें_**
+
+- [डाउनलोड करें](https://github.com/ethereum/remix-desktop/releases)
+- [GitHub](https://github.com/ethereum/remix-desktop)
+
+## प्लगइन्स और एक्सटेंशन {#plugins-extensions}
+
+- [solidity](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) - Visual Studio Code के लिए एथेरियम Solidity भाषा
+- [Solidity + Hardhat for VS Code](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity) - Hardhat टीम द्वारा Solidity और Hardhat समर्थन
+- [Prettier Solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) - prettier का उपयोग कर कोड फ़ॉर्मेटर
+
+## आगे की रीडिंग {#further-reading}
+
+- [एथेरियम IDEs](https://www.alchemy.com/list-of/web3-ides-on-ethereum) _- Alchemy की एथेरियम IDEs की सूची_
+
+_क्या आप किसी सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की हो? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
diff --git a/public/content/translations/hi/developers/docs/index.md b/public/content/translations/hi/developers/docs/index.md
new file mode 100644
index 00000000000..919c19f9e3e
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/index.md
@@ -0,0 +1,25 @@
+---
+title: "एथेरियम विकास प्रलेखन"
+description: "पेश है ethereum.org डेवलपर प्रलेखन।"
+lang: hi
+---
+
+यह दस्तावेज़ आपको एथेरियम के साथ निर्माण करने में मदद करने के लिए डिज़ाइन किया गया है। यह एथेरियम को एक अवधारणा के रूप में कवर करता है, एथेरियम टेक स्टैक की व्याख्या करता है, और अधिक जटिल अनुप्रयोगों और उपयोग के मामलों के लिए उन्नत विषयों को प्रलेखित करता है।
+
+यह एक ओपन-सोर्स सामुदायिक कोशिश है, इसलिए नए विषयों का सुझाव देने, नया कंटेंट जोड़ने और उदाहरण प्रदान करने के लिए स्वतंत्र महसूस करें जहां भी आपको लगता है कि यह सहायक हो सकता है। सभी प्रलेखन GitHub के माध्यम से संपादित किए जा सकते हैं – यदि आप अनिश्चित हैं कि कैसे, तो [इन निर्देशों का पालन करें](https://github.com/ethereum/ethereum-org-website/blob/dev/docs/editing-markdown.md)।
+
+## विकास मॉड्यूल {#development-modules}
+
+अगर यह एथेरियम के विकास में आपकी पहली कोशिश है, तो हम शुरुआत से शुरू करने और एक किताब की तरह अपना काम करने की सलाह देते हैं।
+
+### आधारभूत विषय {#foundational-topics}
+
+@:"
```
-## बूटनोड चलाएँ {#run-a-bootnode}
+## बूटनोड चलाएं {#run-a-bootnode}
-बूटनोड्स पूर्ण नोड्स हैं जो NAT ([नेटवर्क एड्रेस ट्रांसलेशन](https://www.geeksforgeeks.org/network-address-translation-nat/)) के पीछे नहीं होते हैं। प्रत्येक पूर्ण नोड बूटनोड के रूप में कार्य कर सकता है जब तक कि यह सार्वजनिक रूप से उपलब्ध हो।
+बूटनोड्स पूर्ण नोड होते हैं जो NAT ([नेटवर्क पता अनुवाद](https://www.geeksforgeeks.org/network-address-translation-nat/)) के पीछे नहीं होते हैं। प्रत्येक पूर्ण नोड बूटनोड के रूप में कार्य कर सकता है जब तक कि यह सार्वजनिक रूप से उपलब्ध हो।
-जब आप एक नोड शुरू करते हैं तो उसे आपके [ईनोड](/developers/docs/networking-layer/network-addresses/#enode) को लॉग करना चाहिए, जो एक सार्वजनिक पहचानकर्ता है जिसका उपयोग अन्य आपके नोड से कनेक्ट करने के लिए कर सकते हैं।
+जब आप एक नोड शुरू करते हैं तो उसे आपके [enode](/developers/docs/networking-layer/network-addresses/#enode) को लॉग करना चाहिए, जो एक सार्वजनिक पहचानकर्ता है जिसका उपयोग अन्य आपके नोड से कनेक्ट करने के लिए कर सकते हैं।
ईनोड आमतौर पर प्रत्येक पुनरारंभ पर पुनः उत्पन्न होता है, इसलिए अपने बूटनोड के लिए लगातार ईनोड उत्पन्न करने के तरीके पर अपने क्लाइंट के प्रलेखन को देखना सुनिश्चित करें।
एक अच्छा बूटनोड होने के लिए, साथियों की अधिकतम संख्या बढ़ाना एक अच्छा विचार है जो इससे जुड़ सकते हैं। कई साथियों के साथ बूटनोड चलाने से बैंडविड्थ की आवश्यकता में काफी वृद्धि होगी।
-## उपलब्ध बूटनोड {#available-bootnodes}
+## उपलब्ध बूटनोड्स {#available-bootnodes}
-गो-एथेरियम के भीतर बिल्टिन बूटनोड्स की एक सूची [यहां](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23) पाई जा सकती है। इन बूटनोड्स का रखरखाव Ethereum फाउंडेशन और गो-एथेरियम टीम द्वारा किया जाता है।
+go-ethereum के भीतर बिल्टइन बूटनोड्स की सूची [यहां](https://github.com/ethereum/go-ethereum/blob/master/params/bootnodes.go#L23) मिल सकती है। इन बूटनोड्स का रखरखाव Ethereum फाउंडेशन और गो-एथेरियम टीम द्वारा किया जाता है।
स्वयंसेवकों द्वारा बनाए गए बूटनोड्स की अन्य सूचियां उपलब्ध हैं। कृपया हमेशा कम से कम एक आधिकारिक बूटनोड शामिल करना सुनिश्चित करें, अन्यथा आप पर ग्रहण का हमला किया जा सकता है।
diff --git a/public/content/translations/hi/developers/docs/nodes-and-clients/client-diversity/index.md b/public/content/translations/hi/developers/docs/nodes-and-clients/client-diversity/index.md
index b209d51ab1d..2d41cfb8d39 100644
--- a/public/content/translations/hi/developers/docs/nodes-and-clients/client-diversity/index.md
+++ b/public/content/translations/hi/developers/docs/nodes-and-clients/client-diversity/index.md
@@ -1,15 +1,15 @@
---
-title: ग्राहक विविधता
-description: एथेरियम क्लाइंट विविधता के महत्व का एक उच्च स्तरीय स्पष्टीकरण।
+title: "ग्राहक विविधता"
+description: "एथेरियम क्लाइंट विविधता के महत्व का एक उच्च स्तरीय स्पष्टीकरण।"
lang: hi
sidebarDepth: 2
---
एथेरियम नोड का व्यवहार उसके द्वारा चलाए जाने वाले क्लाइंट सॉफ़्टवेयर द्वारा नियंत्रित किया जाता है। कई उत्पादन-स्तर के एथेरियम क्लाइंट हैं, प्रत्येक को अलग-अलग टीमों द्वारा विभिन्न भाषाओं में विकसित किया और बनाए रखा गया है। क्लाइंट को एक सामान्य विनिर्देश के लिए बनाया गया है जो यह सुनिश्चित करता है कि क्लाइंट एक-दूसरे के साथ निर्बाध रूप से संवाद करें और समान कार्यक्षमता रखें और एक समान उपयोगकर्ता अनुभव प्रदान करें। हालाँकि, फिलहाल नोड्स में क्लाइंट का वितरण इतना समान नहीं है कि इस नेटवर्क सुदृढ़ीकरण को इसकी पूरी क्षमता तक महसूस किया जा सके। आदर्श रूप से, यूज़र नेटवर्क में जितना संभव हो उतना क्लाइंट विविधता लाने के लिए विभिन्न क्लाइंट में लगभग समान रूप से विभाजित होते हैं।
-## आवश्यक शर्तें {#prerequisites}
+## पूर्वापेक्षाएं {#prerequisites}
-यदि आप पहले से ही नहीं समझते हैं कि नोड्स और क्लाइंट क्या हैं, तो [नोड्स और क्लाइंट](/developers/docs/nodes-and-clients/) देखें। [निष्पादन](/glossary/#execution-layer) और [आम सहमति](/glossary/#consensus-layer) परतों को शब्दावली में परिभाषित किया गया है।
+यदि आप पहले से नहीं समझते हैं कि नोड्स और क्लाइंट क्या हैं, तो [नोड्स और क्लाइंट](/developers/docs/nodes-and-clients/) देखें। [निष्पादन परत](/glossary/#execution-layer) और [सहमति परत](/glossary/#consensus-layer) को शब्दकोष में परिभाषित किया गया है।
## एक से अधिक क्लाइंट क्यों हैं? {#why-multiple-clients}
@@ -23,61 +23,82 @@ sidebarDepth: 2
एक व्यक्तिगत क्लाइंट में एक बग, एथेरियम नोड्स की कमी का प्रतिनिधित्व करते समय नेटवर्क के लिए जोखिम से कम होता है। कई क्लाइंट में नोड्स के लगभग समान वितरण के कारण, अधिकांश क्लाइंट के साझा मुद्दे से पीड़ित होने की संभावना कम होती है, और परिणामस्वरूप, नेटवर्क अधिक मजबूत होता है।
-### हमलों के लिए लचीलापन {#resilience}
+### हमलों के प्रति लचीलापन {#resilience}
-क्लाइंट विविधता भी हमलों के लिए लचीलापन प्रदान करती है। उदाहरण के लिए, एक हमला जो किसी [विशेष क्लाइंट](https://twitter.com/vdWijden/status/1437712249926393858) को श्रृंखला की किसी विशेष शाखा पर धोखा देता है, के सफल होने की संभावना नहीं होती क्योंकि अन्य क्लाइंट का उसी तरह से शोषण होने की संभावना नहीं होती और कैनोनिकल श्रृंखला अदूषित रहती है। कम क्लाइंट विविधता प्रमुख क्लाइंट पर हैक से जुड़े जोखिम को बढ़ाती है। क्लाइंट विविधता पहले से ही नेटवर्क पर दुर्भावनापूर्ण हमलों के खिलाफ एक महत्वपूर्ण बचाव साबित हुई है, उदाहरण के लिए 2016 में शंघाई सेवा अस्वीकार हमला संभव था क्योंकि हमलावर प्रमुख क्लाइंट (Geth) को धोखा देकर प्रति ब्लॉक हजारों बार धीमी डिस्क i/o ऑपरेशन निष्पादित कर सकते थे। क्योंकि वैकल्पिक क्लाइंट भी ऑनलाइन थे जो कमजोरी को साझा नहीं करते थे, एथेरियम हमले का विरोध करने में सक्षम था और Geth में कमजोरी तय होने के दौरान संचालन जारी रखता था।
+क्लाइंट विविधता भी हमलों के लिए लचीलापन प्रदान करती है। उदाहरण के लिए, कोई हमला जो [किसी विशेष क्लाइंट को धोखा देकर](https://twitter.com/vdWijden/status/1437712249926393858) चेन की किसी विशेष ब्रांच पर ले जाता है, उसके सफल होने की संभावना कम है क्योंकि अन्य क्लाइंट का उसी तरह से शोषण किए जाने की संभावना नहीं है और कैनोनिकल चेन अदूषित बनी रहती है। कम क्लाइंट विविधता प्रमुख क्लाइंट पर हैक से जुड़े जोखिम को बढ़ाती है। क्लाइंट विविधता पहले से ही नेटवर्क पर दुर्भावनापूर्ण हमलों के खिलाफ एक महत्वपूर्ण बचाव साबित हुई है, उदाहरण के लिए 2016 में शंघाई सेवा अस्वीकार हमला संभव था क्योंकि हमलावर प्रमुख क्लाइंट (Geth) को धोखा देकर प्रति ब्लॉक हजारों बार धीमी डिस्क i/o ऑपरेशन निष्पादित कर सकते थे। क्योंकि वैकल्पिक क्लाइंट भी ऑनलाइन थे जो कमजोरी को साझा नहीं करते थे, एथेरियम हमले का विरोध करने में सक्षम था और Geth में कमजोरी तय होने के दौरान संचालन जारी रखता था।
-### हिस्सेदारी का सबूत की अन्तिम स्थिति {#finality}
+### हिस्सेदारी के सबूत की अंतिम स्थिति {#finality}
33% से अधिक एथेरियम नोड्स के साथ सहमति क्लाइंट में एक बग सर्वसम्मति परत को अंतिम रूप देने से रोक सकता है, जिसका अर्थ है कि यूज़र भरोसा नहीं कर सकते हैं कि लेनदेन को किसी बिंदु पर वापस किया या बदला नहीं जाएगा। यह एथेरियम, विशेष रूप से DeFi के शीर्ष पर निर्मित कई ऐप्स के लिए बहुत समस्याग्रस्त होगा।
-
+
+डेल्फी प्रोग्रामिंग भाषा का उपयोग करके एथेरियम के लिए विकास करना सीखें
+
+
+
+विकेन्द्रीकृत अनुप्रयोगों (या "डैप्स") बनाने के लिए इथिरीयम का उपयोग करें जो क्रिप्टोक्यूरेंसी और ब्लॉकचैन तकनीक के लाभों का उपयोग करते हैं। ये डैप भरोसेमंद हो सकते हैं, जिसका अर्थ है कि एक बार इथिरीयम में तैनात होने के बाद, वे हमेशा प्रोग्राम किए गए अनुसार चलेंगे। नए प्रकार के वित्तीय अनुप्रयोग बनाने के लिए वे डिजिटल संपत्ति को नियंत्रित कर सकते हैं। उन्हें विकेंद्रीकृत किया जा सकता है, जिसका अर्थ है कि कोई एकल इकाई या व्यक्ति उन्हें नियंत्रित नहीं करता है और सेंसर के लिए लगभग असंभव है।
+
+एथेरियम पर विकेंद्रीकृत अनुप्रयोग बनाएं और डेल्फी प्रोग्रामिंग भाषा का उपयोग करके स्मार्ट कॉन्ट्रैक्ट्स के साथ इंटरैक्ट करें!
+
+## स्मार्ट कॉन्ट्रैक्ट्स और सॉलिडिटी भाषा के साथ आरंभ करें {#getting-started-with-smart-contracts-and-the-solidity-language}
+
+**डेल्फी को एथेरियम के साथ एकीकृत करने के अपने पहले कदम उठाएं**
+
+पहले एक और बुनियादी प्राइमर की आवश्यकता है? [ethereum.org/learn](/learn/) या [ethereum.org/developers](/developers/) देखें।
+
+- [ब्लॉकचेन समझाया गया](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [स्मार्ट अनुबंधों को समझना](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [अपना पहला स्मार्ट अनुबंध लिखें](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [सॉलिडिटी को कंपाइल और डिप्लॉय करना सीखें](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+
+## शुरुआती संदर्भ और लिंक {#beginner-references-and-links}
+
+**Delphereum लाइब्रेरी का परिचय**
+
+- [डेल्फीरियम क्या है?](https://github.com/svanas/delphereum/blob/master/README.md)
+- [डेल्फी को स्थानीय (इन-मेमोरी) ब्लॉकचेन से कनेक्ट करना](https://medium.com/@svanas/connecting-delphi-to-a-local-in-memory-blockchain-9a1512d6c5b0)
+- [डेल्फी को एथेरियम मेननेट से कनेक्ट करना](https://medium.com/@svanas/connecting-delphi-to-the-ethereum-main-net-5faf1feffd83)
+- [डेल्फी को स्मार्ट अनुबंधों से कनेक्ट करना](https://medium.com/@svanas/connecting-delphi-to-smart-contracts-3146b12803a1)
+
+**क्या आप अभी सेटअप छोड़ कर सीधे सैंपल्स पर जाना चाहते हैं?**
+
+- [3 मिनट का स्मार्ट अनुबंध और डेल्फी - भाग 1](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-61d998571d)
+- [3 मिनट का स्मार्ट अनुबंध और डेल्फी - भाग 2](https://medium.com/@svanas/a-3-minute-smart-contract-and-delphi-part-2-446925faa47b)
+
+## मध्यवर्ती लेख {#intermediate-articles}
+
+- [डेल्फी में एथेरियम-हस्ताक्षरित संदेश हस्ताक्षर उत्पन्न करना](https://medium.com/@svanas/generating-an-ethereum-signed-message-signature-in-delphi-75661ce5031b)
+- [डेल्फी के साथ ईथर ट्रांसफर करना](https://medium.com/@svanas/transferring-ether-with-delphi-b5f24b1a98a4)
+- [डेल्फी के साथ ERC-20 टोकन ट्रांसफर करना](https://medium.com/@svanas/transferring-erc-20-tokens-with-delphi-bb44c05b295d)
+
+## उन्नत उपयोग पैटर्न {#advanced-use-patterns}
+
+- [डेल्फी और एथेरियम नेम सर्विस (ENS)](https://medium.com/@svanas/delphi-and-ethereum-name-service-ens-4443cd278af7)
+- [क्विकनोड, एथेरियम और डेल्फी](https://medium.com/@svanas/quiknode-ethereum-and-delphi-f7bfc9671c23)
+- [डेल्फी और एथेरियम डार्क फ़ॉरेस्ट](https://svanas.medium.com/delphi-and-the-ethereum-dark-forest-5b430da3ad93)
+- [डेल्फी में एक टोकन को दूसरे से स्वैप करना](https://svanas.medium.com/swap-one-token-for-another-in-delphi-bcb999c47f7)
+
+अधिक संसाधनों की तलाश है? [ethereum.org/developers](/developers/) देखें।
diff --git a/public/content/translations/hi/developers/docs/programming-languages/dot-net/index.md b/public/content/translations/hi/developers/docs/programming-languages/dot-net/index.md
new file mode 100644
index 00000000000..b3e5960ebd0
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/dot-net/index.md
@@ -0,0 +1,86 @@
+---
+title: ".नेट डेवलपर्स के लिए इथिरीयम"
+description: ".नेट आधारित प्रोजैक्ट और टूलिंग का उपयोग करके इथिरीयम के लिए विकसित करना सीखें"
+lang: hi
+incomplete: true
+---
+
+.NET-आधारित परियोजनाओं और टूलिंग का उपयोग करके इथेरियम के लिए डेवलप करना सीखें
+
+विकेन्द्रीकृत अनुप्रयोगों (या "डैप्स") बनाने के लिए इथिरीयम का उपयोग करें जो क्रिप्टोक्यूरेंसी और ब्लॉकचैन तकनीक के लाभों का उपयोग करते हैं। ये डैप भरोसेमंद हो सकते हैं, जिसका अर्थ है कि एक बार इथिरीयम में तैनात होने के बाद, वे हमेशा प्रोग्राम किए गए अनुसार चलेंगे। नए प्रकार के वित्तीय अनुप्रयोग बनाने के लिए वे डिजिटल संपत्ति को नियंत्रित कर सकते हैं। उन्हें विकेंद्रीकृत किया जा सकता है, जिसका अर्थ है कि कोई एकल इकाई या व्यक्ति उन्हें नियंत्रित नहीं करता है और सेंसर के लिए लगभग असंभव है।
+
+इथिरीयम के शीर्ष पर विकेन्द्रीकृत अनुप्रयोगों का निर्माण करें और माइक्रोसॉफ्ट टैकनोलजी स्टैक से टूल और भाषाओं का उपयोग करते हुए स्मार्ट अनुबंधों के साथ बातचीत करें - .NET फ्रेमवर्क / .NET कोर के पार VSCode और विज़ुअल स्टूडियो जैसे टूलिंग पर C #, # Visual Basic .NET, F # का समर्थन करें। / .NET मानक। मिनट में माइक्रोसॉफ्ट Azure ब्लॉकचेन का उपयोग करके एज़्योर पर एक इथिरीयम ब्लॉकचेन तैनात करें। .नेट के प्यार को इथिरीयम में लाओ!
+
+## स्मार्ट कॉन्ट्रैक्ट्स और सॉलिडिटी भाषा के साथ आरंभ करें {#getting-started-with-smart-contracts-and-the-solidity-language}
+
+**.NET को इथेरियम के साथ एकीकृत करने के लिए अपने पहले कदम उठाएँ**
+
+पहले एक और बुनियादी प्राइमर की आवश्यकता है? [ethereum.org/learn](/learn/) या [ethereum.org/developers](/developers/) देखें।
+
+- [ब्लॉकचेन समझाया गया](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [स्मार्ट अनुबंधों को समझना](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [अपना पहला स्मार्ट अनुबंध लिखें](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [सॉलिडिटी को कंपाइल और डिप्लॉय करना सीखें](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+
+## शुरुआती संदर्भ और लिंक {#beginner-references-and-links}
+
+**Nethereum लाइब्रेरी और VS कोड सॉलिडिटी का परिचय**
+
+- [Nethereum, आरंभ करें](https://docs.nethereum.com/en/latest/getting-started/)
+- [VS कोड सॉलिडिटी इंस्टॉल करना](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity)
+- [इथेरियम स्मार्ट कॉन्ट्रैक्ट्स बनाने और कॉल करने के लिए एक .NET डेवलपर का वर्कफ़्लो](https://medium.com/coinmonks/a-net-developers-workflow-for-creating-and-calling-ethereum-smart-contracts-44714f191db2)
+- [Nethereum के साथ स्मार्ट कॉन्ट्रैक्ट्स का एकीकरण](https://kauri.io/#collections/Getting%20Started/smart-contracts-integration-with-nethereum/#smart-contracts-integration-with-nethereumm)
+- [Nethereum के साथ .NET और इथेरियम ब्लॉकचेन स्मार्ट कॉन्ट्रैक्ट्स को इंटरफेस करना](https://medium.com/my-blockchain-development-daily-journey/interfacing-net-and-ethereum-blockchain-smart-contracts-with-nethereum-2fa3729ac933), [中文版](https://medium.com/my-blockchain-development-daily-journey/%E4%BD%BF%E7%94%A8nethereum%E9%80%A3%E6%8E%A5-net%E5%92%8C%E4%BB%A5%E5%A4%AA%E7%B6%B2%E5%8D%80%E5%A1%8A%E9%8F%88%E6%99%BA%E8%83%BD%E5%90%88%E7%B4%84-4a96d35ad1e1) में भी
+- [Nethereum - ब्लॉकचेन के लिए एक ओपन-सोर्स .NET इंटीग्रेशन लाइब्रेरी](https://kauri.io/#collections/a%20hackathon%20survival%20guide/nethereum-an-open-source-.net-integration-library/)
+- [Nethereum का उपयोग करके SQL डेटाबेस में इथेरियम लेनदेन लिखना](https://medium.com/coinmonks/writing-ethereum-transactions-to-sql-database-using-nethereum-fd94e0e4fa36)
+- [देखें कि C# और VisualStudio का उपयोग करके इथेरियम स्मार्ट कॉन्ट्रैक्ट्स को आसानी से कैसे डिप्लॉय किया जाए](https://koukia.ca/deploy-ethereum-smart-contracts-using-c-and-visualstudio-5be188ae928c)
+
+**क्या आप अभी सेटअप छोड़ कर सीधे सैंपल्स पर जाना चाहते हैं?**
+
+- [Playground](http://playground.nethereum.com/) - इथेरियम के साथ इंटरैक्ट करें और ब्राउज़र के माध्यम से Nethereum का उपयोग करना सीखें।
+ - खाता बैलेंस की पूछताछ करें [C#](http://playground.nethereum.com/csharp/id/1001) [VB.NET](http://playground.nethereum.com/vb/id/2001)
+ - ERC20 स्मार्ट कॉन्ट्रैक्ट बैलेंस की पूछताछ करें [C#](http://playground.nethereum.com/csharp/id/1005) [VB.NET](http://playground.nethereum.com/vb/id/2004)
+ - किसी खाते में ईथर ट्रांसफर करें [C#](http://playground.nethereum.com/csharp/id/1003) [VB.NET](http://playground.nethereum.com/vb/id/2003)
+ - ... और अधिक!
+
+## मध्यवर्ती लेख {#intermediate-articles}
+
+- [Nethereum वर्कबुक/सैंपल सूची](http://docs.nethereum.com/en/latest/Nethereum.Workbooks/docs/)
+- [अपने खुद के डेवलपमेंट टेस्टचेन डिप्लॉय करें](https://github.com/Nethereum/TestChains)
+- [सॉलिडिटी के लिए VSCode Codegen प्लगइन](https://docs.nethereum.com/en/latest/nethereum-codegen-vscodesolidity/)
+- [यूनिटी और इथेरियम: क्यों और कैसे](https://www.raywenderlich.com/5509-unity-and-ethereum-why-and-how)
+- [इथेरियम डैप्स के लिए ASP.NET कोर वेब API बनाएँ](https://tech-mint.com/blockchain/create-asp-net-core-web-api-for-ethereum-dapps/)
+- [सप्लाई चेन ट्रैकिंग सिस्टम को लागू करने के लिए Nethereum Web3 का उपयोग करना](http://blog.pomiager.com/post/using-nethereum-web3-to-implement-a-supply-chain-traking-system4)
+- [Nethereum ब्लॉक प्रोसेसिंग](https://nethereum.readthedocs.io/en/latest/nethereum-block-processing-detail/), [C# Playground सैंपल](http://playground.nethereum.com/csharp/id/1025) के साथ
+- [Nethereum Websocket स्ट्रीमिंग](https://nethereum.readthedocs.io/en/latest/nethereum-subscriptions-streaming/)
+- [Kaleido और Nethereum](https://kaleido.io/kaleido-and-nethereum/)
+- [Quorum और Nethereum](https://github.com/Nethereum/Nethereum/blob/master/src/Nethereum.Quorum/README.md)
+
+## उन्नत उपयोग पैटर्न {#advanced-use-patterns}
+
+- [Azure Key Vault और Nethereum](https://github.com/Azure-Samples/bc-community-samples/tree/master/akv-nethereum)
+- [Nethereum.DappHybrid](https://github.com/Nethereum/Nethereum.DappHybrid)
+- [Ujo Nethereum बैकएंड रेफरेंस आर्किटेक्चर](https://docs.nethereum.com/en/latest/nethereum-ujo-backend-sample/)
+
+## .NET प्रोजेक्ट्स, टूल्स और अन्य मजेदार चीज़ें {#dot-net-projects-tools-and-other-fun-stuff}
+
+- [Nethereum Playground](http://playground.nethereum.com/) - _ब्राउज़र में Nethereum कोड स्निपेट को संकलित करें, बनाएं और चलाएँ_
+- [Nethereum Codegen Blazor](https://github.com/Nethereum/Nethereum.CodeGen.Blazor) - _Blazor में UI के साथ Nethereum कोडजेन_
+- [Nethereum Blazor](https://github.com/Nethereum/NethereumBlazor) - _एक .NET Wasm SPA लाइट ब्लॉकचेन एक्सप्लोरर और सरल वॉलेट_
+- [Wonka बिजनेस रूल्स इंजन](https://docs.nethereum.com/en/latest/wonka/) - _एक बिजनेस रूल्स इंजन (.NET प्लेटफ़ॉर्म और इथेरियम प्लेटफ़ॉर्म दोनों के लिए) जो स्वाभाविक रूप से मेटाडेटा-चालित है_
+- [Nethermind](https://github.com/NethermindEth/nethermind) - _Linux, Windows, MacOS के लिए एक .NET कोर इथेरियम क्लाइंट_
+- [eth-utils](https://github.com/ethereum/eth-utils/) - _इथेरियम संबंधित कोडबेस के साथ काम करने के लिए उपयोगिता फ़ंक्शन_
+- [TestChains](https://github.com/Nethereum/TestChains) - _तेज प्रतिक्रिया (PoA) के लिए पहले से कॉन्फ़िगर किए गए .NET डेवचेन_
+
+अधिक संसाधनों की तलाश है? [ethereum.org/developers](/developers/) देखें।
+
+## .NET समुदाय के योगदानकर्ता {#dot-net-community-contributors}
+
+Nethereum में, हम अधिकतर [Gitter](https://gitter.im/Nethereum/Nethereum) पर समय बिताते हैं, जहां प्रश्न पूछने/उत्तर देने, सहायता प्राप्त करने, या बस आराम करने के लिए सभी का स्वागत है। [Nethereum GitHub रिपॉजिटरी](https://github.com/Nethereum) पर बेझिझक PR करें या कोई समस्या खोलें, या बस हमारे कई साइड/सैंपल प्रोजेक्ट्स को ब्राउज़ करें। आप हमें [Discord](https://discord.gg/jQPrR58FxX) पर भी ढूँढ़ सकते हैं!
+
+यदि आप Nethermind में नए हैं और आरंभ करने में सहायता की आवश्यकता है, तो हमारे [Discord](http://discord.gg/PaCMRFdvWT) से जुड़ें। हमारे डेवलपर्स आपके सवालों के जवाब देने के लिए हाथ पर हैं। [Nethermind GitHub रिपॉजिटरी](https://github.com/NethermindEth/nethermind) पर PR खोलने या कोई भी समस्या उठाने में संकोच न करें।
+
+## अन्य एकत्रित सूचियाँ {#other-aggregated-lists}
+
+[आधिकारिक Nethereum साइट](https://nethereum.com/)
+[आधिकारिक Nethermind साइट](https://nethermind.io/)
diff --git a/public/content/translations/hi/developers/docs/programming-languages/elixir/index.md b/public/content/translations/hi/developers/docs/programming-languages/elixir/index.md
new file mode 100644
index 00000000000..82975056855
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/elixir/index.md
@@ -0,0 +1,55 @@
+---
+title: "Elixir डेवलपर्स के लिए Ethereum"
+description: "Elixir-आधारित परियोजनाओं और टूलिंग का उपयोग करके Ethereum के लिए विकसित करना सीखें।"
+lang: hi
+incomplete: false
+---
+
+Elixir-आधारित परियोजनाओं और टूलिंग का उपयोग करके Ethereum के लिए विकसित करना सीखें।
+
+विकेन्द्रीकृत अनुप्रयोगों (या "डैप्स") बनाने के लिए इथिरीयम का उपयोग करें जो क्रिप्टोक्यूरेंसी और ब्लॉकचैन तकनीक के लाभों का उपयोग करते हैं। ये डैप्स भरोसेमंद हो सकते हैं, जिसका अर्थ है कि एक बार जब वे एथेरियम में तैनात हो जाते हैं, तो वे हमेशा प्रोग्राम किए गए अनुसार चलेंगे। वे नए प्रकार के वित्तीय अनुप्रयोग बनाने के लिए डिजिटल संपत्ति को नियंत्रित कर सकते हैं। उन्हें विकेंद्रीकृत किया जा सकता है, जिसका अर्थ है कि कोई एकल इकाई या व्यक्ति उन्हें नियंत्रित नहीं करता है और सेंसर के लिए लगभग असंभव है।
+
+## स्मार्ट अनुबंधों और सॉलिडिटी भाषा के साथ आरंभ करना {#getting-started-with-smart-contracts-and-solidity}
+
+**Elixir को Ethereum के साथ एकीकृत करने के लिए अपने पहले कदम उठाएँ**
+
+पहले एक और बुनियादी प्राइमर की आवश्यकता है? [ethereum.org/learn](/learn/) या [ethereum.org/developers](/developers/) देखें।
+
+- [ब्लॉकचेन समझाया गया](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [स्मार्ट अनुबंधों को समझना](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [अपना पहला स्मार्ट अनुबंध लिखें](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [सॉलिडिटी को कंपाइल और डिप्लॉय करना सीखें](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+
+## शुरुआती लेख {#beginner-articles}
+
+- [Ethereum खातों को आखिरकार समझना](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
+- [Ethers — Elixir के लिए एक प्रथम श्रेणी की Ethereum Web3 लाइब्रेरी](https://medium.com/@alisinabh/announcing-ethers-a-first-class-ethereum-web3-library-for-elixir-1d64e9409122)
+
+## मध्यवर्ती लेख {#intermediate-articles}
+
+- [Elixir के साथ रॉ Ethereum अनुबंध लेनदेन पर हस्ताक्षर कैसे करें](https://kohlerjp.medium.com/how-to-sign-raw-ethereum-contract-transactions-with-elixir-f8822bcc813b)
+- [Ethereum स्मार्ट अनुबंध और Elixir](https://medium.com/agile-alpha/ethereum-smart-contracts-and-elixir-c7c4b239ddb4)
+
+## Elixir परियोजनाएँ और उपकरण {#elixir-projects-and-tools}
+
+### सक्रिय {#active}
+
+- [block_keys](https://github.com/ExWeb3/block_keys) - _Elixir में BIP32 और BIP44 कार्यान्वयन (डिटर्मिनिस्टिक वॉलेट्स के लिए मल्टी-अकाउंट पदानुक्रम)_
+- [ethereumex](https://github.com/mana-ethereum/ethereumex) - _Ethereum ब्लॉकचेन के लिए Elixir JSON-RPC क्लाइंट_
+- [ethers](https://github.com/ExWeb3/elixir_ethers) - _Elixir का उपयोग करके Ethereum पर स्मार्ट अनुबंधों के साथ इंटरैक्ट करने के लिए एक व्यापक Web3 लाइब्रेरी_
+- [ethers_kms](https://github.com/ExWeb3/elixir_ethers_kms) - _Ethers के लिए एक KMS साइनर लाइब्रेरी (AWS KMS के साथ लेनदेन पर हस्ताक्षर करें)_
+- [ex_abi](https://github.com/poanetwork/ex_abi) - _Elixir में Ethereum ABI पार्सर/डिकोडर/एनकोडर कार्यान्वयन_
+- [ex_keccak](https://github.com/ExWeb3/ex_keccak) - _एक NIF निर्मित tiny-keccak Rust क्रेट का उपयोग करके Keccak SHA3-256 हैश की गणना के लिए Elixir लाइब्रेरी_
+- [ex_rlp](https://github.com/mana-ethereum/ex_rlp) - _Ethereum के RLP (रिकर्सिव लेंथ प्रीफ़िक्स) एन्कोडिंग का Elixir कार्यान्वयन_
+
+### संग्रहीत / अब रखरखाव नहीं किया जाता {#archived--no-longer-maintained}
+
+- [eth](https://hex.pm/packages/eth) - _Elixir के लिए Ethereum यूटिलिटीज_
+- [exw3](https://github.com/hswick/exw3) - _Elixir के लिए उच्च-स्तरीय Ethereum RPC क्लाइंट_
+- [mana](https://github.com/mana-ethereum/mana) - _Elixir में लिखा गया Ethereum फुल नोड कार्यान्वयन_
+
+अधिक संसाधनों की तलाश है? हमारे [डेवलपर का होम पेज](/developers/) देखें।
+
+## Elixir समुदाय के योगदानकर्ता {#elixir-community-contributors}
+
+[Elixir का स्लैक #ethereum चैनल](https://elixir-lang.slack.com/archives/C5RPZ3RJL) एक तेजी से बढ़ते समुदाय का मेजबान है और उपरोक्त किसी भी परियोजना और संबंधित विषयों पर चर्चा के लिए समर्पित संसाधन है।
diff --git a/public/content/translations/hi/developers/docs/programming-languages/golang/index.md b/public/content/translations/hi/developers/docs/programming-languages/golang/index.md
new file mode 100644
index 00000000000..63b111ca90c
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/golang/index.md
@@ -0,0 +1,84 @@
+---
+title: "गो डेवलपर्स के लिए इथिरीयम"
+description: "गो-आधारित परियोजनाओं और टूलींग का उपयोग करके एथेरियम के लिए विकसित करना सीखें"
+lang: hi
+incomplete: true
+---
+
+Go-आधारित परियोजनाओं और टूलिंग का उपयोग करके Ethereum के लिए विकसित करना सीखें
+
+एथेरियम का उपयोग करके विकेंद्रीकृत अनुप्रयोग (या "dapps") बनाएं। ये डैप भरोसेमंद हो सकते हैं, जिसका अर्थ है कि एक बार इथिरीयम में तैनात होने के बाद, वे हमेशा प्रोग्राम किए गए अनुसार चलेंगे। वे विकेंद्रीकृत होते हैं, जिसका अर्थ है कि वे पीयर-टू-पीयर नेटवर्क पर चलते हैं और इसमें किसी एकल विफलता बिंदु का जोखिम नहीं होता है। कोई एकल इकाई या व्यक्ति इन्हें नियंत्रित नहीं करता है, और इन्हें सेंसर करना लगभग असंभव है। वे डिजिटल संपत्तियों को नियंत्रित कर सकते हैं ताकि नए प्रकार के अनुप्रयोग बनाए जा सकें।
+
+## स्मार्ट अनुबंधों और सॉलिडिटी भाषा के साथ आरंभ करना {#getting-started-with-smart-contracts-and-solidity}
+
+**Go को Ethereum के साथ एकीकृत करने के लिए अपने पहले कदम उठाएँ**
+
+पहले एक और बुनियादी प्राइमर की आवश्यकता है? [ethereum.org/learn](/learn/) या [ethereum.org/developers](/developers/) देखें।
+
+- [ब्लॉकचेन समझाया गया](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [स्मार्ट अनुबंधों को समझना](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [अपना पहला स्मार्ट अनुबंध लिखें](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [सॉलिडिटी को कंपाइल और डिप्लॉय करना सीखें](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [अनुबंध ट्यूटोरियल](https://github.com/ethereum/go-ethereum/wiki/Contract-Tutorial)
+
+## शुरुआती लोगों के लिए लेख और पुस्तकें {#beginner-articles-and-books}
+
+- [Geth के साथ शुरुआत करना](https://medium.com/@tzhenghao/getting-started-with-geth-c1a30b8d6458)
+- [Ethereum से कनेक्ट करने के लिए Golang का उपयोग करें](https://www.youtube.com/watch?v=-7uChuO_VzM)
+- [Golang का उपयोग करके Ethereum स्मार्ट अनुबंध तैनात करें](https://www.youtube.com/watch?v=pytGqQmDslE)
+- [Go में Ethereum स्मार्ट अनुबंधों का परीक्षण और परिनियोजन के लिए चरण-दर-चरण मार्गदर्शिका](https://hackernoon.com/a-step-by-step-guide-to-testing-and-deploying-ethereum-smart-contracts-in-go-9fc34b178d78)
+- [ई-पुस्तक: Go के साथ Ethereum का विकास](https://goethereumbook.org/) - _Go के साथ Ethereum अनुप्रयोग विकसित करें_
+
+## मध्यवर्ती लेख और दस्तावेज़ {#intermediate-articles-and-docs}
+
+- [Go Ethereum प्रलेखन](https://geth.ethereum.org/docs/) - _आधिकारिक Ethereum Golang के लिए प्रलेखन_
+- [Erigon प्रोग्रामर की मार्गदर्शिका](https://github.com/ledgerwatch/erigon/blob/devel/docs/programmers_guide/guide.md) - _स्टेट ट्री, मल्टी-प्रूफ़ और लेनदेन प्रसंस्करण सहित सचित्र मार्गदर्शिका_
+- [Erigon और स्टेटलेस Ethereum](https://youtu.be/3-Mn7OckSus?t=394) - _2020 Ethereum सामुदायिक सम्मेलन (EthCC 3)_
+- [Erigon: Ethereum क्लाइंट को अनुकूलित करना](https://www.youtube.com/watch?v=CSpc1vZQW2Q) - _2018 Devcon 4_
+- [Go Ethereum GoDoc](https://godoc.org/github.com/ethereum/go-ethereum)
+- [Geth के साथ Go में एक डैप बनाना](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/creating-a-dapp-in-go-with-geth/)
+- [Golang और Geth के साथ Ethereum निजी नेटवर्क के साथ काम करें](https://myhsts.org/tutorial-learn-how-to-work-with-ethereum-private-network-with-golang-with-geth.php)
+- [Go के साथ Ethereum पर Solidity अनुबंधों का यूनिट परीक्षण](https://medium.com/coinmonks/unit-testing-solidity-contracts-on-ethereum-with-go-3cc924091281)
+- [Geth को लाइब्रेरी के रूप में उपयोग करने के लिए त्वरित संदर्भ](https://medium.com/coinmonks/web3-go-part-1-31c68c68e20e)
+
+## उन्नत उपयोग पैटर्न {#advanced-use-patterns}
+
+- [GETH सिम्युलेटेड बैकएंड](https://kauri.io/#collections/An%20ethereum%20test%20toolkit%20in%20Go/the-geth-simulated-backend/#_top)
+- [Ethereum और Quorum का उपयोग करके ब्लॉकचेन-एज़-अ-सर्विस ऐप्स](https://blockchain.dcwebmakers.com/blockchain-as-a-service-apps-using-ethereum-and-quorum.html)
+- [Ethereum ब्लॉकचेन अनुप्रयोगों में वितरित भंडारण IPFS और Swarm](https://blockchain.dcwebmakers.com/work-with-distributed-storage-ipfs-and-swarm-in-ethereum.html)
+- [मोबाइल क्लाइंट: लाइब्रेरी और इनप्रोक Ethereum नोड्स](https://github.com/ethereum/go-ethereum/wiki/Mobile-Clients:-Libraries-and-Inproc-Ethereum-Nodes)
+- [देशी डैप्स: Ethereum अनुबंधों के लिए Go बाइंडिंग](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts)
+
+## Go परियोजनाएं और उपकरण {#go-projects-and-tools}
+
+- [Geth / Go Ethereum](https://github.com/ethereum/go-ethereum) - _Ethereum प्रोटोकॉल का आधिकारिक Go कार्यान्वयन_
+- [Go Ethereum कोड विश्लेषण](https://github.com/ZtesoftCS/go-ethereum-code-analysis) - _Go Ethereum स्रोत कोड की समीक्षा और विश्लेषण_
+- [Erigon](https://github.com/ledgerwatch/erigon) - _Go Ethereum का तेज़ व्युत्पन्न, जो संग्रह नोड्स पर केंद्रित है_
+- [Golem](https://github.com/golemfactory/golem) - _Golem कंप्यूटिंग शक्ति के लिए एक वैश्विक बाज़ार बना रहा है_
+- [Quorum](https://github.com/jpmorganchase/quorum) - _डेटा गोपनीयता का समर्थन करने वाला Ethereum का एक अनुमति प्राप्त कार्यान्वयन_
+- [प्रिज़्म](https://github.com/prysmaticlabs/prysm) - _Ethereum 'सेरेनिटी' 2.0 Go कार्यान्वयन_
+- [Eth Tweet](https://github.com/yep/eth-tweet) - _विकेंद्रीकृत ट्विटर: Ethereum ब्लॉकचेन पर चलने वाली एक माइक्रोब्लॉगिंग सेवा_
+- [Plasma MVP Golang](https://github.com/kyokan/plasma) — _न्यूनतम व्यवहार्य प्लाज्मा विनिर्देश का Golang कार्यान्वयन और विस्तार_
+- [ओपन Ethereum माइनिंग पूल](https://github.com/sammy007/open-ethereum-pool) - _एक ओपन सोर्स Ethereum माइनिंग पूल_
+- [Ethereum HD वॉलेट](https://github.com/miguelmota/go-ethereum-hdwallet) - _Go में Ethereum HD वॉलेट व्युत्पत्तियाँ_
+- [मल्टी Geth](https://github.com/multi-geth/multi-geth) - _कई प्रकार के Ethereum नेटवर्क के लिए समर्थन_
+- [Geth लाइट क्लाइंट](https://github.com/zsfelfoldi/go-ethereum/wiki/Geth-Light-Client) - _लाइट Ethereum सबप्रोटोकॉल का Geth कार्यान्वयन_
+- [Ethereum Golang SDK](https://github.com/everFinance/goether) - _Golang में एक सरल Ethereum वॉलेट कार्यान्वयन और यूटिलिटीज_
+- [Covalent Golang SDK](https://github.com/covalenthq/covalent-api-sdk-go) - _200+ ब्लॉकचेन के लिए Go SDK के माध्यम से कुशल ब्लॉकचेन डेटा एक्सेस_
+
+अधिक संसाधनों की तलाश है? [ethereum.org/developers](/developers/) देखें
+
+## Go समुदाय के योगदानकर्ता {#go-community-contributors}
+
+- [Geth Discord](https://discordapp.com/invite/nthXNEv)
+- [Geth Gist](https://gitter.im/ethereum/go-ethereum)
+- [Gophers Slack](https://invite.slack.golangbridge.org/) - [#ethereum चैनल](https://gophers.slack.com/messages/C9HP1S9V2)
+- [StackExchange - Ethereum](https://ethereum.stackexchange.com/)
+- [Multi Geth Gitter](https://gitter.im/ethoxy/multi-geth)
+- [Ethereum Gitter](https://gitter.im/ethereum/home)
+- [Geth लाइट क्लाइंट Gitter](https://gitter.im/ethereum/light-client)
+
+## अन्य एकत्रित सूचियाँ {#other-aggregated-lists}
+
+- [Awesome Ethereum](https://github.com/btomashvili/awesome-ethereum)
+- [Consensys: Ethereum डेवलपर उपकरणों की एक निश्चित सूची](https://media.consensys.net/an-definitive-list-of-ethereum-developer-tools-2159ce865974) | [GitHub स्रोत](https://github.com/ConsenSys/ethereum-developer-tools-list)
diff --git a/public/content/translations/hi/developers/docs/programming-languages/index.md b/public/content/translations/hi/developers/docs/programming-languages/index.md
new file mode 100644
index 00000000000..e1cdfd68fd4
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/index.md
@@ -0,0 +1,33 @@
+---
+title: "प्रोग्रामिंग लैंग्वेजेस"
+description: "जावास्क्रिप्ट, पायथन, गो, रस्ट और अन्य सहित विभिन्न प्रोग्रामिंग भाषाओं के लिए एथेरियम डेवलपमेंट संसाधनों की खोज करें।"
+lang: hi
+---
+
+एक आम गलत धारणा यह है कि डेवलपर्स को एथेरियम पर निर्माण करने के लिए [स्मार्ट अनुबंध](/developers/docs/smart-contracts/) लिखने होंगे। यह गलत है।
+एथेरियम नेटवर्क और समुदाय की खूबियों में से एक यह है कि आप लगभग किसी भी प्रोग्रामिंग भाषा में [भाग ले](/community/) सकते हैं।
+
+एथेरियम और उसका समुदाय खुले स्रोत को गले लगाते हैं। आप सामुदायिक परियोजनाएं पा सकते हैं - ग्राहक कार्यान्वयन, एपीआई, विकास ढांचे, परीक्षण उपकरण - विभिन्न प्रकार की भाषाओं में।
+
+## अपनी भाषा चुनें {#data}
+
+परियोजनाओं, संसाधनों और आभासी समुदायों को खोजने के लिए अपनी पसंद की प्रोग्रामिंग भाषा का चयन करें:
+
+- [डार्ट डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/dart/)
+- [डेल्फी डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/delphi/)
+- [.NET डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/dot-net/)
+- [एलिक्सिर डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/elixir/)
+- [गो डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/golang/)
+- [जावा डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/java/)
+- [जावास्क्रिप्ट डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/javascript/)
+- [पायथन डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/python/)
+- [रूबी डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/ruby/)
+- [रस्ट डेवलपर्स के लिए एथेरियम](/developers/docs/programming-languages/rust/)
+
+### अगर मेरी भाषा समर्थित नहीं है तो क्या होगा {#other-lang}
+
+यदि आप किसी अतिरिक्त प्रोग्रामिंग भाषा के लिए संसाधनों से लिंक करना चाहते हैं या किसी वर्चुअल समुदाय को इंगित करना चाहते हैं तो आप [एक इश्यू खोलकर](https://github.com/ethereum/ethereum-org-website/issues/new/choose) एक नए पेज का अनुरोध कर सकते हैं।
+
+यदि आप केवल वर्तमान में असमर्थित भाषा का उपयोग करके ब्लॉकचेन के साथ इंटरफेस करने के लिए कोड लिखना चाहते हैं
+तो आप एथेरियम नेटवर्क से कनेक्ट करने के लिए [JSON-RPC इंटरफ़ेस](/developers/docs/apis/json-rpc/) का उपयोग कर सकते हैं। कोई भी प्रोग्रामिंग
+TCP/IP का उपयोग करने वाली भाषा इस इंटरफ़ेस का उपयोग कर सकती है.
diff --git a/public/content/translations/hi/developers/docs/programming-languages/java/index.md b/public/content/translations/hi/developers/docs/programming-languages/java/index.md
new file mode 100644
index 00000000000..d762d3ddf2c
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/java/index.md
@@ -0,0 +1,64 @@
+---
+title: "जावा डेवलपर्स के लिए इथिरीयम"
+description: "जावा-आधारित परियोजनाओं और टूलींग का उपयोग करके एथेरियम के लिए विकास करना सीखें"
+lang: hi
+incomplete: true
+---
+
+जावा-आधारित प्रोजेक्ट्स और टूलिंग का उपयोग करके Ethereum के लिए डेवलप करना सीखें
+
+विकेन्द्रीकृत अनुप्रयोगों (या "डैप्स") बनाने के लिए इथिरीयम का उपयोग करें जो क्रिप्टोक्यूरेंसी और ब्लॉकचैन तकनीक के लाभों का उपयोग करते हैं। ये डैप भरोसेमंद हो सकते हैं, जिसका अर्थ है कि एक बार इथिरीयम में तैनात होने के बाद, वे हमेशा प्रोग्राम किए गए अनुसार चलेंगे। नए प्रकार के वित्तीय अनुप्रयोग बनाने के लिए वे डिजिटल संपत्ति को नियंत्रित कर सकते हैं। उन्हें विकेंद्रीकृत किया जा सकता है, जिसका अर्थ है कि कोई एकल इकाई या व्यक्ति उन्हें नियंत्रित नहीं करता है और सेंसर के लिए लगभग असंभव है।
+
+## स्मार्ट अनुबंधों और सॉलिडिटी भाषा के साथ आरंभ करना {#getting-started-with-smart-contracts-and-solidity}
+
+**जावा को Ethereum के साथ इंटीग्रेट करने के लिए अपने पहले कदम उठाएं**
+
+पहले एक और बुनियादी प्राइमर की आवश्यकता है? [ethereum.org/learn](/learn/) या [ethereum.org/developers.](/developers/) देखें।
+
+- [ब्लॉकचेन समझाया गया](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [स्मार्ट अनुबंधों को समझना](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [अपना पहला स्मार्ट अनुबंध लिखें](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [सॉलिडिटी को कंपाइल और डिप्लॉय करना सीखें](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+
+## Ethereum क्लाइंट्स के साथ काम करना {#working-with-ethereum-clients}
+
+[Web3J](https://github.com/web3j/web3j) और Hyperledger Besu का उपयोग करना सीखें, जो दो प्रमुख जावा Ethereum क्लाइंट्स हैं
+
+- [जावा, Eclipse और Web3J के साथ एक Ethereum क्लाइंट से कनेक्ट करना](https://kauri.io/article/b9eb647c47a546bc95693acc0be72546/connecting-to-an-ethereum-client-with-java-eclipse-and-web3j)
+- [जावा और Web3j के साथ एक Ethereum खाते को मैनेज करना](https://kauri.io/article/925d923e12c543da9a0a3e617be963b4/manage-an-ethereum-account-with-java-and-web3j)
+- [अपने स्मार्ट कॉन्ट्रैक्ट से एक जावा रैपर जेनरेट करना](https://kauri.io/article/84475132317d4d6a84a2c42eb9348e4b/generate-a-java-wrapper-from-your-smart-contract)
+- [एक Ethereum स्मार्ट कॉन्ट्रैक्ट के साथ इंटरैक्ट करना](https://kauri.io/article/14dc434d11ef4ee18bf7d57f079e246e/interacting-with-an-ethereum-smart-contract-in-java)
+- [Ethereum स्मार्ट कॉन्ट्रैक्ट इवेंट्स के लिए लिसन करना](https://kauri.io/article/760f495423db42f988d17b8c145b0874/listening-for-ethereum-smart-contract-events-in-java)
+- [Linux के साथ Besu (Pantheon), जावा Ethereum क्लाइंट का उपयोग करना](https://kauri.io/article/276dd27f1458443295eea58403fd6965/using-pantheon-the-java-ethereum-client-with-linux)
+- [जावा इंटीग्रेशन टेस्ट में Hyperledger Besu (Pantheon) नोड को रन करना](https://kauri.io/article/7dc3ecc391e54f7b8cbf4e5fa0caf780/running-a-pantheon-node-in-java-integration-tests)
+- [Web3j चीट शीट](https://kauri.io/web3j-cheat-sheet-\(java-ethereum\)/5dfa1ea941ac3d0001ce1d90/c)
+
+[ethers-kt](https://github.com/Kr1ptal/ethers-kt) का उपयोग करना सीखें, जो EVM-आधारित ब्लॉकचेन के साथ इंटरैक्ट करने के लिए एक एसिंक, उच्च-प्रदर्शन वाली कोटलिन लाइब्रेरी है। जेवीएम और एंड्रॉइड प्लेटफॉर्म को लक्षित करना।
+
+- [ERC20 टोकन ट्रांसफर करना](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/abi/TransferERC20.kt)
+- [इवेंट लिसनिंग के साथ UniswapV2 स्वैप](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/tokenswapwitheventlistening/TokenSwapWithEventListening.kt)
+- [ETH / ERC20 बैलेंस ट्रैकर](https://github.com/Kr1ptal/ethers-kt/blob/master/examples/src/main/kotlin/io/ethers/examples/balancetracker/BalanceTracker.kt)
+
+## मध्यवर्ती लेख {#intermediate-articles}
+
+- [IPFS के साथ एक जावा एप्लिकेशन में स्टोरेज मैनेज करना](https://kauri.io/article/3e8494f4f56f48c4bb77f1f925c6d926/managing-storage-in-a-java-application-with-ipfs)
+- [Web3j के साथ जावा में ERC20 टोकन मैनेज करना](https://kauri.io/article/d13e911bbf624108b1d5718175a5e0a0/manage-erc20-tokens-in-java-with-web3j)
+- [Web3j ट्रांजैक्शन मैनेजर्स](https://kauri.io/article/4cb780bb4d0846438d11885a25b6d7e7/web3j-transaction-managers)
+
+## उन्नत उपयोग पैटर्न {#advanced-use-patterns}
+
+- [जावा स्मार्ट कॉन्ट्रैक्ट डेटा कैश बनाने के लिए Eventeum का उपयोग करना](https://kauri.io/article/fe81ee9612eb4e5a9ab72790ef24283d/using-eventeum-to-build-a-java-smart-contract-data-cache)
+
+## जावा प्रोजेक्ट्स और टूल्स {#java-projects-and-tools}
+
+- [Web3J (Ethereum क्लाइंट्स के साथ इंटरैक्ट करने के लिए लाइब्रेरी)](https://github.com/web3j/web3j)
+- [ethers-kt (EVM-आधारित ब्लॉकचेन के लिए एसिंक, उच्च-प्रदर्शन वाली कोटलिन/जावा/एंड्रॉइड लाइब्रेरी।)](https://github.com/Kr1ptal/ethers-kt)
+- [Eventeum (इवेंट लिसनर)](https://github.com/ConsenSys/eventeum)
+- [Mahuta (IPFS देव टूल्स)](https://github.com/ConsenSys/mahuta)
+
+अधिक संसाधनों की तलाश है? [ethereum.org/developers.](/developers/) देखें।
+
+## जावा समुदाय के योगदानकर्ता {#java-community-contributors}
+
+- [IO Builders](https://io.builders)
+- [Kauri](https://kauri.io)
diff --git a/public/content/translations/hi/developers/docs/programming-languages/javascript/index.md b/public/content/translations/hi/developers/docs/programming-languages/javascript/index.md
new file mode 100644
index 00000000000..cb6ca8f4569
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/javascript/index.md
@@ -0,0 +1,72 @@
+---
+title: "जावास्क्रिप्ट डेवलपर्स के लिए इथिरीयम"
+description: "जावास्क्रिप्ट-आधारित परियोजनाओं और टूलिंग का उपयोग करके इथेरियम के लिए विकसित करना सीखें।"
+lang: hi
+---
+
+जावास्क्रिप्ट इथेरियम पारिस्थितिकी तंत्र में सबसे लोकप्रिय भाषाओं में से एक है। असल में, एक [टीम](https://github.com/ethereumjs) है जो अधिक से अधिक Ethereum को JavaScript में लाने के लिए समर्पित है।
+
+[स्टैक के सभी स्तरों](/developers/docs/ethereum-stack/) पर JavaScript (या कुछ मिलता-जुलता) लिखने के अवसर हैं।
+
+## Ethereum के साथ इंटरेक्ट करें {#interact-with-ethereum}
+
+### JavaScript API लाइब्रेरी {#javascript-api-libraries}
+
+यदि आप ब्लॉकचेन को क्वेरी करने, ट्रांज़ैक्शन भेजने और बहुत कुछ करने के लिए JavaScript लिखना चाहते हैं, तो ऐसा करने का सबसे सुविधाजनक तरीका [JavaScript API लाइब्रेरी](/developers/docs/apis/javascript/) का उपयोग करना है। ये API डेवलपरों को [Ethereum नेटवर्क में नोड्स](/developers/docs/nodes-and-clients/) के साथ आसानी से इंटरेक्ट करने की अनुमति देती हैं।
+
+इथेरियम पर स्मार्ट कॉन्ट्रैक्ट्स के साथ बातचीत करने के लिए आप इन पुस्तकालयों का उपयोग कर सकते हैं, इसलिए यह संभव है कि आप एक डैप का निर्माण करें जहाँ आप पहले से मौजूद कॉन्ट्रैक्ट्स के साथ बातचीत करने के लिए जावास्क्रिप्ट का उपयोग करें।
+
+**देखें**
+
+- [Web3.js](https://web3js.readthedocs.io)
+- [Ethers.js](https://ethers.org) – _इसमें JavaScript और TypeScript में Ethereum वॉलेट कार्यान्वयन और यूटिलिटीज़ शामिल हैं।_
+- [viem](https://viem.sh) – _Ethereum के लिए एक TypeScript इंटरफ़ेस जो Ethereum के साथ इंटरेक्ट करने के लिए निम्न-स्तरीय स्टेटलेस प्रिमिटिव प्रदान करता है।_
+- [Drift](https://ryangoree.github.io/drift/) – _web3 लाइब्रेरी में सहज Ethereum डेवलपमेंट के लिए बिल्ट-इन कैशिंग, हुक और टेस्ट मॉक्स के साथ एक TypeScript मेटा-लाइब्रेरी।_
+
+### स्मार्ट अनुबंध {#smart-contracts}
+
+यदि आप एक JavaScript डेवलपर हैं और अपना स्वयं का स्मार्ट अनुबंध लिखना चाहते हैं, तो आप [Solidity](https://solidity.readthedocs.io) से परिचित होना चाहेंगे। यह सबसे लोकप्रिय स्मार्ट अनुबंध भाषा है और यह वाक्यविन्यास रूप से जावास्क्रिप्ट के समान है, जिससे सीखना आसान हो सकता है।
+
+[स्मार्ट अनुबंध](/developers/docs/smart-contracts/) के बारे में और जानें।
+
+## प्रोटोकॉल को समझें {#understand-the-protocol}
+
+### Ethereum वर्चुअल मशीन {#the-ethereum-virtual-machine}
+
+[Ethereum की वर्चुअल मशीन](/developers/docs/evm/) का एक JavaScript कार्यान्वयन है। यह नवीनतम कांटा नियमों का समर्थन करता है। फोर्क के नियम नियोजित अपग्रेड के परिणामस्वरूप ईवीएम में किए गए परिवर्तनों को संदर्भित करते हैं।
+
+इसे विभिन्न जावास्क्रिप्ट पैकेजों में विभाजित किया गया है जिन्हें आप बेहतर समझने के लिए देख सकते हैं:
+
+- खाते
+- ब्लॉक
+- ब्लॉकचेन ही
+- ट्रांसक्शन्स
+- और अधिक...
+
+इससे आपको "खाता की डेटा संरचना क्या है?" जैसी चीजों को समझने में मदद मिलेगी।
+
+यदि आप कोड पढ़ना पसंद करते हैं, तो यह जावास्क्रिप्ट हमारे डॉक्स के माध्यम से पढ़ने का एक बेहतरीन विकल्प हो सकता है।
+
+**EVM देखें**
+[`@ethereumjs/evm`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/evm)
+
+### नोड और क्लाइंट {#nodes-and-clients}
+
+एक Ethereumjs क्लाइंट सक्रिय विकास में है जो आपको यह पता लगाने देता है कि एथेरियम क्लाइंट आपके द्वारा समझी जाने वाली भाषा में कैसे काम करते हैं; जावास्क्रिप्ट!
+
+**क्लाइंट देखें**
+[`@ethereumjs/client`](https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/client)
+
+## अन्य परियोजनाएँ {#other-projects}
+
+इथेरियम जावास्क्रिप्ट की भूमि में अन्य बहुत सी चीजें चल रही हैं, जिनमें शामिल हैं:
+
+- वॉलेट उपयोगिताओं के पुस्तकालय।
+- इथेरियम कुंजियों को जनरेट करने, आयात करने और निर्यात करने के लिए उपकरण।
+- `merkle-patricia-tree` का कार्यान्वयन – Ethereum येलो पेपर में उल्लिखित एक डेटा संरचना।
+
+[EthereumJS रेपो](https://github.com/ethereumjs) पर जिसमें भी आपकी सबसे अधिक रुचि है, उसके बारे में और जानें।
+
+## आगे की रीडिंग {#further-reading}
+
+_क्या आप किसी सामुदायिक संसाधन के बारे में जानते हैं जिसने आपकी मदद की हो? इस पृष्ठ को संपादित करें और इसे जोड़ें!_
diff --git a/public/content/translations/hi/developers/docs/programming-languages/python/index.md b/public/content/translations/hi/developers/docs/programming-languages/python/index.md
new file mode 100644
index 00000000000..fe6193d8c1e
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/python/index.md
@@ -0,0 +1,99 @@
+---
+title: "इथिरीयम पायथन डेवलपर्स के लिए"
+description: "पायथन आधारित परियोजनाओं और टूलींग का उपयोग करके इथिरीयम के लिए विकसित करना सीखें"
+lang: hi
+incomplete: true
+---
+
+पायथन-आधारित परियोजनाओं और टूलिंग का उपयोग करके इथेरियम के लिए विकसित करना सीखें
+
+विकेन्द्रीकृत अनुप्रयोगों (या "डैप्स") बनाने के लिए इथिरीयम का उपयोग करें जो क्रिप्टोक्यूरेंसी और ब्लॉकचैन तकनीक के लाभों का उपयोग करते हैं। ये डैप भरोसेमंद हो सकते हैं, जिसका अर्थ है कि एक बार इथिरीयम में तैनात होने के बाद, वे हमेशा प्रोग्राम किए गए अनुसार चलेंगे। नए प्रकार के वित्तीय अनुप्रयोग बनाने के लिए वे डिजिटल संपत्ति को नियंत्रित कर सकते हैं। उन्हें विकेंद्रीकृत किया जा सकता है, जिसका अर्थ है कि कोई एकल इकाई या व्यक्ति उन्हें नियंत्रित नहीं करता है और सेंसर के लिए लगभग असंभव है।
+
+## स्मार्ट अनुबंधों और सॉलिडिटी भाषा के साथ आरंभ करना {#getting-started-with-smart-contracts-and-solidity}
+
+**इथेरियम के साथ पायथन को एकीकृत करने के लिए अपना पहला कदम उठाएं**
+
+पहले एक और बुनियादी प्राइमर की आवश्यकता है? [ethereum.org/learn](/learn/) या [ethereum.org/developers](/developers/) देखें।
+
+- [ब्लॉकचेन समझाया गया](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [स्मार्ट अनुबंधों को समझना](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [अपना पहला स्मार्ट अनुबंध लिखें](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [सॉलिडिटी को कंपाइल और डिप्लॉय करना सीखें](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+- [ब्लॉकचेन 2023 रिपोर्ट में पायथन की स्थिति](https://tradingstrategy.ai/blog/the-state-of-python-in-blockchain-in-2023)
+
+## शुरुआती लेख {#beginner-articles}
+
+- [web3.py अवलोकन](https://web3py.readthedocs.io/en/latest/overview.html)
+- [इथेरियम पायथन इकोसिस्टम टूर](https://snakecharmers.ethereum.org/python-ecosystem/)
+- [इथेरियम के लिए एक (पायथन) डेवलपर की मार्गदर्शिका](https://snakecharmers.ethereum.org/a-developers-guide-to-ethereum-pt-1/)
+- [पुरस्कार-योग्य: एक इथेरियम पायथन हैकथॉन गाइड](https://snakecharmers.ethereum.org/prize-worthy/)
+- [वाइपर के साथ स्मार्ट अनुबंधों का परिचय](https://kauri.io/#collections/Getting%20Started/an-introduction-to-smart-contracts-with-vyper/)
+- [पायथन फ्लास्क का उपयोग करके इथेरियम अनुबंध कैसे विकसित करें?](https://medium.com/coinmonks/how-to-develop-ethereum-contract-using-python-flask-9758fe65976e)
+- [Web3.py का परिचय · पायथन डेवलपर्स के लिए इथेरियम](https://www.dappuniversity.com/articles/web3-py-intro)
+- [पायथन और web3.py का उपयोग करके स्मार्ट अनुबंध फ़ंक्शन को कैसे कॉल करें](https://stackoverflow.com/questions/57580702/how-to-call-a-smart-contract-function-using-python-and-web3-py)
+
+## मध्यवर्ती लेख {#intermediate-articles}
+
+- [web3.py के मित्र: Ape का परिचय](https://snakecharmers.ethereum.org/intro-to-ape/)
+- [पायथन प्रोग्रामर्स के लिए डैप डेवलपमेंट](https://levelup.gitconnected.com/dapps-development-for-python-developers-f52b32b54f28)
+- [एक पायथन इथेरियम इंटरफ़ेस बनाना: भाग 1](https://hackernoon.com/creating-a-python-ethereum-interface-part-1-4d2e47ea0f4d)
+- [पायथन में इथेरियम स्मार्ट अनुबंध: एक व्यापक (लगभग) गाइड](https://hackernoon.com/ethereum-smart-contracts-in-python-a-comprehensive-ish-guide-771b03990988)
+
+## उन्नत उपयोग पैटर्न {#advanced-use-patterns}
+
+- [web3.py पैटर्न: रीयल-टाइम इवेंट सब्सक्रिप्शन](https://snakecharmers.ethereum.org/subscriptions/)
+- [web3.py पैटर्न: WebSocketProvider](https://snakecharmers.ethereum.org/websocketprovider/)
+- [पायथन का उपयोग करके इथेरियम स्मार्ट अनुबंध को कंपाइल करना, डिप्लॉय करना और कॉल करना](https://yohanes.gultom.id/2018/11/28/compiling-deploying-and-calling-ethereum-smartcontract-using-python/)
+- [Slither के साथ सॉलिडिटी स्मार्ट अनुबंधों का विश्लेषण करें](https://kauri.io/#collections/DevOps/analyze-solidity-smart-contracts-with-slither/#analyze-solidity-smart-contracts-with-slither)
+- [ब्लॉकचेन फिनटेक ट्यूटोरियल: पायथन के साथ ऋण देना और उधार लेना](https://blog.chain.link/blockchain-fintech-defi-tutorial-lending-borrowing-python/)
+
+## संग्रहीत लेख
+
+- [पायथन और ब्राउनी के साथ अपना खुद का ERC20 टोकन डिप्लॉय करें](https://betterprogramming.pub/python-blockchain-token-deployment-tutorial-create-an-erc20-77a5fd2e1a58)
+- [स्मार्ट अनुबंधों को डिप्लॉय करने के लिए ब्राउनी और पायथन का उपयोग करना](https://dev.to/patrickalphac/using-brownie-for-to-deploy-smart-contracts-1kkp)
+- [ब्राउनी के साथ OpenSea पर NFT बनाना](https://www.freecodecamp.org/news/how-to-make-an-nft-and-render-on-opensea-marketplace/)
+
+## पायथन परियोजनाएं और उपकरण {#python-projects-and-tools}
+
+### सक्रिय: {#active}
+
+- [Web3.py](https://github.com/ethereum/web3.py) - _इथेरियम के साथ इंटरैक्ट करने के लिए पायथन लाइब्रेरी_
+- [Vyper](https://github.com/ethereum/vyper/) - _EVM के लिए पायथनिक स्मार्ट अनुबंध भाषा_
+- [Ape](https://github.com/ApeWorX/ape) - _पायथनिस्ट, डेटा वैज्ञानिकों और सुरक्षा पेशेवरों के लिए स्मार्ट अनुबंध विकास उपकरण_
+- [py-evm](https://github.com/ethereum/py-evm) - _इथेरियम वर्चुअल मशीन का कार्यान्वयन_
+- [eth-tester](https://github.com/ethereum/eth-tester) - _इथेरियम-आधारित अनुप्रयोगों के परीक्षण के लिए उपकरण_
+- [eth-utils](https://github.com/ethereum/eth-utils/) - _इथेरियम संबंधित कोडबेस के साथ काम करने के लिए उपयोगिता फ़ंक्शन_
+- [py-solc-x](https://pypi.org/project/py-solc-x/) - _0.5.x समर्थन के साथ solc सॉलिडिटी कंपाइलर के लिए पायथन रैपर_
+- [pymaker](https://github.com/makerdao/pymaker) - _Maker अनुबंधों के लिए पायथन API_
+- [siwe](https://github.com/signinwithethereum/siwe-py) - _पायथन के लिए इथेरियम से साइन इन करें (siwe)_
+- [इथेरियम एकीकरण के लिए Web3 DeFi](https://github.com/tradingstrategy-ai/web3-ethereum-defi) - _ERC-20, Uniswap और अन्य लोकप्रिय परियोजनाओं के लिए तैयार एकीकरण के साथ एक पायथन पैकेज_
+- [Wake](https://getwake.io) - _अनुबंध परीक्षण, फ़ज़िंग, डिप्लॉयमेंट, भेद्यता स्कैनिंग और कोड नेविगेशन के लिए ऑल-इन-वन पायथन फ्रेमवर्क (भाषा सर्वर - [सॉलिडिटी के लिए उपकरण](https://marketplace.visualstudio.com/items?itemName=AckeeBlockchain.tools-for-solidity))_
+
+### संग्रहीत / अब रखरखाव नहीं किया जाता: {#archived--no-longer-maintained}
+
+- [Trinity](https://github.com/ethereum/trinity) - _इथेरियम पायथन क्लाइंट_
+- [Mamba](https://github.com/arjunaskykok/mamba) - _Vyper भाषा में लिखे गए स्मार्ट अनुबंधों को लिखने, कंपाइल करने और डिप्लॉय करने के लिए फ्रेमवर्क_
+- [Brownie](https://github.com/eth-brownie/brownie) - _इथेरियम स्मार्ट अनुबंधों को डिप्लॉय करने, परीक्षण करने और उनके साथ इंटरैक्ट करने के लिए पायथन फ्रेमवर्क_
+- [pydevp2p](https://github.com/ethereum/pydevp2p) - _इथेरियम P2P स्टैक का कार्यान्वयन_
+- [py-wasm](https://github.com/ethereum/py-wasm) - _वेब असेंबली इंटरप्रेटर का पायथन कार्यान्वयन_
+
+अधिक संसाधनों की तलाश है? [ethereum.org/developers](/developers/) देखें।
+
+## पायथन टूलिंग का उपयोग करने वाली परियोजनाएं {#projects-using-python-tooling}
+
+निम्नलिखित एथेरियम-आधारित परियोजनाएं इस पृष्ठ पर उल्लिखित उपकरणों का उपयोग करती हैं। संबंधित ओपन-सोर्स रिपॉजिटरी उदाहरण कोड और सर्वोत्तम प्रथाओं के लिए एक अच्छे संदर्भ के रूप में कार्य करते हैं।
+
+- [Yearn Finance](https://yearn.finance/) और [Yearn Vault Contracts रिपॉजिटरी](https://github.com/yearn/yearn-vaults)
+- [Curve](https://www.curve.finance/) और [Curve स्मार्ट अनुबंध रिपॉजिटरी](https://github.com/curvefi/curve-contract)
+- [BadgerDAO](https://badger.com/) और [ब्राउनी टूलचेन का उपयोग करने वाले स्मार्ट अनुबंध](https://github.com/Badger-Finance/badger-system)
+- [Sushi](https://sushi.com/) अपने [वेस्टिंग अनुबंधों के प्रबंधन और डिप्लॉयमेंट में पायथन का उपयोग करता है](https://github.com/sushiswap/sushi-vesting-protocols)
+- [Alpha Finance](https://alphafinance.io/), जो Alpha Homora के लिए प्रसिद्ध है, [स्मार्ट अनुबंधों का परीक्षण और डिप्लॉय करने के लिए ब्राउनी का उपयोग करता है](https://github.com/AlphaFinanceLab/alpha-staking-contract)
+
+## पायथन समुदाय चर्चा {#python-community-contributors}
+
+- Web3.py और अन्य पायथन फ्रेमवर्क पर चर्चा के लिए [इथेरियम पायथन समुदाय डिस्कॉर्ड](https://discord.gg/9zk7snTfWe)
+- Vyper स्मार्ट अनुबंध प्रोग्रामिंग पर चर्चा के लिए [Vyper डिस्कॉर्ड](https://discord.gg/SdvKC79cJk)
+
+## अन्य एकत्रित सूचियाँ {#other-aggregated-lists}
+
+Vyper विकी में [Vyper के लिए संसाधनों की एक अविश्वसनीय सूची](https://github.com/vyperlang/vyper/wiki/Vyper-tools-and-resources) है
\ No newline at end of file
diff --git a/public/content/translations/hi/developers/docs/programming-languages/ruby/index.md b/public/content/translations/hi/developers/docs/programming-languages/ruby/index.md
new file mode 100644
index 00000000000..bad48f41afe
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/ruby/index.md
@@ -0,0 +1,60 @@
+---
+title: "रूबी डेवलपर्स के लिए एथेरियम"
+description: "रूबी-आधारित परियोजनाओं और टूलींग का उपयोग करके एथेरियम के लिए विकास करना सीखें।"
+lang: hi
+incomplete: false
+---
+
+रूबी-आधारित परियोजनाओं और टूलिंग का उपयोग करके एथेरियम के लिए विकास करना सीखें।
+
+विकेन्द्रीकृत अनुप्रयोगों (या "डैप्स") बनाने के लिए इथिरीयम का उपयोग करें जो क्रिप्टोक्यूरेंसी और ब्लॉकचैन तकनीक के लाभों का उपयोग करते हैं। ये डैप्स भरोसेमंद हो सकते हैं, जिसका अर्थ है कि एक बार जब वे एथेरियम में तैनात हो जाते हैं, तो वे हमेशा प्रोग्राम किए गए अनुसार चलेंगे। वे नए प्रकार के वित्तीय अनुप्रयोग बनाने के लिए डिजिटल संपत्ति को नियंत्रित कर सकते हैं। उन्हें विकेंद्रीकृत किया जा सकता है, जिसका अर्थ है कि कोई एकल इकाई या व्यक्ति उन्हें नियंत्रित नहीं करता है और सेंसर के लिए लगभग असंभव है।
+
+## स्मार्ट अनुबंधों और सॉलिडिटी भाषा के साथ आरंभ करना {#getting-started-with-smart-contracts-and-solidity}
+
+**रूबी को एथेरियम के साथ एकीकृत करने के लिए अपना पहला कदम उठाएं**
+
+पहले एक और बुनियादी प्राइमर की आवश्यकता है? [ethereum.org/learn](/learn/) या [ethereum.org/developers](/developers/) देखें।
+
+- [ब्लॉकचेन समझाया गया](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [स्मार्ट अनुबंधों को समझना](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [अपना पहला स्मार्ट अनुबंध लिखें](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [सॉलिडिटी को कंपाइल और डिप्लॉय करना सीखें](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+
+## शुरुआती लेख {#beginner-articles}
+
+- [Ethereum खातों को आखिरकार समझना](https://dev.to/q9/finally-understanding-ethereum-accounts-1kpe)
+- [अंततः MetaMask के साथ Rails यूज़र्स को प्रमाणित करना](https://dev.to/q9/finally-authenticating-rails-users-with-metamask-3fj)
+- [रूबी का उपयोग करके एथेरियम नेटवर्क से कैसे कनेक्ट करें](https://www.quicknode.com/guides/web3-sdks/how-to-connect-to-the-ethereum-network-using-ruby)
+- [रूबी में एक नया एथेरियम पता कैसे जनरेट करें](https://www.quicknode.com/guides/web3-sdks/how-to-generate-a-new-ethereum-address-in-ruby)
+
+## मध्यवर्ती लेख {#intermediate-articles}
+
+- [रूबी के साथ ब्लॉकचेन ऐप](https://www.nopio.com/blog/blockchain-app-ruby/)
+- [स्मार्ट अनुबंध को निष्पादित करने के लिए एथेरियम से जुड़े रूबी का उपयोग करें](https://titanwolf.org/Network/Articles/Article?AID=87285822-9b25-49d5-ba2a-7ad95fff7ef9)
+
+## रूबी परियोजनाएं और उपकरण {#ruby-projects-and-tools}
+
+### सक्रिय {#active}
+
+- [eth.rb](https://github.com/q9f/eth.rb) - _एथेरियम खातों, संदेशों और लेन-देन को संभालने के लिए रूबी लाइब्रेरी और RPC-क्लाइंट_
+- [keccak.rb](https://github.com/q9f/keccak.rb) - _एथेरियम द्वारा उपयोग किया जाने वाला केकक (SHA3) हैश_
+- [siwe-ruby](https://github.com/signinwithethereum/siwe-ruby) - _Sign-In with Ethereum का रूबी कार्यान्वयन_
+- [siwe-rails](https://github.com/signinwithethereum/siwe-rails) - _Rails जेम जो SIWE लोकल साइन इन रूट्स जोड़ता है_
+- [siwe-rails-examples](https://github.com/signinwithethereum/siwe-rails-examples) - _कस्टम कंट्रोलर के साथ Ruby on Rails का उपयोग करते हुए SIWE उदाहरण_
+- [omniauth-siwe](https://github.com/signinwithethereum/omniauth-siwe) - _Sign In With Ethereum (SIWE) के लिए OmniAuth रणनीति_
+- [omniauth-nft](https://github.com/valthon/omniauth-nft) - _NFT स्वामित्व के माध्यम से प्रमाणित करने के लिए OmniAuth रणनीति_
+- [ethereum-on-rails](https://github.com/q9f/ethereum-on-rails) - _Ethereum on Rails टेम्प्लेट जो MetaMask को Ruby on Rails से कनेक्ट करने की अनुमति देता है_
+
+### संग्रहीत / अब रखरखाव नहीं किया जाता {#archived--no-longer-maintained}
+
+- [web3-eth](https://github.com/spikewilliams/vtada-ethereum) - _रूबी के साथ एथेरियम नोड के RPC तरीकों को कॉल करना_
+- [ethereum_tree](https://github.com/longhoangwkm/ethereum_tree) - _BIP32 मानक के अनुसार एक पदानुक्रमित नियतात्मक वॉलेट से ETH पते उत्पन्न करने के लिए रूबी लाइब्रेरी_
+- [etherlite](https://github.com/budacom/etherlite) - _Ruby on Rails के लिए एथेरियम एकीकरण_
+- [ethereum.rb](https://github.com/EthWorks/ethereum.rb) - _रूबी एथेरियम क्लाइंट जो लेनदेन भेजने, अनुबंध बनाने और उनके साथ इंटरैक्ट करने के लिए JSON-RPC इंटरफ़ेस का उपयोग करता है, और साथ ही एथेरियम नोड के साथ काम करने के लिए एक उपयोगी टूलकिट है_
+- [omniauth-ethereum.rb](https://github.com/q9f/omniauth-ethereum.rb) - _OmniAuth के लिए एथेरियम प्रदाता रणनीति लागू करता है_
+
+अधिक संसाधनों की तलाश है? हमारे [डेवलपर का होम पेज](/developers/) देखें।
+
+## रूबी समुदाय के योगदानकर्ता {#ruby-community-contributors}
+
+[Ethereum Ruby Telegram group](https://t.me/ruby_eth) तेजी से बढ़ते समुदाय का मेजबान है और उपरोक्त किसी भी परियोजना और संबंधित विषयों पर चर्चा के लिए समर्पित संसाधन है।
diff --git a/public/content/translations/hi/developers/docs/programming-languages/rust/index.md b/public/content/translations/hi/developers/docs/programming-languages/rust/index.md
new file mode 100644
index 00000000000..e4a516a6dbf
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/programming-languages/rust/index.md
@@ -0,0 +1,65 @@
+---
+title: "जंग डेवलपर्स के लिए इथिरीयम"
+description: "रस्ट आधारित प्रोग्राम भाषा परियोजनाओं और टूलिंग का उपयोग करके एथेरियम के लिए विकसित करना सीखें"
+lang: hi
+incomplete: true
+---
+
+रस्ट-आधारित परियोजनाओं और टूलिंग का उपयोग करके एथेरियम के लिए विकसित करना सीखें
+
+विकेन्द्रीकृत अनुप्रयोगों (या "डैप्स") बनाने के लिए इथिरीयम का उपयोग करें जो क्रिप्टोक्यूरेंसी और ब्लॉकचैन तकनीक के लाभों का उपयोग करते हैं। ये डैप भरोसेमंद हो सकते हैं, जिसका अर्थ है कि एक बार इथिरीयम में तैनात होने के बाद, वे हमेशा प्रोग्राम किए गए अनुसार चलेंगे। नए प्रकार के वित्तीय अनुप्रयोग बनाने के लिए वे डिजिटल परिसंपत्तियों को नियंत्रित कर सकते हैं। उन्हें विकेंद्रीकृत किया जा सकता है, जिसका अर्थ है कि कोई एकल इकाई या व्यक्ति उन्हें नियंत्रित नहीं करता है और सेंसर के लिए लगभग असंभव है।
+
+## स्मार्ट अनुबंधों और सॉलिडिटी भाषा के साथ आरंभ करना {#getting-started-with-smart-contracts-and-solidity}
+
+**रस्ट को एथेरियम के साथ एकीकृत करने के लिए अपने पहले कदम उठाएं**
+
+पहले एक और बुनियादी प्राइमर की आवश्यकता है? [ethereum.org/learn](/learn/) या [ethereum.org/developers](/developers/) देखें।
+
+- [ब्लॉकचेन समझाया गया](https://kauri.io/article/d55684513211466da7f8cc03987607d5/blockchain-explained)
+- [स्मार्ट अनुबंधों को समझना](https://kauri.io/article/e4f66c6079e74a4a9b532148d3158188/ethereum-101-part-5-the-smart-contract)
+- [अपना पहला स्मार्ट अनुबंध लिखें](https://kauri.io/article/124b7db1d0cf4f47b414f8b13c9d66e2/remix-ide-your-first-smart-contract)
+- [सॉलिडिटी को कंपाइल और डिप्लॉय करना सीखें](https://kauri.io/article/973c5f54c4434bb1b0160cff8c695369/understanding-smart-contract-compilation-and-deployment)
+
+## शुरुआती लेख {#beginner-articles}
+
+- [The Rust Ethereum Client](https://openethereum.github.io/) \* **ध्यान दें कि OpenEthereum को [पदावनत कर दिया गया है](https://medium.com/openethereum/gnosis-joins-erigon-formerly-turbo-geth-to-release-next-gen-ethereum-client-c6708dd06dd) और अब इसे बनाए नहीं रखा जा रहा है।** इसका उपयोग सावधानी से करें और बेहतर होगा कि किसी अन्य क्लाइंट कार्यान्वयन पर स्विच करें।
+- [रस्ट का उपयोग करके एथेरियम को लेनदेन भेजना](https://kauri.io/#collections/A%20Hackathon%20Survival%20Guide/sending-ethereum-transactions-with-rust/)
+- [Kovan के लिए Rust Wasm में अनुबंध कैसे लिखें, इस पर एक चरण-दर-चरण ट्यूटोरियल](https://github.com/paritytech/pwasm-tutorial)
+
+## मध्यवर्ती लेख {#intermediate-articles}
+
+## उन्नत उपयोग पैटर्न {#advanced-use-patterns}
+
+- [एथेरियम-जैसे नेटवर्क के साथ इंटरैक्ट करने के लिए pwasm_ethereum एक्सटर्न लाइब्रेरी](https://github.com/openethereum/pwasm-ethereum)
+
+- [JavaScript और Rust का उपयोग करके एक विकेंद्रीकृत चैट बनाएं](https://medium.com/perlin-network/build-a-decentralized-chat-using-javascript-rust-webassembly-c775f8484b52)
+
+- [Vue.js और Rust का उपयोग करके एक विकेंद्रीकृत टूडू ऐप बनाएं](https://medium.com/@jjmace01/build-a-decentralized-todo-app-using-vue-js-rust-webassembly-5381a1895beb)
+
+- [Rust में एक ब्लॉकचेन बनाएं](https://blog.logrocket.com/how-to-build-a-blockchain-in-rust/)
+
+## रस्ट परियोजनाएं और उपकरण {#rust-projects-and-tools}
+
+- [pwasm-ethereum](https://github.com/paritytech/pwasm-ethereum) - _एथेरियम-जैसे नेटवर्क के साथ इंटरैक्ट करने के लिए एक्सटर्न का संग्रह_
+- [Lighthouse](https://github.com/sigp/lighthouse) - _तेज एथेरियम सहमति परत क्लाइंट_
+- [Ethereum WebAssembly](https://ewasm.readthedocs.io/en/mkdocs/) - _WebAssembly के एक नियतात्मक सबसेट का उपयोग करके एथेरियम स्मार्ट अनुबंध निष्पादन परत का प्रस्तावित नया स्वरूप_
+- [oasis_std](https://docs.rs/oasis-std/latest/oasis_std/index.html) - _OASIS API संदर्भ_
+- [Solaris](https://github.com/paritytech/sol-rs) - _नेटिव Parity क्लाइंट EVM का उपयोग करके सॉलिडिटी स्मार्ट अनुबंध यूनिट परीक्षण हार्नेस।_
+- [SputnikVM](https://github.com/rust-blockchain/evm) - _रस्ट एथेरियम वर्चुअल मशीन कार्यान्वयन_
+- [Wavelet](https://wavelet.perlin.net/docs/smart-contracts) - _Rust में Wavelet स्मार्ट अनुबंध_
+- [Foundry](https://github.com/foundry-rs/foundry) - _एथेरियम एप्लिकेशन विकास के लिए टूलकिट_
+- [Alloy](https://alloy.rs) - _एथेरियम और अन्य EVM-आधारित श्रृंखलाओं के साथ इंटरैक्ट करने के लिए उच्च-प्रदर्शन, अच्छी तरह से परीक्षित और प्रलेखित लाइब्रेरीज़।_
+- [Ethers_rs](https://github.com/gakonst/ethers-rs) - _एथेरियम लाइब्रेरी और वॉलेट कार्यान्वयन_
+- [SewUp](https://github.com/second-state/SewUp) - _एक लाइब्रेरी जो आपको रस्ट के साथ अपना एथेरियम वेबअसेंबली अनुबंध बनाने में मदद करती है, ठीक वैसे ही जैसे एक सामान्य बैकएंड में विकसित किया जाता है_
+- [Substreams](https://github.com/streamingfast/substreams) - _समानांतर ब्लॉकचेन डेटा अनुक्रमण तकनीक_
+- [Reth](https://github.com/paradigmxyz/reth) Reth (रस्ट एथेरियम का संक्षिप्त रूप) एक नया एथेरियम फुल-नोड कार्यान्वयन है
+- [Awesome Ethereum Rust](https://github.com/Vid201/awesome-ethereum-rust) - _Rust में लिखे गए एथेरियम इकोसिस्टम में परियोजनाओं का एक क्यूरेटेड संग्रह_
+
+अधिक संसाधनों की तलाश है? [ethereum.org/developers.](/developers/) देखें।
+
+## रस्ट समुदाय के योगदानकर्ता {#rust-community-contributors}
+
+- [Ethereum WebAssembly](https://gitter.im/ewasm/Lobby)
+- [Oasis Gitter](https://gitter.im/Oasis-official/Lobby)
+- [Parity Gitter](https://gitter.im/paritytech/parity)
+- [Enigma](https://discord.gg/SJK32GY)
diff --git a/public/content/translations/hi/developers/docs/scaling/index.md b/public/content/translations/hi/developers/docs/scaling/index.md
new file mode 100644
index 00000000000..55986e0c7bd
--- /dev/null
+++ b/public/content/translations/hi/developers/docs/scaling/index.md
@@ -0,0 +1,113 @@
+---
+title: "स्केलिंग"
+description: "एथेरियम समुदाय द्वारा वर्तमान में विकसित किए जा रहे विभिन्न स्केलिंग विकल्पों का परिचय।"
+lang: hi
+sidebarDepth: 3
+---
+
+## स्केलिंग का अवलोकन {#scaling-overview}
+
+जैसे-जैसे एथेरियम का उपयोग करने वाले लोगों की संख्या बढ़ी है, ब्लॉकचेन कुछ क्षमता सीमाओं तक पहुंच गया है। इसने नेटवर्क के उपयोग की लागत को बढ़ा दिया है, जिससे "स्केलिंग समाधानों" की आवश्यकता पैदा हो गई है। कई समाधानों पर शोध किया जा रहा है, उनका परीक्षण किया जा रहा है और उन्हें लागू किया जा रहा है जो समान लक्ष्यों को प्राप्त करने के लिए अलग-अलग दृष्टिकोण अपनाते हैं।
+
+स्केलेबिलिटी का मुख्य लक्ष्य विकेंद्रीकरण या सुरक्षा से समझौता किए बिना लेन-देन की गति (तेज अंतिमता) और लेन-देन थ्रूपुट (प्रति सेकंड लेन-देन की उच्च संख्या) को बढ़ाना है। लेयर 1 एथेरियम ब्लॉकचेन पर, अधिक मांग के कारण लेनदेन धीमा हो जाता है और [गैस की कीमतें](/developers/docs/gas/) अव्यवहार्य हो जाती हैं। गति और प्रवाह के मामले में नेटवर्क क्षमता बढ़ाना एथेरियम के सार्थक और बड़े पैमाने पर अपनाने के लिए मौलिक है।
+
+जबकि गति और प्रवाह महत्वपूर्ण हैं, यह आवश्यक है कि इन लक्ष्यों को सक्षम करने वाले स्केलिंग समाधान विकेंद्रीकृत और सुरक्षित रहें। नोड ऑपरेटरों के लिए प्रवेश बाधा को कम रखना केंद्रीकृत और असुरक्षित कंप्यूटिंग शक्ति की ओर प्रगति को रोकने के लिए महत्वपूर्ण है।
+
+अवधारणात्मक रूप से हम पहले स्केलिंग को या तो ऑनचेन स्केलिंग या ऑफचेन स्केलिंग के रूप में वर्गीकृत करते हैं।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+आपको सभी बुनियादी विषयों की अच्छी समझ होनी चाहिए। स्केलिंग समाधानों को लागू करना उन्नत है क्योंकि प्रौद्योगिकी कम युद्ध-परीक्षित है, और इस पर शोध और विकास जारी है।
+
+## ऑनचेन स्केलिंग {#onchain-scaling}
+
+ऑनचेन स्केलिंग के लिए एथेरियम प्रोटोकॉल (लेयर 1 [मेननेट](/glossary/#mainnet)) में बदलाव की आवश्यकता है। लंबे समय तक, ब्लॉकचेन को शार्डिंग करने की उम्मीद एथेरियम को स्केल करने के लिए थी। इसमें ब्लॉकचेन को अलग-अलग टुकड़ों (शार्ड्स) में विभाजित करना शामिल था जिन्हें सत्यापनकर्ताओं के उपसमुच्चयों द्वारा सत्यापित किया जाना था। हालाँकि, लेयर-2 रोलअप्स द्वारा स्केलिंग प्राथमिक स्केलिंग तकनीक के रूप में आगे बढ़ गई है। यह एथेरियम ब्लॉक्स से जुड़े डेटा के एक नए सस्ते रूप के जोड़ने से समर्थित है जो विशेष रूप से उपयोगकर्ताओं के लिए रोलअप्स को सस्ता बनाने के लिए डिज़ाइन किया गया है।
+
+### शार्डिंग {#sharding}
+
+शार्डिंग डेटाबेस को विभाजित करने की प्रक्रिया है। सत्यापनकर्ताओं के उपसमुच्चय एथेरियम के सभी हिस्सों को ट्रैक करने के बजाय व्यक्तिगत शार्ड्स के लिए जिम्मेदार होंगे। शार्डिंग लंबे समय से एथेरियम के [रोडमैप](/roadmap/) पर था, और एक बार इसे प्रूफ-ऑफ-स्टेक में द मर्ज से पहले भेजे जाने का इरादा था। हालांकि, [लेयर 2 रोलअप](#layer-2-scaling) के तेजी से विकास और [डैंकशार्डिंग](/roadmap/danksharding) के आविष्कार (एथेरियम ब्लॉक में रोलअप डेटा के ब्लॉब जोड़ना जिसे सत्यापनकर्ताओं द्वारा बहुत कुशलता से सत्यापित किया जा सकता है) ने एथेरियम समुदाय को शार्डिंग द्वारा स्केलिंग के बजाय रोलअप-केंद्रित स्केलिंग का पक्ष लेने के लिए प्रेरित किया है। यह एथेरियम की सहमति तर्क को सरल रखने में भी मदद करेगा।
+
+## ऑफचेन स्केलिंग {#offchain-scaling}
+
+ऑफचेन समाधान लेयर 1 मेननेट से अलग लागू किए जाते हैं - उन्हें मौजूदा एथेरियम प्रोटोकॉल में किसी बदलाव की आवश्यकता नहीं होती है। कुछ समाधान, जिन्हें "लेयर 2" समाधान के रूप में जाना जाता है, अपनी सुरक्षा सीधे लेयर 1 एथेरियम सहमति से प्राप्त करते हैं, जैसे [ऑप्टिमिस्टिक रोलअप](/developers/docs/scaling/optimistic-rollups/), [ज़ीरो-नॉलेज रोलअप](/developers/docs/scaling/zk-rollups/) या [स्टेट चैनल](/developers/docs/scaling/state-channels/)। अन्य समाधानों में विभिन्न रूपों में नई चेन का निर्माण शामिल है जो अपनी सुरक्षा मेननेट से अलग प्राप्त करते हैं, जैसे [साइडचेन](#sidechains), [वैलिडियम](#validium), या [प्लाज़्मा चेन](#plasma)। ये समाधान मेननेट के साथ संवाद करते हैं लेकिन विभिन्न लक्ष्यों को प्राप्त करने के लिए अलग तरह से अपनी सुरक्षा प्राप्त करते हैं।
+
+### लेयर 2 स्केलिंग {#layer-2-scaling}
+
+ऑफचेन समाधानों की यह श्रेणी मेननेट एथेरियम से अपनी सुरक्षा प्राप्त करती है।
+
+लेयर 2 एक सामूहिक शब्द है जो ऐसे समाधानों के लिए है जो एथेरियम मेननेट (लेयर 1) से बाहर लेनदेन को संभालकर आपके एप्लिकेशन को स्केल करने में मदद करने के लिए डिज़ाइन किए गए हैं, जबकि मेननेट के मजबूत विकेंद्रीकृत सुरक्षा मॉडल का लाभ उठाते हैं। जब नेटवर्क व्यस्त होता है तो लेनदेन की गति प्रभावित होती है, जिससे कुछ प्रकार के डैप्स के लिए उपयोगकर्ता अनुभव खराब हो जाता है। और जैसे-जैसे नेटवर्क व्यस्त होता जाता है, गैस की कीमतें बढ़ जाती हैं क्योंकि लेनदेन भेजने वाले एक-दूसरे को पछाड़ने की कोशिश करते हैं। यह एथेरियम का उपयोग करना बहुत महंगा बना सकता है।
+
+अधिकांश लेयर 2 समाधान एक सर्वर या सर्वरों के समूह के इर्द-गिर्द केंद्रित होते हैं, जिनमें से प्रत्येक को नोड, सत्यापनकर्ता, ऑपरेटर, अनुक्रमक, ब्लॉक निर्माता, या इसी तरह के शब्द के रूप में संदर्भित किया जा सकता है। कार्यान्वयन के आधार पर, ये लेयर 2 नोड उन व्यक्तियों, व्यवसायों या संस्थाओं द्वारा चलाए जा सकते हैं जो उनका उपयोग करते हैं, या किसी तीसरे पक्ष के ऑपरेटर द्वारा, या व्यक्तियों के एक बड़े समूह द्वारा (मेननेट के समान)। सामान्य तौर पर, लेनदेन सीधे लेयर 1 (मेननेट) पर जमा करने के बजाय इन लेयर 2 नोड्स पर जमा किए जाते हैं। कुछ समाधानों के लिए, लेयर 2 इंस्टेंस उन्हें ग्रुप में बैच करता है, फिर उन्हें लेयर 1 में एंकर करता है, जिसके बाद वे लेयर 1 द्वारा सुरक्षित हो जाते हैं और उन्हें बदला नहीं जा सकता है। यह कैसे किया जाता है इसका विवरण विभिन्न लेयर 2 प्रौद्योगिकियों और कार्यान्वयनों के बीच काफी भिन्न होता है।
+
+एक विशिष्ट लेयर 2 इंस्टेंस खुला हो सकता है और कई एप्लिकेशन द्वारा साझा किया जा सकता है, या किसी एक प्रोजेक्ट द्वारा तैनात किया जा सकता है और केवल उनके एप्लिकेशन का समर्थन करने के लिए समर्पित हो सकता है।
+
+#### लेयर 2 की आवश्यकता क्यों है? {#why-is-layer-2-needed}
+
+- प्रति सेकंड बढ़े हुए लेनदेन उपयोगकर्ता अनुभव को बहुत बेहतर बनाते हैं, और मेननेट इथेरियम पर नेटवर्क भीड़ को कम करते हैं।
+- लेनदेन को मेननेट एथेरियम के लिए एक ही लेनदेन में रोल किया जाता है, जिससे उपयोगकर्ताओं के लिए गैस शुल्क कम हो जाता है और एथेरियम को हर जगह के लोगों के लिए अधिक समावेशी और सुलभ बनाता है।
+- स्केलेबिलिटी के लिए कोई भी अपडेट विकेंद्रीकरण या सुरक्षा की कीमत पर नहीं होना चाहिए - लेयर 2 एथेरियम के ऊपर बनाया जाता है।
+- ऐसे एप्लिकेशन-विशिष्ट लेयर 2 नेटवर्क हैं जो बड़े पैमाने पर संपत्तियों के साथ काम करते समय अपने खुद के दक्षता समूह लाते हैं।
+
+[लेयर 2 के बारे में अधिक जानें](/layer-2/)।
+
+#### रोलअप {#rollups}
+
+रोलअप्स लेयर 1 के बाहर लेनदेन निष्पादन करते हैं और फिर डेटा को लेयर 1 पर पोस्ट किया जाता है जहां सहमति प्राप्त की जाती है। चूंकि लेनदेन डेटा लेयर 1 ब्लॉक्स में शामिल होता है, यह रोलअप्स को मूल इथेरियम सुरक्षा द्वारा सुरक्षित होने की अनुमति देता है।
+
+अलग-अलग सुरक्षा मॉडल के साथ दो प्रकार के रोलअप्स हैं:
+
+- **ऑप्टिमिस्टिक रोलअप**: यह मानता है कि लेनदेन डिफ़ॉल्ट रूप से मान्य होते हैं और केवल चुनौती की स्थिति में, [**धोखाधड़ी प्रमाण**](/glossary/#fraud-proof) के माध्यम से गणना चलाता है। [ऑप्टिमिस्टिक रोलअप के बारे में और जानें](/developers/docs/scaling/optimistic-rollups/)।
+- **ज़ीरो-नॉलेज रोलअप**: ऑफ़चेन गणना चलाता है और चेन पर [**वैधता प्रमाण**](/glossary/#validity-proof) सबमिट करता है। [ज़ीरो-नॉलेज रोलअप के बारे में और जानें](/developers/docs/scaling/zk-rollups/)।
+
+#### स्टेट चैनल {#channels}
+
+स्टेट चैनल मल्टीसिग अनुबंधों का उपयोग करते हैं, जिससे प्रतिभागी तेजी से और स्वतंत्र रूप से ऑफचेन लेनदेन कर सकते हैं, फिर मेननेट के साथ अंतिमता का निपटान करते हैं। यह नेटवर्क भीड़, शुल्क और देरी को कम करता है। वर्तमान में दो प्रकार के चैनल हैं - स्टेट चैनल्स और पेमेंट चैनल्स।
+
+[स्टेट चैनल](/developers/docs/scaling/state-channels/) के बारे में और जानें।
+
+### साइडचेन {#sidechains}
+
+साइडचेन एक स्वतंत्र EVM-संगत ब्लॉकचेन है जो मेननेट के समानांतर चलता है। ये दो-तरफा पुलों के माध्यम से एथेरियम के साथ संगत हैं और अपने चुने हुए सहमति नियमों और ब्लॉक पैरामीटर के तहत चलते हैं।
+
+[साइडचेन](/developers/docs/scaling/sidechains/) के बारे में और जानें।
+
+### प्लाज़्मा {#plasma}
+
+प्लाज़्मा चेन एक अलग ब्लॉकचेन है जो मुख्य एथेरियम चेन से जुड़ी होती है और विवादों में मध्यस्थता करने के लिए धोखाधड़ी प्रमाण (जैसे [ऑप्टिमिस्टिक रोलअप](/developers/docs/scaling/optimistic-rollups/)) का उपयोग करती है।
+
+[प्लाज़्मा](/developers/docs/scaling/plasma/) के बारे में और जानें।
+
+### वैलिडियम {#validium}
+
+एक वैलिडियम चेन शून्य-ज्ञान रोलअप्स की तरह वैधता प्रमाणों का उपयोग करती है लेकिन डेटा को मुख्य लेयर 1 इथेरियम चेन पर संग्रहित नहीं किया जाता है। यह प्रति वैलिडियम चेन प्रति सेकंड 10,000 लेनदेन तक ले जा सकता है और कई चेन समानांतर चलाई जा सकती हैं।
+
+[वैलिडियम](/developers/docs/scaling/validium/) के बारे में और जानें।
+
+## इतने सारे स्केलिंग समाधानों की आवश्यकता क्यों है? {#why-do-we-need-these}
+
+- कई समाधान नेटवर्क के किसी एक भाग पर समग्र भीड़ को कम करने में मदद कर सकते हैं और एकल विफलता बिंदुओं को भी रोक सकते हैं।
+- पूरा उसके हिस्सों के योग से बड़ा है। विभिन्न समाधान मौजूद हो सकते हैं और सामंजस्य में काम कर सकते हैं, जो भविष्य के लेनदेन की गति और प्रवाह पर एक घातीय प्रभाव की अनुमति देता है।
+- सभी समाधानों को सीधे एथेरियम सहमति एल्गोरिथम का उपयोग करने की आवश्यकता नहीं है, और विकल्प ऐसे लाभ प्रदान कर सकते हैं जिन्हें अन्यथा प्राप्त करना मुश्किल होगा।
+
+## क्या आप एक दृश्य शिक्षार्थी हैं? {#visual-learner}
+
+नोट: एथेरियम निश्चित आकार के मान ("हैश") बनाने के लिए नियमित रूप से हैश फ़ंक्शंस का उपयोग करता है। हैश एथेरियम में एक महत्वपूर्ण भूमिका निभाते हैं, लेकिन आप अभी के लिए उन्हें सुरक्षित रूप से अद्वितीय आईडी के रूप में सोच सकते हैं।
+
+
+
+_एक ब्लॉकचेन अनिवार्य रूप से एक लिंक्ड सूची है; प्रत्येक ब्लॉक में पिछले ब्लॉक का एक संदर्भ होता है।_
+
+यह डेटा संरचना कोई नई बात नहीं है, लेकिन नेटवर्क को नियंत्रित करने वाले नियम (यानी, पीयर-टू-पीयर प्रोटोकॉल) हैं। कोई केंद्रीय प्राधिकरण नहीं है; साथियों के नेटवर्क को नेटवर्क को बनाए रखने के लिए सहयोग करना चाहिए, और यह तय करने के लिए प्रतिस्पर्धा करनी चाहिए कि अगले ब्लॉक में कौन से लेनदेन शामिल किए जाएं। तो, जब आप किसी दोस्त को कुछ पैसे भेजना चाहते हैं, तो आपको उस लेनदेन को नेटवर्क पर प्रसारित करना होगा, फिर उसके आगामी ब्लॉक में शामिल होने की प्रतीक्षा करनी होगी।
+
+ब्लॉकचेन के लिए यह सत्यापित करने का एकमात्र तरीका है कि वास्तव में एक उपयोगकर्ता से दूसरे को पैसा भेजा गया था, उस ब्लॉकचेन के लिए एक मूल मुद्रा (यानी, उस ब्लॉकचेन द्वारा बनाई और शासित) का उपयोग करना है। एथेरियम में, इस मुद्रा को ईथर कहा जाता है, और एथेरियम ब्लॉकचेन में खाता शेष का एकमात्र आधिकारिक रिकॉर्ड होता है।
+
+## एक नया प्रतिमान {#a-new-paradigm}
+
+इस नए विकेंद्रीकृत टेक स्टैक ने नए डेवलपर उपकरण बनाए हैं। ऐसे उपकरण कई प्रोग्रामिंग भाषाओं में मौजूद हैं, लेकिन हम पाइथन के दृष्टिकोण से देखेंगे। फिर से दोहराएँ: भले ही पाइथन आपकी पसंद की भाषा न हो, लेकिन साथ में चलना बहुत मुश्किल नहीं होना चाहिए।
+
+पाइथन डेवलपर्स जो एथेरियम के साथ इंटरैक्ट करना चाहते हैं, वे [Web3.py](https://web3py.readthedocs.io/) का उपयोग करने की संभावना रखते हैं। Web3.py एक लाइब्रेरी है जो आपके एथेरियम नोड से कनेक्ट होने, फिर उससे डेटा भेजने और प्राप्त करने के तरीके को बहुत सरल बनाती है।
+
+नोट: "एथेरियम नोड" और "एथेरियम क्लाइंट" का उपयोग एक दूसरे के स्थान पर किया जाता है। दोनों ही मामलों में, यह उस सॉफ़्टवेयर को संदर्भित करता है जिसे एथेरियम नेटवर्क में एक भागीदार चलाता है। यह सॉफ़्टवेयर ब्लॉक डेटा पढ़ सकता है, जब श्रृंखला में नए ब्लॉक जोड़े जाते हैं तो अपडेट प्राप्त कर सकता है, नए लेनदेन प्रसारित कर सकता है, और बहुत कुछ। तकनीकी रूप से, क्लाइंट सॉफ़्टवेयर है, नोड सॉफ़्टवेयर चलाने वाला कंप्यूटर है।
+
+[एथेरियम क्लाइंट](/developers/docs/nodes-and-clients/) को [आईपीसी](https://wikipedia.org/wiki/Inter-process_communication), HTTP, या वेबसॉकेट द्वारा पहुंच योग्य होने के लिए कॉन्फ़िगर किया जा सकता है, इसलिए Web3.py को इस कॉन्फ़िगरेशन को प्रतिबिंबित करने की आवश्यकता होगी। Web3.py इन कनेक्शन विकल्पों को **प्रदाता** के रूप में संदर्भित करता है। आप अपने नोड के साथ Web3.py इंस्टेंस को लिंक करने के लिए तीन प्रदाताओं में से एक को चुनना चाहेंगे।
+
+
+
+_एथेरियम नोड और Web3.py को एक ही प्रोटोकॉल के माध्यम से संचार करने के लिए कॉन्फ़िगर करें, जैसे, इस आरेख में आईपीसी।_
+
+एक बार जब Web3.py ठीक से कॉन्फ़िगर हो जाता है, तो आप ब्लॉकचेन के साथ इंटरैक्ट करना शुरू कर सकते हैं। यहाँ आने वाले समय के पूर्वावलोकन के रूप में Web3.py उपयोग के कुछ उदाहरण दिए गए हैं:
+
+```python
+# ब्लॉक डेटा पढ़ें:
+w3.eth.get_block('latest')
+
+# एक लेनदेन भेजें:
+w3.eth.send_transaction({'from': ..., 'to': ..., 'value': ...})
+```
+
+## इंस्टॉलेशन {#installation}
+
+इस वॉकथ्रू में, हम सिर्फ एक पाइथन इंटरप्रेटर के भीतर काम करेंगे। हम कोई भी डायरेक्टरी, फाइलें, क्लास या फंक्शन नहीं बनाएंगे।
+
+नोट: नीचे दिए गए उदाहरणों में, `$` से शुरू होने वाले कमांड टर्मिनल में चलाए जाने के लिए हैं। (`$` टाइप न करें, यह केवल लाइन की शुरुआत का प्रतीक है।)
+
+सबसे पहले, एक्सप्लोर करने के लिए एक उपयोगकर्ता-अनुकूल वातावरण के लिए [IPython](https://ipython.org/) इंस्टॉल करें। IPython अन्य सुविधाओं के अलावा, टैब पूर्णता प्रदान करता है, जिससे यह देखना बहुत आसान हो जाता है कि Web3.py के भीतर क्या संभव है।
+
+```bash
+pip install ipython
+```
+
+Web3.py को `web3` नाम से प्रकाशित किया गया है। इसे इस तरह स्थापित करें:
+
+```bash
+pip install web3
+```
+
+एक और बात – हम बाद में एक ब्लॉकचेन का अनुकरण करने जा रहे हैं, जिसके लिए कुछ और निर्भरताएँ की आवश्यकता है। आप उन्हें इसके माध्यम से इंस्टॉल कर सकते हैं:
+
+```bash
+pip install 'web3[tester]'
+```
+
+आप जाने के लिए पूरी तरह तैयार हैं!
+
+नोट: `web3[tester]` पैकेज पाइथन 3.10.xx तक काम करता है
+
+## एक सैंडबॉक्स शुरू करें {#spin-up-a-sandbox}
+
+अपने टर्मिनल में `ipython` चलाकर एक नया पाइथन वातावरण खोलें। यह `python` चलाने के तुलनीय है, लेकिन अधिक आकर्षक सुविधाओं के साथ आता है।
+
+```bash
+ipython
+```
+
+यह आपके द्वारा चलाए जा रहे पाइथन और आईपाइथन के संस्करणों के बारे में कुछ जानकारी प्रिंट करेगा, फिर आपको इनपुट की प्रतीक्षा में एक प्रॉम्प्ट देखना चाहिए:
+
+```python
+In [1]:
+```
+
+अब आप एक इंटरैक्टिव पाइथन शेल देख रहे हैं। अनिवार्य रूप से, यह खेलने के लिए एक सैंडबॉक्स है। यदि आप यहां तक पहुंच गए हैं, तो Web3.py को आयात करने का समय आ गया है:
+
+```python
+In [1]: from web3 import Web3
+```
+
+## Web3 मॉड्यूल का परिचय {#introducing-the-web3-module}
+
+एथेरियम का प्रवेश द्वार होने के अलावा, [Web3](https://web3py.readthedocs.io/en/stable/overview.html#base-api) मॉड्यूल कुछ सुविधा फ़ंक्शन प्रदान करता है। आइए कुछ का पता लगाएं।
+
+एथेरियम एप्लिकेशन में, आपको आमतौर पर मुद्रा मूल्यवर्ग को बदलने की आवश्यकता होगी। Web3 मॉड्यूल सिर्फ इसके लिए कुछ सहायक विधियाँ प्रदान करता है: [from_wei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.from_wei) और [to_wei](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.to_wei)।
+
+
+नोट: कंप्यूटर दशमलव गणित को संभालने में कुख्यात रूप से खराब हैं। इससे बचने के लिए, डेवलपर्स अक्सर डॉलर की राशि को सेंट में संग्रहीत करते हैं। उदाहरण के लिए, $5.99 की कीमत वाली किसी वस्तु को डेटाबेस में 599 के रूप में संग्रहीत किया जा सकता है।
+
+ईथर में लेनदेन को संभालते समय एक समान पैटर्न का उपयोग किया जाता है। हालाँकि, दो दशमलव बिंदुओं के बजाय, ईथर में 18 होते हैं! ईथर के सबसे छोटे मूल्यवर्ग को wei कहा जाता है, इसलिए लेनदेन भेजते समय यही मान निर्दिष्ट किया जाता है।
+
+1 ईथर = 1000000000000000000 wei
+
+1 wei = 0.000000000000000001 ईथर
+
+
+
+कुछ मानों को wei में और उससे बदलने का प्रयास करें। ध्यान दें कि ईथर और wei के बीच [कई मूल्यवर्गों के नाम हैं](https://web3py.readthedocs.io/en/stable/troubleshooting.html#how-do-i-convert-currency-denominations)। उनमें से एक बेहतर ज्ञात **gwei** है, क्योंकि यह अक्सर लेनदेन शुल्क का प्रतिनिधित्व करता है।
+
+```python
+In [2]: Web3.to_wei(1, 'ether')
+Out[2]: 1000000000000000000
+
+In [3]: Web3.from_wei(500000000, 'gwei')
+Out[3]: Decimal('0.5')
+```
+
+Web3 मॉड्यूल पर अन्य उपयोगिता विधियों में डेटा प्रारूप कन्वर्टर्स (उदाहरण के लिए, [`toHex`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.toHex)), पता सहायक (उदाहरण के लिए, [`isAddress`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.isAddress)), और हैश फ़ंक्शन (उदाहरण के लिए, [`keccak`](https://web3py.readthedocs.io/en/stable/web3.main.html#web3.Web3.keccak)) शामिल हैं। इनमें से कई को श्रृंखला में बाद में कवर किया जाएगा। सभी उपलब्ध विधियों और गुणों को देखने के लिए, `Web3` टाइप करके IPython के ऑटो-कम्प्लीट का उपयोग करें। और अवधि के बाद टैब कुंजी को दो बार दबाएं।
+
+## श्रृंखला से बात करें {#talk-to-the-chain}
+
+सुविधा विधियाँ प्यारी हैं, लेकिन चलिए ब्लॉकचेन पर आगे बढ़ते हैं। अगला कदम एक एथेरियम नोड के साथ संचार करने के लिए Web3.py को कॉन्फ़िगर करना है। यहां हमारे पास आईपीसी, HTTP, या वेबसॉकेट प्रदाताओं का उपयोग करने का विकल्प है।
+
+हम इस रास्ते पर नहीं जाएंगे, लेकिन HTTP प्रदाता का उपयोग करके एक पूर्ण वर्कफ़्लो का एक उदाहरण कुछ इस तरह दिख सकता है:
+
+- एक एथेरियम नोड डाउनलोड करें, उदा., [Geth](https://geth.ethereum.org/)।
+- एक टर्मिनल विंडो में Geth शुरू करें और नेटवर्क को सिंक करने की प्रतीक्षा करें। डिफ़ॉल्ट HTTP पोर्ट `8545` है, लेकिन यह विन्यास योग्य है।
+- `localhost:8545` पर HTTP के माध्यम से नोड से कनेक्ट करने के लिए Web3.py को बताएं।
+ `w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))`
+- नोड के साथ इंटरैक्ट करने के लिए `w3` इंस्टेंस का उपयोग करें।
+
+हालांकि यह इसे करने का एक "वास्तविक" तरीका है, सिंकिंग प्रक्रिया में घंटों लगते हैं और यदि आप केवल एक विकास वातावरण चाहते हैं तो यह अनावश्यक है। Web3.py इस उद्देश्य के लिए एक चौथा प्रदाता प्रदान करता है, **EthereumTesterProvider**। यह टेस्टर प्रदाता एक सिम्युलेटेड एथेरियम नोड से लिंक करता है जिसमें खेलने के लिए आराम की अनुमतियाँ और नकली मुद्रा होती है।
+
+
+
+_EthereumTesterProvider एक सिम्युलेटेड नोड से कनेक्ट होता है और त्वरित विकास वातावरण के लिए आसान है।_
+
+उस सिम्युलेटेड नोड को [eth-tester](https://github.com/ethereum/eth-tester) कहा जाता है और हमने इसे `pip install web3[tester]` कमांड के हिस्से के रूप में इंस्टॉल किया है। इस टेस्टर प्रदाता का उपयोग करने के लिए Web3.py को कॉन्फ़िगर करना उतना ही सरल है जितना कि:
+
+```python
+In [4]: w3 = Web3(Web3.EthereumTesterProvider())
+```
+
+अब आप चेन सर्फ करने के लिए तैयार हैं! ऐसा लोग नहीं कहते हैं। मैंने बस इसे बना दिया। आइए एक त्वरित दौरा करें।
+
+## त्वरित दौरा {#the-quick-tour}
+
+सबसे पहली बात, एक सामान्य जांच:
+
+```python
+In [5]: w3.is_connected()
+Out[5]: True
+```
+
+चूंकि हम टेस्टर प्रदाता का उपयोग कर रहे हैं, यह बहुत मूल्यवान परीक्षण नहीं है, लेकिन अगर यह विफल हो जाता है, तो संभावना है कि आपने `w3` वैरिएबल को इंस्टेंटियेट करते समय कुछ गलत टाइप किया है। दोहरी जांच करें कि आपने आंतरिक कोष्ठक शामिल किया है, यानी, `Web3.EthereumTesterProvider()`।
+
+## टूर स्टॉप #1: [खाते](/developers/docs/accounts/) {#tour-stop-1-accounts}
+
+एक सुविधा के रूप में, टेस्टर प्रदाता ने कुछ खाते बनाए और उन्हें परीक्षण ईथर के साथ प्रीलोड किया।
+
+सबसे पहले, आइए उन खातों की सूची देखें:
+
+```python
+In [6]: w3.eth.accounts
+Out[6]: ['0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
+ '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF',
+ '0x6813Eb9362372EEF6200f3b1dbC3f819671cBA69', ...]
+```
+
+यदि आप यह कमांड चलाते हैं, तो आपको `0x` से शुरू होने वाले दस स्ट्रिंग्स की एक सूची देखनी चाहिए। प्रत्येक एक **सार्वजनिक पता** है और कुछ मायनों में, एक चेकिंग खाते पर खाता संख्या के समान है। आप यह पता किसी ऐसे व्यक्ति को प्रदान करेंगे जो आपको ईथर भेजना चाहता था।
+
+जैसा कि उल्लेख किया गया है, टेस्टर प्रदाता ने इन प्रत्येक खातों को कुछ परीक्षण ईथर के साथ प्रीलोड किया है। आइए जानें कि पहले खाते में कितना है:
+
+```python
+In [7]: w3.eth.get_balance(w3.eth.accounts[0])
+Out[7]: 1000000000000000000000000
+```
+
+यह बहुत सारे शून्य हैं! नकली बैंक तक हंसते हुए जाने से पहले, पहले से मुद्रा मूल्यवर्ग के बारे में उस सबक को याद करें। ईथर मान सबसे छोटे मूल्यवर्ग, wei में दर्शाए जाते हैं। उसे ईथर में बदलें:
+
+```python
+In [8]: w3.from_wei(1000000000000000000000000, 'ether')
+Out[8]: Decimal('1000000')
+```
+
+एक मिलियन परीक्षण ईथर - अभी भी बहुत बुरा नहीं है।
+
+## टूर स्टॉप #2: ब्लॉक डेटा {#tour-stop-2-block-data}
+
+आइए इस सिम्युलेटेड ब्लॉकचेन की स्थिति पर एक नज़र डालें:
+
+```python
+In [9]: w3.eth.get_block('latest')
+Out[9]: AttributeDict({
+ 'number': 0,
+ 'hash': HexBytes('0x9469878...'),
+ 'parentHash': HexBytes('0x0000000...'),
+ ...
+ 'transactions': []
+})
+```
+
+एक ब्लॉक के बारे में बहुत सारी जानकारी वापस आती है, लेकिन यहाँ इंगित करने के लिए बस कुछ बातें हैं:
+
+- ब्लॉक नंबर शून्य है - चाहे आपने कितने समय पहले टेस्टर प्रदाता को कॉन्फ़िगर किया हो। वास्तविक एथेरियम नेटवर्क के विपरीत, जो हर 12 सेकंड में एक नया ब्लॉक जोड़ता है, यह सिमुलेशन तब तक इंतजार करेगा जब तक आप इसे कुछ काम नहीं देते।
+- `transactions` एक खाली सूची है, उसी कारण से: हमने अभी तक कुछ नहीं किया है। यह पहला ब्लॉक एक **खाली ब्लॉक** है, बस श्रृंखला को शुरू करने के लिए।
+- ध्यान दें कि `parentHash` केवल खाली बाइट्स का एक गुच्छा है। यह दर्शाता है कि यह श्रृंखला का पहला ब्लॉक है, जिसे **जेनेसिस ब्लॉक** भी कहा जाता है।
+
+## टूर स्टॉप #3: [लेनदेन](/developers/docs/transactions/) {#tour-stop-3-transactions}
+
+हम ब्लॉक शून्य पर अटके हुए हैं जब तक कि कोई लंबित लेनदेन न हो, तो चलिए एक देते हैं। एक खाते से दूसरे खाते में कुछ परीक्षण ईथर भेजें:
+
+```python
+In [10]: tx_hash = w3.eth.send_transaction({
+ 'from': w3.eth.accounts[0],
+ 'to': w3.eth.accounts[1],
+ 'value': w3.to_wei(3, 'ether'),
+ 'gas': 21000
+})
+```
+
+यह आमतौर पर वह बिंदु है जहां आप अपने लेनदेन को एक नए ब्लॉक में शामिल होने के लिए कई सेकंड तक प्रतीक्षा करते हैं। पूरी प्रक्रिया कुछ इस तरह होती है:
+
+1. एक लेनदेन जमा करें और लेनदेन हैश को पकड़ कर रखें। जब तक लेनदेन वाले ब्लॉक को बनाया और प्रसारित नहीं किया जाता, तब तक लेनदेन "लंबित" है।
+ `tx_hash = w3.eth.send_transaction({ …` })`
+2. लेनदेन को एक ब्लॉक में शामिल किए जाने की प्रतीक्षा करें:
+ `w3.eth.wait_for_transaction_receipt(tx_hash)`
+3. एप्लिकेशन लॉजिक जारी रखें। सफल लेनदेन देखने के लिए:
+ `w3.eth.get_transaction(tx_hash)`
+
+हमारा सिम्युलेटेड वातावरण तुरंत एक नए ब्लॉक में लेनदेन जोड़ देगा, इसलिए हम तुरंत लेनदेन देख सकते हैं:
+
+```python
+In [11]: w3.eth.get_transaction(tx_hash)
+Out[11]: AttributeDict({
+ 'hash': HexBytes('0x15e9fb95dc39...'),
+ 'blockNumber': 1,
+ 'transactionIndex': 0,
+ 'from': '0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf',
+ 'to': '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF',
+ 'value': 3000000000000000000,
+ ...
+})
+```
+
+आपको यहाँ कुछ परिचित विवरण दिखाई देंगे: `from`, `to`, और `value` फ़ील्ड हमारे `send_transaction` कॉल के इनपुट से मेल खाना चाहिए। दूसरी आश्वस्त करने वाली बात यह है कि यह लेनदेन ब्लॉक नंबर 1 के भीतर पहले लेनदेन (`'transactionIndex': 0`) के रूप में शामिल किया गया था।
+
+हम शामिल दो खातों के शेष राशि की जांच करके इस लेनदेन की सफलता को आसानी से सत्यापित कर सकते हैं। तीन ईथर को एक से दूसरे में जाना चाहिए था।
+
+```python
+In [12]: w3.eth.get_balance(w3.eth.accounts[0])
+Out[12]: 999996999979000000000000
+
+In [13]: w3.eth.get_balance(w3.eth.accounts[1])
+Out[13]: 1000003000000000000000000
+```
+
+बाद वाला अच्छा लग रहा है! शेष राशि 1,000,000 से 1,000,003 ईथर हो गई। लेकिन पहले खाते का क्या हुआ? ऐसा लगता है कि इसने तीन ईथर से थोड़ा अधिक खो दिया है। अफसोस, जीवन में कुछ भी मुफ्त नहीं है, और एथेरियम सार्वजनिक नेटवर्क का उपयोग करने के लिए आपको अपने साथियों को उनकी सहायक भूमिका के लिए क्षतिपूर्ति करने की आवश्यकता है। लेनदेन जमा करने वाले खाते से एक छोटा लेनदेन शुल्क काटा गया था - यह शुल्क गैस की जली हुई मात्रा (ETH हस्तांतरण के लिए 21000 यूनिट गैस) को एक आधार शुल्क से गुणा किया जाता है जो नेटवर्क गतिविधि के अनुसार बदलता है और एक टिप जो उस सत्यापनकर्ता को जाता है जो लेनदेन को एक ब्लॉक में शामिल करता है।
+
+[गैस](/developers/docs/gas/#post-london) पर और अधिक
+
+नोट: सार्वजनिक नेटवर्क पर, लेनदेन शुल्क नेटवर्क की मांग और आप कितनी जल्दी एक लेनदेन को संसाधित करना चाहते हैं, के आधार पर परिवर्तनीय हैं। यदि आप शुल्क की गणना कैसे की जाती है, इसके टूटने में रुचि रखते हैं, तो कैसे लेनदेन एक ब्लॉक में शामिल किए जाते हैं पर मेरी पिछली पोस्ट देखें।
+
+## और साँस लें {#and-breathe}
+
+हम थोड़ी देर से इस पर हैं, इसलिए यह ब्रेक लेने के लिए किसी भी जगह की तरह एक अच्छी जगह लगती है। रैबिट होल जारी है, और हम इस श्रृंखला के भाग दो में अन्वेषण जारी रखेंगे। आने वाली कुछ अवधारणाएँ: एक वास्तविक नोड से जुड़ना, स्मार्ट अनुबंध और टोकन। क्या आपके पास कोई अनुवर्ती प्रश्न हैं? मुझे बताएं! आपकी प्रतिक्रिया प्रभावित करेगी कि हम यहां से कहां जाते हैं। [ट्विटर](https://twitter.com/wolovim) के माध्यम से अनुरोधों का स्वागत है।
diff --git a/public/content/translations/hi/developers/tutorials/all-you-can-cache/index.md b/public/content/translations/hi/developers/tutorials/all-you-can-cache/index.md
new file mode 100644
index 00000000000..34e30dabd4b
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/all-you-can-cache/index.md
@@ -0,0 +1,867 @@
+---
+title: "वह सब कुछ जो आप कैश कर सकते हैं"
+description: "सस्ते रोलअप लेनदेन के लिए कैशिंग अनुबंध बनाने और उपयोग करने का तरीका जानें"
+author: "ओरी पोमेरेन्ट्ज़"
+tags: [ "परत 2", "कैशिंग", "स्टोरेज" ]
+skill: intermediate
+published: 2022-09-15
+lang: hi
+---
+
+रोलअप का उपयोग करते समय, लेनदेन में एक बाइट की लागत भंडारण स्लॉट की लागत से बहुत अधिक महंगी होती है। इसलिए, ऑन-चेन में जितना संभव हो उतनी जानकारी कैश करना समझ में आता है।
+
+इस लेख में आप सीखेंगे कि कैशिंग अनुबंध को इस तरह से कैसे बनाया और उपयोग किया जाए कि कोई भी पैरामीटर मान जिसका कई बार उपयोग होने की संभावना है, उसे कैश किया जाएगा और बहुत कम संख्या में बाइट्स के साथ उपयोग के लिए उपलब्ध होगा (पहली बार के बाद), और इस कैश का उपयोग करने वाले ऑफ़-चेन कोड को कैसे लिखना है।
+
+यदि आप लेख को छोड़ना चाहते हैं और केवल स्रोत कोड देखना चाहते हैं, [तो यह यहां है](https://github.com/qbzzt/20220915-all-you-can-cache)। डेवलपमेंट स्टैक [Foundry](https://getfoundry.sh/introduction/installation/) है।
+
+## समग्र डिजाइन {#overall-design}
+
+सरलता के लिए, हम यह मान लेंगे कि सभी लेनदेन पैरामीटर `uint256`, 32 बाइट्स लंबे हैं। जब हमें कोई लेनदेन प्राप्त होता है, तो हम प्रत्येक पैरामीटर को इस तरह पार्स करेंगे:
+
+1. यदि पहला बाइट `0xFF` है, तो अगले 32 बाइट्स को पैरामीटर मान के रूप में लें और इसे कैश में लिखें।
+
+2. यदि पहला बाइट `0xFE` है, तो अगले 32 बाइट्स को पैरामीटर मान के रूप में लें, लेकिन इसे कैश में _न_ लिखें।
+
+3. किसी भी अन्य मान के लिए, शीर्ष चार बिट्स को अतिरिक्त बाइट्स की संख्या के रूप में लें, और नीचे के चार बिट्स को कैश की के सबसे महत्वपूर्ण बिट्स के रूप में लें। यहां कुछ उदाहरण दिए गए हैं:
+
+ | कॉलडेटा में बाइट्स | कैश की |
+ | :----------------- | -------: |
+ | 0x0F | 0x0F |
+ | 0x10,0x10 | 0x10 |
+ | 0x12,0xAC | 0x02AC |
+ | 0x2D,0xEA, 0xD6 | 0x0DEAD6 |
+
+## कैश मैनिपुलेशन {#cache-manipulation}
+
+कैश [`Cache.sol`](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol) में कार्यान्वित किया गया है। आइए इसे लाइन-दर-लाइन देखें।
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+
+contract Cache {
+
+ bytes1 public constant INTO_CACHE = 0xFF;
+ bytes1 public constant DONT_CACHE = 0xFE;
+```
+
+इन स्थिरांकों का उपयोग उन विशेष मामलों की व्याख्या करने के लिए किया जाता है जहां हम सभी जानकारी प्रदान करते हैं और या तो इसे कैश में लिखा चाहते हैं या नहीं। कैश में लिखने के लिए पहले से अप्रयुक्त भंडारण स्लॉट्स में दो [`SSTORE`](https://www.evm.codes/#55) संचालन की आवश्यकता होती है, जिसमें प्रत्येक की लागत 22100 गैस होती है, इसलिए हम इसे वैकल्पिक बनाते हैं।
+
+```solidity
+
+ mapping(uint => uint) public val2key;
+```
+
+मानों और उनकी कीज़ के बीच एक [मैपिंग](https://www.geeksforgeeks.org/solidity/solidity-mappings/)। लेनदेन भेजने से पहले मानों को एन्कोड करने के लिए यह जानकारी आवश्यक है।
+
+```solidity
+ // स्थान n में की n+1 के लिए मान है, क्योंकि हमें शून्य को
+ // "कैश में नहीं" के रूप में संरक्षित करने की आवश्यकता है।
+ uint[] public key2val;
+```
+
+हम कीज़ से मानों तक मैपिंग के लिए एक ऐरे का उपयोग कर सकते हैं क्योंकि हम कीज़ असाइन करते हैं, और सरलता के लिए हम इसे क्रमिक रूप से करते हैं।
+
+```solidity
+ function cacheRead(uint _key) public view returns (uint) {
+ require(_key <= key2val.length, "अप्रारंभीकृत कैश प्रविष्टि पढ़ना");
+ return key2val[_key-1];
+ } // cacheRead
+```
+
+कैश से एक मान पढ़ें।
+
+```solidity
+ // यदि कोई मान पहले से कैश में नहीं है, तो उसे लिखें
+ // परीक्षण को काम करने में सक्षम करने के लिए केवल सार्वजनिक
+ function cacheWrite(uint _value) public returns (uint) {
+ // यदि मान पहले से ही कैश में है, तो वर्तमान की लौटाएं
+ if (val2key[_value] != 0) {
+ return val2key[_value];
+ }
+```
+
+कैश में एक ही मान को एक से अधिक बार रखने का कोई मतलब नहीं है। यदि मान पहले से ही वहां है, तो बस मौजूदा की लौटाएं।
+
+```solidity
+ // चूंकि 0xFE एक विशेष मामला है, कैश द्वारा रखी जा सकने वाली सबसे बड़ी की
+ // 0x0D है जिसके बाद 15 0xFF हैं। यदि कैश की लंबाई पहले से ही इतनी
+ // बड़ी है, तो विफल हो जाएं।
+ // 1 2 3 4 5 6 7 8 9 A B C D E F
+ require(key2val.length+1 < 0x0DFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
+ "कैश ओवरफ़्लो");
+```
+
+मुझे नहीं लगता कि हमें कभी इतना बड़ा कैश मिलेगा (लगभग 1.8\*1037 प्रविष्टियाँ, जिसे स्टोर करने के लिए लगभग 1027 टीबी की आवश्यकता होगी)। हालाँकि, मैं इतना बूढ़ा हो गया हूँ कि मुझे ["640kB हमेशा पर्याप्त होगा"](https://quoteinvestigator.com/2011/09/08/640k-enough/) याद है। यह परीक्षण बहुत सस्ता है।
+
+```solidity
+ // अगली की का उपयोग करके मान लिखें
+ val2key[_value] = key2val.length+1;
+```
+
+रिवर्स लुकअप जोड़ें (मान से की तक)।
+
+```solidity
+ key2val.push(_value);
+```
+
+फॉरवर्ड लुकअप जोड़ें (की से मान तक)। क्योंकि हम क्रमिक रूप से मान निर्दिष्ट करते हैं, हम इसे अंतिम ऐरे मान के बाद जोड़ सकते हैं।
+
+```solidity
+ return key2val.length;
+ } // cacheWrite
+```
+
+`key2val` की नई लंबाई लौटाएं, जो वह सेल है जहां नया मान संग्रहीत है।
+
+```solidity
+ function _calldataVal(uint startByte, uint length)
+ private pure returns (uint)
+```
+
+यह फ़ंक्शन मनमानी लंबाई (32 बाइट्स तक, शब्द आकार) के कॉलडेटा से एक मान पढ़ता है।
+
+```solidity
+ {
+ uint _retVal;
+
+ require(length < 0x21,
+ "_calldataVal लंबाई सीमा 32 बाइट्स है");
+ require(length + startByte <= msg.data.length,
+ "_calldataVal कॉलडेटासाइज से परे पढ़ने की कोशिश कर रहा है");
+```
+
+यह फ़ंक्शन आंतरिक है, इसलिए यदि बाकी कोड सही ढंग से लिखा गया है, तो इन परीक्षणों की आवश्यकता नहीं है। हालाँकि, उनकी लागत बहुत अधिक नहीं है, इसलिए हम उन्हें भी रख सकते हैं।
+
+```solidity
+ assembly {
+ _retVal := calldataload(startByte)
+ }
+```
+
+यह कोड [Yul](https://docs.soliditylang.org/en/v0.8.16/yul.html) में है। यह कॉलडेटा से 32 बाइट मान पढ़ता है। यह तब भी काम करता है जब कॉलडेटा `startByte+32` से पहले रुक जाता है क्योंकि EVM में अप्रारंभीकृत स्थान को शून्य माना जाता है।
+
+```solidity
+ _retVal = _retVal >> (256-length*8);
+```
+
+हमें आवश्यक रूप से 32 बाइट का मान नहीं चाहिए। यह अतिरिक्त बाइट्स से छुटकारा दिलाता है।
+
+```solidity
+ return _retVal;
+ } // _calldataVal
+
+
+ // _fromByte से शुरू होकर, कॉलडेटा से एक पैरामीटर पढ़ें
+ function _readParam(uint _fromByte) internal
+ returns (uint _nextByte, uint _parameterValue)
+ {
+```
+
+कॉलडेटा से एक पैरामीटर पढ़ें। ध्यान दें कि हमें न केवल पढ़े गए मान को लौटाना होगा, बल्कि अगले बाइट के स्थान को भी लौटाना होगा क्योंकि पैरामीटर 1 बाइट से 33 बाइट्स तक हो सकते हैं।
+
+```solidity
+ // पहला बाइट हमें बताता है कि बाकी की व्याख्या कैसे करें
+ uint8 _firstByte;
+
+ _firstByte = uint8(_calldataVal(_fromByte, 1));
+```
+
+Solidity संभावित खतरनाक [निहित प्रकार रूपांतरण](https://docs.soliditylang.org/en/v0.8.16/types.html#implicit-conversions) को प्रतिबंधित करके बग की संख्या को कम करने का प्रयास करता है। एक डाउनग्रेड, उदाहरण के लिए 256 बिट से 8 बिट तक, स्पष्ट होना चाहिए।
+
+```solidity
+
+ // मान पढ़ें, लेकिन इसे कैश में न लिखें
+ if (_firstByte == uint8(DONT_CACHE))
+ return(_fromByte+33, _calldataVal(_fromByte+1, 32));
+
+ // मान पढ़ें, और इसे कैश में लिखें
+ if (_firstByte == uint8(INTO_CACHE)) {
+ uint _param = _calldataVal(_fromByte+1, 32);
+ cacheWrite(_param);
+ return(_fromByte+33, _param);
+ }
+
+ // अगर हम यहां पहुंचे तो इसका मतलब है कि हमें कैश से पढ़ना है
+
+ // पढ़ने के लिए अतिरिक्त बाइट्स की संख्या
+ uint8 _extraBytes = _firstByte / 16;
+```
+
+निचले [निबल](https://en.wikipedia.org/wiki/Nibble) को लें और इसे कैश से मान पढ़ने के लिए अन्य बाइट्स के साथ मिलाएं।
+
+```solidity
+ uint _key = (uint256(_firstByte & 0x0F) << (8*_extraBytes)) +
+ _calldataVal(_fromByte+1, _extraBytes);
+
+ return (_fromByte+_extraBytes+1, cacheRead(_key));
+
+ } // _readParam
+
+
+ // n पैरामीटर पढ़ें (फ़ंक्शन जानते हैं कि वे कितने पैरामीटर की अपेक्षा करते हैं)
+ function _readParams(uint _paramNum) internal returns (uint[] memory) {
+```
+
+हम कॉलडेटा से ही पैरामीटर्स की संख्या प्राप्त कर सकते हैं, लेकिन हमें कॉल करने वाले फ़ंक्शन जानते हैं कि वे कितने पैरामीटर्स की अपेक्षा करते हैं। उन्हें हमें बताने देना आसान है।
+
+```solidity
+ // वे पैरामीटर जो हम पढ़ते हैं
+ uint[] memory params = new uint[](_paramNum);
+
+ // पैरामीटर बाइट 4 से शुरू होते हैं, उससे पहले यह फ़ंक्शन सिग्नेचर है
+ uint _atByte = 4;
+
+ for(uint i=0; i<_paramNum; i++) {
+ (_atByte, params[i]) = _readParam(_atByte);
+ }
+```
+
+पैरामीटर तब तक पढ़ें जब तक आपके पास आवश्यक संख्या न हो जाए। यदि हम कॉलडेटा के अंत से आगे जाते हैं, तो `_readParams` कॉल को रिवर्ट कर देगा।
+
+```solidity
+
+ return(params);
+ } // readParams
+
+ // _readParams का परीक्षण करने के लिए, चार पैरामीटर पढ़ने का परीक्षण करें
+ function fourParam() public
+ returns (uint256,uint256,uint256,uint256)
+ {
+ uint[] memory params;
+ params = _readParams(4);
+ return (params[0], params[1], params[2], params[3]);
+ } // fourParam
+```
+
+Foundry का एक बड़ा फायदा यह है कि यह Solidity में परीक्षण लिखने की अनुमति देता है ([नीचे कैश का परीक्षण देखें](#testing-the-cache))। यह यूनिट परीक्षणों को बहुत आसान बनाता है। यह एक फ़ंक्शन है जो चार पैरामीटर पढ़ता है और उन्हें लौटाता है ताकि परीक्षण यह सत्यापित कर सके कि वे सही थे।
+
+```solidity
+ // एक मान प्राप्त करें, बाइट्स लौटाएं जो इसे एन्कोड करेंगे (यदि संभव हो तो कैश का उपयोग करके)
+ function encodeVal(uint _val) public view returns(bytes memory) {
+```
+
+`encodeVal` एक फ़ंक्शन है जिसे ऑफ़-चेन कोड कैश का उपयोग करने वाले कॉलडेटा बनाने में मदद के लिए कॉल करता है। यह एक मान प्राप्त करता है और इसे एन्कोड करने वाले बाइट्स लौटाता है। यह फ़ंक्शन एक `view` है, इसलिए इसे किसी लेनदेन की आवश्यकता नहीं है और जब इसे बाहरी रूप से कॉल किया जाता है तो कोई गैस खर्च नहीं होती है।
+
+```solidity
+ uint _key = val2key[_val];
+
+ // मान अभी तक कैश में नहीं है, इसे जोड़ें
+ if (_key == 0)
+ return bytes.concat(INTO_CACHE, bytes32(_val));
+```
+
+[EVM](/developers/docs/evm/) में सभी अप्रारंभीकृत भंडारण को शून्य माना जाता है। इसलिए यदि हम किसी ऐसे मान के लिए की खोज करते हैं जो वहां नहीं है, तो हमें शून्य मिलता है। उस स्थिति में, इसे एन्कोड करने वाले बाइट्स `INTO_CACHE` हैं (ताकि यह अगली बार कैश हो जाए), उसके बाद वास्तविक मान आता है।
+
+```solidity
+ // यदि की <0x10 है, तो इसे एकल बाइट के रूप में लौटाएं
+ if (_key < 0x10)
+ return bytes.concat(bytes1(uint8(_key)));
+```
+
+एकल बाइट्स सबसे आसान हैं। हम `bytes` प्रकार को एक बाइट ऐरे में बदलने के लिए [`bytes.concat`](https://docs.soliditylang.org/en/v0.8.16/types.html#the-functions-bytes-concat-and-string-concat) का उपयोग करते हैं, जो किसी भी लंबाई का हो सकता है। नाम के बावजूद, यह केवल एक तर्क के साथ प्रदान किए जाने पर ठीक काम करता है।
+
+```solidity
+ // दो बाइट मान, 0x1vvv के रूप में एन्कोड किया गया
+ if (_key < 0x1000)
+ return bytes.concat(bytes2(uint16(_key) | 0x1000));
+```
+
+जब हमारे पास 163 से कम की एक की होती है, तो हम इसे दो बाइट्स में व्यक्त कर सकते हैं। हम पहले `_key`, जो एक 256 बिट मान है, को 16 बिट मान में बदलते हैं और पहले बाइट में अतिरिक्त बाइट्स की संख्या जोड़ने के लिए लॉजिकल ऑर का उपयोग करते हैं। फिर हम इसे `bytes2` मान में डालते हैं, जिसे `bytes` में बदला जा सकता है।
+
+```solidity
+ // शायद निम्नलिखित पंक्तियों को एक लूप के रूप में करने का एक चतुर तरीका है,
+ // लेकिन यह एक व्यू फ़ंक्शन है इसलिए मैं प्रोग्रामर के समय और
+ // सरलता के लिए अनुकूलन कर रहा हूँ।
+
+ if (_key < 16*256**2)
+ return bytes.concat(bytes3(uint24(_key) | (0x2 * 16 * 256**2)));
+ if (_key < 16*256**3)
+ return bytes.concat(bytes4(uint32(_key) | (0x3 * 16 * 256**3)));
+ .
+ .
+ .
+ if (_key < 16*256**14)
+ return bytes.concat(bytes15(uint120(_key) | (0xE * 16 * 256**14)));
+ if (_key < 16*256**15)
+ return bytes.concat(bytes16(uint128(_key) | (0xF * 16 * 256**15)));
+```
+
+अन्य मान (3 बाइट्स, 4 बाइट्स, आदि) उसी तरह से संभाला जाता है, बस अलग-अलग फ़ील्ड आकार के साथ।
+
+```solidity
+ // यदि हम यहाँ पहुँचते हैं, तो कुछ गलत है।
+ revert("encodeVal में त्रुटि, नहीं होनी चाहिए");
+```
+
+अगर हम यहां पहुंचते हैं तो इसका मतलब है कि हमें एक की मिली है जो 16\*25615 से कम नहीं है। लेकिन `cacheWrite` कीज़ को सीमित करता है ताकि हम 14\*25616 तक भी नहीं पहुँच सकें (जिसका पहला बाइट 0xFE होगा, इसलिए यह `DONT_CACHE` जैसा दिखेगा)। लेकिन अगर भविष्य में कोई प्रोग्रामर बग पेश करता है तो परीक्षण जोड़ने में हमें बहुत अधिक लागत नहीं लगती है।
+
+```solidity
+ } // encodeVal
+
+} // Cache
+```
+
+### कैश का परीक्षण {#testing-the-cache}
+
+Foundry का एक फायदा यह है कि [यह आपको Solidity में परीक्षण लिखने देता है](https://getfoundry.sh/forge/tests/overview/), जो यूनिट परीक्षण लिखना आसान बनाता है। `Cache` वर्ग के लिए परीक्षण [यहां](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/Cache.t.sol) हैं। क्योंकि परीक्षण कोड दोहराव वाला होता है, जैसा कि परीक्षण होते हैं, यह लेख केवल दिलचस्प भागों की व्याख्या करता है।
+
+```solidity
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+
+
+// कंसोल के लिए `forge test -vv` चलाने की आवश्यकता है।
+import "forge-std/console.sol";
+```
+
+यह केवल बॉयलरप्लेट है जो परीक्षण पैकेज और `console.log` का उपयोग करने के लिए आवश्यक है।
+
+```solidity
+import "src/Cache.sol";
+```
+
+हमें उस अनुबंध को जानने की जरूरत है जिसका हम परीक्षण कर रहे हैं।
+
+```solidity
+contract CacheTest is Test {
+ Cache cache;
+
+ function setUp() public {
+ cache = new Cache();
+ }
+```
+
+`setUp` फ़ंक्शन को प्रत्येक परीक्षण से पहले कॉल किया जाता है। इस मामले में हम बस एक नया कैश बनाते हैं, ताकि हमारे परीक्षण एक-दूसरे को प्रभावित न करें।
+
+```solidity
+ function testCaching() public {
+```
+
+परीक्षण वे फ़ंक्शन हैं जिनके नाम `test` से शुरू होते हैं। यह फ़ंक्शन मूल कैश कार्यक्षमता की जाँच करता है, मानों को लिखता है और उन्हें फिर से पढ़ता है।
+
+```solidity
+ for(uint i=1; i<5000; i++) {
+ cache.cacheWrite(i*i);
+ }
+
+ for(uint i=1; i<5000; i++) {
+ assertEq(cache.cacheRead(i), i*i);
+```
+
+यह है कि आप [`assert...` फ़ंक्शंस](https://getfoundry.sh/reference/forge-std/std-assertions/) का उपयोग करके वास्तविक परीक्षण कैसे करते हैं। इस मामले में, हम यह जाँचते हैं कि हमने जो मान लिखा है वह वही है जिसे हमने पढ़ा है। हम `cache.cacheWrite` के परिणाम को छोड़ सकते हैं क्योंकि हम जानते हैं कि कैश कीज़ रैखिक रूप से निर्दिष्ट की जाती हैं।
+
+```solidity
+ }
+ } // testCaching
+
+
+ // एक ही मान को कई बार कैश करें, सुनिश्चित करें कि की वही रहे
+ //
+ function testRepeatCaching() public {
+ for(uint i=1; i<100; i++) {
+ uint _key1 = cache.cacheWrite(i);
+ uint _key2 = cache.cacheWrite(i);
+ assertEq(_key1, _key2);
+ }
+```
+
+पहले हम प्रत्येक मान को कैश में दो बार लिखते हैं और सुनिश्चित करते हैं कि कीज़ समान हैं (जिसका अर्थ है कि दूसरा लेखन वास्तव में नहीं हुआ)।
+
+```solidity
+ for(uint i=1; i<100; i+=3) {
+ uint _key = cache.cacheWrite(i);
+ assertEq(_key, i);
+ }
+ } // testRepeatCaching
+```
+
+सिद्धांत रूप में, एक बग हो सकता है जो लगातार कैश लिखने को प्रभावित नहीं करता है। तो यहाँ हम कुछ ऐसे लेख करते हैं जो लगातार नहीं होते हैं और देखते हैं कि मान अभी भी फिर से नहीं लिखे गए हैं।
+
+```solidity
+ // मेमोरी बफर से एक uint पढ़ें (यह सुनिश्चित करने के लिए कि हम उन पैरामीटरों को वापस प्राप्त करें
+ // जो हमने भेजे हैं)
+ function toUint256(bytes memory _bytes, uint256 _start) internal pure
+ returns (uint256)
+```
+
+`bytes memory` बफर से 256 बिट शब्द पढ़ें। यह यूटिलिटी फ़ंक्शन हमें यह सत्यापित करने देता है कि जब हम कैश का उपयोग करने वाले फ़ंक्शन कॉल चलाते हैं तो हमें सही परिणाम प्राप्त होते हैं।
+
+```solidity
+ {
+ require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
+ uint256 tempUint;
+
+ assembly {
+ tempUint := mload(add(add(_bytes, 0x20), _start))
+ }
+```
+
+Yul `uint256` से परे डेटा संरचनाओं का समर्थन नहीं करता है, इसलिए जब आप एक अधिक परिष्कृत डेटा संरचना, जैसे कि मेमोरी बफर `_bytes` का उल्लेख करते हैं, तो आपको उस संरचना का पता मिलता है। Solidity `bytes memory` मानों को 32 बाइट शब्द के रूप में संग्रहीत करता है जिसमें लंबाई होती है, उसके बाद वास्तविक बाइट्स होते हैं, इसलिए बाइट नंबर `_start` प्राप्त करने के लिए हमें `_bytes+32+_start` की गणना करने की आवश्यकता है।
+
+```solidity
+
+ return tempUint;
+ } // toUint256
+
+ // fourParams() के लिए फ़ंक्शन सिग्नेचर, सौजन्य से
+ // https://www.4byte.directory/signatures/?bytes4_signature=0x3edc1e6d
+ bytes4 constant FOUR_PARAMS = 0x3edc1e6d;
+
+ // बस कुछ स्थिर मान यह देखने के लिए कि हमें सही मान वापस मिल रहे हैं
+ uint256 constant VAL_A = 0xDEAD60A7;
+ uint256 constant VAL_B = 0xBEEF;
+ uint256 constant VAL_C = 0x600D;
+ uint256 constant VAL_D = 0x600D60A7;
+```
+
+परीक्षण के लिए हमें कुछ स्थिरांक चाहिए।
+
+```solidity
+ function testReadParam() public {
+```
+
+`fourParams()` को कॉल करें, एक फ़ंक्शन जो `readParams` का उपयोग करता है, यह परीक्षण करने के लिए कि हम पैरामीटर सही ढंग से पढ़ सकते हैं।
+
+```solidity
+ address _cacheAddr = address(cache);
+ bool _success;
+ bytes memory _callInput;
+ bytes memory _callOutput;
+```
+
+हम कैश का उपयोग करके किसी फ़ंक्शन को कॉल करने के लिए सामान्य ABI तंत्र का उपयोग नहीं कर सकते हैं, इसलिए हमें निम्न स्तर के [`.call()`](https://docs.soliditylang.org/en/v0.8.16/types.html#members-of-addresses) तंत्र का उपयोग करने की आवश्यकता है। वह तंत्र इनपुट के रूप में `bytes memory` लेता है, और उसे (साथ ही एक बूलियन मान) आउटपुट के रूप में लौटाता है।
+
+```solidity
+ // पहली कॉल, कैश खाली है
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+```
+
+एक ही अनुबंध के लिए दोनों कैश्ड फ़ंक्शन (लेनदेन से सीधे कॉल के लिए) और गैर-कैश्ड फ़ंक्शन (अन्य स्मार्ट अनुबंधों से कॉल के लिए) का समर्थन करना उपयोगी है। ऐसा करने के लिए हमें सही फ़ंक्शन को कॉल करने के लिए Solidity तंत्र पर भरोसा करना जारी रखना होगा, बजाय इसके कि सब कुछ [एक `fallback` फ़ंक्शन](https://docs.soliditylang.org/en/v0.8.16/contracts.html#fallback-function) में डाल दिया जाए। ऐसा करने से कम्पोजिबिलिटी बहुत आसान हो जाती है। ज्यादातर मामलों में फ़ंक्शन की पहचान करने के लिए एक बाइट ही काफी होगी, इसलिए हम तीन बाइट्स (16\*3=48 गैस) बर्बाद कर रहे हैं। हालाँकि, जैसा कि मैं यह लिख रहा हूँ, उन 48 गैस की लागत 0.07 सेंट है, जो सरल, कम बग प्रवण, कोड की एक उचित लागत है।
+
+```solidity
+ // पहला मान, इसे कैश में जोड़ें
+ cache.INTO_CACHE(),
+ bytes32(VAL_A),
+```
+
+पहला मान: एक फ्लैग जो कहता है कि यह एक पूर्ण मान है जिसे कैश में लिखा जाना चाहिए, उसके बाद मान के 32 बाइट्स आते हैं। अन्य तीन मान समान हैं, सिवाय इसके कि `VAL_B` को कैश में नहीं लिखा जाता है और `VAL_C` तीसरा और चौथा दोनों पैरामीटर है।
+
+```solidity
+ .
+ .
+ .
+ );
+ (_success, _callOutput) = _cacheAddr.call(_callInput);
+```
+
+यह वह जगह है जहां हम वास्तव में `Cache` अनुबंध को कॉल करते हैं।
+
+```solidity
+ assertEq(_success, true);
+```
+
+हम उम्मीद करते हैं कि कॉल सफल होगी।
+
+```solidity
+ assertEq(cache.cacheRead(1), VAL_A);
+ assertEq(cache.cacheRead(2), VAL_C);
+```
+
+हम एक खाली कैश से शुरू करते हैं और फिर `VAL_A` और उसके बाद `VAL_C` जोड़ते हैं। हम उम्मीद करेंगे कि पहले वाले की की 1 होगी, और दूसरे की 2 होगी।
+
+```
+ assertEq(toUint256(_callOutput,0), VAL_A);
+ assertEq(toUint256(_callOutput,32), VAL_B);
+ assertEq(toUint256(_callOutput,64), VAL_C);
+ assertEq(toUint256(_callOutput,96), VAL_C);
+```
+
+आउटपुट चार पैरामीटर हैं। यहां हम सत्यापित करते हैं कि यह सही है।
+
+```solidity
+ // दूसरी कॉल, हम कैश का उपयोग कर सकते हैं
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+
+ // कैश में पहला मान
+ bytes1(0x01),
+```
+
+16 से नीचे की कैश कीज़ केवल एक बाइट की होती हैं।
+
+```solidity
+ // दूसरा मान, इसे कैश में न जोड़ें
+ cache.DONT_CACHE(),
+ bytes32(VAL_B),
+
+ // तीसरा और चौथा मान, एक ही मान
+ bytes1(0x02),
+ bytes1(0x02)
+ );
+ .
+ .
+ .
+ } // testReadParam
+```
+
+कॉल के बाद के परीक्षण पहली कॉल के बाद के परीक्षणों के समान हैं।
+
+```solidity
+ function testEncodeVal() public {
+```
+
+यह फ़ंक्शन `testReadParam` के समान है, सिवाय इसके कि पैरामीटर को स्पष्ट रूप से लिखने के बजाय हम `encodeVal()` का उपयोग करते हैं।
+
+```solidity
+ .
+ .
+ .
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+ cache.encodeVal(VAL_A),
+ cache.encodeVal(VAL_B),
+ cache.encodeVal(VAL_C),
+ cache.encodeVal(VAL_D)
+ );
+ .
+ .
+ .
+ assertEq(_callInput.length, 4+1*4);
+ } // testEncodeVal
+```
+
+`testEncodeVal()` में एकमात्र अतिरिक्त परीक्षण यह सत्यापित करना है कि `_callInput` की लंबाई सही है। पहली कॉल के लिए यह 4+33\*4 है। दूसरे के लिए, जहां हर मान पहले से ही कैश में है, यह 4+1\*4 है।
+
+```solidity
+ // जब की एक बाइट से अधिक हो तो encodeVal का परीक्षण करें
+ // अधिकतम तीन बाइट्स क्योंकि कैश को चार बाइट्स तक भरने में
+ // बहुत समय लगता है।
+ function testEncodeValBig() public {
+ // कैश में कई मान रखें।
+ // चीजों को सरल रखने के लिए, मान n के लिए की n का उपयोग करें।
+ for(uint i=1; i<0x1FFF; i++) {
+ cache.cacheWrite(i);
+ }
+```
+
+ऊपर दिया गया `testEncodeVal` फ़ंक्शन कैश में केवल चार मान लिखता है, इसलिए [फ़ंक्शन का वह हिस्सा जो बहु-बाइट मानों से संबंधित है](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/Cache.sol#L144-L171) की जाँच नहीं की जाती है। लेकिन वह कोड जटिल और त्रुटि-प्रवण है।
+
+इस फ़ंक्शन का पहला भाग एक लूप है जो 1 से 0x1FFF तक के सभी मानों को क्रम से कैश में लिखता है, ताकि हम उन मानों को एन्कोड कर सकें और जान सकें कि वे कहाँ जा रहे हैं।
+
+```solidity
+ .
+ .
+ .
+
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+ cache.encodeVal(0x000F), // एक बाइट 0x0F
+ cache.encodeVal(0x0010), // दो बाइट्स 0x1010
+ cache.encodeVal(0x0100), // दो बाइट्स 0x1100
+ cache.encodeVal(0x1000) // तीन बाइट्स 0x201000
+ );
+```
+
+एक बाइट, दो बाइट और तीन बाइट मानों का परीक्षण करें। हम इससे आगे का परीक्षण नहीं करते हैं क्योंकि पर्याप्त स्टैक प्रविष्टियाँ (कम से कम 0x10000000, लगभग एक चौथाई अरब) लिखने में बहुत समय लगेगा।
+
+```solidity
+ .
+ .
+ .
+ .
+ } // testEncodeValBig
+
+
+ // परीक्षण करें कि अत्यधिक छोटे बफर के साथ हमें एक रिवर्ट मिलता है
+ function testShortCalldata() public {
+```
+
+असामान्य मामले में क्या होता है, इसका परीक्षण करें जहां पर्याप्त पैरामीटर नहीं हैं।
+
+```solidity
+ .
+ .
+ .
+ (_success, _callOutput) = _cacheAddr.call(_callInput);
+ assertEq(_success, false);
+ } // testShortCalldata
+```
+
+चूंकि यह रिवर्ट होता है, इसलिए हमें जो परिणाम मिलना चाहिए वह `false` है।
+
+```
+ // कैश कीज़ के साथ कॉल करें जो वहां नहीं हैं
+ function testNoCacheKey() public {
+ .
+ .
+ .
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+
+ // पहला मान, इसे कैश में जोड़ें
+ cache.INTO_CACHE(),
+ bytes32(VAL_A),
+
+ // दूसरा मान
+ bytes1(0x0F),
+ bytes2(0x1234),
+ bytes11(0xA10102030405060708090A)
+ );
+```
+
+यह फ़ंक्शन चार पूरी तरह से वैध पैरामीटर प्राप्त करता है, सिवाय इसके कि कैश खाली है इसलिए पढ़ने के लिए कोई मान नहीं हैं।
+
+```solidity
+ .
+ .
+ .
+ // परीक्षण करें कि अत्यधिक लंबे बफर के साथ सब कुछ ठीक काम करता है
+ function testLongCalldata() public {
+ address _cacheAddr = address(cache);
+ bool _success;
+ bytes memory _callInput;
+ bytes memory _callOutput;
+
+ // पहली कॉल, कैश खाली है
+ _callInput = bytes.concat(
+ FOUR_PARAMS,
+
+ // पहला मान, इसे कैश में जोड़ें
+ cache.INTO_CACHE(), bytes32(VAL_A),
+
+ // दूसरा मान, इसे कैश में जोड़ें
+ cache.INTO_CACHE(), bytes32(VAL_B),
+
+ // तीसरा मान, इसे कैश में जोड़ें
+ cache.INTO_CACHE(), bytes32(VAL_C),
+
+ // चौथा मान, इसे कैश में जोड़ें
+ cache.INTO_CACHE(), bytes32(VAL_D),
+
+ // और "शुभकामनाओं" के लिए एक और मान
+ bytes4(0x31112233)
+ );
+```
+
+यह फ़ंक्शन पांच मान भेजता है। हम जानते हैं कि पांचवें मान को अनदेखा कर दिया जाता है क्योंकि यह एक वैध कैश प्रविष्टि नहीं है, जो अगर शामिल नहीं किया गया होता तो एक रिवर्ट का कारण बनता।
+
+```solidity
+ (_success, _callOutput) = _cacheAddr.call(_callInput);
+ assertEq(_success, true);
+ .
+ .
+ .
+ } // testLongCalldata
+
+} // CacheTest
+
+```
+
+## एक नमूना एप्लिकेशन {#a-sample-app}
+
+Solidity में परीक्षण लिखना बहुत अच्छी बात है, लेकिन दिन के अंत में एक डैप को उपयोगी होने के लिए श्रृंखला के बाहर से अनुरोधों को संसाधित करने में सक्षम होना चाहिए। यह लेख `WORM` के साथ एक डैप में कैशिंग का उपयोग करने का तरीका बताता है, जिसका अर्थ है "एक बार लिखें, कई बार पढ़ें"। यदि कोई की अभी तक नहीं लिखी गई है, तो आप उस पर एक मान लिख सकते हैं। यदि की पहले से लिखी हुई है, तो आपको एक रिवर्ट मिलता है।
+
+### अनुबंध {#the-contract}
+
+[यह अनुबंध है](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/src/WORM.sol)। यह ज्यादातर वही दोहराता है जो हम पहले ही `Cache` और `CacheTest` के साथ कर चुके हैं, इसलिए हम केवल उन हिस्सों को कवर करते हैं जो दिलचस्प हैं।
+
+```solidity
+import "./Cache.sol";
+
+contract WORM is Cache {
+```
+
+`Cache` का उपयोग करने का सबसे आसान तरीका इसे अपने अनुबंध में इनहेरिट करना है।
+
+```solidity
+ function writeEntryCached() external {
+ uint[] memory params = _readParams(2);
+ writeEntry(params[0], params[1]);
+ } // writeEntryCached
+```
+
+यह फ़ंक्शन ऊपर `CacheTest` में `fourParam` के समान है। क्योंकि हम ABI विनिर्देशों का पालन नहीं करते हैं, इसलिए फ़ंक्शन में कोई पैरामीटर घोषित न करना सबसे अच्छा है।
+
+```solidity
+ // हमें कॉल करना आसान बनाएं
+ // writeEntryCached() के लिए फ़ंक्शन हस्ताक्षर, सौजन्य से
+ // https://www.4byte.directory/signatures/?bytes4_signature=0xe4e4f2d3
+ bytes4 constant public WRITE_ENTRY_CACHED = 0xe4e4f2d3;
+```
+
+बाहरी कोड जो `writeEntryCached` को कॉल करता है, उसे मैन्युअल रूप से कॉलडेटा बनाना होगा, बजाय `worm.writeEntryCached` का उपयोग करने के, क्योंकि हम ABI विनिर्देशों का पालन नहीं करते हैं। इस स्थिर मान का होना इसे लिखना आसान बनाता है।
+
+ध्यान दें कि यद्यपि हम `WRITE_ENTRY_CACHED` को एक स्टेट चर के रूप में परिभाषित करते हैं, इसे बाहरी रूप से पढ़ने के लिए इसके लिए गेटर फ़ंक्शन का उपयोग करना आवश्यक है, `worm.WRITE_ENTRY_CACHED()`।
+
+```solidity
+ function readEntry(uint key) public view
+ returns (uint _value, address _writtenBy, uint _writtenAtBlock)
+```
+
+रीड फ़ंक्शन एक `view` है, इसलिए इसे किसी लेनदेन की आवश्यकता नहीं है और इसमें गैस खर्च नहीं होती है। परिणामस्वरूप, पैरामीटर के लिए कैश का उपयोग करने का कोई लाभ नहीं है। व्यू फ़ंक्शंस के साथ, सरल मानक तंत्र का उपयोग करना सबसे अच्छा है।
+
+### परीक्षण कोड {#the-testing-code}
+
+[यह अनुबंध के लिए परीक्षण कोड है](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/test/WORM.t.sol)। फिर से, आइए केवल दिलचस्प बातों पर ध्यान दें।
+
+```solidity
+ function testWReadWrite() public {
+ worm.writeEntry(0xDEAD, 0x60A7);
+
+ vm.expectRevert(bytes("प्रविष्टि पहले से लिखी हुई है"));
+ worm.writeEntry(0xDEAD, 0xBEEF);
+```
+
+[यह (`vm.expectRevert`)](https://book.getfoundry.sh/cheatcodes/expect-revert#expectrevert) है कि हम एक Foundry परीक्षण में कैसे निर्दिष्ट करते हैं कि अगली कॉल विफल होनी चाहिए, और विफलता का रिपोर्ट किया गया कारण। यह तब लागू होता है जब हम सिंटैक्स `. का उपयोग करते हैं()` बजाय इसके कि हम कॉलडेटा बनाएं और निम्न-स्तरीय इंटरफ़ेस (`.call()`, आदि) का उपयोग करके अनुबंध को कॉल करें।
+
+```solidity
+ function testReadWriteCached() public {
+ uint cacheGoat = worm.cacheWrite(0x60A7);
+```
+
+यहां हम इस तथ्य का उपयोग करते हैं कि `cacheWrite` कैश की लौटाता है। यह कुछ ऐसा नहीं है जिसे हम उत्पादन में उपयोग करने की उम्मीद करेंगे, क्योंकि `cacheWrite` स्टेट को बदलता है, और इसलिए इसे केवल एक लेनदेन के दौरान ही कॉल किया जा सकता है। लेनदेन के पास रिटर्न मान नहीं होते हैं, यदि उनके पास परिणाम होते हैं तो उन परिणामों को इवेंट्स के रूप में उत्सर्जित किया जाना चाहिए। तो `cacheWrite` रिटर्न मान केवल ऑन-चेन कोड से सुलभ है, और ऑन-चेन कोड को पैरामीटर कैशिंग की आवश्यकता नहीं है।
+
+```solidity
+ (_success,) = address(worm).call(_callInput);
+```
+
+यह है कि हम Solidity को कैसे बताते हैं कि जबकि `.call()` के दो रिटर्न मान हैं, हम केवल पहले की परवाह करते हैं।
+
+```solidity
+ (_success,) = address(worm).call(_callInput);
+ assertEq(_success, false);
+```
+
+चूंकि हम निम्न स्तर `.call()` फ़ंक्शन का उपयोग करते हैं, इसलिए हम `vm.expectRevert()` का उपयोग नहीं कर सकते हैं और हमें कॉल से प्राप्त बूलियन सफलता मान को देखना होगा।
+
+```solidity
+ event EntryWritten(uint indexed key, uint indexed value);
+
+ .
+ .
+ .
+
+ _callInput = bytes.concat(
+ worm.WRITE_ENTRY_CACHED(), worm.encodeVal(a), worm.encodeVal(b));
+ vm.expectEmit(true, true, false, false);
+ emit EntryWritten(a, b);
+ (_success,) = address(worm).call(_callInput);
+```
+
+यह वह तरीका है जिससे हम सत्यापित करते हैं कि कोड Foundry में [एक इवेंट सही ढंग से उत्सर्जित करता है](https://getfoundry.sh/reference/cheatcodes/expect-emit/)।
+
+### क्लाइंट {#the-client}
+
+एक चीज जो आपको Solidity परीक्षणों के साथ नहीं मिलती है, वह है JavaScript कोड जिसे आप अपने एप्लिकेशन में काट और चिपका सकते हैं। उस कोड को लिखने के लिए मैंने WORM को [Optimism Goerli](https://community.optimism.io/docs/useful-tools/networks/#optimism-goerli), [Optimism's](https://www.optimism.io/) नए टेस्टनेट पर डिप्लॉय किया। यह [`0xd34335b1d818cee54e3323d3246bd31d94e6a78a`](https://goerli-optimism.etherscan.io/address/0xd34335b1d818cee54e3323d3246bd31d94e6a78a) पते पर है।
+
+[आप क्लाइंट के लिए JavaScript कोड यहां देख सकते हैं](https://github.com/qbzzt/20220915-all-you-can-cache/blob/main/javascript/index.js)। इसका उपयोग करने के लिए:
+
+1. git रिपॉजिटरी को क्लोन करें:
+
+ ```sh
+ git clone https://github.com/qbzzt/20220915-all-you-can-cache.git
+ ```
+
+2. आवश्यक पैकेज स्थापित करें:
+
+ ```sh
+ cd javascript
+ yarn
+ ```
+
+3. कॉन्फ़िगरेशन फ़ाइल कॉपी करें:
+
+ ```sh
+ cp .env.example .env
+ ```
+
+4. अपने कॉन्फ़िगरेशन के लिए `.env` संपादित करें:
+
+ | पैरामीटर | मूल्य |
+ | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+ | MNEMONIC | एक ऐसे खाते के लिए स्मरक जिसके पास लेनदेन के भुगतान के लिए पर्याप्त ETH है। [आप Optimism Goerli नेटवर्क के लिए मुफ्त ETH यहाँ से प्राप्त कर सकते हैं](https://optimismfaucet.xyz/)। |
+ | OPTIMISM_GOERLI_URL | Optimism Goerli का URL। सार्वजनिक एंडपॉइंट, `https://goerli.optimism.io`, दर सीमित है लेकिन यहां हमें जो चाहिए उसके लिए पर्याप्त है |
+
+5. `index.js` चलाएँ।
+
+ ```sh
+ node index.js
+ ```
+
+ यह नमूना एप्लिकेशन पहले WORM में एक प्रविष्टि लिखता है, कॉलडेटा और Etherscan पर लेनदेन के लिए एक लिंक प्रदर्शित करता है। फिर यह उस प्रविष्टि को वापस पढ़ता है, और उस की को प्रदर्शित करता है जिसका वह उपयोग करता है और प्रविष्टि में मान (मान, ब्लॉक संख्या और लेखक) प्रदर्शित करता है।
+
+अधिकांश क्लाइंट सामान्य Dapp JavaScript है। तो फिर हम केवल दिलचस्प भागों पर जाएंगे।
+
+```javascript
+.
+.
+.
+const main = async () => {
+ const func = await worm.WRITE_ENTRY_CACHED()
+
+ // हर बार एक नई की की आवश्यकता होती है
+ const key = await worm.encodeVal(Number(new Date()))
+```
+
+एक दिए गए स्लॉट में केवल एक बार लिखा जा सकता है, इसलिए हम यह सुनिश्चित करने के लिए टाइमस्टैम्प का उपयोग करते हैं कि हम स्लॉट का पुन: उपयोग न करें।
+
+```javascript
+const val = await worm.encodeVal("0x600D")
+
+// एक प्रविष्टि लिखें
+const calldata = func + key.slice(2) + val.slice(2)
+```
+
+Ethers को उम्मीद है कि कॉल डेटा एक हेक्स स्ट्रिंग होगा, `0x` जिसके बाद सम संख्या में हेक्साडेसिमल अंक होंगे। चूंकि `key` और `val` दोनों `0x` से शुरू होते हैं, इसलिए हमें उन हेडर को हटाने की जरूरत है।
+
+```javascript
+const tx = await worm.populateTransaction.writeEntryCached()
+tx.data = calldata
+
+sentTx = await wallet.sendTransaction(tx)
+```
+
+Solidity परीक्षण कोड की तरह, हम सामान्य रूप से कैश्ड फ़ंक्शन को कॉल नहीं कर सकते हैं। इसके बजाय, हमें एक निचले स्तर के तंत्र का उपयोग करने की आवश्यकता है।
+
+```javascript
+ .
+ .
+ .
+ // अभी-अभी लिखी गई प्रविष्टि पढ़ें
+ const realKey = '0x' + key.slice(4) // FF ध्वज हटाएं
+ const entryRead = await worm.readEntry(realKey)
+ .
+ .
+ .
+```
+
+प्रविष्टियों को पढ़ने के लिए हम सामान्य तंत्र का उपयोग कर सकते हैं। `view` फ़ंक्शंस के साथ पैरामीटर कैशिंग का उपयोग करने की कोई आवश्यकता नहीं है।
+
+## निष्कर्ष {#conclusion}
+
+इस लेख में कोड एक अवधारणा का प्रमाण है, इसका उद्देश्य विचार को समझना आसान बनाना है। उत्पादन-तैयार प्रणाली के लिए आप कुछ अतिरिक्त कार्यक्षमता लागू करना चाह सकते हैं:
+
+- `uint256` न होने वाले मानों को संभालें। उदाहरण के लिए, स्ट्रिंग्स।
+- एक वैश्विक कैश के बजाय, शायद उपयोगकर्ताओं और कैश के बीच एक मैपिंग हो। विभिन्न यूज़र अलग-अलग मानों का उपयोग करते हैं।
+- पतों के लिए उपयोग किए जाने वाले मान अन्य उद्देश्यों के लिए उपयोग किए जाने वाले मानों से भिन्न होते हैं। सिर्फ पतों के लिए एक अलग कैश रखना समझदारी हो सकती है।
+- वर्तमान में, कैश कीज़ "पहले आओ, सबसे छोटी की" एल्गोरिथम पर हैं। पहले सोलह मानों को एक बाइट के रूप में भेजा जा सकता है। अगले 4080 मान दो बाइट्स के रूप में भेजे जा सकते हैं। अगले लगभग दस लाख मान तीन बाइट्स हैं, आदि। एक उत्पादन प्रणाली को कैश प्रविष्टियों पर उपयोग काउंटरों को रखना चाहिए और उन्हें पुनर्गठित करना चाहिए ताकि सोलह _सबसे आम_ मान एक बाइट के हों, अगले 4080 सबसे आम मान दो बाइट्स के हों, आदि।
+
+ हालाँकि, यह एक संभावित खतरनाक ऑपरेशन है। इवेंट्स के निम्नलिखित क्रम की कल्पना करें:
+
+ 1. नोआम नेव `encodeVal` को उस पते को एन्कोड करने के लिए कॉल करता है जिस पर वह टोकन भेजना चाहता है। वह पता एप्लिकेशन पर उपयोग किए जाने वाले पहले में से एक है, इसलिए एन्कोडेड मान 0x06 है। यह एक `view` फ़ंक्शन है, लेनदेन नहीं, इसलिए यह नोआम और उसके द्वारा उपयोग किए जाने वाले नोड के बीच है, और इसके बारे में कोई और नहीं जानता है
+
+ 2. ओवेन ओनर कैश रीऑर्डरिंग ऑपरेशन चलाता है। बहुत कम लोग वास्तव में उस पते का उपयोग करते हैं, इसलिए अब इसे 0x201122 के रूप में एन्कोड किया गया है। एक अलग मान, 1018, को 0x06 असाइन किया गया है।
+
+ 3. नोआम नेव अपने टोकन 0x06 पर भेजता है। वे `0x0000000000000000000000000de0b6b3a7640000` पते पर जाते हैं, और चूंकि कोई भी उस पते के लिए निजी कुंजी नहीं जानता है, इसलिए वे बस वहीं फंसे रहते हैं। नोआम _खुश नहीं_ है।
+
+ इस समस्या को हल करने के तरीके हैं, और कैश रीऑर्डर के दौरान मेमपूल में होने वाले लेनदेन की संबंधित समस्या, लेकिन आपको इसके बारे में पता होना चाहिए।
+
+मैंने यहाँ Optimism के साथ कैशिंग का प्रदर्शन किया, क्योंकि मैं एक Optimism कर्मचारी हूँ और यह वह रोलअप है जिसे मैं सबसे अच्छी तरह जानता हूँ। लेकिन इसे किसी भी रोलअप के साथ काम करना चाहिए जो आंतरिक प्रसंस्करण के लिए न्यूनतम लागत वसूलता है, ताकि तुलना में लेनदेन डेटा को L1 पर लिखना प्रमुख व्यय हो।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
+
diff --git a/public/content/translations/hi/developers/tutorials/app-plasma/index.md b/public/content/translations/hi/developers/tutorials/app-plasma/index.md
new file mode 100644
index 00000000000..9e9ee6aa6aa
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/app-plasma/index.md
@@ -0,0 +1,1255 @@
+---
+title: "एक ऐप-विशिष्ट प्लाज्मा लिखें जो गोपनीयता को संरक्षित रखता है"
+description: "इस ट्यूटोरियल में, हम जमा के लिए एक अर्ध-गुप्त बैंक बनाते हैं। बैंक एक केंद्रीकृत घटक है; यह प्रत्येक उपयोगकर्ता की शेष राशि जानता है। हालाँकि, यह जानकारी ऑन-चेन संग्रहीत नहीं है। इसके बजाय, बैंक स्टेट का एक हैश पोस्ट करता है। हर बार जब कोई लेनदेन होता है, तो बैंक नया हैश पोस्ट करता है, साथ ही एक ज़ीरो-नॉलेज प्रमाण के साथ कि उसके पास एक हस्ताक्षरित लेनदेन है जो हैश स्टेट को नए में बदल देता है। इस ट्यूटोरियल को पढ़ने के बाद, आप न केवल यह समझेंगे कि ज़ीरो-नॉलेज प्रमाणों का उपयोग कैसे करें, बल्कि यह भी समझेंगे कि आप उनका उपयोग क्यों करते हैं और सुरक्षित रूप से ऐसा कैसे करें।"
+author: "ओरी पोमेरेन्ट्ज़"
+tags: [ "ज़ीरो-नॉलेज", "सर्वर", "ऑफ-चेन", "गोपनीयता" ]
+skill: advanced
+lang: hi
+published: 2025-10-15
+---
+
+## परिचय {#introduction}
+
+[रोलअप](/developers/docs/scaling/zk-rollups/) के विपरीत, [प्लाज्मा](/developers/docs/scaling/plasma) अखंडता के लिए एथेरियम मेननेट का उपयोग करते हैं, लेकिन उपलब्धता के लिए नहीं। इस लेख में, हम एक ऐसा एप्लिकेशन लिखते हैं जो प्लाज्मा की तरह व्यवहार करता है, जिसमें एथेरियम अखंडता (कोई अनधिकृत परिवर्तन नहीं) की गारंटी देता है, लेकिन उपलब्धता की नहीं (एक केंद्रीकृत घटक डाउन हो सकता है और पूरे सिस्टम को अक्षम कर सकता है)।
+
+हम यहां जो एप्लिकेशन लिखते हैं वह एक गोपनीयता-संरक्षण बैंक है। विभिन्न पतों में शेष राशि वाले खाते होते हैं, और वे अन्य खातों में पैसे (ETH) भेज सकते हैं। बैंक स्टेट (खाते और उनकी शेष राशि) और लेनदेन के हैश पोस्ट करता है, लेकिन वास्तविक शेष राशि को ऑफ-चेन रखता है जहां वे निजी रह सकते हैं।
+
+## डिज़ाइन {#design}
+
+यह एक उत्पादन-तैयार प्रणाली नहीं है, बल्कि एक शिक्षण उपकरण है। जैसे, यह कई सरलीकरण मान्यताओं के साथ लिखा गया है।
+
+- निश्चित खाता पूल। खातों की एक विशिष्ट संख्या है, और प्रत्येक खाता एक पूर्व निर्धारित पते से संबंधित है। यह एक बहुत ही सरल प्रणाली बनाता है क्योंकि ज़ीरो-नॉलेज प्रमाणों में चर-आकार की डेटा संरचनाओं को संभालना मुश्किल है। एक उत्पादन-तैयार प्रणाली के लिए, हम [मर्कल रूट](/developers/tutorials/merkle-proofs-for-offline-data-integrity/) का उपयोग स्टेट हैश के रूप में कर सकते हैं और आवश्यक शेष राशि के लिए मर्कल प्रमाण प्रदान कर सकते हैं।
+
+- मेमोरी भंडारण। एक उत्पादन प्रणाली पर, हमें पुनरारंभ की स्थिति में उन्हें संरक्षित करने के लिए सभी खाता शेषों को डिस्क पर लिखने की आवश्यकता है। यहां, यह ठीक है अगर जानकारी बस खो जाती है।
+
+- केवल स्थानांतरण। एक उत्पादन प्रणाली को बैंक में संपत्ति जमा करने और उन्हें निकालने के तरीके की आवश्यकता होगी। लेकिन यहां उद्देश्य केवल अवधारणा को स्पष्ट करना है, इसलिए यह बैंक केवल स्थानांतरण तक ही सीमित है।
+
+### ज़ीरो-नॉलेज प्रमाण {#zero-knowledge-proofs}
+
+एक मौलिक स्तर पर, एक ज़ीरो-नॉलेज प्रमाण यह दर्शाता है कि सिद्ध करने वाला कुछ डेटा, _Dataprivate_ जानता है, जैसे कि कुछ सार्वजनिक डेटा, _Datapublic_, और _Dataprivate_ के बीच एक संबंध _Relationship_ है। सत्यापनकर्ता _Relationship_ और _Datapublic_ जानता है।
+
+गोपनीयता बनाए रखने के लिए, हमें स्टेट्स और लेनदेन को निजी रखने की आवश्यकता है। लेकिन अखंडता सुनिश्चित करने के लिए, हमें स्टेट्स के [क्रिप्टोग्राफिक हैश](https://en.wikipedia.org/wiki/Cryptographic_hash_function) को सार्वजनिक करने की आवश्यकता है। लेनदेन सबमिट करने वाले लोगों को यह साबित करने के लिए कि वे लेनदेन वास्तव में हुए हैं, हमें लेनदेन हैश भी पोस्ट करने की आवश्यकता है।
+
+अधिकांश मामलों में, _Dataprivate_ ज़ीरो-नॉलेज प्रमाण प्रोग्राम के लिए इनपुट है, और _Datapublic_ आउटपुट है।
+
+_Dataprivate_ में ये फ़ील्ड:
+
+- _Staten_, पुराना स्टेट
+- _Staten+1_, नया स्टेट
+- _Transaction_, एक लेनदेन जो पुराने स्टेट से नए में बदलता है। इस लेनदेन में इन फ़ील्ड को शामिल करने की आवश्यकता है:
+ - _गंतव्य पता_ जो स्थानांतरण प्राप्त करता है
+ - _राशि_ जो स्थानांतरित की जा रही है
+ - _नॉन्स_ यह सुनिश्चित करने के लिए कि प्रत्येक लेनदेन केवल एक बार संसाधित किया जा सकता है।
+ स्रोत पता लेनदेन में होने की आवश्यकता नहीं है, क्योंकि इसे हस्ताक्षर से पुनर्प्राप्त किया जा सकता है।
+- _हस्ताक्षर_, एक हस्ताक्षर जो लेनदेन करने के लिए अधिकृत है। हमारे मामले में, लेनदेन करने के लिए अधिकृत एकमात्र पता स्रोत पता है। क्योंकि हमारी ज़ीरो-नॉलेज प्रणाली जिस तरह से काम करती है, हमें एथेरियम हस्ताक्षर के अलावा, खाते की सार्वजनिक कुंजी की भी आवश्यकता है।
+
+_Datapublic_ में ये फ़ील्ड हैं:
+
+- _Hash(Staten)_ पुराने स्टेट का हैश
+- _Hash(Staten+1)_ नए स्टेट का हैश
+- _Hash(Transaction)_ उस लेनदेन का हैश जो स्टेट को _Staten_ से _Staten+1_ में बदलता है।
+
+यह संबंध कई शर्तों की जाँच करता है:
+
+- सार्वजनिक हैश वास्तव में निजी फ़ील्ड के लिए सही हैश हैं।
+- लेनदेन, जब पुराने स्टेट पर लागू होता है, तो नए स्टेट में परिणामित होता है।
+- हस्ताक्षर लेनदेन के स्रोत पते से आता है।
+
+क्रिप्टोग्राफिक हैश कार्यों के गुणों के कारण, इन शर्तों को साबित करना अखंडता सुनिश्चित करने के लिए पर्याप्त है।
+
+### डेटा संरचनाएं {#data-structures}
+
+प्राथमिक डेटा संरचना सर्वर द्वारा धारित स्टेट है। प्रत्येक खाते के लिए, सर्वर खाता शेष और एक [नॉन्स](https://en.wikipedia.org/wiki/Cryptographic_nonce) का ट्रैक रखता है, जिसका उपयोग [रीप्ले हमलों](https://en.wikipedia.org/wiki/Replay_attack) को रोकने के लिए किया जाता है।
+
+### घटक {#components}
+
+इस प्रणाली को दो घटकों की आवश्यकता है:
+
+- _सर्वर_ जो लेनदेन प्राप्त करता है, उन्हें संसाधित करता है, और ज़ीरो-नॉलेज प्रमाणों के साथ श्रृंखला में हैश पोस्ट करता है।
+- एक _स्मार्ट अनुबंध_ जो हैश संग्रहीत करता है और यह सुनिश्चित करने के लिए ज़ीरो-नॉलेज प्रमाणों को सत्यापित करता है कि स्टेट संक्रमण वैध हैं।
+
+### डेटा और नियंत्रण प्रवाह {#flows}
+
+ये वे तरीके हैं जिनसे विभिन्न घटक एक खाते से दूसरे खाते में स्थानांतरित करने के लिए संवाद करते हैं।
+
+1. एक वेब ब्राउज़र एक हस्ताक्षरित लेनदेन सबमिट करता है जो हस्ताक्षरकर्ता के खाते से एक अलग खाते में स्थानांतरण के लिए कहता है।
+
+2. सर्वर यह सत्यापित करता है कि लेनदेन वैध है:
+
+ - हस्ताक्षरकर्ता के पास बैंक में पर्याप्त शेष राशि वाला एक खाता है।
+ - प्राप्तकर्ता के पास बैंक में एक खाता है।
+
+3. सर्वर हस्ताक्षरकर्ता की शेष राशि से स्थानांतरित राशि घटाकर और इसे प्राप्तकर्ता की शेष राशि में जोड़कर नए स्टेट की गणना करता है।
+
+4. सर्वर एक ज़ीरो-नॉलेज प्रमाण की गणना करता है कि स्टेट परिवर्तन एक वैध है।
+
+5. सर्वर एथेरियम को एक लेनदेन सबमिट करता है जिसमें शामिल है:
+
+ - नया स्टेट हैश
+ - लेनदेन हैश (ताकि लेनदेन भेजने वाला जान सके कि इसे संसाधित किया गया है)
+ - ज़ीरो-नॉलेज प्रमाण जो यह साबित करता है कि नए स्टेट में संक्रमण वैध है
+
+6. स्मार्ट अनुबंध ज़ीरो-नॉलेज प्रमाण को सत्यापित करता है।
+
+7. यदि ज़ीरो-नॉलेज प्रमाण सही निकलता है, तो स्मार्ट अनुबंध इन क्रियाओं को करता है:
+ - वर्तमान स्टेट हैश को नए स्टेट हैश में अपडेट करें
+ - नए स्टेट हैश और लेनदेन हैश के साथ एक लॉग प्रविष्टि उत्सर्जित करें
+
+### उपकरण {#tools}
+
+क्लाइंट-साइड कोड के लिए, हम [Vite](https://vite.dev/), [React](https://react.dev/), [Viem](https://viem.sh/), और [Wagmi](https://wagmi.sh/) का उपयोग करने जा रहे हैं। ये उद्योग-मानक उपकरण हैं; यदि आप इनसे परिचित नहीं हैं, तो आप [इस ट्यूटोरियल](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) का उपयोग कर सकते हैं।
+
+सर्वर का अधिकांश भाग [Node](https://nodejs.org/en) का उपयोग करके JavaScript में लिखा गया है। ज़ीरो-नॉलेज भाग [Noir](https://noir-lang.org/) में लिखा गया है। हमें संस्करण `1.0.0-beta.10` की आवश्यकता है, इसलिए [निर्देशानुसार Noir इंस्टॉल करने](https://noir-lang.org/docs/getting_started/quick_start) के बाद, चलाएँ:
+
+```
+noirup -v 1.0.0-beta.10
+```
+
+हम जिस ब्लॉकचेन का उपयोग करते हैं वह `anvil` है, जो एक स्थानीय परीक्षण ब्लॉकचेन है जो [Foundry](https://getfoundry.sh/introduction/installation) का हिस्सा है।
+
+## कार्यान्वयन {#implementation}
+
+क्योंकि यह एक जटिल प्रणाली है, हम इसे चरणों में लागू करेंगे।
+
+### चरण 1 - मैनुअल ज़ीरो-नॉलेज {#stage-1}
+
+पहले चरण के लिए, हम ब्राउज़र में एक लेनदेन पर हस्ताक्षर करेंगे और फिर ज़ीरो-नॉलेज प्रमाण को मैन्युअल रूप से जानकारी प्रदान करेंगे। ज़ीरो-नॉलेज कोड को यह जानकारी `server/noir/Prover.toml` में प्राप्त होने की उम्मीद है ([यहां](https://noir-lang.org/docs/getting_started/project_breakdown#provertoml-1) प्रलेखित)।
+
+इसे क्रियान्वित देखने के लिए:
+
+1. सुनिश्चित करें कि आपके पास [Node](https://nodejs.org/en/download) और [Noir](https://noir-lang.org/install) इंस्टॉल हैं। अधिमानतः, उन्हें macOS, Linux, या [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) जैसे UNIX सिस्टम पर इंस्टॉल करें।
+
+2. चरण 1 कोड डाउनलोड करें और क्लाइंट कोड की सेवा के लिए वेब सर्वर शुरू करें।
+
+ ```sh
+ git clone https://github.com/qbzzt/250911-zk-bank.git -b 01-manual-zk
+ cd 250911-zk-bank
+ cd client
+ npm install
+ npm run dev
+ ```
+
+ यहां आपको एक वेब सर्वर की आवश्यकता का कारण यह है कि, कुछ प्रकार की धोखाधड़ी को रोकने के लिए, कई वॉलेट (जैसे MetaMask) सीधे डिस्क से परोसी गई फ़ाइलों को स्वीकार नहीं करते हैं
+
+3. वॉलेट के साथ एक ब्राउज़र खोलें।
+
+4. वॉलेट में, एक नया पासफ़्रेज़ दर्ज करें। ध्यान दें कि यह आपके मौजूदा पासफ़्रेज़ को हटा देगा, इसलिए _सुनिश्चित करें कि आपके पास एक बैकअप है_।
+
+ पासफ़्रेज़ `test test test test test test test test test test test junk` है, जो anvil के लिए डिफ़ॉल्ट परीक्षण पासफ़्रेज़ है।
+
+5. [क्लाइंट-साइड कोड](http://localhost:5173/) पर ब्राउज़ करें।
+
+6. वॉलेट से कनेक्ट करें और अपने गंतव्य खाते और राशि का चयन करें।
+
+7. **Sign** पर क्लिक करें और लेनदेन पर हस्ताक्षर करें।
+
+8. **Prover.toml** शीर्षक के अंतर्गत, आपको टेक्स्ट मिलेगा। `server/noir/Prover.toml` को उस टेक्स्ट से बदलें।
+
+9. ज़ीरो-नॉलेज प्रमाण निष्पादित करें।
+
+ ```sh
+ cd ../server/noir
+ nargo execute
+ ```
+
+ आउटपुट इसके समान होना चाहिए
+
+ ```
+ ori@CryptoDocGuy:~/noir/250911-zk-bank/server/noir$ nargo execute
+
+ [zkBank] सर्किट विटनेस सफलतापूर्वक हल किया गया
+ [zkBank] विटनेस को target/zkBank.gz में सहेजा गया
+ [zkBank] सर्किट आउटपुट: (0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b, 0x0cfc0a67cb7308e4e9b254026b54204e34f6c8b041be207e64c5db77d95dd82d, 0x450cf9da6e180d6159290554ae3d8787, 0x6d8bc5a15b9037e52fb59b6b98722a85)
+ ```
+
+10. अंतिम दो मानों की तुलना वेब ब्राउज़र पर देखे गए हैश से करें ताकि यह देखा जा सके कि संदेश सही ढंग से हैश किया गया है या नहीं।
+
+#### `server/noir/Prover.toml` {#server-noir-prover-toml}
+
+[यह फ़ाइल](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Prover.toml) Noir द्वारा अपेक्षित सूचना प्रारूप दिखाती है।
+
+```toml
+message="send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 500 finney (milliEth) 0 "
+```
+
+संदेश टेक्स्ट प्रारूप में है, जो उपयोगकर्ता के लिए समझना आसान बनाता है (जो हस्ताक्षर करते समय आवश्यक है) और Noir कोड को पार्स करने के लिए। एक ओर भिन्नात्मक स्थानांतरण को सक्षम करने के लिए, और दूसरी ओर आसानी से पठनीय होने के लिए, राशि को फिनी में उद्धृत किया गया है। अंतिम संख्या [नॉन्स](https://en.wikipedia.org/wiki/Cryptographic_nonce) है।
+
+स्ट्रिंग 100 वर्ण लंबी है। ज़ीरो-नॉलेज प्रमाण चर-आकार के डेटा को अच्छी तरह से नहीं संभालते हैं, इसलिए अक्सर डेटा को पैड करना आवश्यक होता है।
+
+```toml
+pubKeyX=["0x83",...,"0x75"]
+pubKeyY=["0x35",...,"0xa5"]
+signature=["0xb1",...,"0x0d"]
+```
+
+ये तीन पैरामीटर निश्चित आकार के बाइट ऐरे हैं।
+
+```toml
+[[accounts]]
+address="0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+balance=100_000
+nonce=0
+
+[[accounts]]
+address="0x70997970C51812dc3A010C7d01b50e0d17dc79C8"
+balance=100_000
+nonce=0
+```
+
+यह संरचनाओं की एक सरणी निर्दिष्ट करने का तरीका है। प्रत्येक प्रविष्टि के लिए, हम पता, शेष राशि (milliETH a.k.a. में) निर्दिष्ट करते हैं। [फिनी](https://cryptovalleyjournal.com/glossary/finney/)), और अगला नॉन्स मान।
+
+#### `client/src/Transfer.tsx` {#client-src-transfer-tsx}
+
+[यह फ़ाइल](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/client/src/Transfer.tsx) क्लाइंट-साइड प्रोसेसिंग को लागू करती है और `server/noir/Prover.toml` फ़ाइल उत्पन्न करती है (वह जिसमें ज़ीरो-नॉलेज पैरामीटर शामिल हैं)।
+
+यहाँ और अधिक दिलचस्प भागों की व्याख्या है।
+
+```tsx
+export default attrs => {
+```
+
+यह फ़ंक्शन `Transfer` React घटक बनाता है, जिसे अन्य फ़ाइलें आयात कर सकती हैं।
+
+```tsx
+ const accounts = [
+ "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+ "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
+ "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
+ "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
+ "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
+ ]
+```
+
+ये खाता पते हैं, जो `test ...` द्वारा बनाए गए पते हैं। test junk` पासफ़्रेज़। यदि आप अपने स्वयं के पतों का उपयोग करना चाहते हैं, तो बस इस परिभाषा को संशोधित करें।
+
+```tsx
+ const account = useAccount()
+ const wallet = createWalletClient({
+ transport: custom(window.ethereum!)
+ })
+```
+
+ये [Wagmi हुक](https://wagmi.sh/react/api/hooks) हमें [viem](https://viem.sh/) लाइब्रेरी और वॉलेट तक पहुंचने देते हैं।
+
+```tsx
+ const message = `send ${toAccount} ${ethAmount*1000} finney (milliEth) ${nonce}`.padEnd(100, " ")
+```
+
+यह संदेश है, जिसे रिक्त स्थान से भरा गया है। हर बार जब कोई [`useState`](https://react.dev/reference/react/useState) वेरिएबल बदलता है, तो कंपोनेंट फिर से खींचा जाता है और `message` अपडेट हो जाता है।
+
+```tsx
+ const sign = async () => {
+```
+
+यह फ़ंक्शन तब कॉल किया जाता है जब उपयोगकर्ता **Sign** बटन पर क्लिक करता है। संदेश स्वचालित रूप से अपडेट हो जाता है, लेकिन हस्ताक्षर के लिए वॉलेट में उपयोगकर्ता की मंजूरी की आवश्यकता होती है, और हम तब तक इसके लिए नहीं पूछना चाहते जब तक कि आवश्यक न हो।
+
+```tsx
+ const signature = await wallet.signMessage({
+ account: fromAccount,
+ message,
+ })
+```
+
+वॉलेट से [संदेश पर हस्ताक्षर करने](https://viem.sh/docs/accounts/local/signMessage) के लिए कहें।
+
+```tsx
+ const hash = hashMessage(message)
+```
+
+संदेश हैश प्राप्त करें। उपयोगकर्ता को डिबगिंग (Noir कोड का) के लिए इसे प्रदान करना सहायक होता है।
+
+```tsx
+ const pubKey = await recoverPublicKey({
+ hash,
+ signature
+ })
+```
+
+[सार्वजनिक कुंजी प्राप्त करें](https://viem.sh/docs/utilities/recoverPublicKey)। यह [Noir `ecrecover`](https://github.com/colinnielsen/ecrecover-noir) फ़ंक्शन के लिए आवश्यक है।
+
+```tsx
+ setSignature(signature)
+ setHash(hash)
+ setPubKey(pubKey)
+```
+
+स्टेट वेरिएबल्स सेट करें। ऐसा करने से (`sign` फ़ंक्शन से बाहर निकलने के बाद) घटक फिर से खींचा जाता है और उपयोगकर्ता को अद्यतन मान दिखाता है।
+
+```tsx
+ let proverToml = `
+```
+
+`Prover.toml` के लिए टेक्स्ट।
+
+```tsx
+message="${message}"
+
+pubKeyX=${hexToArray(pubKey.slice(4,4+2*32))}
+pubKeyY=${hexToArray(pubKey.slice(4+2*32))}
+```
+
+Viem हमें 65-बाइट हेक्साडेसिमल स्ट्रिंग के रूप में सार्वजनिक कुंजी प्रदान करता है। पहला बाइट `0x04` है, जो एक संस्करण मार्कर है। इसके बाद सार्वजनिक कुंजी के `x` के लिए 32 बाइट और फिर सार्वजनिक कुंजी के `y` के लिए 32 बाइट्स हैं।
+
+हालाँकि, Noir को यह जानकारी दो बाइट ऐरे के रूप में प्राप्त करने की उम्मीद है, एक `x` के लिए और एक `y` के लिए। ज़ीरो-नॉलेज प्रमाण के हिस्से के रूप में पार्स करने के बजाय क्लाइंट पर इसे पार्स करना आसान है।
+
+ध्यान दें कि यह सामान्य रूप से ज़ीरो-नॉलेज में एक अच्छा अभ्यास है। ज़ीरो-नॉलेज प्रमाण के अंदर कोड महंगा होता है, इसलिए कोई भी प्रोसेसिंग जो ज़ीरो-नॉलेज प्रमाण के बाहर की जा सकती है, उसे ज़ीरो-नॉलेज प्रमाण के बाहर ही किया जाना चाहिए।
+
+```tsx
+signature=${hexToArray(signature.slice(2,-2))}
+```
+
+हस्ताक्षर भी 65-बाइट हेक्साडेसिमल स्ट्रिंग के रूप में प्रदान किया जाता है। हालाँकि, सार्वजनिक कुंजी को पुनर्प्राप्त करने के लिए अंतिम बाइट केवल आवश्यक है। चूंकि सार्वजनिक कुंजी पहले से ही Noir कोड को प्रदान की जाएगी, इसलिए हमें हस्ताक्षर को सत्यापित करने के लिए इसकी आवश्यकता नहीं है, और Noir कोड को इसकी आवश्यकता नहीं है।
+
+```tsx
+${accounts.map(accountInProverToml).reduce((a,b) => a+b, "")}
+`
+```
+
+खाते प्रदान करें।
+
+```tsx
+ setProverToml(proverToml)
+ }
+
+ return (
+ <>
+ Transfer
+```
+
+यह घटक का HTML (अधिक सटीक रूप से, [JSX](https://react.dev/learn/writing-markup-with-jsx)) प्रारूप है।
+
+#### `server/noir/src/main.nr` {#server-noir-src-main-nr}
+
+[यह फ़ाइल](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/src/main.nr) वास्तविक ज़ीरो-नॉलेज कोड है।
+
+```
+use std::hash::pedersen_hash;
+```
+
+[Pedersen हैश](https://rya-sge.github.io/access-denied/2024/05/07/pedersen-hash-function/) [Noir मानक लाइब्रेरी](https://noir-lang.org/docs/noir/standard_library/cryptographic_primitives/hashes#pedersen_hash) के साथ प्रदान किया गया है। ज़ीरो-नॉलेज प्रमाण आमतौर पर इस हैश फ़ंक्शन का उपयोग करते हैं। मानक हैश कार्यों की तुलना में [अरिथमैटिक सर्किट](https://rareskills.io/post/arithmetic-circuit) के अंदर गणना करना बहुत आसान है।
+
+```
+use keccak256::keccak256;
+use dep::ecrecover;
+```
+
+ये दो फ़ंक्शन बाहरी लाइब्रेरी हैं, जो [`Nargo.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Nargo.toml) में परिभाषित हैं। वे ठीक वही हैं जिसके लिए उनका नाम रखा गया है, एक फ़ंक्शन जो [keccak256 हैश](https://emn178.github.io/online-tools/keccak_256.html) की गणना करता है और एक फ़ंक्शन जो एथेरियम हस्ताक्षर सत्यापित करता है और हस्ताक्षरकर्ता का एथेरियम पता पुनर्प्राप्त करता है।
+
+```
+global ACCOUNT_NUMBER : u32 = 5;
+```
+
+Noir [Rust](https://www.rust-lang.org/) से प्रेरित है। वेरिएबल, डिफ़ॉल्ट रूप से, स्थिरांक होते हैं। इस तरह हम वैश्विक कॉन्फ़िगरेशन स्थिरांक को परिभाषित करते हैं। विशेष रूप से, `ACCOUNT_NUMBER` हमारे द्वारा संग्रहीत खातों की संख्या है।
+
+`u` नामक डेटा प्रकार उस संख्या के बिट्स, अहस्ताक्षरित होते हैं। केवल समर्थित प्रकार `u8`, `u16`, `u32`, `u64`, और `u128` हैं।
+
+```
+global FLAT_ACCOUNT_FIELDS : u32 = 2;
+```
+
+इस वेरिएबल का उपयोग खातों के पेडरसन हैश के लिए किया जाता है, जैसा कि नीचे बताया गया है।
+
+```
+global MESSAGE_LENGTH : u32 = 100;
+```
+
+जैसा कि ऊपर बताया गया है, संदेश की लंबाई निश्चित है। यह यहां निर्दिष्ट है।
+
+```
+global ASCII_MESSAGE_LENGTH : [u8; 3] = [0x31, 0x30, 0x30];
+global HASH_BUFFER_SIZE : u32 = 26+3+MESSAGE_LENGTH;
+```
+
+[EIP-191 हस्ताक्षर](https://eips.ethereum.org/EIPS/eip-191) के लिए 26-बाइट उपसर्ग वाले बफर की आवश्यकता होती है, जिसके बाद ASCII में संदेश की लंबाई और अंत में संदेश होता है।
+
+```
+struct Account {
+ balance: u128,
+ address: Field,
+ nonce: u32,
+}
+```
+
+हम एक खाते के बारे में जो जानकारी संग्रहीत करते हैं। [`Field`](https://noir-lang.org/docs/noir/concepts/data_types/fields) एक संख्या है, जो आमतौर पर 253 बिट तक होती है, जिसका उपयोग सीधे [अरिथमैटिक सर्किट](https://rareskills.io/post/arithmetic-circuit) में किया जा सकता है जो ज़ीरो-नॉलेज प्रमाण को लागू करता है। यहां हम 160-बिट एथेरियम पते को संग्रहीत करने के लिए `Field` का उपयोग करते हैं।
+
+```
+struct TransferTxn {
+ from: Field,
+ to: Field,
+ amount: u128,
+ nonce: u32
+}
+```
+
+स्थानांतरण लेनदेन के लिए हम जो जानकारी संग्रहीत करते हैं।
+
+```
+fn flatten_account(account: Account) -> [Field; FLAT_ACCOUNT_FIELDS] {
+```
+
+एक फ़ंक्शन परिभाषा। पैरामीटर `Account` जानकारी है। परिणाम `Field` चर की एक सरणी है, जिसकी लंबाई `FLAT_ACCOUNT_FIELDS` है
+
+```
+ let flat = [
+ account.address,
+ ((account.balance << 32) + account.nonce.into()).into(),
+ ];
+```
+
+सरणी में पहला मान खाता पता है। दूसरे में शेष राशि और नॉन्स दोनों शामिल हैं। `.into()` कॉल एक संख्या को उस डेटा प्रकार में बदल देती है जो उसे होना चाहिए। `account.nonce` एक `u32` मान है, लेकिन इसे `account.balance « 32`, एक `u128` मान, में जोड़ने के लिए, इसे `u128` होना चाहिए। वह पहला `.into()` है। दूसरा `u128` परिणाम को `Field` में परिवर्तित करता है ताकि यह सरणी में फिट हो जाए।
+
+```
+ flat
+}
+```
+
+Noir में, फ़ंक्शन केवल अंत में एक मान लौटा सकते हैं (कोई जल्दी वापसी नहीं है)। रिटर्न मान निर्दिष्ट करने के लिए, आप इसे फ़ंक्शन के समापन ब्रैकेट से ठीक पहले मूल्यांकन करते हैं।
+
+```
+fn flatten_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] {
+```
+
+यह फ़ंक्शन खाता सरणी को `Field` सरणी में बदल देता है, जिसे पीटरसन हैश के इनपुट के रूप में उपयोग किया जा सकता है।
+
+```
+ let mut flat: [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] = [0; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER];
+```
+
+यह एक परिवर्तनीय चर निर्दिष्ट करने का तरीका है, अर्थात, _नहीं_ एक स्थिरांक। Noir में चरों का हमेशा एक मान होना चाहिए, इसलिए हम इस चर को सभी शून्यों पर आरम्भ करते हैं।
+
+```
+ for i in 0..ACCOUNT_NUMBER {
+```
+
+यह एक `for` लूप है। ध्यान दें कि सीमाएँ स्थिरांक हैं। Noir लूपों की सीमाएँ संकलन समय पर ज्ञात होनी चाहिए। इसका कारण यह है कि अंकगणितीय परिपथ प्रवाह नियंत्रण का समर्थन नहीं करते हैं। `for` लूप को संसाधित करते समय, कंपाइलर बस इसके अंदर के कोड को कई बार रखता है, प्रत्येक पुनरावृत्ति के लिए एक।
+
+```
+ let fields = flatten_account(accounts[i]);
+ for j in 0..FLAT_ACCOUNT_FIELDS {
+ flat[i*FLAT_ACCOUNT_FIELDS + j] = fields[j];
+ }
+ }
+
+ flat
+}
+
+fn hash_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> Field {
+ pedersen_hash(flatten_accounts(accounts))
+}
+```
+
+अंत में, हम उस फ़ंक्शन पर पहुँचे जो खाता सरणी को हैश करता है।
+
+```
+fn find_account(accounts: [Account; ACCOUNT_NUMBER], address: Field) -> u32 {
+ let mut account : u32 = ACCOUNT_NUMBER;
+
+ for i in 0..ACCOUNT_NUMBER {
+ if accounts[i].address == address {
+ account = i;
+ }
+ }
+```
+
+यह फ़ंक्शन एक विशिष्ट पते के साथ खाता ढूंढता है। यह फ़ंक्शन मानक कोड में बहुत अक्षम होगा क्योंकि यह सभी खातों पर पुनरावृति करता है, भले ही उसने पता ढूंढ लिया हो।
+
+हालाँकि, ज़ीरो-नॉलेज प्रमाणों में, कोई प्रवाह नियंत्रण नहीं होता है। अगर हमें कभी कोई शर्त जाँचने की ज़रूरत पड़ती है, तो हमें उसे हर बार जाँचना पड़ता है।
+
+`if` कथनों के साथ भी कुछ ऐसा ही होता है। ऊपर दिए गए लूप में `if` कथन को इन गणितीय कथनों में अनुवादित किया गया है।
+
+_conditionresult = accounts[i].address == address_ // एक यदि वे बराबर हैं, अन्यथा शून्य
+
+_accountnew = conditionresult\*i + (1-conditionresult)\*accountold_
+
+```rust
+ assert (account < ACCOUNT_NUMBER, f"{address} does not have an account");
+
+ account
+}
+```
+
+[`assert`](https://noir-lang.org/docs/dev/noir/concepts/assert) फ़ंक्शन ज़ीरो-नॉलेज प्रमाण को क्रैश कर देता है यदि अभिकथन झूठा है। इस मामले में, यदि हमें संबंधित पते के साथ कोई खाता नहीं मिल पाता है। पते की रिपोर्ट करने के लिए, हम एक [प्रारूप स्ट्रिंग](https://noir-lang.org/docs/noir/concepts/data_types/strings#format-strings) का उपयोग करते हैं।
+
+```rust
+fn apply_transfer_txn(accounts: [Account; ACCOUNT_NUMBER], txn: TransferTxn) -> [Account; ACCOUNT_NUMBER] {
+```
+
+यह फ़ंक्शन एक स्थानांतरण लेनदेन लागू करता है और नई खाता सरणी लौटाता है।
+
+```rust
+ let from = find_account(accounts, txn.from);
+ let to = find_account(accounts, txn.to);
+
+ let (txnFrom, txnAmount, txnNonce, accountNonce) =
+ (txn.from, txn.amount, txn.nonce, accounts[from].nonce);
+```
+
+हम Noir में एक प्रारूप स्ट्रिंग के अंदर संरचना तत्वों तक नहीं पहुंच सकते हैं, इसलिए हम एक प्रयोग करने योग्य प्रतिलिपि बनाते हैं।
+
+```rust
+ assert (accounts[from].balance >= txn.amount,
+ f"{txnFrom} does not have {txnAmount} finney");
+
+ assert (accounts[from].nonce == txn.nonce,
+ f"Transaction has nonce {txnNonce}, but the account is expected to use {accountNonce}");
+```
+
+ये दो शर्तें हैं जो एक लेनदेन को अमान्य कर सकती हैं।
+
+```rust
+ let mut newAccounts = accounts;
+
+ newAccounts[from].balance -= txn.amount;
+ newAccounts[from].nonce += 1;
+ newAccounts[to].balance += txn.amount;
+
+ newAccounts
+}
+```
+
+नई खाता सरणी बनाएँ और फिर उसे लौटाएँ।
+
+```rust
+fn readAddress(messageBytes: [u8; MESSAGE_LENGTH]) -> Field
+```
+
+यह फ़ंक्शन संदेश से पता पढ़ता है।
+
+```rust
+{
+ let mut result : Field = 0;
+
+ for i in 7..47 {
+```
+
+पता हमेशा 20 बाइट (a.k.a.) लंबा होता है। 40 हेक्साडेसिमल अंक) लंबा, और वर्ण #7 से शुरू होता है।
+
+```rust
+ result *= 0x10;
+ if messageBytes[i] >= 48 & messageBytes[i] <= 57 { // 0-9
+ result += (messageBytes[i]-48).into();
+ }
+ if messageBytes[i] >= 65 & messageBytes[i] <= 70 { // A-F
+ result += (messageBytes[i]-65+10).into()
+ }
+ if messageBytes[i] >= 97 & messageBytes[i] <= 102 { // a-f
+ result += (messageBytes[i]-97+10).into()
+ }
+ }
+
+ result
+}
+
+fn readAmountAndNonce(messageBytes: [u8; MESSAGE_LENGTH]) -> (u128, u32)
+```
+
+संदेश से राशि और नॉन्स पढ़ें।
+
+```rust
+{
+ let mut amount : u128 = 0;
+ let mut nonce: u32 = 0;
+ let mut stillReadingAmount: bool = true;
+ let mut lookingForNonce: bool = false;
+ let mut stillReadingNonce: bool = false;
+```
+
+संदेश में, पते के बाद पहली संख्या फिनी की राशि है (a.k.a.) स्थानांतरित करने के लिए ETH का हज़ारवां हिस्सा)। दूसरी संख्या नॉन्स है। उनके बीच के किसी भी पाठ को अनदेखा कर दिया जाता है।
+
+```rust
+ for i in 48..MESSAGE_LENGTH {
+ if messageBytes[i] >= 48 & messageBytes[i] <= 57 { // 0-9
+ let digit = (messageBytes[i]-48);
+
+ if stillReadingAmount {
+ amount = amount*10 + digit.into();
+ }
+
+ if lookingForNonce { // हम बस इसे पा चुके हैं
+ stillReadingNonce = true;
+ lookingForNonce = false;
+ }
+
+ if stillReadingNonce {
+ nonce = nonce*10 + digit.into();
+ }
+ } else {
+ if stillReadingAmount {
+ stillReadingAmount = false;
+ lookingForNonce = true;
+ }
+ if stillReadingNonce {
+ stillReadingNonce = false;
+ }
+ }
+ }
+
+ (amount, nonce)
+}
+```
+
+[टपल](https://noir-lang.org/docs/noir/concepts/data_types/tuples) लौटाना एक फ़ंक्शन से कई मान लौटाने का Noir तरीका है।
+
+```rust
+fn readTransferTxn(message: str) -> TransferTxn
+{
+ let mut txn: TransferTxn = TransferTxn { from: 0, to: 0, amount:0, nonce:0 };
+ let messageBytes = message.as_bytes();
+
+ txn.to = readAddress(messageBytes);
+ let (amount, nonce) = readAmountAndNonce(messageBytes);
+ txn.amount = amount;
+ txn.nonce = nonce;
+
+ txn
+}
+```
+
+यह फ़ंक्शन संदेश को बाइट्स में परिवर्तित करता है, फिर राशियों को `TransferTxn` में परिवर्तित करता है।
+
+```rust
+// Viem के hashMessage के समतुल्य
+// https://viem.sh/docs/utilities/hashMessage#hashmessage
+fn hashMessage(message: str) -> [u8;32] {
+```
+
+हम खातों के लिए पेडरसन हैश का उपयोग करने में सक्षम थे क्योंकि वे केवल ज़ीरो-नॉलेज प्रमाण के अंदर हैश किए जाते हैं। हालाँकि, इस कोड में हमें संदेश के हस्ताक्षर की जाँच करने की आवश्यकता है, जो ब्राउज़र द्वारा उत्पन्न होता है। इसके लिए, हमें [EIP 191](https://eips.ethereum.org/EIPS/eip-191) में एथेरियम हस्ताक्षर प्रारूप का पालन करना होगा। इसका मतलब है कि हमें एक मानक उपसर्ग, ASCII में संदेश की लंबाई और स्वयं संदेश के साथ एक संयुक्त बफर बनाने की आवश्यकता है, और इसे हैश करने के लिए एथेरियम मानक keccak256 का उपयोग करना होगा।
+
+```rust
+ // ASCII उपसर्ग
+ let prefix_bytes = [
+ 0x19, // \x19
+ 0x45, // 'E'
+ 0x74, // 't'
+ 0x68, // 'h'
+ 0x65, // 'e'
+ 0x72, // 'r'
+ 0x65, // 'e'
+ 0x75, // 'u'
+ 0x6D, // 'm'
+ 0x20, // ' '
+ 0x53, // 'S'
+ 0x69, // 'i'
+ 0x67, // 'g'
+ 0x6E, // 'n'
+ 0x65, // 'e'
+ 0x64, // 'd'
+ 0x20, // ' '
+ 0x4D, // 'M'
+ 0x65, // 'e'
+ 0x73, // 's'
+ 0x73, // 's'
+ 0x61, // 'a'
+ 0x67, // 'g'
+ 0x65, // 'e'
+ 0x3A, // ':'
+ 0x0A // '\n'
+ ];
+```
+
+ऐसे मामलों से बचने के लिए जहां कोई एप्लिकेशन उपयोगकर्ता से ऐसे संदेश पर हस्ताक्षर करने के लिए कहता है जिसका उपयोग लेनदेन के रूप में या किसी अन्य उद्देश्य के लिए किया जा सकता है, EIP 191 निर्दिष्ट करता है कि सभी हस्ताक्षरित संदेश वर्ण 0x19 (एक मान्य ASCII वर्ण नहीं) से शुरू होते हैं, जिसके बाद `Ethereum Signed Message:` और एक नई पंक्ति आती है।
+
+```rust
+ let mut buffer: [u8; HASH_BUFFER_SIZE] = [0u8; HASH_BUFFER_SIZE];
+ for i in 0..26 {
+ buffer[i] = prefix_bytes[i];
+ }
+
+ let messageBytes : [u8; MESSAGE_LENGTH] = message.as_bytes();
+
+ if MESSAGE_LENGTH <= 9 {
+ for i in 0..1 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+1] = messageBytes[i];
+ }
+ }
+
+ if MESSAGE_LENGTH >= 10 & MESSAGE_LENGTH <= 99 {
+ for i in 0..2 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+2] = messageBytes[i];
+ }
+ }
+
+ if MESSAGE_LENGTH >= 100 {
+ for i in 0..3 {
+ buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
+ }
+
+ for i in 0..MESSAGE_LENGTH {
+ buffer[i+26+3] = messageBytes[i];
+ }
+ }
+
+ assert(MESSAGE_LENGTH < 1000, "तीन अंकों से अधिक लंबाई वाले संदेश समर्थित नहीं हैं");
+```
+
+999 तक संदेश की लंबाई को संभालें और यदि यह अधिक है तो विफल हो जाएं। मैंने यह कोड जोड़ा है, भले ही संदेश की लंबाई एक स्थिरांक है, क्योंकि इससे इसे बदलना आसान हो जाता है। एक उत्पादन प्रणाली पर, आप बेहतर प्रदर्शन के लिए शायद यह मान लेंगे कि `MESSAGE_LENGTH` नहीं बदलता है।
+
+```rust
+ keccak256::keccak256(buffer, HASH_BUFFER_SIZE)
+}
+```
+
+एथेरियम मानक `keccak256` फ़ंक्शन का उपयोग करें।
+
+```rust
+fn signatureToAddressAndHash(
+ message: str,
+ pubKeyX: [u8; 32],
+ pubKeyY: [u8; 32],
+ signature: [u8; 64]
+ ) -> (Field, Field, Field) // पता, हैश का पहला 16 बाइट, हैश का अंतिम 16 बाइट
+{
+```
+
+यह फ़ंक्शन हस्ताक्षर को सत्यापित करता है, जिसके लिए संदेश हैश की आवश्यकता होती है। फिर यह हमें वह पता प्रदान करता है जिसने इस पर हस्ताक्षर किया है और संदेश हैश। संदेश हैश को दो `Field` मानों में प्रदान किया जाता है क्योंकि वे बाइट सरणी की तुलना में प्रोग्राम के बाकी हिस्सों में उपयोग करना आसान होते हैं।
+
+हमें दो `Field` मानों का उपयोग करने की आवश्यकता है क्योंकि फ़ील्ड गणना एक बड़ी संख्या के [मॉड्यूलो](https://en.wikipedia.org/wiki/Modulo) की जाती है, लेकिन वह संख्या आमतौर पर 256 बिट से कम होती है (अन्यथा EVM में उन गणनाओं को करना मुश्किल होगा)।
+
+```rust
+ let hash = hashMessage(message);
+
+ let mut (hash1, hash2) = (0,0);
+
+ for i in 0..16 {
+ hash1 = hash1*256 + hash[31-i].into();
+ hash2 = hash2*256 + hash[15-i].into();
+ }
+```
+
+`hash1` और `hash2` को परिवर्तनीय चर के रूप में निर्दिष्ट करें, और बाइट दर बाइट उनमें हैश लिखें।
+
+```rust
+ (
+ ecrecover::ecrecover(pubKeyX, pubKeyY, signature, hash),
+```
+
+यह [Solidity के `ecrecover`](https://docs.soliditylang.org/en/v0.8.30/cheatsheet.html#mathematical-and-cryptographic-functions) के समान है, जिसमें दो महत्वपूर्ण अंतर हैं:
+
+- यदि हस्ताक्षर मान्य नहीं है, तो कॉल एक `assert` विफल कर देता है और प्रोग्राम निरस्त हो जाता है।
+- हालांकि सार्वजनिक कुंजी को हस्ताक्षर और हैश से पुनर्प्राप्त किया जा सकता है, यह प्रसंस्करण बाह्य रूप से किया जा सकता है और, इसलिए, ज़ीरो-नॉलेज प्रमाण के अंदर करने लायक नहीं है। यदि कोई हमें यहां धोखा देने की कोशिश करता है, तो हस्ताक्षर सत्यापन विफल हो जाएगा।
+
+```rust
+ hash1,
+ hash2
+ )
+}
+
+fn main(
+ accounts: [Account; ACCOUNT_NUMBER],
+ message: str,
+ pubKeyX: [u8; 32],
+ pubKeyY: [u8; 32],
+ signature: [u8; 64],
+ ) -> pub (
+ Field, // पुराने खाता सरणी का हैश
+ Field, // नए खाता सरणी का हैश
+ Field, // संदेश हैश का पहला 16 बाइट
+ Field, // संदेश हैश का अंतिम 16 बाइट
+ )
+```
+
+अंत में, हम `main` फ़ंक्शन पर पहुँचते हैं। हमें यह साबित करने की आवश्यकता है कि हमारे पास एक लेनदेन है जो खातों के हैश को पुराने मान से नए में वैध रूप से बदलता है। हमें यह भी साबित करने की आवश्यकता है कि इसका यह विशिष्ट लेनदेन हैश है ताकि जिसने इसे भेजा है वह जान सके कि उनके लेनदेन को संसाधित कर लिया गया है।
+
+```rust
+{
+ let mut txn = readTransferTxn(message);
+```
+
+हमें `txn` को परिवर्तनीय होने की आवश्यकता है क्योंकि हम संदेश से से पता नहीं पढ़ते हैं, हम इसे हस्ताक्षर से पढ़ते हैं।
+
+```rust
+ let (fromAddress, txnHash1, txnHash2) = signatureToAddressAndHash(
+ message,
+ pubKeyX,
+ pubKeyY,
+ signature);
+
+ txn.from = fromAddress;
+
+ let newAccounts = apply_transfer_txn(accounts, txn);
+
+ (
+ hash_accounts(accounts),
+ hash_accounts(newAccounts),
+ txnHash1,
+ txnHash2
+ )
+}
+```
+
+### चरण 2 - एक सर्वर जोड़ना {#stage-2}
+
+दूसरे चरण में, हम एक सर्वर जोड़ते हैं जो ब्राउज़र से स्थानांतरण लेनदेन प्राप्त करता है और लागू करता है।
+
+इसे क्रियान्वित देखने के लिए:
+
+1. Vite को रोकें यदि यह चल रहा है।
+
+2. सर्वर वाली शाखा डाउनलोड करें और सुनिश्चित करें कि आपके पास सभी आवश्यक मॉड्यूल हैं।
+
+ ```sh
+ git checkout 02-add-server
+ cd client
+ npm install
+ cd ../server
+ npm install
+ ```
+
+ Noir कोड को संकलित करने की कोई आवश्यकता नहीं है, यह वही कोड है जिसका उपयोग आपने चरण 1 के लिए किया था।
+
+3. सर्वर शुरू करें।
+
+ ```sh
+ npm run start
+ ```
+
+4. एक अलग कमांड-लाइन विंडो में, ब्राउज़र कोड की सेवा के लिए Vite चलाएँ।
+
+ ```sh
+ cd client
+ npm run dev
+ ```
+
+5. क्लाइंट कोड को [http://localhost:5173](http://localhost:5173) पर ब्राउज़ करें
+
+6. लेनदेन जारी करने से पहले, आपको नॉन्स के साथ-साथ वह राशि भी जाननी होगी जो आप भेज सकते हैं। यह जानकारी प्राप्त करने के लिए, **Update account data** पर क्लिक करें और संदेश पर हस्ताक्षर करें।
+
+ यहाँ हमारे सामने एक दुविधा है। एक ओर, हम ऐसे संदेश पर हस्ताक्षर नहीं करना चाहते हैं जिसका पुन: उपयोग किया जा सके ([रीप्ले हमला](https://en.wikipedia.org/wiki/Replay_attack)), यही कारण है कि हम पहली बार में एक नॉन्स चाहते हैं। हालाँकि, हमारे पास अभी तक कोई नॉन्स नहीं है। इसका समाधान एक ऐसा नॉन्स चुनना है जिसका उपयोग केवल एक बार किया जा सके और जो हमारे पास दोनों तरफ पहले से ही है, जैसे कि वर्तमान समय।
+
+ इस समाधान के साथ समस्या यह है कि समय पूरी तरह से सिंक्रनाइज़ नहीं हो सकता है। तो इसके बजाय, हम एक ऐसे मान पर हस्ताक्षर करते हैं जो हर मिनट बदलता है। इसका मतलब है कि रीप्ले हमलों के प्रति हमारी भेद्यता की खिड़की अधिकतम एक मिनट है। यह देखते हुए कि उत्पादन में हस्ताक्षरित अनुरोध TLS द्वारा संरक्षित होगा, और सुरंग के दूसरी तरफ - सर्वर - पहले से ही शेष राशि और नॉन्स का खुलासा कर सकता है (उसे काम करने के लिए उन्हें जानना होगा), यह एक स्वीकार्य जोखिम है।
+
+7. एक बार जब ब्राउज़र को शेष राशि और नॉन्स वापस मिल जाते हैं, तो यह स्थानांतरण फ़ॉर्म दिखाता है। गंतव्य पता और राशि चुनें और **Transfer** पर क्लिक करें। इस अनुरोध पर हस्ताक्षर करें।
+
+8. स्थानांतरण देखने के लिए, या तो **Update account data** या उस विंडो में देखें जहां आप सर्वर चलाते हैं। सर्वर हर बार बदलने पर स्टेट को लॉग करता है।
+
+ ```
+ ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
+
+ > server@1.0.0 start
+ > node --experimental-json-modules index.mjs
+
+ पोर्ट 3000 पर सुनना
+ Txn भेजें 0x90F79bf6EB2c4f870365E785982E1f101E93b906 36000 फ़िन्नी (milliEth) 0 संसाधित
+ नई स्टेट:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 के पास 64000 (1)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 के पास 100000 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC के पास 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 के पास 136000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 के पास 100000 (0)
+ Txn भेजें 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 7200 फ़िन्नी (milliEth) 1 संसाधित
+ नई स्टेट:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 के पास 56800 (2)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 के पास 107200 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC के पास 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 के पास 136000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 के पास 100000 (0)
+ Txn भेजें 0x90F79bf6EB2c4f870365E785982E1f101E93b906 3000 फ़िन्नी (milliEth) 2 संसाधित
+ नई स्टेट:
+ 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 के पास 53800 (3)
+ 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 के पास 107200 (0)
+ 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC के पास 100000 (0)
+ 0x90F79bf6EB2c4f870365E785982E1f101E93b906 के पास 139000 (0)
+ 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 के पास 100000 (0)
+ ```
+
+#### `server/index.mjs` {#server-index-mjs-1}
+
+[यह फ़ाइल](https://github.com/qbzzt/250911-zk-bank/blob/02-add-server/server/index.mjs) में सर्वर प्रक्रिया शामिल है, और [`main.nr`](https://github.com/qbzzt/250911-zk-bank/blob/02-add-server/server/noir/src/main.nr) पर Noir कोड के साथ इंटरैक्ट करती है। यहाँ दिलचस्प भागों की व्याख्या है।
+
+```js
+import { Noir } from '@noir-lang/noir_js'
+```
+
+[noir.js](https://www.npmjs.com/package/@noir-lang/noir_js) लाइब्रेरी JavaScript कोड और Noir कोड के बीच इंटरफ़ेस करती है।
+
+```js
+const circuit = JSON.parse(await fs.readFile("./noir/target/zkBank.json"))
+const noir = new Noir(circuit)
+```
+
+अरिथमैटिक सर्किट लोड करें—संकलित Noir प्रोग्राम जिसे हमने पिछले चरण में बनाया था—और इसे निष्पादित करने की तैयारी करें।
+
+```js
+// हम केवल एक हस्ताक्षरित अनुरोध के जवाब में खाता जानकारी प्रदान करते हैं
+const accountInformation = async signature => {
+ const fromAddress = await recoverAddress({
+ hash: hashMessage("खाता डेटा प्राप्त करें " + Math.floor((new Date().getTime())/60000)),
+ signature
+ })
+```
+
+खाता जानकारी प्रदान करने के लिए, हमें केवल हस्ताक्षर की आवश्यकता है। कारण यह है कि हम पहले से ही जानते हैं कि संदेश क्या होने वाला है, और इसलिए संदेश हैश।
+
+```js
+const processMessage = async (message, signature) => {
+```
+
+एक संदेश को संसाधित करें और उस लेनदेन को निष्पादित करें जिसे वह एन्कोड करता है।
+
+```js
+ // सार्वजनिक कुंजी प्राप्त करें
+ const pubKey = await recoverPublicKey({
+ hash,
+ signature
+ })
+```
+
+अब जब हम सर्वर पर JavaScript चलाते हैं, तो हम क्लाइंट के बजाय वहां सार्वजनिक कुंजी पुनर्प्राप्त कर सकते हैं।
+
+```js
+ let noirResult
+ try {
+ noirResult = await noir.execute({
+ message,
+ signature: signature.slice(2,-2).match(/.{2}/g).map(x => `0x${x}`),
+ pubKeyX,
+ pubKeyY,
+ accounts: Accounts
+ })
+```
+
+`noir.execute` Noir प्रोग्राम चलाता है। पैरामीटर [`Prover.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Prover.toml) में प्रदान किए गए लोगों के बराबर हैं। ध्यान दें कि लंबे मान हेक्साडेसिमल स्ट्रिंग्स (`["0x60", "0xA7"]`) की एक सरणी के रूप में प्रदान किए जाते हैं, न कि एकल हेक्साडेसिमल मान (`0x60A7`) के रूप में, जिस तरह से Viem इसे करता है।
+
+```js
+ } catch (err) {
+ console.log(`Noir त्रुटि: ${err}`)
+ throw Error("अमान्य लेनदेन, संसाधित नहीं हुआ")
+ }
+```
+
+यदि कोई त्रुटि है, तो उसे पकड़ें और फिर क्लाइंट को एक सरलीकृत संस्करण रिले करें।
+
+```js
+ Accounts[fromAccountNumber].nonce++
+ Accounts[fromAccountNumber].balance -= amount
+ Accounts[toAccountNumber].balance += amount
+```
+
+लेनदेन लागू करें। हमने इसे पहले ही Noir कोड में कर लिया है, लेकिन परिणाम को वहां से निकालने के बजाय इसे यहां फिर से करना आसान है।
+
+```js
+let Accounts = [
+ {
+ address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+ balance: 5000,
+ nonce: 0,
+ },
+```
+
+प्रारंभिक `Accounts` संरचना।
+
+### चरण 3 - एथेरियम स्मार्ट अनुबंध {#stage-3}
+
+1. सर्वर और क्लाइंट प्रक्रियाओं को रोकें।
+
+2. स्मार्ट अनुबंधों के साथ शाखा डाउनलोड करें और सुनिश्चित करें कि आपके पास सभी आवश्यक मॉड्यूल हैं।
+
+ ```sh
+ git checkout 03-smart-contracts
+ cd client
+ npm install
+ cd ../server
+ npm install
+ ```
+
+3. एक अलग कमांड-लाइन विंडो में `anvil` चलाएँ।
+
+4. सत्यापन कुंजी और सॉलिडिटी सत्यापनकर्ता उत्पन्न करें, फिर सत्यापनकर्ता कोड को सॉलिडिटी परियोजना में कॉपी करें।
+
+ ```sh
+ cd noir
+ bb write_vk -b ./target/zkBank.json -o ./target --oracle_hash keccak
+ bb write_solidity_verifier -k ./target/vk -o ./target/Verifier.sol
+ cp target/Verifier.sol ../../smart-contracts/src
+ ```
+
+5. स्मार्ट अनुबंधों पर जाएं और `anvil` ब्लॉकचेन का उपयोग करने के लिए पर्यावरण चर सेट करें।
+
+ ```sh
+ cd ../../smart-contracts
+ export ETH_RPC_URL=http://localhost:8545
+ ETH_PRIVATE_KEY=ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
+ ```
+
+6. `Verifier.sol` को परिनियोजित करें और पते को एक पर्यावरण चर में संग्रहीत करें।
+
+ ```sh
+ VERIFIER_ADDRESS=`forge create src/Verifier.sol:HonkVerifier --private-key $ETH_PRIVATE_KEY --optimize --broadcast | awk '/Deployed to:/ {print $3}'`
+ echo $VERIFIER_ADDRESS
+ ```
+
+7. `ZkBank` अनुबंध को परिनियोजित करें।
+
+ ```sh
+ ZKBANK_ADDRESS=`forge create ZkBank --private-key $ETH_PRIVATE_KEY --broadcast --constructor-args $VERIFIER_ADDRESS 0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b | awk '/Deployed to:/ {print $3}'`
+ echo $ZKBANK_ADDRESS
+ ```
+
+ `0x199..67b` मान `Accounts` की प्रारंभिक स्टेट का पेडरसन हैश है। यदि आप `server/index.mjs` में इस प्रारंभिक स्टेट को संशोधित करते हैं, तो आप ज़ीरो-नॉलेज प्रमाण द्वारा रिपोर्ट किए गए प्रारंभिक हैश को देखने के लिए एक लेनदेन चला सकते हैं।
+
+8. सर्वर चलाएँ।
+
+ ```sh
+ cd ../server
+ npm run start
+ ```
+
+9. क्लाइंट को एक अलग कमांड-लाइन विंडो में चलाएँ।
+
+ ```sh
+ cd client
+ npm run dev
+ ```
+
+10. कुछ लेनदेन चलाएँ।
+
+11. यह सत्यापित करने के लिए कि स्टेट ऑन-चेन बदल गया है, सर्वर प्रक्रिया को पुनरारंभ करें। देखें कि `ZkBank` अब लेनदेन स्वीकार नहीं करता है, क्योंकि लेनदेन में मूल हैश मान ऑन-चेन संग्रहीत हैश मान से भिन्न होता है।
+
+ यह अपेक्षित प्रकार की त्रुटि है।
+
+ ```
+ ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
+
+ > server@1.0.0 start
+ > node --experimental-json-modules index.mjs
+
+ पोर्ट 3000 पर सुनना
+ सत्यापन त्रुटि: ContractFunctionExecutionError: अनुबंध फ़ंक्शन "processTransaction" निम्नलिखित कारण से वापस आ गया:
+ गलत पुराना स्टेट हैश
+
+ अनुबंध कॉल:
+ पता: 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
+ फ़ंक्शन: processTransaction(bytes _proof, bytes32[] _publicInputs)
+ आर्ग्स: (0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf00000000000000000000000000000000000000000000000b75c020998797da7800000000000000000000000000000000000000000000000
+ ```
+
+#### `server/index.mjs` {#server-index-mjs-2}
+
+इस फ़ाइल में परिवर्तन ज्यादातर वास्तविक प्रमाण बनाने और इसे ऑन-चेन जमा करने से संबंधित हैं।
+
+```js
+import { exec } from 'child_process'
+import util from 'util'
+
+const execPromise = util.promisify(exec)
+```
+
+हमें वास्तविक प्रमाण बनाने के लिए [बैरटेनबर्ग पैकेज](https://github.com/AztecProtocol/aztec-packages/tree/next/barretenberg) का उपयोग करने की आवश्यकता है जिसे ऑन-चेन भेजना है। हम इस पैकेज का उपयोग या तो कमांड-लाइन इंटरफ़ेस (`bb`) चलाकर या [JavaScript लाइब्रेरी, `bb.js`](https://www.npmjs.com/package/@aztec/bb.js) का उपयोग करके कर सकते हैं। JavaScript लाइब्रेरी मूल रूप से कोड चलाने की तुलना में बहुत धीमी है, इसलिए हम कमांड-लाइन का उपयोग करने के लिए यहां [`exec`](https://nodejs.org/api/child_process.html#child_processexeccommand-options-callback) का उपयोग करते हैं।
+
+ध्यान दें कि यदि आप `bb.js` का उपयोग करने का निर्णय लेते हैं, तो आपको एक ऐसे संस्करण का उपयोग करने की आवश्यकता है जो आपके द्वारा उपयोग किए जा रहे Noir के संस्करण के साथ संगत हो। लिखने के समय, वर्तमान Noir संस्करण (1.0.0-beta.11) `bb.js` संस्करण 0.87 का उपयोग करता है।
+
+```js
+const zkBankAddress = process.env.ZKBANK_ADDRESS || "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"
+```
+
+यहां का पता वह है जो आपको तब मिलता है जब आप एक साफ `anvil` से शुरू करते हैं और उपरोक्त निर्देशों का पालन करते हैं।
+
+```js
+const walletClient = createWalletClient({
+ chain: anvil,
+ transport: http(),
+ account: privateKeyToAccount("0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6")
+})
+```
+
+यह निजी कुंजी `anvil` में डिफ़ॉल्ट पूर्व-वित्तपोषित खातों में से एक है।
+
+```js
+const generateProof = async (witness, fileID) => {
+```
+
+`bb` निष्पादन योग्य का उपयोग करके एक प्रमाण उत्पन्न करें।
+
+```js
+ const fname = `witness-${fileID}.gz`
+ await fs.writeFile(fname, witness)
+```
+
+साक्षी को एक फ़ाइल में लिखें।
+
+```js
+ await execPromise(`bb prove -b ./noir/target/zkBank.json -w ${fname} -o ${fileID} --oracle_hash keccak --output_format fields`)
+```
+
+वास्तव में प्रमाण बनाएँ। यह चरण सार्वजनिक चर वाली एक फ़ाइल भी बनाता है, लेकिन हमें इसकी आवश्यकता नहीं है। हमें वे चर `noir.execute` से पहले ही मिल गए थे।
+
+```js
+ const proof = "0x" + JSON.parse(await fs.readFile(`./${fileID}/proof_fields.json`)).reduce((a,b) => a+b, "").replace(/0x/g, "")
+```
+
+प्रमाण `Field` मानों का एक JSON सरणी है, जिनमें से प्रत्येक को एक हेक्साडेसिमल मान के रूप में दर्शाया गया है। हालाँकि, हमें इसे लेनदेन में एकल `bytes` मान के रूप में भेजने की आवश्यकता है, जिसे Viem एक बड़ी हेक्साडेसिमल स्ट्रिंग द्वारा दर्शाता है। यहां हम सभी मानों को जोड़कर, सभी `0x` को हटाकर और फिर अंत में एक जोड़कर प्रारूप बदलते हैं।
+
+```js
+ await execPromise(`rm -r ${fname} ${fileID}`)
+
+ return proof
+}
+```
+
+सफाई करें और प्रमाण लौटाएं।
+
+```js
+const processMessage = async (message, signature) => {
+ .
+ .
+ .
+
+ const publicFields = noirResult.returnValue.map(x=>'0x' + x.slice(2).padStart(64, "0"))
+```
+
+सार्वजनिक फ़ील्ड को 32-बाइट मानों की एक सरणी होनी चाहिए। हालाँकि, चूँकि हमें लेन-देन हैश को दो `Field` मानों के बीच विभाजित करने की आवश्यकता थी, यह 16-बाइट मान के रूप में दिखाई देता है। यहां हम शून्य जोड़ते हैं ताकि Viem समझ सके कि यह वास्तव में 32 बाइट है।
+
+```js
+ const proof = await generateProof(noirResult.witness, `${fromAddress}-${nonce}`)
+```
+
+प्रत्येक पता प्रत्येक नॉन्स का उपयोग केवल एक बार करता है ताकि हम साक्षी फ़ाइल और आउटपुट निर्देशिका के लिए एक अद्वितीय पहचानकर्ता के रूप में `fromAddress` और `nonce` के संयोजन का उपयोग कर सकें।
+
+```js
+ try {
+ await zkBank.write.processTransaction([
+ proof, publicFields])
+ } catch (err) {
+ console.log(`सत्यापन त्रुटि: ${err}`)
+ throw Error("लेनदेन को ऑनचेन सत्यापित नहीं कर सकते")
+ }
+ .
+ .
+ .
+}
+```
+
+श्रृंखला में लेनदेन भेजें।
+
+#### `smart-contracts/src/ZkBank.sol` {#smart-contracts-src-zkbank-sol}
+
+यह ऑन-चेन कोड है जो लेनदेन प्राप्त करता है।
+
+```solidity
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.21;
+
+import {HonkVerifier} from "./Verifier.sol";
+
+contract ZkBank {
+ HonkVerifier immutable myVerifier;
+ bytes32 currentStateHash;
+
+ constructor(address _verifierAddress, bytes32 _initialStateHash) {
+ currentStateHash = _initialStateHash;
+ myVerifier = HonkVerifier(_verifierAddress);
+ }
+```
+
+ऑन-चेन कोड को दो चरों का ट्रैक रखने की आवश्यकता है: सत्यापनकर्ता (एक अलग अनुबंध जो `nargo` द्वारा बनाया गया है) और वर्तमान स्टेट हैश।
+
+```solidity
+ event TransactionProcessed(
+ bytes32 indexed transactionHash,
+ bytes32 oldStateHash,
+ bytes32 newStateHash
+ );
+```
+
+हर बार जब स्टेट बदलता है, तो हम एक `TransactionProcessed` इवेंट उत्सर्जित करते हैं।
+
+```solidity
+ function processTransaction(
+ bytes calldata _proof,
+ bytes32[] calldata _publicFields
+ ) public {
+```
+
+यह फ़ंक्शन लेनदेन को संसाधित करता है। यह प्रमाण ( `बाइट्स` के रूप में) और सार्वजनिक इनपुट (`बाइट्स32` सरणी के रूप में) प्राप्त करता है, उस प्रारूप में जो सत्यापनकर्ता की आवश्यकता होती है (ऑन-चेन प्रसंस्करण को कम करने और इसलिए गैस लागत को कम करने के लिए)।
+
+```solidity
+ require(_publicInputs[0] == currentStateHash,
+ "गलत पुराना स्टेट हैश");
+```
+
+ज़ीरो-नॉलेज प्रमाण यह होना चाहिए कि लेनदेन हमारे वर्तमान हैश से एक नए में बदल जाता है।
+
+```solidity
+ myVerifier.verify(_proof, _publicFields);
+```
+
+ज़ीरो-नॉलेज प्रमाण को सत्यापित करने के लिए सत्यापनकर्ता अनुबंध को कॉल करें। यह चरण लेनदेन को वापस कर देता है यदि ज़ीरो-नॉलेज प्रमाण गलत है।
+
+```solidity
+ currentStateHash = _publicFields[1];
+
+ emit TransactionProcessed(
+ _publicFields[2]<<128 | _publicFields[3],
+ _publicFields[0],
+ _publicFields[1]
+ );
+ }
+}
+```
+
+यदि सब कुछ सही हो जाता है, तो स्टेट हैश को नए मान में अपडेट करें और `TransactionProcessed` इवेंट उत्सर्जित करें।
+
+## केंद्रीकृत घटक द्वारा दुरुपयोग {#abuses}
+
+सूचना सुरक्षा में तीन विशेषताएँ होती हैं:
+
+- _गोपनीयता_, उपयोगकर्ता उस जानकारी को नहीं पढ़ सकते हैं जिसे पढ़ने के लिए वे अधिकृत नहीं हैं।
+- _अखंडता_, जानकारी को अधिकृत उपयोगकर्ताओं द्वारा अधिकृत तरीके से छोड़कर नहीं बदला जा सकता है।
+- _उपलब्धता_, अधिकृत उपयोगकर्ता प्रणाली का उपयोग कर सकते हैं।
+
+इस प्रणाली पर, ज़ीरो-नॉलेज प्रमाणों के माध्यम से अखंडता प्रदान की जाती है। उपलब्धता की गारंटी देना बहुत कठिन है, और गोपनीयता असंभव है, क्योंकि बैंक को प्रत्येक खाते की शेष राशि और सभी लेनदेन जानने होंगे। ऐसी किसी इकाई को जो जानकारी रखती है, उसे उस जानकारी को साझा करने से रोकने का कोई तरीका नहीं है।
+
+हो सकता है कि [स्टील्थ एड्रेस](https://vitalik.eth.limo/general/2023/01/20/stealth.html) का उपयोग करके वास्तव में गोपनीय बैंक बनाना संभव हो, लेकिन यह इस लेख के दायरे से बाहर है।
+
+### गलत जानकारी {#false-info}
+
+एक तरीका जिससे सर्वर अखंडता का उल्लंघन कर सकता है, वह है जब [डेटा का अनुरोध किया जाता है](https://github.com/qbzzt/250911-zk-bank/blob/03-smart-contracts/server/index.mjs#L278-L291) तो गलत जानकारी प्रदान करना।
+
+इसे हल करने के लिए, हम एक दूसरा Noir प्रोग्राम लिख सकते हैं जो खातों को एक निजी इनपुट के रूप में और उस पते को जिसके लिए जानकारी का अनुरोध किया गया है, एक सार्वजनिक इनपुट के रूप में प्राप्त करता है। आउटपुट उस पते की शेष राशि और नॉन्स है, और खातों का हैश है।
+
+बेशक, इस प्रमाण को ऑन-चेन सत्यापित नहीं किया जा सकता है, क्योंकि हम ऑन-चेन नॉन्स और शेष राशि पोस्ट नहीं करना चाहते हैं। हालाँकि, इसे ब्राउज़र में चलने वाले क्लाइंट कोड द्वारा सत्यापित किया जा सकता है।
+
+### जबरन लेनदेन {#forced-txns}
+
+L2s पर उपलब्धता सुनिश्चित करने और सेंसरशिप को रोकने का सामान्य तंत्र [जबरन लेनदेन](https://docs.optimism.io/stack/transactions/forced-transaction) है। लेकिन जबरन लेनदेन ज़ीरो-नॉलेज प्रमाणों के साथ संयुक्त नहीं होते हैं। सर्वर ही एकमात्र इकाई है जो लेनदेन को सत्यापित कर सकती है।
+
+हम जबरन लेनदेन स्वीकार करने के लिए `smart-contracts/src/ZkBank.sol` को संशोधित कर सकते हैं और सर्वर को स्टेट बदलने से रोक सकते हैं जब तक कि वे संसाधित न हो जाएं। हालाँकि, यह हमें एक सरल सेवा-से-इनकार हमले के लिए खोलता है। क्या होगा यदि एक जबरन लेनदेन अमान्य है और इसलिए संसाधित करना असंभव है?
+
+इसका समाधान यह है कि एक ज़ीरो-नॉलेज प्रमाण हो कि एक जबरन लेनदेन अमान्य है। यह सर्वर को तीन विकल्प देता है:
+
+- जबरन लेनदेन को संसाधित करें, यह साबित करते हुए एक ज़ीरो-नॉलेज प्रमाण प्रदान करें कि इसे संसाधित किया गया है और नया स्टेट हैश।
+- जबरन लेनदेन को अस्वीकार करें, और अनुबंध को एक ज़ीरो-नॉलेज प्रमाण प्रदान करें कि लेनदेन अमान्य है (अज्ञात पता, खराब नॉन्स, या अपर्याप्त शेष राशि)।
+- जबरन लेनदेन को अनदेखा करें। सर्वर को वास्तव में लेनदेन को संसाधित करने के लिए मजबूर करने का कोई तरीका नहीं है, लेकिन इसका मतलब है कि पूरी प्रणाली अनुपलब्ध है।
+
+#### उपलब्धता बॉन्ड {#avail-bonds}
+
+वास्तविक जीवन के कार्यान्वयन में, सर्वर को चालू रखने के लिए शायद किसी प्रकार का लाभ का मकसद होगा। हम इस प्रोत्साहन को सर्वर द्वारा एक उपलब्धता बॉन्ड पोस्ट करके मजबूत कर सकते हैं जिसे कोई भी जला सकता है यदि एक निश्चित अवधि के भीतर एक जबरन लेनदेन संसाधित नहीं होता है।
+
+### खराब Noir कोड {#bad-noir-code}
+
+आम तौर पर, लोगों को एक स्मार्ट अनुबंध पर भरोसा करने के लिए हम स्रोत कोड को [ब्लॉक एक्सप्लोरर](https://eth.blockscout.com/address/0x7D16d2c4e96BCFC8f815E15b771aC847EcbDB48b?tab=contract) पर अपलोड करते हैं। हालाँकि, ज़ीरो-नॉलेज प्रमाणों के मामले में, यह अपर्याप्त है।
+
+`Verifier.sol` में सत्यापन कुंजी होती है, जो Noir प्रोग्राम का एक फ़ंक्शन है। हालाँकि, वह कुंजी हमें यह नहीं बताती कि Noir प्रोग्राम क्या था। वास्तव में एक विश्वसनीय समाधान के लिए, आपको Noir प्रोग्राम (और वह संस्करण जिसने इसे बनाया है) अपलोड करना होगा। अन्यथा, ज़ीरो-नॉलेज प्रमाण एक अलग प्रोग्राम को प्रतिबिंबित कर सकते हैं, जिसमें एक बैक डोर हो।
+
+जब तक ब्लॉक एक्सप्लोरर हमें Noir प्रोग्राम अपलोड और सत्यापित करने की अनुमति देना शुरू नहीं करते, तब तक आपको इसे स्वयं करना चाहिए (अधिमानतः [IPFS](/developers/tutorials/ipfs-decentralized-ui/) पर)। फिर परिष्कृत उपयोगकर्ता स्रोत कोड डाउनलोड करने, इसे स्वयं संकलित करने, `Verifier.sol` बनाने और यह सत्यापित करने में सक्षम होंगे कि यह ऑन-चेन वाले के समान है।
+
+## निष्कर्ष {#conclusion}
+
+प्लाज्मा-प्रकार के अनुप्रयोगों को सूचना भंडारण के रूप में एक केंद्रीकृत घटक की आवश्यकता होती है। यह संभावित कमजोरियों को खोलता है, लेकिन बदले में, हमें उन तरीकों से गोपनीयता बनाए रखने की अनुमति देता है जो स्वयं ब्लॉकचेन पर उपलब्ध नहीं हैं। ज़ीरो-नॉलेज प्रमाणों के साथ हम अखंडता सुनिश्चित कर सकते हैं और संभवतः केंद्रीकृत घटक को चलाने वाले किसी भी व्यक्ति के लिए उपलब्धता बनाए रखने के लिए इसे आर्थिक रूप से लाभप्रद बना सकते हैं।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
+
+## आभार {#acknowledgements}
+
+- जोश क्राइट्स ने इस लेख का एक मसौदा पढ़ा और एक कांटेदार Noir मुद्दे पर मेरी मदद की।
+
+कोई भी शेष त्रुटि मेरी जिम्मेदारी है।
diff --git a/public/content/translations/hi/developers/tutorials/calling-a-smart-contract-from-javascript/index.md b/public/content/translations/hi/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
new file mode 100644
index 00000000000..d768b49b1a9
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/calling-a-smart-contract-from-javascript/index.md
@@ -0,0 +1,131 @@
+---
+title: "जावास्क्रिप्ट से एक स्मार्ट अनुबंध को कॉल करना"
+description: "Dai टोकन उदाहरण का उपयोग करके जावास्क्रिप्ट से स्मार्ट अनुबंध फ़ंक्शन को कैसे कॉल करें"
+author: jdourlens
+tags: [ "लेनदेन", "frontend", "JavaScript", "web3.js" ]
+skill: beginner
+lang: hi
+published: 2020-04-19
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/calling-a-smart-contract-from-javascript/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+इस ट्यूटोरियल में हम देखेंगे कि जावास्क्रिप्ट से [स्मार्ट अनुबंध](/developers/docs/smart-contracts/) फ़ंक्शन को कैसे कॉल किया जाए। सबसे पहले एक स्मार्ट अनुबंध की स्थिति को पढ़ना है (उदाहरण के लिए, एक ERC20 धारक का शेष), फिर हम टोकन हस्तांतरण करके ब्लॉकचेन की स्थिति को संशोधित करेंगे। आपको [ब्लॉकचेन के साथ इंटरैक्ट करने के लिए एक JS वातावरण स्थापित करने](/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/) से पहले से ही परिचित होना चाहिए।
+
+इस उदाहरण के लिए हम DAI टोकन के साथ खेलेंगे, परीक्षण के उद्देश्य के लिए हम ganache-cli का उपयोग करके ब्लॉकचेन को फोर्क करेंगे और एक ऐसे पते को अनलॉक करेंगे जिसमें पहले से ही बहुत सारे DAI हैं:
+
+```bash
+ganache-cli -f https://mainnet.infura.io/v3/[आपकी इन्फुरा कुंजी] -d -i 66 1 --unlock 0x4d10ae710Bd8D1C31bd7465c8CBC3add6F279E81
+```
+
+एक स्मार्ट अनुबंध के साथ इंटरैक्ट करने के लिए हमें इसके पते और ABI की आवश्यकता होगी:
+
+```js
+const ERC20TransferABI = [
+ {
+ constant: false,
+ inputs: [
+ {
+ name: "_to",
+ type: "address",
+ },
+ {
+ name: "_value",
+ type: "uint256",
+ },
+ ],
+ name: "transfer",
+ outputs: [
+ {
+ name: "",
+ type: "bool",
+ },
+ ],
+ payable: false,
+ stateMutability: "nonpayable",
+ type: "function",
+ },
+ {
+ constant: true,
+ inputs: [
+ {
+ name: "_owner",
+ type: "address",
+ },
+ ],
+ name: "balanceOf",
+ outputs: [
+ {
+ name: "balance",
+ type: "uint256",
+ },
+ ],
+ payable: false,
+ stateMutability: "view",
+ type: "function",
+ },
+]
+
+const DAI_ADDRESS = "0x6b175474e89094c44da98b954eedeac495271d0f"
+```
+
+इस प्रोजेक्ट के लिए हमने सिर्फ `balanceOf` और `transfer` फ़ंक्शन को रखने के लिए पूरे ERC20 ABI को हटा दिया है, लेकिन आप [पूरा ERC20 ABI यहां](https://ethereumdev.io/abi-for-erc20-contract-on-ethereum/) पा सकते हैं।
+
+फिर हमें अपने स्मार्ट अनुबंध को इंस्टेंशिएट करने की आवश्यकता है:
+
+```js
+const web3 = new Web3("http://localhost:8545")
+
+const daiToken = new web3.eth.Contract(ERC20TransferABI, DAI_ADDRESS)
+```
+
+हम दो पते भी सेट करेंगे:
+
+- वह जो हस्तांतरण प्राप्त करेगा और
+- वह जिसे हमने पहले ही अनलॉक कर दिया है जो इसे भेजेगा:
+
+```js
+const senderAddress = "0x4d10ae710Bd8D1C31bd7465c8CBC3add6F279E81"
+const receiverAddress = "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+```
+
+अगले भाग में हम `balanceOf` फ़ंक्शन को कॉल करेंगे ताकि दोनों पतों पर मौजूद टोकन की वर्तमान राशि को पुनः प्राप्त किया जा सके।
+
+## कॉल: एक स्मार्ट अनुबंध से मान पढ़ना {#call-reading-value-from-a-smart-contract}
+
+पहला उदाहरण एक "स्थिर" विधि को कॉल करेगा और बिना कोई लेनदेन भेजे EVM में इसकी स्मार्ट अनुबंध विधि को निष्पादित करेगा। इसके लिए हम एक पते का ERC20 शेष पढ़ेंगे। [ERC20 टोकन के बारे में हमारा लेख पढ़ें](/developers/tutorials/understand-the-erc-20-token-smart-contract/)।
+
+आप एक इंस्टेंशिएटेड स्मार्ट अनुबंध विधियों तक पहुँच सकते हैं जिसके लिए आपने ABI प्रदान किया है: `yourContract.methods.methodname`। `call` फ़ंक्शन का उपयोग करके आपको फ़ंक्शन को निष्पादित करने का परिणाम प्राप्त होगा।
+
+```js
+daiToken.methods.balanceOf(senderAddress).call(function (err, res) {
+ if (err) {
+ console.log("एक त्रुटि हुई", err)
+ return
+ }
+ console.log("शेष है: ", res)
+})
+```
+
+याद रखें कि DAI ERC20 में 18 दशमलव हैं जिसका अर्थ है कि सही राशि प्राप्त करने के लिए आपको 18 शून्य हटाने होंगे। `uint256` को स्ट्रिंग्स के रूप में लौटाया जाता है क्योंकि जावास्क्रिप्ट बड़े संख्यात्मक मानों को नहीं संभालता है। यदि आप सुनिश्चित नहीं हैं [कि JS में बड़ी संख्याओं से कैसे निपटा जाए, तो bignumber.js के बारे में हमारा ट्यूटोरियल देखें](https://ethereumdev.io/how-to-deal-with-big-numbers-in-javascript/)।
+
+## भेजें: एक स्मार्ट अनुबंध फ़ंक्शन को एक लेनदेन भेजना {#send-sending-a-transaction-to-a-smart-contract-function}
+
+दूसरे उदाहरण के लिए हम अपने दूसरे पते पर 10 DAI भेजने के लिए DAI स्मार्ट अनुबंध के हस्तांतरण फ़ंक्शन को कॉल करेंगे। हस्तांतरण फ़ंक्शन दो पैरामीटर स्वीकार करता है: प्राप्तकर्ता का पता और हस्तांतरण करने के लिए टोकन की राशि:
+
+```js
+daiToken.methods
+ .transfer(receiverAddress, "100000000000000000000")
+ .send({ from: senderAddress }, function (err, res) {
+ if (err) {
+ console.log("एक त्रुटि हुई", err)
+ return
+ }
+ console.log("लेनदेन का हैश: " + res)
+ })
+```
+
+कॉल फ़ंक्शन उस लेनदेन का हैश लौटाता है जिसे ब्लॉकचेन में माइन किया जाएगा। एथेरियम पर, लेनदेन हैश पूर्वानुमानित होते हैं - इस तरह हम लेनदेन के निष्पादित होने से पहले उसका हैश प्राप्त कर सकते हैं ([यहां जानें कि हैश की गणना कैसे की जाती है](https://ethereum.stackexchange.com/questions/45648/how-to-calculate-the-assigned-txhash-of-a-transaction)).
+
+चूंकि फ़ंक्शन केवल लेनदेन को ब्लॉकचेन में जमा करता है, इसलिए हम तब तक परिणाम नहीं देख सकते जब तक हमें यह पता न चल जाए कि इसे कब माइन किया गया है और ब्लॉकचेन में शामिल किया गया है। अगले ट्यूटोरियल में हम सीखेंगे [कि इसके हैश को जानकर ब्लॉकचेन पर लेनदेन के निष्पादित होने की प्रतीक्षा कैसे करें](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/)।
diff --git a/public/content/translations/hi/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md b/public/content/translations/hi/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
new file mode 100644
index 00000000000..e45823d40aa
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/creating-a-wagmi-ui-for-your-contract/index.md
@@ -0,0 +1,585 @@
+---
+title: "आपके अनुबंध के लिए एक यूज़र इंटरफ़ेस बनाना"
+description: "TypeScript, React, Vite और Wagmi जैसे आधुनिक घटकों का उपयोग करके, हम एक आधुनिक, लेकिन न्यूनतम, यूज़र इंटरफ़ेस पर जाएँगे और सीखेंगे कि वॉलेट को यूज़र इंटरफ़ेस से कैसे कनेक्ट करें, जानकारी पढ़ने के लिए स्मार्ट अनुबंध को कॉल करें, स्मार्ट अनुबंध में लेनदेन भेजें, और परिवर्तनों की पहचान करने के लिए स्मार्ट अनुबंध से इवेंट्स की निगरानी करें।"
+author: "ओरी पोमेरेन्ट्ज़"
+tags: [ "typescript", "react", "vite", "wagmi", "frontend" ]
+skill: beginner
+published: 2023-11-01
+lang: hi
+sidebarDepth: 3
+---
+
+आपको एथेरियम इकोसिस्टम में एक ऐसी सुविधा मिली जिसकी हमें आवश्यकता है। आपने इसे लागू करने के लिए स्मार्ट अनुबंध लिखे, और शायद कुछ संबंधित कोड भी जो ऑफ-चेन चलता है। यह बहुत बढ़िया है! दुर्भाग्य से, यूज़र इंटरफ़ेस के बिना आपके पास कोई यूज़र नहीं होगा, और पिछली बार जब आपने कोई वेबसाइट लिखी थी तो लोग डायल-अप मोडेम का उपयोग करते थे और JavaScript नया था।
+
+यह लेख आपके लिए है। मैं मानता हूँ कि आप प्रोग्रामिंग जानते हैं, और शायद थोड़ी JavaScript और HTML भी, लेकिन आपके यूज़र इंटरफ़ेस कौशल पुराने और आउट ऑफ डेट हैं। हम साथ मिलकर एक सरल आधुनिक एप्लिकेशन पर काम करेंगे ताकि आप देख सकें कि इन दिनों यह कैसे किया जाता है।
+
+## यह क्यों महत्वपूर्ण है {#why-important}
+
+सिद्धांत रूप में, आप लोगों को अपने अनुबंधों के साथ इंटरैक्ट करने के लिए [Etherscan](https://holesky.etherscan.io/address/0x432d810484add7454ddb3b5311f0ac2e95cecea8#writeContract) या [Blockscout](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=write_contract) का उपयोग करा सकते हैं। यह अनुभवी Ethereans के लिए बहुत अच्छा होगा। लेकिन हम [एक और अरब लोगों](https://blog.ethereum.org/2021/05/07/ethereum-for-the-next-billion) की सेवा करने की कोशिश कर रहे हैं। यह एक बेहतरीन यूज़र अनुभव के बिना नहीं होगा, और एक अनुकूल यूज़र इंटरफ़ेस इसका एक बड़ा हिस्सा है।
+
+## Greeter एप्लिकेशन {#greeter-app}
+
+एक आधुनिक UI कैसे काम करता है इसके पीछे बहुत सारे सिद्धांत हैं, और [बहुत सारी अच्छी साइटें](https://react.dev/learn/thinking-in-react) हैं [जो इसे समझाती हैं](https://wagmi.sh/core/getting-started)। उन साइटों द्वारा किए गए अच्छे काम को दोहराने के बजाय, मैं यह मानूंगा कि आप करके सीखना पसंद करते हैं और एक ऐसे एप्लिकेशन से शुरू करना चाहते हैं जिसके साथ आप खेल सकते हैं। चीजों को पूरा करने के लिए आपको अभी भी सिद्धांत की आवश्यकता है, और हम उस पर पहुँचेंगे - हम बस स्रोत फ़ाइल दर स्रोत फ़ाइल जाएँगे, और जैसे-जैसे हम उन तक पहुँचेंगे, चीजों पर चर्चा करेंगे।
+
+### इंस्टॉलेशन {#installation}
+
+1. यदि आवश्यक हो, तो अपने वॉलेट में [Holesky ब्लॉकचेन](https://chainlist.org/?search=holesky&testnets=true) जोड़ें और [टेस्ट ETH](https://www.holeskyfaucet.io/) प्राप्त करें।
+
+2. github रिपॉजिटरी को क्लोन करें।
+
+ ```sh
+ git clone https://github.com/qbzzt/20230801-modern-ui.git
+ ```
+
+3. आवश्यक पैकेज इंस्टॉल करें।
+
+ ```sh
+ cd 20230801-modern-ui
+ pnpm install
+ ```
+
+4. एप्लिकेशन शुरू करें।
+
+ ```sh
+ pnpm dev
+ ```
+
+5. एप्लिकेशन द्वारा दिखाए गए URL पर ब्राउज़ करें। अधिकांश मामलों में, वह [http://localhost:5173/](http://localhost:5173/) है।
+
+6. आप अनुबंध स्रोत कोड, Hardhat के Greeter का थोड़ा संशोधित संस्करण, [एक ब्लॉकचेन एक्सप्लोरर पर](https://eth-holesky.blockscout.com/address/0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8?tab=contract) देख सकते हैं।
+
+### फ़ाइल वॉक थ्रू {#file-walk-through}
+
+#### `index.html` {#index-html}
+
+यह फ़ाइल मानक HTML बॉयलरप्लेट है, सिवाय इस लाइन के, जो स्क्रिप्ट फ़ाइल को आयात करती है।
+
+```html
+
+```
+
+#### `src/main.tsx` {#main-tsx}
+
+फ़ाइल एक्सटेंशन हमें बताता है कि यह फ़ाइल [TypeScript](https://www.typescriptlang.org/) में लिखा गया एक [React घटक](https://www.w3schools.com/react/react_components.asp) है, जो JavaScript का एक एक्सटेंशन है जो [टाइप चेकिंग](https://en.wikipedia.org/wiki/Type_system#Type_checking) का समर्थन करता है। TypeScript को JavaScript में संकलित किया जाता है, इसलिए हम इसे क्लाइंट-साइड निष्पादन के लिए उपयोग कर सकते हैं।
+
+```tsx
+import '@rainbow-me/rainbowkit/styles.css'
+import { RainbowKitProvider } from '@rainbow-me/rainbowkit'
+import * as React from 'react'
+import * as ReactDOM from 'react-dom/client'
+import { WagmiConfig } from 'wagmi'
+import { chains, config } from './wagmi'
+```
+
+हमें जिस लाइब्रेरी कोड की आवश्यकता है उसे आयात करें।
+
+```tsx
+import { App } from './App'
+```
+
+उस React घटक को आयात करें जो एप्लिकेशन को लागू करता है (नीचे देखें)।
+
+```tsx
+ReactDOM.createRoot(document.getElementById('root')!).render(
+```
+
+रूट React घटक बनाएँ। `render` का पैरामीटर [JSX](https://www.w3schools.com/react/react_jsx.asp) है, जो एक एक्सटेंशन भाषा है जो HTML और JavaScript/TypeScript दोनों का उपयोग करती है। यहाँ विस्मयादिबोधक बिंदु TypeScript घटक को बताता है: \"आप नहीं जानते कि `document.getElementById('root')` `ReactDOM.createRoot` के लिए एक वैध पैरामीटर होगा, लेकिन चिंता न करें - मैं डिवेलपर हूँ और मैं आपको बता रहा हूँ कि यह होगा\"।
+
+```tsx
+
+```
+
+एप्लिकेशन [एक `React.StrictMode` घटक](https://react.dev/reference/react/StrictMode) के अंदर जा रहा है। यह घटक React लाइब्रेरी को अतिरिक्त डिबगिंग जाँचें डालने के लिए कहता है, जो विकास के दौरान उपयोगी है।
+
+```tsx
+
+```
+
+एप्लिकेशन [एक `WagmiConfig` घटक](https://wagmi.sh/react/api/WagmiProvider) के अंदर भी है। [wagmi (we are going to make it) लाइब्रेरी](https://wagmi.sh/) React UI परिभाषाओं को एथेरियम विकेंद्रीकृत अनुप्रयोग लिखने के लिए [viem लाइब्रेरी](https://viem.sh/) से जोड़ती है।
+
+```tsx
+
+```
+
+और अंत में, [एक `RainbowKitProvider` घटक](https://www.rainbowkit.com/)। यह घटक लॉग ऑन करने और वॉलेट और एप्लिकेशन के बीच संचार को संभालता है।
+
+```tsx
+
+
+ ,
+)
+```
+
+बेशक, हमें अन्य घटकों को बंद करना होगा।
+
+#### `src/App.tsx` {#app-tsx}
+
+```tsx
+import { ConnectButton } from '@rainbow-me/rainbowkit'
+import { useAccount } from 'wagmi'
+import { Greeter } from './components/Greeter'
+
+export function App() {
+```
+
+यह एक React घटक बनाने का मानक तरीका है - एक फ़ंक्शन को परिभाषित करें जिसे हर बार रेंडर करने की आवश्यकता होने पर कॉल किया जाता है। इस फ़ंक्शन में आम तौर पर शीर्ष पर कुछ TypeScript या JavaScript कोड होता है, जिसके बाद एक `return` कथन होता है जो JSX कोड लौटाता है।
+
+```tsx
+ const { isConnected } = useAccount()
+```
+
+यहां हम यह जांचने के लिए [`useAccount`](https://wagmi.sh/react/api/hooks/useAccount) का उपयोग करते हैं कि हम वॉलेट के माध्यम से ब्लॉकचेन से जुड़े हैं या नहीं।
+
+परंपरा के अनुसार, React में `use...` नामक फ़ंक्शन [हुक](https://www.w3schools.com/react/react_hooks.asp) होते हैं जो किसी प्रकार का डेटा लौटाते हैं। जब आप ऐसे हुक का उपयोग करते हैं, तो न केवल आपके घटक को डेटा मिलता है, बल्कि जब वह डेटा बदलता है तो घटक को अद्यतन जानकारी के साथ फिर से प्रस्तुत किया जाता है।
+
+```tsx
+ return (
+ <>
+```
+
+एक React घटक के JSX को एक घटक लौटाना _होता_ है। जब हमारे पास कई घटक होते हैं और हमारे पास कुछ भी नहीं होता है जो \"स्वाभाविक रूप से\" लपेटता है, तो हम एक खाली घटक (`<> ...` का उपयोग करते हैं `) उन्हें एक ही घटक में बनाने के लिए।
+
+```tsx
+ Greeter
+ = (evt) =>
+ setNewGreeting(evt.target.value)
+```
+
+यह नए अभिवादन इनपुट फ़ील्ड के बदलने पर इवेंट हैंडलर है। प्रकार, [`ChangeEventHandler`](https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/forms_and_events/), निर्दिष्ट करता है कि यह एक HTML इनपुट तत्व के मान परिवर्तन के लिए हैंडलर है। `` भाग का उपयोग किया जाता है क्योंकि यह एक [जेनेरिक प्रकार](https://www.w3schools.com/typescript/typescript_basic_generics.php) है।
+
+```tsx
+ const preparedTx = usePrepareContractWrite({
+ address: greeterAddr,
+ abi: greeterABI,
+ functionName: 'setGreeting',
+ args: [ newGreeting ]
+ })
+ const workingTx = useContractWrite(preparedTx.config)
+```
+
+क्लाइंट के दृष्टिकोण से ब्लॉकचेन लेनदेन जमा करने की यह प्रक्रिया है:
+
+1. ब्लॉकचेन में एक नोड को [`eth_estimateGas`](https://docs.alchemy.com/reference/eth-estimategas) का उपयोग करके लेनदेन भेजें।
+2. नोड से प्रतिक्रिया की प्रतीक्षा करें।
+3. जब प्रतिक्रिया प्राप्त हो जाए, तो यूज़र से वॉलेट के माध्यम से लेनदेन पर हस्ताक्षर करने के लिए कहें। यह कदम नोड प्रतिक्रिया प्राप्त होने के _बाद_ होना चाहिए क्योंकि यूज़र को उस पर हस्ताक्षर करने से पहले लेनदेन की गैस लागत दिखाई जाती है।
+4. यूज़र द्वारा स्वीकृति की प्रतीक्षा करें।
+5. लेनदेन फिर से भेजें, इस बार [`eth_sendRawTransaction`](https://docs.alchemy.com/reference/eth-sendrawtransaction) का उपयोग करके।
+
+चरण 2 में संभवतः एक बोधगम्य समय लगेगा, जिसके दौरान यूज़र सोचेंगे कि क्या उनका कमांड वास्तव में यूज़र इंटरफ़ेस द्वारा प्राप्त किया गया था और उनसे पहले से ही लेनदेन पर हस्ताक्षर करने के लिए क्यों नहीं कहा जा रहा है। यह खराब यूज़र अनुभव (UX) बनाता है।
+
+समाधान [तैयारी हुक](https://wagmi.sh/react/prepare-hooks) का उपयोग करना है। हर बार जब कोई पैरामीटर बदलता है, तो तुरंत नोड को `eth_estimateGas` अनुरोध भेजें। फिर, जब यूज़र वास्तव में लेनदेन भेजना चाहता है (**अभिवादन अपडेट करें** दबाकर), तो गैस लागत ज्ञात होती है और यूज़र तुरंत वॉलेट पेज देख सकता है।
+
+```tsx
+ return (
+```
+
+अब हम अंत में वापसी के लिए वास्तविक HTML बना सकते हैं।
+
+```tsx
+ <>
+ Greeter
+ {
+ !readResults.isError && !readResults.isLoading &&
+
+```
+
+एक `ShowGreeting` घटक बनाएँ (नीचे समझाया गया है), लेकिन केवल तभी जब अभिवादन ब्लॉकचेन से सफलतापूर्वक पढ़ा गया हो।
+
+```tsx
+
+```
+
+यह इनपुट टेक्स्ट फ़ील्ड है जहाँ यूज़र एक नया अभिवादन सेट कर सकता है। हर बार जब यूज़र कोई की दबाता है, तो हम `greetingChange` को कॉल करते हैं जो `setNewGreeting` को कॉल करता है। चूंकि `setNewGreeting` `useState` हुक से आता है, यह `Greeter` घटक को फिर से प्रस्तुत करने का कारण बनता है। इसका मतलब है कि:
+
+- हमें नए अभिवादन का मान रखने के लिए `value` निर्दिष्ट करने की आवश्यकता है, क्योंकि अन्यथा यह डिफ़ॉल्ट, खाली स्ट्रिंग में वापस आ जाएगा।
+- `usePrepareContractWrite` को हर बार `newGreeting` बदलने पर कॉल किया जाता है, जिसका अर्थ है कि तैयार लेनदेन में हमेशा नवीनतम `newGreeting` होगा।
+
+```tsx
+
+```
+
+यदि कोई `workingTx.write` नहीं है तो हम अभी भी अभिवादन अपडेट भेजने के लिए आवश्यक जानकारी की प्रतीक्षा कर रहे हैं, इसलिए बटन अक्षम है। यदि कोई `workingTx.write` मान है तो वह लेनदेन भेजने के लिए कॉल करने वाला फ़ंक्शन है।
+
+```tsx
+
+ {attrs.name}
+
+ {JSON.stringify(attrs.object, null, 2)}
+```
+
+अधिकांश फ़ील्ड [`JSON.stringify`](https://www.w3schools.com/js/js_json_stringify.asp) का उपयोग करके प्रदर्शित किए जाते हैं।
+
+```tsx
+
+ { funs.length > 0 &&
+ <>
+ फ़ंक्शन:
+
+```
+
+अपवाद फ़ंक्शन हैं, जो [JSON मानक](https://www.json.org/json-en.html) का हिस्सा नहीं हैं, इसलिए उन्हें अलग से प्रदर्शित करना होगा।
+
+```tsx
+ {funs.map((f, i) =>
+```
+
+JSX के भीतर, `{` घुंघराले कोष्ठक `}` के अंदर के कोड को JavaScript के रूप में व्याख्या किया जाता है। फिर, `(` नियमित कोष्ठक `)` के अंदर के कोड की फिर से JSX के रूप में व्याख्या की जाती है।
+
+```tsx
+ (- {f}
)
+ )}
+```
+
+React को [DOM ट्री](https://www.w3schools.com/js/js_htmldom.asp) में टैग के लिए अलग पहचानकर्ता की आवश्यकता होती है। इसका मतलब है कि एक ही टैग के बच्चों (इस मामले में, [अनऑर्डर्ड सूची](https://www.w3schools.com/tags/tag_ul.asp)), को अलग-अलग `key` विशेषताओं की आवश्यकता होती है।
+
+```tsx
+
+
+ }
+
+
+}
+```
+
+विभिन्न HTML टैग समाप्त करें।
+
+##### अंतिम `export` {#the-final-export}
+
+```tsx
+export { Greeter }
+```
+
+`Greeter` घटक वह है जिसे हमें एप्लिकेशन के लिए निर्यात करने की आवश्यकता है।
+
+#### `src/wagmi.ts` {#wagmi-ts}
+
+अंत में, WAGMI से संबंधित विभिन्न परिभाषाएँ `src/wagmi.ts` में हैं। मैं यहां सब कुछ समझाने नहीं जा रहा हूं, क्योंकि इसका अधिकांश हिस्सा बॉयलरप्लेट है जिसे आपको बदलने की संभावना नहीं है।
+
+यहां का कोड [github पर](https://github.com/qbzzt/20230801-modern-ui/blob/main/src/wagmi.ts) जैसा बिल्कुल नहीं है क्योंकि बाद में लेख में हम एक और चेन ([Redstone Holesky](https://redstone.xyz/docs/network-info)) जोड़ते हैं।
+
+```ts
+import { getDefaultWallets } from '@rainbow-me/rainbowkit'
+import { configureChains, createConfig } from 'wagmi'
+import { holesky, sepolia } from 'wagmi/chains'
+```
+
+एप्लिकेशन द्वारा समर्थित ब्लॉकचेन आयात करें। आप समर्थित चेनों की सूची [viem github में](https://github.com/wagmi-dev/viem/tree/main/src/chains/definitions) देख सकते हैं।
+
+```ts
+import { publicProvider } from 'wagmi/providers/public'
+
+const walletConnectProjectId = 'c96e690bb92b6311e8e9b2a6a22df575'
+```
+
+[WalletConnect](https://walletconnect.com/) का उपयोग करने में सक्षम होने के लिए आपको अपने एप्लिकेशन के लिए एक प्रोजेक्ट ID की आवश्यकता है। आप इसे [cloud.walletconnect.com पर](https://cloud.walletconnect.com/sign-in) प्राप्त कर सकते हैं।
+
+```ts
+const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia ],
+ [
+ publicProvider(),
+ ],
+)
+
+const { connectors } = getDefaultWallets({
+ appName: 'My wagmi + RainbowKit App',
+ chains,
+ projectId: walletConnectProjectId,
+})
+
+export const config = createConfig({
+ autoConnect: true,
+ connectors,
+ publicClient,
+ webSocketPublicClient,
+})
+
+export { chains }
+```
+
+### एक और ब्लॉकचेन जोड़ना {#add-blockchain}
+
+इन दिनों बहुत सारे [L2 स्केलिंग समाधान](/layer-2/) हैं, और आप कुछ ऐसे का समर्थन करना चाह सकते हैं जिन्हें viem अभी तक समर्थन नहीं करता है। ऐसा करने के लिए, आप `src/wagmi.ts` को संशोधित करते हैं। ये निर्देश बताते हैं कि [Redstone Holesky](https://redstone.xyz/docs/network-info) कैसे जोड़ा जाए।
+
+1. viem से `defineChain` प्रकार आयात करें।
+
+ ```ts
+ import { defineChain } from 'viem'
+ ```
+
+2. नेटवर्क परिभाषा जोड़ें।
+
+ ```ts
+ const redstoneHolesky = defineChain({
+ id: 17_001,
+ name: 'Redstone Holesky',
+ network: 'redstone-holesky',
+ nativeCurrency: {
+ decimals: 18,
+ name: 'Ether',
+ symbol: 'ETH',
+ },
+ rpcUrls: {
+ default: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ public: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ },
+ blockExplorers: {
+ default: { name: 'Explorer', url: 'https://explorer.holesky.redstone.xyz' },
+ },
+ })
+ ```
+
+3. नई चेन को `configureChains` कॉल में जोड़ें।
+
+ ```ts
+ const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia, redstoneHolesky ],
+ [ publicProvider(), ],
+ )
+ ```
+
+4. सुनिश्चित करें कि एप्लिकेशन नए नेटवर्क पर आपके अनुबंधों के लिए पता जानता है। इस मामले में, हम `src/components/Greeter.tsx` को संशोधित करते हैं:
+
+ ```ts
+ const contractAddrs : AddressPerBlockchainType = {
+ // Holesky
+ 17000: '0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8',
+
+ // Redstone Holesky
+ 17001: '0x4919517f82a1B89a32392E1BF72ec827ba9986D3',
+
+ // Sepolia
+ 11155111: '0x7143d5c190F048C8d19fe325b748b081903E3BF0'
+ }
+ ```
+
+## निष्कर्ष {#conclusion}
+
+बेशक, आप वास्तव में `Greeter` के लिए एक यूज़र इंटरफ़ेस प्रदान करने की परवाह नहीं करते हैं। आप अपने स्वयं के अनुबंधों के लिए एक यूज़र इंटरफ़ेस बनाना चाहते हैं। अपना स्वयं का एप्लिकेशन बनाने के लिए, इन चरणों को चलाएँ:
+
+1. एक wagmi एप्लिकेशन बनाने के लिए निर्दिष्ट करें।
+
+ ```sh copy
+ pnpm create wagmi
+ ```
+
+2. एप्लिकेशन को नाम दें।
+
+3. **React** फ्रेमवर्क चुनें।
+
+4. **Vite** वैरिएंट चुनें।
+
+5. आप [Rainbow kit](https://www.rainbowkit.com/docs/installation#manual-setup) जोड़ सकते हैं।
+
+अब जाएँ और अपने अनुबंधों को व्यापक दुनिया के लिए प्रयोग करने योग्य बनाएँ।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
+
diff --git a/public/content/translations/hi/developers/tutorials/deploying-your-first-smart-contract/index.md b/public/content/translations/hi/developers/tutorials/deploying-your-first-smart-contract/index.md
new file mode 100644
index 00000000000..b4ebe5d8e16
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/deploying-your-first-smart-contract/index.md
@@ -0,0 +1,101 @@
+---
+title: "अपना पहला स्मार्ट अनुबंध डिप्लॉय करना"
+description: "एथेरियम टेस्ट नेटवर्क पर अपना पहला स्मार्ट अनुबंध डिप्लॉय करने का एक परिचय"
+author: "jdourlens"
+tags:
+ [
+ "स्मार्ट अनुबंध",
+ "remix",
+ "सोलिडीटी",
+ "परिनियोजित करना"
+ ]
+skill: beginner
+lang: hi
+published: 2020-04-03
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/deploying-your-first-smart-contract/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+मुझे लगता है कि आप भी हमारी तरह एथेरियम ब्लॉकचेन पर अपने पहले [स्मार्ट अनुबंध](/developers/docs/smart-contracts/) को [डिप्लॉय](/developers/docs/smart-contracts/deploying/) करने और उसके साथ इंटरैक्ट करने के लिए उत्साहित हैं।
+
+चिंता न करें, क्योंकि यह हमारा पहला स्मार्ट अनुबंध है, हम इसे [स्थानीय टेस्ट नेटवर्क](/developers/docs/networks/) पर डिप्लॉय करेंगे, ताकि इसे डिप्लॉय करने और इसके साथ जितना चाहें खेलने में आपका कोई खर्च न हो।
+
+## अपना अनुबंध लिखना {#writing-our-contract}
+
+पहला कदम [Remix पर जाना](https://remix.ethereum.org/) और एक नई फ़ाइल बनाना है। Remix इंटरफ़ेस के ऊपरी बाएँ भाग में एक नई फ़ाइल जोड़ें और अपनी इच्छित फ़ाइल का नाम दर्ज करें।
+
+
+
+नई फ़ाइल में, हम निम्नलिखित कोड पेस्ट करेंगे।
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.17;
+
+contract Counter {
+
+ // गणनाओं की संख्या रखने के लिए अहस्ताक्षरित int प्रकार का सार्वजनिक चर
+ uint256 public count = 0;
+
+ // वह फ़ंक्शन जो हमारे काउंटर को बढ़ाता है
+ function increment() public {
+ count += 1;
+ }
+
+ // गणना मान प्राप्त करने के लिए गैर-आवश्यक गेटर
+ function getCount() public view returns (uint256) {
+ return count;
+ }
+
+}
+```
+
+यदि आप प्रोग्रामिंग के आदी हैं तो आप आसानी से अनुमान लगा सकते हैं कि यह प्रोग्राम क्या करता है। यहाँ पंक्ति-दर-पंक्ति एक व्याख्या दी गई है:
+
+- पंक्ति 4: हम `Counter` नाम से एक अनुबंध को परिभाषित करते हैं।
+- पंक्ति 7: हमारा अनुबंध `count` नामक एक अहस्ताक्षरित पूर्णांक संग्रहीत करता है जो 0 से शुरू होता है।
+- पंक्ति 10: पहला फ़ंक्शन अनुबंध की स्थिति को संशोधित करेगा और हमारे `count` चर को `increment()` करेगा।
+- पंक्ति 15: दूसरा फ़ंक्शन स्मार्ट अनुबंध के बाहर `count` चर के मान को पढ़ने में सक्षम होने के लिए सिर्फ एक गेटर है। ध्यान दें कि, जैसा कि हमने अपने `count` चर को सार्वजनिक के रूप में परिभाषित किया है, यह आवश्यक नहीं है लेकिन इसे एक उदाहरण के रूप में दिखाया गया है।
+
+हमारे पहले सरल स्मार्ट अनुबंध के लिए बस इतना ही। जैसा कि आप जानते होंगे, यह Java या C++ जैसी OOP (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) भाषाओं के एक वर्ग जैसा दिखता है। अब हमारे अनुबंध के साथ खेलने का समय है।
+
+## हमारे अनुबंध को डिप्लॉय करना {#deploying-our-contract}
+
+जैसा कि हमने अपना पहला स्मार्ट अनुबंध लिखा है, अब हम इसे ब्लॉकचेन पर डिप्लॉय करेंगे ताकि इसके साथ खेल सकें।
+
+[ब्लॉकचेन पर स्मार्ट अनुबंध को डिप्लॉय करना](/developers/docs/smart-contracts/deploying/) वास्तव में केवल एक लेनदेन भेजना है जिसमें संकलित स्मार्ट अनुबंध का कोड होता है, बिना किसी प्राप्तकर्ता को निर्दिष्ट किए।
+
+हम पहले बाईं ओर संकलन आइकन पर क्लिक करके [अनुबंध का संकलन](/developers/docs/smart-contracts/compiling/) करेंगे:
+
+
+
+फिर संकलन बटन पर क्लिक करें:
+
+
+
+आप "ऑटो कंपाइल" विकल्प चुन सकते हैं ताकि जब आप टेक्स्ट एडिटर पर सामग्री सहेजते हैं तो अनुबंध हमेशा संकलित हो जाएगा।
+
+फिर "डिप्लॉय और रन ट्रांजैक्शन" स्क्रीन पर नेविगेट करें:
+
+
+
+एक बार जब आप "डिप्लॉय और रन ट्रांजैक्शन" स्क्रीन पर हों, तो दोबारा जांचें कि आपका अनुबंध का नाम दिखाई देता है और डिप्लॉय पर क्लिक करें। जैसा कि आप पृष्ठ के शीर्ष पर देख सकते हैं, वर्तमान परिवेश "जावास्क्रिप्ट VM" है जिसका अर्थ है कि हम तेजी से और बिना किसी शुल्क के परीक्षण करने में सक्षम होने के लिए एक स्थानीय परीक्षण ब्लॉकचेन पर अपने स्मार्ट अनुबंध को डिप्लॉय और इंटरैक्ट करेंगे।
+
+
+
+एक बार जब आप "डिप्लॉय" बटन पर क्लिक कर लेंगे, तो आप देखेंगे कि आपका अनुबंध नीचे दिखाई दे रहा है। इसे विस्तृत करने के लिए बाईं ओर तीर पर क्लिक करें ताकि हम अपने अनुबंध की सामग्री देख सकें। यह हमारा चर `counter`, हमारा `increment()` फ़ंक्शन और गेटर `getCounter()` है।
+
+यदि आप `count` या `getCount` बटन पर क्लिक करते हैं, तो यह वास्तव में अनुबंध के `count` चर की सामग्री को पुनः प्राप्त करेगा और इसे प्रदर्शित करेगा। चूंकि हमने अभी तक `increment` फ़ंक्शन को कॉल नहीं किया है, इसलिए इसे 0 प्रदर्शित करना चाहिए।
+
+
+
+आइए अब बटन पर क्लिक करके `increment` फ़ंक्शन को कॉल करें। आप देखेंगे कि किए गए लेनदेन के लॉग विंडो के नीचे दिखाई दे रहे हैं। आप देखेंगे कि जब आप `increment` बटन के बजाय डेटा को पुनः प्राप्त करने के लिए बटन दबा रहे होते हैं तो लॉग अलग होते हैं। ऐसा इसलिए है क्योंकि ब्लॉकचेन पर डेटा पढ़ने के लिए किसी लेनदेन (लिखने) या शुल्क की आवश्यकता नहीं होती है। क्योंकि केवल ब्लॉकचेन की स्थिति को संशोधित करने के लिए एक लेनदेन करने की आवश्यकता होती है:
+
+
+
+इन्क्रिमेंट बटन दबाने के बाद जो हमारे `increment()` फ़ंक्शन को कॉल करने के लिए एक लेनदेन उत्पन्न करेगा, यदि हम काउंट या गेटकाउंट बटन पर वापस क्लिक करते हैं तो हम अपने स्मार्ट अनुबंध की नई अपडेट की गई स्थिति को पढ़ेंगे, जिसमें काउंट वेरिएबल 0 से बड़ा होगा।
+
+
+
+अगले ट्यूटोरियल में, हम कवर करेंगे [कि आप अपने स्मार्ट अनुबंधों में इवेंट्स कैसे जोड़ सकते हैं](/developers/tutorials/logging-events-smart-contracts/)। लॉगिंग इवेंट्स आपके स्मार्ट अनुबंध को डीबग करने और यह समझने का एक सुविधाजनक तरीका है कि फ़ंक्शन को कॉल करते समय क्या हो रहा है।
diff --git a/public/content/translations/hi/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md b/public/content/translations/hi/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
new file mode 100644
index 00000000000..7d6b0cb77c6
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
@@ -0,0 +1,372 @@
+---
+title: "स्थानीय, मल्टी-क्लाइंट टेस्टनेट पर डैप को कैसे विकसित और परीक्षण करें"
+description: "यह गाइड आपको डैप को डिप्लॉय और टेस्ट करने के लिए टेस्टनेट का उपयोग करने से पहले एक मल्टी-क्लाइंट स्थानीय एथेरियम टेस्टनेट को कैसे इंस्टेंटियेट और कॉन्फ़िगर करना है, इसके बारे में बताएगा।"
+author: "Tedi Mitiku"
+tags:
+ [
+ "क्लाइंट्स",
+ "नोड्स",
+ "स्मार्ट अनुबंध",
+ "कम्पोज़ेबिलिटी",
+ "सहमति परत",
+ "निष्पादन परत",
+ "परिक्षण"
+ ]
+skill: intermediate
+lang: hi
+published: 2023-04-11
+---
+
+## परिचय {#introduction}
+
+यह गाइड आपको एक कॉन्फ़िगर करने योग्य स्थानीय एथेरियम टेस्टनेट को इंस्टेंटियेट करने, उस पर एक स्मार्ट अनुबंध को डिप्लॉय करने और अपने डैप के खिलाफ टेस्ट चलाने के लिए टेस्टनेट का उपयोग करने की प्रक्रिया के बारे में बताएगा। यह गाइड उन dApp डेवलपर्स के लिए डिज़ाइन किया गया है जो लाइव टेस्टनेट या मेननेट पर डिप्लॉय करने से पहले विभिन्न नेटवर्क कॉन्फ़िगरेशन के विरुद्ध अपने डैप्स को स्थानीय रूप से विकसित और परीक्षण करना चाहते हैं।
+
+इस गाइड में, आप:
+
+- [Kurtosis](https://www.kurtosis.com/) का उपयोग करके [`eth-network-package`](https://github.com/kurtosis-tech/eth-network-package) के साथ एक स्थानीय एथेरियम टेस्टनेट को इंस्टेंटियेट करें,
+- एक डैप को कंपाइल करने, डिप्लॉय करने और टेस्ट करने के लिए अपने हार्डहैट डैप विकास परिवेश को स्थानीय टेस्टनेट से कनेक्ट करें, और
+- विभिन्न नेटवर्क कॉन्फ़िगरेशन के खिलाफ विकास और परीक्षण वर्कफ़्लो को सक्षम करने के लिए, नोड्स की संख्या और विशिष्ट EL/CL क्लाइंट पेयरिंग जैसे पैरामीटर सहित स्थानीय टेस्टनेट को कॉन्फ़िगर करें।
+
+### Kurtosis क्या है? {#what-is-kurtosis}
+
+[Kurtosis](https://www.kurtosis.com/) एक कंपोज़ेबल बिल्ड सिस्टम है जिसे मल्टी-कंटेनर परीक्षण वातावरण को कॉन्फ़िगर करने के लिए डिज़ाइन किया गया है। यह विशेष रूप से डेवलपर्स को पुनरुत्पादनीय वातावरण बनाने में सक्षम बनाता है जिसके लिए डायनामिक सेटअप लॉजिक की आवश्यकता होती है, जैसे कि ब्लॉकचेन टेस्टनेट।
+
+इस गाइड में, Kurtosis eth-network-package [`geth`](https://geth.ethereum.org/) निष्पादन परत (EL) क्लाइंट, साथ ही [`teku`](https://consensys.io/teku), [`lighthouse`](https://lighthouse.sigmaprime.io/), और [`lodestar`](https://lodestar.chainsafe.io/) सहमति परत (CL) क्लाइंट के समर्थन के साथ एक स्थानीय एथेरियम टेस्टनेट को स्पिन करता है। यह पैकेज हार्डहैट नेटवर्क, गनाश और एनविल जैसे फ्रेमवर्क में नेटवर्क के लिए एक कॉन्फ़िगर करने योग्य और कंपोज़ेबल विकल्प के रूप में कार्य करता है। Kurtosis डेवलपर्स को उनके द्वारा उपयोग किए जाने वाले टेस्टनेट पर अधिक नियंत्रण और लचीलापन प्रदान करता है, जो एक प्रमुख कारण है कि [Ethereum फाउंडेशन ने मर्ज का परीक्षण करने के लिए Kurtosis का उपयोग किया](https://www.kurtosis.com/blog/testing-the-ethereum-merge) और नेटवर्क अपग्रेड के परीक्षण के लिए इसका उपयोग करना जारी रखता है।
+
+## Kurtosis को सेट करना {#setting-up-kurtosis}
+
+आगे बढ़ने से पहले, सुनिश्चित करें कि आपके पास है:
+
+- अपनी स्थानीय मशीन पर [डॉकर इंजन को इंस्टॉल और शुरू किया](https://docs.kurtosis.com/install/#i-install--start-docker)
+- [Kurtosis CLI को इंस्टॉल किया](https://docs.kurtosis.com/install#ii-install-the-cli) (या यदि आपके पास पहले से ही CLI इंस्टॉल है तो इसे नवीनतम रिलीज़ में अपग्रेड किया गया)
+- [Node.js](https://nodejs.org/en), [yarn](https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable), और [npx](https://www.npmjs.com/package/npx) इंस्टॉल किया (आपके dApp परिवेश के लिए)
+
+## एक स्थानीय एथेरियम टेस्टनेट को इंस्टेंटियेट करना {#instantiate-testnet}
+
+एक स्थानीय एथेरियम टेस्टनेट को स्पिन अप करने के लिए, चलाएँ:
+
+```python
+kurtosis --enclave local-eth-testnet run github.com/kurtosis-tech/eth-network-package
+```
+
+नोट: यह कमांड आपके नेटवर्क का नाम: "local-eth-testnet” `--enclave` फ्लैग का उपयोग करके रखता है।
+
+Kurtosis उन कदमों को प्रिंट करेगा जो यह अंदर ही अंदर ले रहा है क्योंकि यह निर्देशों की व्याख्या, सत्यापन और फिर निष्पादन के लिए काम करता है। अंत में, आपको एक आउटपुट देखना चाहिए जो निम्नलिखित जैसा दिखता है:
+
+```python
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+INFO[2023-04-04T18:09:44-04:00] || Created enclave: local-eth-testnet ||
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+Name: local-eth-testnet
+UUID: 39372d756ae8
+Status: RUNNING
+Creation Time: Tue, 04 Apr 2023 18:09:03 EDT
+
+========================================= Files Artifacts =========================================
+UUID Name
+d4085a064230 cl-genesis-data
+1c62cb792e4c el-genesis-data
+bd60489b73a7 genesis-generation-config-cl
+b2e593fe5228 genesis-generation-config-el
+d552a54acf78 geth-prefunded-keys
+5f7e661eb838 prysm-password
+054e7338bb59 validator-keystore-0
+
+========================================== User Services ==========================================
+UUID Name Ports Status
+e20f129ee0c5 cl-client-0-beacon http: 4000/tcp -> RUNNING
+ metrics: 5054/tcp ->
+ tcp-discovery: 9000/tcp -> 127.0.0.1:54263
+ udp-discovery: 9000/udp -> 127.0.0.1:60470
+a8b6c926cdb4 cl-client-0-validator http: 5042/tcp -> 127.0.0.1:54267 RUNNING
+ metrics: 5064/tcp ->
+d7b802f623e8 el-client-0 engine-rpc: 8551/tcp -> 127.0.0.1:54253 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:54251
+ tcp-discovery: 30303/tcp -> 127.0.0.1:54254
+ udp-discovery: 30303/udp -> 127.0.0.1:53834
+ ws: 8546/tcp -> 127.0.0.1:54252
+514a829c0a84 prelaunch-data-generator-1680646157905431468 STOPPED
+62bd62d0aa7a prelaunch-data-generator-1680646157915424301 STOPPED
+05e9619e0e90 prelaunch-data-generator-1680646157922872635 STOPPED
+
+```
+
+बधाई हो! आपने डॉकर पर एक CL (`lighthouse`) और EL क्लाइंट (`geth`) के साथ एक स्थानीय एथेरियम टेस्टनेट को इंस्टेंटियेट करने के लिए Kurtosis का उपयोग किया।
+
+### समीक्षा {#review-instantiate-testnet}
+
+इस अनुभाग में, आपने एक कमांड निष्पादित किया जिसने Kurtosis को Kurtosis [Enclave](https://docs.kurtosis.com/advanced-concepts/enclaves/) के भीतर एक स्थानीय एथेरियम टेस्टनेट को स्पिन करने के लिए [`eth-network-package` जो कि GitHub पर रिमोटली होस्टेड है](https://github.com/kurtosis-tech/eth-network-package) का उपयोग करने का निर्देश दिया। अपने एन्क्लेव के अंदर, आपको "फ़ाइल कलाकृतियाँ" और "उपयोगकर्ता सेवाएँ" दोनों मिलेंगी।
+
+आपके एन्क्लेव में [फ़ाइल कलाकृतियाँ](https://docs.kurtosis.com/advanced-concepts/files-artifacts/) में EL और CL क्लाइंट को बूटस्ट्रैप करने के लिए उत्पन्न और उपयोग किए गए सभी डेटा शामिल हैं। डेटा इस [डॉकर छवि](https://github.com/ethpandaops/ethereum-genesis-generator) से निर्मित `prelaunch-data-generator` सेवा का उपयोग करके बनाया गया था
+
+यूज़र सेवाएँ आपके एन्क्लेव में संचालित होने वाली सभी कंटेनरीकृत सेवाओं को प्रदर्शित करती हैं। आप देखेंगे कि एक एकल नोड, जिसमें एक EL क्लाइंट और एक CL क्लाइंट दोनों हैं, बनाया गया है।
+
+## अपने डैप विकास परिवेश को स्थानीय एथेरियम टेस्टनेट से कनेक्ट करें {#connect-your-dapp}
+
+### डैप विकास परिवेश सेट करें {#set-up-dapp-env}
+
+अब जब आपके पास एक रनिंग स्थानीय टेस्टनेट है, तो आप अपने स्थानीय टेस्टनेट का उपयोग करने के लिए अपने डैप विकास परिवेश को कनेक्ट कर सकते हैं। इस गाइड में हार्डहैट फ्रेमवर्क का उपयोग आपके स्थानीय टेस्टनेट पर एक ब्लैकजैक डैप को डिप्लॉय करने के लिए किया जाएगा।
+
+अपने डैप विकास परिवेश को स्थापित करने के लिए, हमारे सैंपल डैप वाली रिपॉजिटरी को क्लोन करें और इसकी निर्भरताएँ स्थापित करें, चलाएँ:
+
+```python
+git clone https://github.com/kurtosis-tech/awesome-kurtosis.git && cd awesome-kurtosis/smart-contract-example && yarn
+```
+
+यहाँ उपयोग किया गया [smart-contract-example](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example) फ़ोल्डर [हार्डहैट](https://hardhat.org/) फ्रेमवर्क का उपयोग करके एक डैप डेवलपर के लिए विशिष्ट सेटअप है:
+
+- [`contracts/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/contracts) में एक ब्लैकजैक डैप के लिए कुछ सरल स्मार्ट अनुबंध हैं
+- [`scripts/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/scripts) में आपके स्थानीय एथेरियम नेटवर्क पर एक टोकन अनुबंध को डिप्लॉय करने के लिए एक स्क्रिप्ट है
+- [`test/`](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/smart-contract-example/test) में आपके टोकन अनुबंध के लिए एक सरल .js परीक्षण है यह पुष्टि करने के लिए कि हमारे ब्लैकजैक डैप में प्रत्येक खिलाड़ी के लिए 1000 मिंट किए गए हैं
+- [`hardhat.config.ts`](https://github.com/kurtosis-tech/awesome-kurtosis/blob/main/smart-contract-example/hardhat.config.ts) आपके हार्डहैट सेटअप को कॉन्फ़िगर करता है
+
+### स्थानीय टेस्टनेट का उपयोग करने के लिए हार्डहैट को कॉन्फ़िगर करें {#configure-hardhat}
+
+आपके डैप विकास परिवेश के सेट हो जाने पर, अब आप Kurtosis का उपयोग करके बनाए गए स्थानीय एथेरियम टेस्टनेट का उपयोग करने के लिए हार्डहैट को कनेक्ट करेंगे। इसे पूरा करने के लिए, अपनी `hardhat.config.ts` कॉन्फ़िग फ़ाइल में `localnet` स्ट्रक्ट में `<$YOUR_PORT>` को किसी भी `el-client-` सेवा से rpc uri आउटपुट के पोर्ट से बदलें। इस सैंपल मामले में, पोर्ट `64248` होगा। आपका पोर्ट अलग होगा।
+
+`hardhat.config.ts` में उदाहरण:
+
+```js
+localnet: {
+url: 'http://127.0.0.1:<$YOUR_PORT>',// TODO: ETH नेटवर्क Kurtosis पैकेज द्वारा उत्पादित एक नोड URI के पोर्ट के साथ $YOUR_PORT को बदलें
+
+// ये eth-network-package द्वारा बनाए गए प्रीफंडेड टेस्ट खातों से जुड़ी निजी कुंजी हैं
+//
+accounts: [
+ "ef5177cd0b6b21c87db5a0bf35d4084a8a57a9d6a064f86d51ac85f2b873a4e2",
+ "48fcc39ae27a0e8bf0274021ae6ebd8fe4a0e12623d61464c498900b28feb567",
+ "7988b3a148716ff800414935b305436493e1f25237a2a03e5eebc343735e2f31",
+ "b3c409b6b0b3aa5e65ab2dc1930534608239a478106acf6f3d9178e9f9b00b35",
+ "df9bb6de5d3dc59595bcaa676397d837ff49441d211878c024eabda2cd067c9f",
+ "7da08f856b5956d40a72968f93396f6acff17193f013e8053f6fbb6c08c194d6",
+ ],
+},
+```
+
+एक बार जब आप अपनी फ़ाइल सहेज लेते हैं, तो आपका हार्डहैट डैप विकास परिवेश अब आपके स्थानीय एथेरियम टेस्टनेट से जुड़ जाता है! आप यह सत्यापित कर सकते हैं कि आपका टेस्टनेट चलाकर काम कर रहा है:
+
+```python
+npx hardhat balances --network localnet
+```
+
+आउटपुट कुछ इस तरह दिखना चाहिए:
+
+```python
+0x878705ba3f8Bc32FCf7F4CAa1A35E72AF65CF766 has balance 10000000000000000000000000
+0x4E9A3d9D1cd2A2b2371b8b3F489aE72259886f1A has balance 10000000000000000000000000
+0xdF8466f277964Bb7a0FFD819403302C34DCD530A has balance 10000000000000000000000000
+0x5c613e39Fc0Ad91AfDA24587e6f52192d75FBA50 has balance 10000000000000000000000000
+0x375ae6107f8cC4cF34842B71C6F746a362Ad8EAc has balance 10000000000000000000000000
+0x1F6298457C5d76270325B724Da5d1953923a6B88 has balance 10000000000000000000000000
+```
+
+यह पुष्टि करता है कि हार्डहैट आपके स्थानीय टेस्टनेट का उपयोग कर रहा है और `eth-network-package` द्वारा बनाए गए पूर्व-वित्त पोषित खातों का पता लगाता है।
+
+### अपने डैप को स्थानीय रूप से डिप्लॉय और टेस्ट करें {#deploy-and-test-dapp}
+
+dApp विकास परिवेश के स्थानीय एथेरियम टेस्टनेट से पूरी तरह से कनेक्ट होने के साथ, अब आप स्थानीय टेस्टनेट का उपयोग करके अपने dApp के विरुद्ध विकास और परीक्षण वर्कफ़्लो चला सकते हैं।
+
+स्थानीय प्रोटोटाइपिंग और विकास के लिए `ChipToken.sol` स्मार्ट अनुबंध को कंपाइल और डिप्लॉय करने के लिए, चलाएँ:
+
+```python
+npx hardhat compile
+npx hardhat run scripts/deploy.ts --network localnet
+```
+
+आउटपुट कुछ इस तरह दिखना चाहिए:
+
+```python
+ChipToken को डिप्लॉय किया गया: 0xAb2A01BC351770D09611Ac80f1DE076D56E0487d
+```
+
+अब अपने स्थानीय डैप के खिलाफ `simple.js` परीक्षण चलाने का प्रयास करें ताकि यह पुष्टि हो सके कि हमारे ब्लैकजैक डैप में प्रत्येक खिलाड़ी के लिए 1000 मिंट किए गए हैं:
+
+आउटपुट कुछ इस तरह दिखना चाहिए:
+
+```python
+npx hardhat test --network localnet
+```
+
+आउटपुट कुछ इस तरह दिखना चाहिए:
+
+```python
+ChipToken
+ mint
+ ✔ PLAYER ONE के लिए 1000 चिप्स मिंट करने चाहिए
+
+ 1 पासिंग (654ms)
+```
+
+### समीक्षा {#review-dapp-workflows}
+
+इस बिंदु पर, आपने अब एक dApp विकास परिवेश स्थापित कर लिया है, इसे Kurtosis द्वारा बनाए गए एक स्थानीय एथेरियम नेटवर्क से जोड़ा है, और अपने dApp के विरुद्ध एक सरल परीक्षण को कंपाइल, डिप्लॉय और चलाया है।
+
+अब आइए देखें कि आप विभिन्न नेटवर्क कॉन्फ़िगरेशन के तहत हमारे डैप्स के परीक्षण के लिए अंतर्निहित नेटवर्क को कैसे कॉन्फ़िगर कर सकते हैं।
+
+## स्थानीय एथेरियम टेस्टनेट को कॉन्फ़िगर करना {#configure-testnet}
+
+### क्लाइंट कॉन्फ़िगरेशन और नोड्स की संख्या बदलना {#configure-client-config-and-num-nodes}
+
+आपके स्थानीय एथेरियम टेस्टनेट को विभिन्न EL और CL क्लाइंट पेयर, साथ ही नोड्स की एक अलग संख्या का उपयोग करने के लिए कॉन्फ़िगर किया जा सकता है, जो उस परिदृश्य और विशिष्ट नेटवर्क कॉन्फ़िगरेशन पर निर्भर करता है जिसे आप विकसित या परीक्षण करना चाहते हैं। इसका मतलब है कि, एक बार सेट हो जाने पर, आप एक अनुकूलित स्थानीय टेस्टनेट को स्पिन अप कर सकते हैं और इसका उपयोग समान वर्कफ़्लो (डिप्लॉयमेंट, परीक्षण, आदि) चलाने के लिए कर सकते हैं। यह सुनिश्चित करने के लिए कि सब कुछ अपेक्षा के अनुरूप काम करता है, विभिन्न नेटवर्क कॉन्फ़िगरेशन के तहत। जिन अन्य पैरामीटरों को आप संशोधित कर सकते हैं, उनके बारे में अधिक जानने के लिए, इस लिंक पर जाएँ।
+
+इसे आजमा कर देखें! आप एक JSON फ़ाइल के माध्यम से `eth-network-package` को विभिन्न कॉन्फ़िगरेशन विकल्प पास कर सकते हैं। यह नेटवर्क पैरामीटर्स JSON फ़ाइल विशिष्ट कॉन्फ़िगरेशन प्रदान करती है जिसका उपयोग Kurtosis स्थानीय एथेरियम नेटवर्क को सेट करने के लिए करेगा।
+
+डिफ़ॉल्ट कॉन्फ़िगरेशन फ़ाइल लें और इसे अलग-अलग EL/CL जोड़े के साथ तीन नोड्स को स्पिन करने के लिए संपादित करें:
+
+- नोड 1 `geth`/`lighthouse` के साथ
+- नोड 2 `geth`/`lodestar` के साथ
+- नोड 3 `geth`/`teku` के साथ
+
+यह कॉन्फ़िगरेशन आपके dApp के परीक्षण के लिए एथेरियम नोड कार्यान्वयन का एक विषम नेटवर्क बनाता है। आपकी कॉन्फ़िगरेशन फ़ाइल अब इस तरह दिखनी चाहिए:
+
+```yaml
+{
+ "participants":
+ [
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "lighthouse",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "lodestar",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ {
+ "el_client_type": "geth",
+ "el_client_image": "",
+ "el_client_log_level": "",
+ "cl_client_type": "teku",
+ "cl_client_image": "",
+ "cl_client_log_level": "",
+ "beacon_extra_params": [],
+ "el_extra_params": [],
+ "validator_extra_params": [],
+ "builder_network_params": null,
+ },
+ ],
+ "network_params":
+ {
+ "preregistered_validator_keys_mnemonic": "giant issue aisle success illegal bike spike question tent bar rely arctic volcano long crawl hungry vocal artwork sniff fantasy very lucky have athlete",
+ "num_validator_keys_per_node": 64,
+ "network_id": "3151908",
+ "deposit_contract_address": "0x4242424242424242424242424242424242424242",
+ "seconds_per_slot": 12,
+ "genesis_delay": 120,
+ "capella_fork_epoch": 5,
+ },
+}
+```
+
+प्रत्येक `participants` स्ट्रक्ट नेटवर्क में एक नोड से मैप करता है, इसलिए 3 `participants` स्ट्रक्ट Kurtosis को आपके नेटवर्क में 3 नोड्स स्पिन करने के लिए कहेंगे। प्रत्येक `participants` स्ट्रक्ट आपको उस विशिष्ट नोड के लिए उपयोग किए गए EL और CL जोड़ी को निर्दिष्ट करने की अनुमति देगा।
+
+`network_params` स्ट्रक्ट नेटवर्क सेटिंग्स को कॉन्फ़िगर करता है जिनका उपयोग प्रत्येक नोड के लिए जेनेसिस फ़ाइलें बनाने के लिए किया जाता है, साथ ही नेटवर्क के प्रति स्लॉट सेकंड जैसी अन्य सेटिंग्स भी।
+
+अपनी संपादित पैरामीटर्स फ़ाइल को अपनी इच्छानुसार किसी भी डायरेक्टरी में सहेजें (नीचे दिए गए उदाहरण में, इसे डेस्कटॉप पर सहेजा गया है) और फिर चलाकर अपना Kurtosis पैकेज चलाने के लिए इसका उपयोग करें:
+
+```python
+kurtosis clean -a && kurtosis run --enclave local-eth-testnet github.com/kurtosis-tech/eth-network-package "$(cat ~/eth-network-params.json)"
+```
+
+नोट: `kurtosis clean -a` कमांड का उपयोग यहाँ Kurtosis को नया शुरू करने से पहले पुराने टेस्टनेट और उसकी सामग्री को नष्ट करने का निर्देश देने के लिए किया जाता है।
+
+फिर से, Kurtosis थोड़ी देर के लिए काम करेगा और हो रहे अलग-अलग कदमों को प्रिंट करेगा। आखिरकार, आउटपुट कुछ इस तरह दिखना चाहिए:
+
+```python
+स्टारलार्क कोड सफलतापूर्वक चला। कोई आउटपुट नहीं लौटाया गया।
+INFO[2023-04-07T11:43:16-04:00] ==========================================================
+INFO[2023-04-07T11:43:16-04:00] || Created enclave: local-eth-testnet ||
+INFO[2023-04-07T11:43:16-04:00] ==========================================================
+Name: local-eth-testnet
+UUID: bef8c192008e
+Status: RUNNING
+Creation Time: Fri, 07 Apr 2023 11:41:58 EDT
+
+========================================= Files Artifacts =========================================
+UUID Name
+cc495a8e364a cl-genesis-data
+7033fcdb5471 el-genesis-data
+a3aef43fc738 genesis-generation-config-cl
+8e968005fc9d genesis-generation-config-el
+3182cca9d3cd geth-prefunded-keys
+8421166e234f prysm-password
+d9e6e8d44d99 validator-keystore-0
+23f5ba517394 validator-keystore-1
+4d28dea40b5c validator-keystore-2
+
+========================================== User Services ==========================================
+UUID Name Ports Status
+485e6fde55ae cl-client-0-beacon http: 4000/tcp -> http://127.0.0.1:65010 RUNNING
+ metrics: 5054/tcp -> http://127.0.0.1:65011
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65012
+ udp-discovery: 9000/udp -> 127.0.0.1:54455
+73739bd158b2 cl-client-0-validator http: 5042/tcp -> 127.0.0.1:65016 RUNNING
+ metrics: 5064/tcp -> http://127.0.0.1:65017
+1b0a233cd011 cl-client-1-beacon http: 4000/tcp -> 127.0.0.1:65021 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65023
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65024
+ udp-discovery: 9000/udp -> 127.0.0.1:56031
+ validator-metrics: 5064/tcp -> 127.0.0.1:65022
+949b8220cd53 cl-client-1-validator http: 4000/tcp -> 127.0.0.1:65028 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65030
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65031
+ udp-discovery: 9000/udp -> 127.0.0.1:60784
+ validator-metrics: 5064/tcp -> 127.0.0.1:65029
+c34417bea5fa cl-client-2 http: 4000/tcp -> 127.0.0.1:65037 RUNNING
+ metrics: 8008/tcp -> 127.0.0.1:65035
+ tcp-discovery: 9000/tcp -> 127.0.0.1:65036
+ udp-discovery: 9000/udp -> 127.0.0.1:63581
+e19738e6329d el-client-0 engine-rpc: 8551/tcp -> 127.0.0.1:64986 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:64988
+ tcp-discovery: 30303/tcp -> 127.0.0.1:64987
+ udp-discovery: 30303/udp -> 127.0.0.1:55706
+ ws: 8546/tcp -> 127.0.0.1:64989
+e904687449d9 el-client-1 engine-rpc: 8551/tcp -> 127.0.0.1:64993 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:64995
+ tcp-discovery: 30303/tcp -> 127.0.0.1:64994
+ udp-discovery: 30303/udp -> 127.0.0.1:58096
+ ws: 8546/tcp -> 127.0.0.1:64996
+ad6f401126fa el-client-2 engine-rpc: 8551/tcp -> 127.0.0.1:65003 RUNNING
+ rpc: 8545/tcp -> 127.0.0.1:65001
+ tcp-discovery: 30303/tcp -> 127.0.0.1:65000
+ udp-discovery: 30303/udp -> 127.0.0.1:57269
+ ws: 8546/tcp -> 127.0.0.1:65002
+12d04a9dbb69 prelaunch-data-generator-1680882122181135513 STOPPED
+5b45f9c0504b prelaunch-data-generator-1680882122192182847 STOPPED
+3d4aaa75e218 prelaunch-data-generator-1680882122201668972 STOPPED
+```
+
+बधाई हो! आपने अपने स्थानीय टेस्टनेट को 1 के बजाय 3 नोड्स रखने के लिए सफलतापूर्वक कॉन्फ़िगर किया है। अपने dApp (डिप्लॉय और टेस्ट) के खिलाफ पहले किए गए समान वर्कफ़्लो को चलाने के लिए, अपने `hardhat.config.ts` कॉन्फ़िग फ़ाइल में `localnet` स्ट्रक्ट में `<$YOUR_PORT>` को अपने नए, 3-नोड स्थानीय टेस्टनेट में किसी भी `el-client-` सेवा से rpc uri आउटपुट के पोर्ट से बदलकर हमारे द्वारा पहले किए गए समान संचालन करें।
+
+## निष्कर्ष {#conclusion}
+
+और बस इतना ही! इस संक्षिप्त गाइड को संक्षेप में बताने के लिए, आपने:
+
+- Kurtosis का उपयोग करके Docker पर एक स्थानीय एथेरियम टेस्टनेट बनाया
+- अपने स्थानीय dApp विकास परिवेश को स्थानीय एथेरियम नेटवर्क से जोड़ा
+- एक dApp को डिप्लॉय किया और स्थानीय एथेरियम नेटवर्क पर उसके खिलाफ एक सरल परीक्षण चलाया
+- अंतर्निहित एथेरियम नेटवर्क को 3 नोड्स के लिए कॉन्फ़िगर किया
+
+हम आपसे यह सुनना पसंद करेंगे कि आपके लिए क्या अच्छा रहा, क्या सुधार किया जा सकता है, या आपके किसी भी प्रश्न का उत्तर देने के लिए। [GitHub](https://github.com/kurtosis-tech/kurtosis/issues/new/choose) के माध्यम से या [हमें ईमेल करें](mailto:feedback@kurtosistech.com) के माध्यम से संपर्क करने में संकोच न करें!
+
+### अन्य उदाहरण और गाइड {#other-examples-guides}
+
+हम आपको हमारे [क्विकस्टार्ट](https://docs.kurtosis.com/quickstart) (जहां आप शीर्ष पर एक Postgres डेटाबेस और API बनाएंगे) और हमारे [awesome-kurtosis रिपॉजिटरी](https://github.com/kurtosis-tech/awesome-kurtosis) में हमारे अन्य उदाहरणों को देखने के लिए प्रोत्साहित करते हैं, जहां आपको कुछ बेहतरीन उदाहरण मिलेंगे, जिनमें इनके लिए पैकेज शामिल हैं:
+
+- उसी स्थानीय एथेरियम टेस्टनेट को स्पिन करना, लेकिन अतिरिक्त सेवाओं से जुड़ा हुआ है जैसे कि एक ट्रांज़ैक्शन स्पैमर (लेन-देन का अनुकरण करने के लिए), एक फोर्क मॉनिटर, और एक कनेक्टेड ग्राफाना और प्रोमेथियस इंस्टेंस
+- उसी स्थानीय एथेरियम नेटवर्क के खिलाफ [सब-नेटवर्किंग परीक्षण](https://github.com/kurtosis-tech/awesome-kurtosis/tree/main/ethereum-network-partition-test) करना
diff --git a/public/content/translations/hi/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md b/public/content/translations/hi/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
new file mode 100644
index 00000000000..774331bb9c8
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/index.md
@@ -0,0 +1,144 @@
+---
+title: "अनुबंध आकार सीमा से निपटने के लिए अनुबंधों का आकार छोटा करना"
+description: "आप अपने स्मार्ट अनुबंधों को बहुत बड़ा होने से रोकने के लिए क्या कर सकते हैं?"
+author: Markus Waas
+lang: hi
+tags: [ "सोलिडीटी", "स्मार्ट अनुबंध", "स्टोरेज" ]
+skill: intermediate
+published: 2020-06-26
+source: soliditydeveloper.com
+sourceUrl: https://soliditydeveloper.com/max-contract-size
+---
+
+## एक सीमा क्यों है? {#why-is-there-a-limit}
+
+[22 नवंबर, 2016](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/) को Spurious Dragon हार्ड-फोर्क ने [EIP-170](https://eips.ethereum.org/EIPS/eip-170) पेश किया जिसने 24.576 kb की स्मार्ट अनुबंध आकार सीमा जोड़ी। एक Solidity डेवलपर के रूप में आपके लिए इसका मतलब है कि जब आप अपने अनुबंध में अधिक से अधिक कार्यक्षमता जोड़ते हैं, तो किसी बिंदु पर आप सीमा तक पहुंच जाएंगे और डिप्लॉय करते समय आपको यह त्रुटि दिखाई देगी:
+
+`चेतावनी: अनुबंध कोड का आकार 24576 बाइट्स से अधिक है (Spurious Dragon में शुरू की गई एक सीमा)। यह अनुबंध मेननेट पर डिप्लॉय करने योग्य नहीं हो सकता है। ऑप्टिमाइज़र को सक्षम करने पर विचार करें (कम "रन" मान के साथ!), रिवर्ट स्ट्रिंग्स को बंद करें, या लाइब्रेरी का उपयोग करें।`
+
+यह सीमा डिनायल-ऑफ-सर्विस (DOS) हमलों को रोकने के लिए शुरू की गई थी। गैस के हिसाब से किसी अनुबंध पर कोई भी कॉल अपेक्षाकृत सस्ता है। हालांकि, Ethereum नोड्स के लिए एक अनुबंध कॉल का प्रभाव बुलाए गए अनुबंध कोड के आकार के आधार पर असंगत रूप से बढ़ जाता है (डिस्क से कोड पढ़ना, कोड को पूर्व-संसाधित करना, मर्कल प्रूफ में डेटा जोड़ना)। जब भी आपके पास ऐसी स्थिति होती है जहां हमलावर को दूसरों के लिए बहुत काम करने के लिए कुछ संसाधनों की आवश्यकता होती है, तो आपको DOS हमलों की संभावना मिलती है।
+
+मूल रूप से यह कम समस्या थी क्योंकि एक प्राकृतिक अनुबंध आकार सीमा ब्लॉक गैस सीमा है। जाहिर है, एक अनुबंध को एक लेनदेन के भीतर डिप्लॉय किया जाना चाहिए जिसमें अनुबंध का पूरा बाइटकोड होता है। यदि आप उस एक लेनदेन को एक ब्लॉक में शामिल करते हैं, तो आप उस सारी गैस का उपयोग कर सकते हैं, लेकिन यह अनंत नहीं है। [लंदन अपग्रेड](/ethereum-forks/#london) के बाद से, ब्लॉक गैस सीमा नेटवर्क मांग के आधार पर 15M और 30M यूनिट के बीच भिन्न हो सकी है।
+
+निम्नलिखित में हम उनके संभावित प्रभाव के अनुसार क्रमबद्ध कुछ तरीकों को देखेंगे। इसे वजन घटाने के संदर्भ में सोचें। किसी के लिए अपने लक्ष्य वजन (हमारे मामले में 24kb) तक पहुंचने के लिए सबसे अच्छी रणनीति पहले बड़े प्रभाव वाले तरीकों पर ध्यान केंद्रित करना है। ज्यादातर मामलों में सिर्फ अपने आहार को ठीक करने से आप वहां पहुंच जाएंगे, लेकिन कभी-कभी आपको थोड़ा और चाहिए होता है। फिर आप कुछ व्यायाम (मध्यम प्रभाव) या यहां तक कि पूरक (छोटा प्रभाव) भी जोड़ सकते हैं।
+
+## बड़ा प्रभाव {#big-impact}
+
+### अपने अनुबंधों को अलग करें {#separate-your-contracts}
+
+यह हमेशा आपका पहला तरीका होना चाहिए। आप अनुबंध को कई छोटे अनुबंधों में कैसे अलग कर सकते हैं? यह आम तौर पर आपको अपने अनुबंधों के लिए एक अच्छी वास्तुकला के साथ आने के लिए मजबूर करता है। कोड पठनीयता के दृष्टिकोण से छोटे अनुबंध हमेशा पसंद किए जाते हैं। अनुबंधों को विभाजित करने के लिए, अपने आप से पूछें:
+
+- कौन से फंक्शन एक साथ हैं? फंक्शन का प्रत्येक सेट अपने स्वयं के अनुबंध में सबसे अच्छा हो सकता है।
+- कौन से फंक्शन को अनुबंध की स्टेट पढ़ने या स्टेट के केवल एक विशिष्ट उपसमूह की आवश्यकता नहीं होती है?
+- क्या आप भंडारण और कार्यक्षमता को विभाजित कर सकते हैं?
+
+### लाइब्रेरी {#libraries}
+
+भंडारण से कार्यक्षमता कोड को दूर ले जाने का एक सरल तरीका [लाइब्रेरी](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#libraries) का उपयोग करना है। लाइब्रेरी फंक्शन को आंतरिक के रूप में घोषित न करें क्योंकि वे संकलन के दौरान सीधे [अनुबंध में जोड़े जाएंगे](https://ethereum.stackexchange.com/questions/12975/are-internal-functions-in-libraries-not-covered-by-linking)। लेकिन यदि आप सार्वजनिक फंक्शन का उपयोग करते हैं, तो वे वास्तव में एक अलग लाइब्रेरी अनुबंध में होंगे। लाइब्रेरी के उपयोग को और अधिक सुविधाजनक बनाने के लिए [using for](https://solidity.readthedocs.io/en/v0.6.10/contracts.html#using-for) पर विचार करें।
+
+### प्रॉक्सी {#proxies}
+
+एक अधिक उन्नत रणनीति एक प्रॉक्सी प्रणाली होगी। लाइब्रेरी बैक में `DELEGATECALL` का उपयोग करती हैं जो केवल कॉलिंग अनुबंध की स्टेट के साथ दूसरे अनुबंध के फंक्शन को निष्पादित करता है। प्रॉक्सी सिस्टम के बारे में अधिक जानने के लिए [यह ब्लॉग पोस्ट](https://hackernoon.com/how-to-make-smart-contracts-upgradable-2612e771d5a2) देखें। वे आपको अधिक कार्यक्षमता देते हैं, उदाहरण के लिए, वे अपग्रेडेबिलिटी को सक्षम करते हैं, लेकिन वे बहुत अधिक जटिलता भी जोड़ते हैं। मैं केवल अनुबंध के आकार को कम करने के लिए उन्हें नहीं जोड़ूंगा जब तक कि किसी भी कारण से यह आपका एकमात्र विकल्प न हो।
+
+## मध्यम प्रभाव {#medium-impact}
+
+### फंक्शन हटाएं {#remove-functions}
+
+यह स्पष्ट होना चाहिए। फंक्शन एक अनुबंध के आकार को काफी बढ़ा देते हैं।
+
+- **बाहरी**: अक्सर हम सुविधा के कारणों से बहुत सारे व्यू फंक्शन जोड़ते हैं। यह तब तक पूरी तरह से ठीक है जब तक आप आकार की सीमा तक नहीं पहुंच जाते। तब आप बिल्कुल ज़रूरी फंक्शन के अलावा बाकी सभी को हटाने के बारे में सोचना चाहेंगे।
+- **आंतरिक**: आप आंतरिक/निजी फंक्शन भी हटा सकते हैं और जब तक फंक्शन को केवल एक बार कॉल किया जाता है, तब तक कोड को इनलाइन कर सकते हैं।
+
+### अतिरिक्त वेरिएबल से बचें {#avoid-additional-variables}
+
+```solidity
+function get(uint id) returns (address,address) {
+ MyStruct memory myStruct = myStructs[id];
+ return (myStruct.addr1, myStruct.addr2);
+}
+```
+
+```solidity
+function get(uint id) returns (address,address) {
+ return (myStructs[id].addr1, myStructs[id].addr2);
+}
+```
+
+इस तरह के एक साधारण बदलाव से **0.28kb** का अंतर आता है। संभावना है कि आप अपने अनुबंधों में कई समान स्थितियां पा सकते हैं और वे वास्तव में महत्वपूर्ण मात्रा में जुड़ सकती हैं।
+
+### त्रुटि संदेश छोटा करें {#shorten-error-message}
+
+लंबे रिवर्ट संदेश और विशेष रूप से कई अलग-अलग रिवर्ट संदेश अनुबंध को फुला सकते हैं। इसके बजाय छोटे त्रुटि कोड का उपयोग करें और उन्हें अपने अनुबंध में डीकोड करें। एक लंबा संदेश बहुत छोटा हो सकता है:
+
+```solidity
+require(msg.sender == owner, "Only the owner of this contract can call this function");
+```
+
+```solidity
+require(msg.sender == owner, "OW1");
+```
+
+### त्रुटि संदेशों के बजाय कस्टम त्रुटियों का उपयोग करें
+
+[Solidity 0.8.4](https://blog.soliditylang.org/2021/04/21/custom-errors/) में कस्टम त्रुटियों को पेश किया गया है। वे आपके अनुबंधों के आकार को कम करने का एक शानदार तरीका हैं, क्योंकि वे ABI-एन्कोडेड चयनकर्ताओं के रूप में होते हैं (जैसे फंक्शन होते हैं)।
+
+```solidity
+error Unauthorized();
+
+if (msg.sender != owner) {
+ revert Unauthorized();
+}
+```
+
+### ऑप्टिमाइज़र में कम रन मान पर विचार करें {#consider-a-low-run-value-in-the-optimizer}
+
+आप ऑप्टिमाइज़र सेटिंग्स भी बदल सकते हैं। 200 का डिफ़ॉल्ट मान का मतलब है कि यह बाइटकोड को अनुकूलित करने की कोशिश कर रहा है जैसे कि एक फ़ंक्शन को 200 बार कॉल किया जाता है। यदि आप इसे 1 में बदलते हैं, तो आप मूल रूप से ऑप्टिमाइज़र को प्रत्येक फ़ंक्शन को केवल एक बार चलाने के मामले के लिए अनुकूलित करने के लिए कहते हैं। केवल एक बार चलने के लिए एक अनुकूलित फ़ंक्शन का मतलब है कि यह स्वयं डिप्लॉयमेंट के लिए अनुकूलित है। ध्यान रखें कि **यह फंक्शन चलाने के लिए [गैस लागत](/developers/docs/gas/) को बढ़ाता है**, इसलिए आप ऐसा नहीं करना चाह सकते हैं।
+
+## छोटा प्रभाव {#small-impact}
+
+### फंक्शन को स्ट्रक्चर पास करने से बचें {#avoid-passing-structs-to-functions}
+
+यदि आप [ABIEncoderV2](https://solidity.readthedocs.io/en/v0.6.10/layout-of-source-files.html#abiencoderv2) का उपयोग कर रहे हैं, तो यह किसी फ़ंक्शन में स्ट्रक्चर पास न करने में मदद कर सकता है। पैरामीटर को स्ट्रक्चर के रूप में पास करने के बजाय, आवश्यक पैरामीटर सीधे पास करें। इस उदाहरण में हमने एक और **0.1kb** बचाया।
+
+```solidity
+function get(uint id) returns (address,address) {
+ return _get(myStruct);
+}
+
+function _get(MyStruct memory myStruct) private view returns(address,address) {
+ return (myStruct.addr1, myStruct.addr2);
+}
+```
+
+```solidity
+function get(uint id) returns(address,address) {
+ return _get(myStructs[id].addr1, myStructs[id].addr2);
+}
+
+function _get(address addr1, address addr2) private view returns(address,address) {
+ return (addr1, addr2);
+}
+```
+
+### फंक्शन और वेरिएबल के लिए सही विज़िबिलिटी घोषित करें {#declare-correct-visibility-for-functions-and-variables}
+
+- फंक्शन या वेरिएबल जो केवल बाहर से कॉल किए जाते हैं? उन्हें `public` के बजाय `external` के रूप में घोषित करें।
+- फंक्शन या वेरिएबल केवल अनुबंध के भीतर से कॉल किए जाते हैं? उन्हें `public` के बजाय `private` या `internal` के रूप में घोषित करें।
+
+### मॉडिफ़ायर निकालें {#remove-modifiers}
+
+मॉडिफ़ायर, विशेष रूप से जब गहन रूप से उपयोग किए जाते हैं, अनुबंध के आकार पर महत्वपूर्ण प्रभाव डाल सकते हैं। उन्हें हटाने और इसके बजाय फंक्शन का उपयोग करने पर विचार करें।
+
+```solidity
+modifier checkStuff() {}
+
+function doSomething() checkStuff {}
+```
+
+```solidity
+function checkStuff() private {}
+
+function doSomething() { checkStuff(); }
+```
+
+ये टिप्स आपको अनुबंध के आकार को काफी कम करने में मदद करेंगे। एक बार फिर, मैं इस पर पर्याप्त जोर नहीं दे सकता, सबसे बड़े प्रभाव के लिए यदि संभव हो तो हमेशा अनुबंधों को विभाजित करने पर ध्यान केंद्रित करें।
diff --git a/public/content/translations/hi/developers/tutorials/eip-1271-smart-contract-signatures/index.md b/public/content/translations/hi/developers/tutorials/eip-1271-smart-contract-signatures/index.md
new file mode 100644
index 00000000000..be82f5c7309
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/eip-1271-smart-contract-signatures/index.md
@@ -0,0 +1,123 @@
+---
+title: "EIP-1271: स्मार्ट अनुबंध हस्ताक्षरों पर हस्ताक्षर करना और उन्हें सत्यापित करना"
+description: "EIP-1271 के साथ स्मार्ट अनुबंध हस्ताक्षर बनाने और सत्यापन का एक अवलोकन। हम सेफ (पहले Gnosis Safe) में उपयोग किए गए EIP-1271 कार्यान्वयन के माध्यम से भी चलते हैं, ताकि स्मार्ट अनुबंध डिवेलपरों के लिए एक ठोस उदाहरण प्रदान किया जा सके जिस पर वे निर्माण कर सकें।"
+author: "नाथन एच. लेउंग"
+lang: hi
+tags: [ "eip-1271", "स्मार्ट अनुबंध", "सत्यापन", "हस्ताक्षर" ]
+skill: intermediate
+published: 2023-01-12
+---
+
+[EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) मानक स्मार्ट अनुबंधों को हस्ताक्षरों को सत्यापित करने की अनुमति देता है।
+
+इस ट्यूटोरियल में, हम डिजिटल हस्ताक्षर, EIP-1271 की पृष्ठभूमि और [Safe](https://safe.global/) (पहले Gnosis Safe) द्वारा उपयोग किए गए EIP-1271 के विशिष्ट कार्यान्वयन का अवलोकन देते हैं। कुल मिलाकर, यह आपके अपने अनुबंधों में EIP-1271 को लागू करने के लिए एक शुरुआती बिंदु के रूप में काम कर सकता है।
+
+## हस्ताक्षर क्या है?
+
+इस संदर्भ में, एक हस्ताक्षर (अधिक सटीक रूप से, एक "डिजिटल हस्ताक्षर") एक संदेश है और साथ ही एक प्रकार का सबूत है कि संदेश एक विशिष्ट व्यक्ति/प्रेषक/पते से आया है।
+
+उदाहरण के लिए, एक डिजिटल हस्ताक्षर इस तरह दिख सकता है:
+
+1. संदेश: “मैं अपनी एथेरियम वॉलेट से इस वेबसाइट में लॉग इन करना चाहता हूं।”
+2. हस्ताक्षरकर्ता: मेरा पता `0x000…` है
+3. सबूत: यहां कुछ सबूत है कि मैंने, `0x000…`, वास्तव में यह पूरा संदेश बनाया है (यह आमतौर पर कुछ क्रिप्टोग्राफिक होता है)।
+
+यह ध्यान रखना महत्वपूर्ण है कि एक डिजिटल हस्ताक्षर में "संदेश" और "हस्ताक्षर" दोनों शामिल हैं।
+
+क्यों? उदाहरण के लिए, यदि आपने मुझे हस्ताक्षर करने के लिए एक अनुबंध दिया, और फिर मैंने हस्ताक्षर पृष्ठ को काट दिया और आपको अनुबंध के बाकी हिस्सों के बिना केवल मेरे हस्ताक्षर वापस दे दिए, तो अनुबंध मान्य नहीं होगा।
+
+उसी तरह, एक डिजिटल हस्ताक्षर का एक संबंधित संदेश के बिना कोई मतलब नहीं है!
+
+## EIP-1271 क्यों मौजूद है?
+
+एथेरियम-आधारित ब्लॉकचेन पर उपयोग के लिए एक डिजिटल हस्ताक्षर बनाने के लिए, आपको आम तौर पर एक गुप्त निजी चाबी की आवश्यकता होती है जिसे कोई और नहीं जानता है। यही वह है जो आपके हस्ताक्षर को आपका बनाता है (गुप्त चाबी के ज्ञान के बिना कोई भी समान हस्ताक्षर नहीं बना सकता है)।
+
+आपके एथेरियम खाते (यानी, आपके बाहरी स्वामित्व वाले खाते/EOA) के साथ एक निजी चाबी जुड़ी हुई है, और यह वह निजी चाबी है जिसका आमतौर पर उपयोग तब किया जाता है जब कोई वेबसाइट या डैप आपसे हस्ताक्षर मांगता है (उदाहरण के लिए, "एथेरियम से लॉग इन करें" के लिए)।
+
+एक ऐप आपके द्वारा ethers.js जैसी किसी थर्ड-पार्टी लाइब्रेरी का उपयोग करके बनाए गए [हस्ताक्षर को सत्यापित कर सकता है](https://www.alchemy.com/docs/how-to-verify-a-message-signature-on-ethereum) [आपकी निजी चाबी को जाने बिना](https://en.wikipedia.org/wiki/Public-key_cryptography) और विश्वास कर सकता है कि हस्ताक्षर _आपने_ ही बनाया था।
+
+> वास्तव में, क्योंकि EOA डिजिटल हस्ताक्षर सार्वजनिक-चाबी क्रिप्टोग्राफ़ी का उपयोग करते हैं, उन्हें **ऑफ-चेन** उत्पन्न और सत्यापित किया जा सकता है! गैसलेस DAO वोटिंग इसी तरह काम करती है — ऑन-चेन वोट जमा करने के बजाय, क्रिप्टोग्राफिक लाइब्रेरी का उपयोग करके डिजिटल हस्ताक्षर ऑफ-चेन बनाए और सत्यापित किए जा सकते हैं।
+
+जबकि EOA खातों में एक निजी चाबी होती है, स्मार्ट अनुबंध खातों में किसी भी प्रकार की निजी या गुप्त चाबी नहीं होती है (इसलिए "एथेरियम से लॉग इन करें", आदि मूल रूप से स्मार्ट अनुबंध खातों के साथ काम नहीं कर सकते हैं)।
+
+समस्या जिसे EIP-1271 हल करना चाहता है: हम कैसे बता सकते हैं कि एक स्मार्ट अनुबंध हस्ताक्षर मान्य है यदि स्मार्ट अनुबंध में कोई "रहस्य" नहीं है जिसे वह हस्ताक्षर में शामिल कर सकता है?
+
+## EIP-1271 कैसे काम करता है?
+
+स्मार्ट अनुबंधों में निजी चाबियाँ नहीं होती हैं जिनका उपयोग संदेशों पर हस्ताक्षर करने के लिए किया जा सकता है। तो हम कैसे बता सकते हैं कि कोई हस्ताक्षर प्रामाणिक है?
+
+खैर, एक विचार यह है कि हम स्मार्ट अनुबंध से _पूछ_ सकते हैं कि क्या कोई हस्ताक्षर प्रामाणिक है!
+
+EIP-1271 जो करता है वह इस विचार को मानकीकृत करता है कि किसी दिए गए हस्ताक्षर के मान्य होने पर एक स्मार्ट अनुबंध से "पूछना"।
+
+EIP-1271 को लागू करने वाले एक अनुबंध में `isValidSignature` नामक एक फ़ंक्शन होना चाहिए जो एक संदेश और एक हस्ताक्षर लेता है। अनुबंध तब कुछ सत्यापन तर्क चला सकता है (विनिर्देश यहां कुछ भी विशिष्ट लागू नहीं करता है) और फिर एक मान लौटाता है जो इंगित करता है कि हस्ताक्षर मान्य है या नहीं।
+
+यदि `isValidSignature` एक मान्य परिणाम लौटाता है, तो यह लगभग अनुबंध कह रहा है "हाँ, मैं इस हस्ताक्षर + संदेश को मंजूरी देता हूँ!"
+
+### इंटरफ़ेस
+
+यहाँ EIP-1271 विनिर्देश में सटीक इंटरफ़ेस है (हम नीचे `_hash` पैरामीटर के बारे में बात करेंगे, लेकिन अभी के लिए, इसे सत्यापित किए जा रहे संदेश के रूप में सोचें):
+
+```jsx
+pragma solidity ^0.5.0;
+
+contract ERC1271 {
+
+ // bytes4(keccak256("isValidSignature(bytes32,bytes)")
+ bytes4 constant internal MAGICVALUE = 0x1626ba7e;
+
+ /**
+ * @dev प्रदान किए गए हस्ताक्षर प्रदान किए गए हैश के लिए मान्य है या नहीं, यह वापस करना चाहिए
+ * @param _hash हस्ताक्षर किए जाने वाले डेटा का हैश
+ * @param _signature _hash से संबद्ध हस्ताक्षर बाइट ऐरे
+ *
+ * फ़ंक्शन पास होने पर बाइट्स4 मैजिक मान 0x1626ba7e वापस करना होगा।
+ * स्टेट को संशोधित नहीं करना चाहिए (solc < 0.5 के लिए STATICCALL का उपयोग करना, solc > 0.5 के लिए व्यू मॉडिफ़ायर)
+ * बाहरी कॉलों की अनुमति देनी चाहिए
+ */
+ function isValidSignature(
+ bytes32 _hash,
+ bytes memory _signature)
+ public
+ view
+ returns (bytes4 magicValue);
+}
+```
+
+## उदाहरण EIP-1271 कार्यान्वयन: सेफ़
+
+अनुबंध `isValidSignature` को कई तरीकों से लागू कर सकते हैं - विनिर्देश केवल सटीक कार्यान्वयन के बारे में बहुत कुछ नहीं कहता है।
+
+एक उल्लेखनीय अनुबंध जो EIP-1271 को लागू करता है, वह है Safe (पहले Gnosis Safe)।
+
+सेफ के कोड में, `isValidSignature` [लागू किया गया है](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol) ताकि हस्ताक्षरों को [दो तरीकों](https://ethereum.stackexchange.com/questions/122635/signing-messages-as-a-gnosis-safe-eip1271-support) से बनाया और सत्यापित किया जा सके:
+
+1. ऑन-चेन संदेश
+ 1. निर्माण: एक सेफ़ का मालिक एक संदेश पर "हस्ताक्षर" करने के लिए एक नया सेफ़ लेनदेन बनाता है, संदेश को लेनदेन में डेटा के रूप में पास करता है। एक बार जब पर्याप्त मालिक मल्टीसिग थ्रेसहोल्ड तक पहुंचने के लिए लेनदेन पर हस्ताक्षर कर देते हैं, तो लेनदेन प्रसारित और चलाया जाता है। लेनदेन में, एक सेफ़ फ़ंक्शन होता है जो संदेश को "अनुमोदित" संदेशों की सूची में जोड़ता है।
+ 2. सत्यापन: सेफ़ अनुबंध पर `isValidSignature` को कॉल करें, और सत्यापित करने के लिए संदेश को संदेश पैरामीटर के रूप में पास करें और [हस्ताक्षर पैरामीटर के लिए एक खाली मान](https://github.com/safe-global/safe-contracts/blob/main/contracts/handler/CompatibilityFallbackHandler.sol#L32) (यानी, `0x`)। सेफ़ देखेगा कि हस्ताक्षर पैरामीटर खाली है और हस्ताक्षर को क्रिप्टोग्राफ़िक रूप से सत्यापित करने के बजाय, यह बस आगे बढ़ेगा और जांच करेगा कि संदेश "अनुमोदित" संदेशों की सूची में है या नहीं।
+2. ऑफ-चेन संदेश:
+ 1. निर्माण: एक सेफ़ का मालिक ऑफ-चेन एक संदेश बनाता है, फिर अन्य सेफ़ मालिकों से प्रत्येक व्यक्तिगत रूप से संदेश पर हस्ताक्षर करवाता है जब तक कि मल्टीसिग अनुमोदन थ्रेसहोल्ड को पार करने के लिए पर्याप्त हस्ताक्षर न हो जाएं।
+ 2. सत्यापन: `isValidSignature` को कॉल करें। संदेश पैरामीटर में, सत्यापित किए जाने वाले संदेश को पास करें। हस्ताक्षर पैरामीटर में, प्रत्येक सेफ़ मालिक के अलग-अलग हस्ताक्षरों को एक साथ, एक के बाद एक जोड़कर पास करें। सेफ़ यह जांच करेगा कि थ्रेसहोल्ड को पूरा करने के लिए पर्याप्त हस्ताक्षर हैं **और** प्रत्येक हस्ताक्षर मान्य है। यदि ऐसा है, तो यह सफल हस्ताक्षर सत्यापन का संकेत देने वाला एक मान लौटाएगा।
+
+## `_hash` पैरामीटर वास्तव में क्या है? पूरा संदेश क्यों नहीं पास करें?
+
+आपने शायद देखा होगा कि [EIP-1271 इंटरफ़ेस](https://eips.ethereum.org/EIPS/eip-1271) में `isValidSignature` फ़ंक्शन संदेश को ही नहीं, बल्कि `_hash` पैरामीटर को लेता है। इसका मतलब यह है कि `isValidSignature` को पूर्ण मनमानी-लंबाई वाले संदेश को पास करने के बजाय, हम संदेश का 32-बाइट हैश (आमतौर पर keccak256) पास करते हैं।
+
+कॉलडेटा का प्रत्येक बाइट - यानी, स्मार्ट अनुबंध फ़ंक्शन को दिया गया फ़ंक्शन पैरामीटर डेटा - [16 गैस (4 गैस यदि शून्य बाइट)](https://eips.ethereum.org/EIPS/eip-2028) की लागत आती है, इसलिए यदि संदेश लंबा है तो इससे बहुत सारी गैस बच सकती है।
+
+### पिछले EIP-1271 विनिर्देश
+
+जंगल में EIP-1271 विनिर्देश हैं जिनमें `isValidSignature` फ़ंक्शन होता है जिसमें `bytes` प्रकार का पहला पैरामीटर (निश्चित-लंबाई `bytes32` के बजाय मनमानी-लंबाई) और पैरामीटर का नाम `message` होता है। यह EIP-1271 मानक का [पुराना संस्करण](https://github.com/safe-global/safe-contracts/issues/391#issuecomment-1075427206) है।
+
+## मेरे अपने अनुबंधों में EIP-1271 को कैसे लागू किया जाना चाहिए?
+
+यहां विनिर्देश बहुत खुला है। सेफ कार्यान्वयन में कुछ अच्छे विचार हैं:
+
+- आप अनुबंध के "मालिक" से EOA हस्ताक्षरों को मान्य मान सकते हैं।
+- आप स्वीकृत संदेशों की एक सूची संग्रहीत कर सकते हैं और केवल उन्हें ही मान्य मान सकते हैं।
+
+अंत में, यह अनुबंध डिवेलपर के रूप में आप पर निर्भर है!
+
+## निष्कर्ष
+
+[EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) एक बहुमुखी मानक है जो स्मार्ट अनुबंधों को हस्ताक्षरों को सत्यापित करने की अनुमति देता है। यह स्मार्ट अनुबंधों को EOA की तरह अधिक कार्य करने के लिए द्वार खोलता है - उदाहरण के लिए स्मार्ट अनुबंधों के साथ काम करने के लिए "एथेरियम से लॉग इन करें" के लिए एक तरीका प्रदान करना - और इसे कई तरीकों से लागू किया जा सकता है (सेफ में विचार करने के लिए एक गैर-तुच्छ, दिलचस्प कार्यान्वयन है)।
diff --git a/public/content/translations/hi/developers/tutorials/erc-721-vyper-annotated-code/index.md b/public/content/translations/hi/developers/tutorials/erc-721-vyper-annotated-code/index.md
new file mode 100644
index 00000000000..cdf6790e6b0
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/erc-721-vyper-annotated-code/index.md
@@ -0,0 +1,628 @@
+---
+title: "Vyper ERC-721 अनुबंध वॉकथ्रू"
+description: "रयुया नाकामुरा का ERC-721 अनुबंध और यह कैसे काम करता है"
+author: "ओरी पोमेरेन्ट्ज़"
+lang: hi
+tags: [ "vyper", "erc-721", "python" ]
+skill: beginner
+published: 2021-04-01
+---
+
+## परिचय {#introduction}
+
+[ERC-721](/developers/docs/standards/tokens/erc-721/) मानक का उपयोग नॉन-फंजिबल टोकन (NFT) के स्वामित्व को बनाए रखने के लिए किया जाता है।
+[ERC-20](/developers/docs/standards/tokens/erc-20/) टोकन एक वस्तु के रूप में व्यवहार करते हैं, क्योंकि अलग-अलग टोकन के बीच कोई अंतर नहीं होता है।
+इसके विपरीत, ERC-721 टोकन उन संपत्तियों के लिए डिज़ाइन किए गए हैं जो समान हैं लेकिन समान नहीं हैं, जैसे कि अलग-अलग बिल्ली
+कार्टून या अचल संपत्ति के अलग-अलग टुकड़ों के शीर्षक।
+
+इस लेख में हम [रयुया नाकामुरा के ERC-721 अनुबंध](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy) का विश्लेषण करेंगे।
+यह अनुबंध [Vyper](https://vyper.readthedocs.io/en/latest/index.html) में लिखा गया है, जो एक Python-जैसी अनुबंध भाषा है जिसे Solidity की तुलना में असुरक्षित कोड लिखना कठिन बनाने के लिए डिज़ाइन किया गया है।
+
+## अनुबंध {#contract}
+
+```python
+# @dev ERC-721 नॉन-फंजिबल टोकन मानक का कार्यान्वयन।
+# @author रयुया नाकामुरा (@nrryuya)
+# इससे संशोधित: https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
+```
+
+Vyper में टिप्पणियाँ, Python की तरह, हैश (`#`) से शुरू होती हैं और लाइन के अंत तक जारी रहती हैं। `@` वाली टिप्पणियों का उपयोग [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) द्वारा मानव-पठनीय दस्तावेज़ीकरण बनाने के लिए किया जाता है।
+
+```python
+from vyper.interfaces import ERC721
+
+implements: ERC721
+```
+
+ERC-721 इंटरफ़ेस Vyper भाषा में अंतर्निहित है।
+[आप कोड परिभाषा यहाँ देख सकते हैं](https://github.com/vyperlang/vyper/blob/master/vyper/builtin_interfaces/ERC721.py)।
+इंटरफ़ेस परिभाषा Python में लिखी गई है, न कि Vyper में, क्योंकि इंटरफ़ेस का उपयोग न केवल ब्लॉकचेन के भीतर किया जाता है, बल्कि एक बाहरी क्लाइंट से ब्लॉकचेन में एक लेनदेन भेजते समय भी किया जाता है, जो Python में लिखा जा सकता है।
+
+पहली लाइन इंटरफ़ेस को आयात करती है, और दूसरी यह निर्दिष्ट करती है कि हम इसे यहाँ लागू कर रहे हैं।
+
+### ERC721Receiver इंटरफ़ेस {#receiver-interface}
+
+```python
+# safeTransferFrom() द्वारा बुलाए गए अनुबंध के लिए इंटरफ़ेस
+interface ERC721Receiver:
+ def onERC721Received(
+```
+
+ERC-721 दो प्रकार के हस्तांतरण का समर्थन करता है:
+
+- `transferFrom`, जो प्रेषक को किसी भी गंतव्य पते को निर्दिष्ट करने देता है और हस्तांतरण की जिम्मेदारी प्रेषक पर डालता है। इसका मतलब है कि आप एक अमान्य पते पर स्थानांतरित कर सकते हैं, इस मामले में NFT हमेशा के लिए खो जाता है।
+- `safeTransferFrom`, जो जांचता है कि गंतव्य पता एक अनुबंध है या नहीं। यदि ऐसा है, तो ERC-721 अनुबंध प्राप्त करने वाले अनुबंध से पूछता है कि क्या वह NFT प्राप्त करना चाहता है।
+
+`safeTransferFrom` अनुरोधों का उत्तर देने के लिए एक प्राप्त करने वाले अनुबंध को `ERC721Receiver` लागू करना होगा।
+
+```python
+ _operator: address,
+ _from: address,
+```
+
+`_from` पता टोकन का वर्तमान स्वामी है। `_operator` पता वह है जिसने हस्तांतरण का अनुरोध किया था (भत्ते के कारण ये दोनों समान नहीं हो सकते हैं)।
+
+```python
+ _tokenId: uint256,
+```
+
+ERC-721 टोकन आईडी 256 बिट्स हैं। आमतौर पर वे टोकन का प्रतिनिधित्व करने वाली किसी भी चीज़ के विवरण को हैश करके बनाए जाते हैं।
+
+```python
+ _data: Bytes[1024]
+```
+
+अनुरोध में 1024 बाइट्स तक का उपयोगकर्ता डेटा हो सकता है।
+
+```python
+ ) -> bytes32: view
+```
+
+उन मामलों को रोकने के लिए जिनमें एक अनुबंध गलती से एक हस्तांतरण स्वीकार कर लेता है, वापसी मान एक बूलियन नहीं है, बल्कि एक विशिष्ट मान के साथ 256 बिट्स है।
+
+यह फ़ंक्शन एक `view` है, जिसका अर्थ है कि यह ब्लॉकचेन की स्थिति को पढ़ सकता है, लेकिन इसे संशोधित नहीं कर सकता है।
+
+### घटनाएँ {#events}
+
+[इवेंट्स](https://media.consensys.net/technical-introduction-to-events-and-logs-in-ethereum-a074d65dd61e) को ब्लॉकचेन के बाहर के उपयोगकर्ताओं और सर्वरों को इवेंट्स के बारे में सूचित करने के लिए उत्सर्जित किया जाता है। ध्यान दें कि इवेंट्स की सामग्री ब्लॉकचेन पर अनुबंधों के लिए उपलब्ध नहीं है।
+
+```python
+# @dev किसी भी तंत्र द्वारा किसी भी NFT का स्वामित्व बदलने पर उत्सर्जित होता है। यह इवेंट तब उत्सर्जित होता है जब NFTs बनाए जाते हैं (`from` == 0) और नष्ट हो जाते हैं (`to` == 0)। अपवाद: अनुबंध निर्माण के दौरान, बिना Transfer उत्सर्जित किए किसी भी संख्या में NFTs बनाए और असाइन किए जा सकते हैं। किसी भी हस्तांतरण के समय, उस NFT के लिए स्वीकृत पता (यदि कोई हो) रीसेट हो जाता है।
+# @param _from NFT का प्रेषक (यदि पता शून्य पता है तो यह टोकन निर्माण को इंगित करता है)।
+# @param _to NFT का रिसीवर (यदि पता शून्य पता है तो यह टोकन विनाश को इंगित करता है)।
+# @param _tokenId वह NFT जिसे स्थानांतरित किया गया था।
+event Transfer:
+ sender: indexed(address)
+ receiver: indexed(address)
+ tokenId: indexed(uint256)
+```
+
+यह ERC-20 Transfer इवेंट के समान है, सिवाय इसके कि हम राशि के बजाय `tokenId` की रिपोर्ट करते हैं।
+शून्य पते का कोई स्वामी नहीं है, इसलिए परंपरा के अनुसार हम इसका उपयोग टोकन के निर्माण और विनाश की रिपोर्ट करने के लिए करते हैं।
+
+```python
+# @dev यह तब उत्सर्जित होता है जब किसी NFT के लिए स्वीकृत पता बदल दिया जाता है या उसकी पुष्टि की जाती है। शून्य पता इंगित करता है कि कोई स्वीकृत पता नहीं है। जब एक Transfer इवेंट उत्सर्जित होता है, तो यह यह भी इंगित करता है कि उस NFT के लिए स्वीकृत पता (यदि कोई हो) रीसेट हो जाता है।
+# @param _owner NFT का स्वामी।
+# @param _approved पता जिसे हम स्वीकृत कर रहे हैं।
+# @param _tokenId NFT जिसे हम स्वीकृत कर रहे हैं।
+event Approval:
+ owner: indexed(address)
+ approved: indexed(address)
+ tokenId: indexed(uint256)
+```
+
+एक ERC-721 अनुमोदन एक ERC-20 भत्ते के समान है। एक विशिष्ट पते को एक विशिष्ट टोकन स्थानांतरित करने की अनुमति है। यह अनुबंधों को टोकन स्वीकार करने पर प्रतिक्रिया देने के लिए एक तंत्र देता है। अनुबंध इवेंट्स को नहीं सुन सकते हैं, इसलिए यदि आप केवल टोकन को उनके पास स्थानांतरित करते हैं तो वे इसके बारे में "नहीं जानते" हैं। इस तरह मालिक पहले एक अनुमोदन प्रस्तुत करता है और फिर अनुबंध को एक अनुरोध भेजता है: "मैंने आपको टोकन X को स्थानांतरित करने के लिए अनुमोदित किया है, कृपया करें ..."।
+
+यह ERC-721 मानक को ERC-20 मानक के समान बनाने के लिए एक डिज़ाइन विकल्प है। क्योंकि ERC-721 टोकन फंजिबल नहीं हैं, एक अनुबंध यह भी पहचान सकता है कि उसे टोकन के स्वामित्व को देखकर एक विशिष्ट टोकन मिला है।
+
+```python
+# @dev यह तब उत्सर्जित होता है जब किसी मालिक के लिए एक ऑपरेटर सक्षम या अक्षम होता है। ऑपरेटर मालिक के सभी NFTs का प्रबंधन कर सकता है।
+# @param _owner NFT का स्वामी।
+# @param _operator पता जिस पर हम ऑपरेटर अधिकार सेट कर रहे हैं।
+# @param _approved ऑपरेटर अधिकारों की स्थिति (सही यदि ऑपरेटर अधिकार दिए गए हैं और गलत यदि रद्द कर दिए गए हैं)।
+event ApprovalForAll:
+ owner: indexed(address)
+ operator: indexed(address)
+ approved: bool
+```
+
+कभी-कभी एक _ऑपरेटर_ होना उपयोगी होता है जो एक विशिष्ट प्रकार के खाते के सभी टोकन (वे जो एक विशिष्ट अनुबंध द्वारा प्रबंधित होते हैं) का प्रबंधन कर सकता है, जो एक पावर ऑफ अटॉर्नी के समान है। उदाहरण के लिए, मैं एक अनुबंध को ऐसी शक्ति देना चाह सकता हूं जो यह जांचता है कि मैंने छह महीने से इससे संपर्क नहीं किया है, और यदि ऐसा है तो मेरी संपत्ति को मेरे उत्तराधिकारियों में वितरित कर देता है (यदि उनमें से कोई इसके लिए पूछता है, तो अनुबंध बिना लेनदेन के बुलाए कुछ नहीं कर सकते)। ERC-20 में हम बस एक विरासत अनुबंध को एक उच्च भत्ता दे सकते हैं, लेकिन यह ERC-721 के लिए काम नहीं करता है क्योंकि टोकन फंजिबल नहीं हैं। यह समतुल्य है।
+
+`approved` मान हमें बताता है कि क्या इवेंट एक अनुमोदन के लिए है, या एक अनुमोदन की वापसी के लिए है।
+
+### स्टेट चर {#state-vars}
+
+इन चरों में टोकन की वर्तमान स्थिति होती है: कौन से उपलब्ध हैं और उनके मालिक कौन हैं। इनमें से अधिकांश `HashMap` ऑब्जेक्ट हैं, [दो प्रकारों के बीच मौजूद एकदिशीय मैपिंग](https://vyper.readthedocs.io/en/latest/types.html#mappings)।
+
+```python
+# @dev NFT आईडी से उस पते पर मैपिंग जो इसका मालिक है।
+idToOwner: HashMap[uint256, address]
+
+# @dev NFT आईडी से स्वीकृत पते पर मैपिंग।
+idToApprovals: HashMap[uint256, address]
+```
+
+Ethereum में उपयोगकर्ता और अनुबंध पहचान 160-बिट पतों द्वारा दर्शाई जाती हैं। ये दो चर टोकन आईडी से उनके मालिकों और उन्हें स्थानांतरित करने के लिए स्वीकृत लोगों (प्रत्येक के लिए अधिकतम एक) के लिए मैप करते हैं। Ethereum में, अनइनिशियलाइज़्ड डेटा हमेशा शून्य होता है, इसलिए यदि कोई मालिक या स्वीकृत ट्रांसफरर नहीं है तो उस टोकन का मान शून्य होता है।
+
+```python
+# @dev मालिक के पते से उसके टोकन की गिनती तक मैपिंग।
+ownerToNFTokenCount: HashMap[address, uint256]
+```
+
+यह चर प्रत्येक मालिक के लिए टोकन की गिनती रखता है। मालिकों से टोकन तक कोई मैपिंग नहीं है, इसलिए एक विशिष्ट मालिक के स्वामित्व वाले टोकन की पहचान करने का एकमात्र तरीका ब्लॉकचेन के इवेंट इतिहास में वापस देखना और उपयुक्त `Transfer` इवेंट्स को देखना है। हम यह जानने के लिए इस चर का उपयोग कर सकते हैं कि हमारे पास सभी NFTs कब हैं और हमें समय में और भी आगे देखने की आवश्यकता नहीं है।
+
+ध्यान दें कि यह एल्गोरिथम केवल उपयोगकर्ता इंटरफेस और बाहरी सर्वर के लिए काम करता है। ब्लॉकचेन पर चल रहा कोड स्वयं पिछले इवेंट्स को नहीं पढ़ सकता है।
+
+```python
+# @dev मालिक के पते से ऑपरेटर पतों की मैपिंग तक मैपिंग।
+ownerToOperators: HashMap[address, HashMap[address, bool]]
+```
+
+एक खाते में एक से अधिक ऑपरेटर हो सकते हैं। एक साधारण `HashMap` उनका ट्रैक रखने के लिए अपर्याप्त है, क्योंकि प्रत्येक कुंजी एक ही मान की ओर ले जाती है। इसके बजाय, आप मान के रूप में `HashMap[address, bool]` का उपयोग कर सकते हैं। डिफ़ॉल्ट रूप से प्रत्येक पते के लिए मान `False` है, जिसका अर्थ है कि यह एक ऑपरेटर नहीं है। आप आवश्यकतानुसार मान `True` पर सेट कर सकते हैं।
+
+```python
+# @dev मिंटर का पता, जो एक टोकन मिंट कर सकता है
+minter: address
+```
+
+नए टोकन किसी तरह बनाने होंगे। इस अनुबंध में एक ही इकाई है जिसे ऐसा करने की अनुमति है, `minter`। उदाहरण के लिए, यह एक खेल के लिए पर्याप्त होने की संभावना है। अन्य उद्देश्यों के लिए, एक अधिक जटिल व्यावसायिक तर्क बनाना आवश्यक हो सकता है।
+
+```python
+# @dev इंटरफ़ेस आईडी से बूल तक मैपिंग कि यह समर्थित है या नहीं
+supportedInterfaces: HashMap[bytes32, bool]
+
+# @dev ERC165 का ERC165 इंटरफ़ेस आईडी
+ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
+
+# @dev ERC721 का ERC165 इंटरफ़ेस आईडी
+ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
+```
+
+[ERC-165](https://eips.ethereum.org/EIPS/eip-165) एक अनुबंध के लिए यह खुलासा करने के लिए एक तंत्र निर्दिष्ट करता है कि एप्लिकेशन इसके साथ कैसे संवाद कर सकते हैं, यह किन ERCs के अनुरूप है। इस मामले में, अनुबंध ERC-165 और ERC-721 के अनुरूप है।
+
+### फ़ंक्शन {#functions}
+
+ये वे फ़ंक्शन हैं जो वास्तव में ERC-721 को लागू करते हैं।
+
+#### कंस्ट्रक्टर {#constructor}
+
+```python
+@external
+def __init__():
+```
+
+Vyper में, Python की तरह, कंस्ट्रक्टर फ़ंक्शन को `__init__` कहा जाता है।
+
+```python
+ """
+ @dev अनुबंध कंस्ट्रक्टर।
+ """
+```
+
+Python में, और Vyper में, आप एक बहु-पंक्ति स्ट्रिंग (`"""` से शुरू और समाप्त होती है) निर्दिष्ट करके और इसे किसी भी तरह से उपयोग न करके भी एक टिप्पणी बना सकते हैं। इन टिप्पणियों में [NatSpec](https://vyper.readthedocs.io/en/latest/natspec.html) भी शामिल हो सकता है।
+
+```python
+ self.supportedInterfaces[ERC165_INTERFACE_ID] = True
+ self.supportedInterfaces[ERC721_INTERFACE_ID] = True
+ self.minter = msg.sender
+```
+
+स्टेट चर तक पहुँचने के लिए आप `self.` (फिर से, Python की तरह ही) का उपयोग करते हैं।
+
+#### फ़ंक्शन देखें {#views}
+
+ये ऐसे फ़ंक्शन हैं जो ब्लॉकचेन की स्थिति को संशोधित नहीं करते हैं, और इसलिए यदि उन्हें बाहरी रूप से बुलाया जाता है तो उन्हें मुफ्त में निष्पादित किया जा सकता है। यदि व्यू फ़ंक्शंस को एक अनुबंध द्वारा बुलाया जाता है तो उन्हें अभी भी हर नोड पर निष्पादित किया जाना है और इसलिए गैस की लागत होती है।
+
+```python
+@view
+@external
+```
+
+एक फ़ंक्शन परिभाषा से पहले ये कीवर्ड जो एक एट साइन (`@`) से शुरू होते हैं, उन्हें _डेकोरेशन_ कहा जाता है। वे उन परिस्थितियों को निर्दिष्ट करते हैं जिनमें एक फ़ंक्शन को बुलाया जा सकता है।
+
+- `@view` निर्दिष्ट करता है कि यह फ़ंक्शन एक व्यू है।
+- `@external` निर्दिष्ट करता है कि इस विशेष फ़ंक्शन को लेनदेन और अन्य अनुबंधों द्वारा बुलाया जा सकता है।
+
+```python
+def supportsInterface(_interfaceID: bytes32) -> bool:
+```
+
+Python के विपरीत, Vyper एक [स्टेटिक टाइप्ड भाषा](https://wikipedia.org/wiki/Type_system#Static_type_checking) है।
+आप [डेटा प्रकार](https://vyper.readthedocs.io/en/latest/types.html) की पहचान किए बिना किसी चर, या किसी फ़ंक्शन पैरामीटर की घोषणा नहीं कर सकते। इस मामले में इनपुट पैरामीटर `bytes32` है, जो 256-बिट मान है ([Ethereum Virtual Machine](/developers/docs/evm/) का मूल शब्द आकार 256 बिट्स है)। आउटपुट एक बूलियन मान है। परंपरा के अनुसार, फ़ंक्शन पैरामीटर के नाम एक अंडरस्कोर (`_`) से शुरू होते हैं।
+
+```python
+ """
+ @dev इंटरफ़ेस पहचान ERC-165 में निर्दिष्ट है।
+ @param _interfaceID इंटरफ़ेस का आईडी
+ """
+ return self.supportedInterfaces[_interfaceID]
+```
+
+`self.supportedInterfaces` HashMap से मान लौटाएं, जो कंस्ट्रक्टर (`__init__`) में सेट है।
+
+```python
+### VIEW FUNCTIONS ###
+```
+
+ये व्यू फ़ंक्शंस हैं जो उपयोगकर्ताओं और अन्य अनुबंधों के लिए टोकन के बारे में जानकारी उपलब्ध कराते हैं।
+
+```python
+@view
+@external
+def balanceOf(_owner: address) -> uint256:
+ """
+ @dev `_owner` के स्वामित्व वाले NFTs की संख्या लौटाता है।
+ यदि `_owner` शून्य पता है तो फेंकता है। शून्य पते को सौंपे गए NFTs को अमान्य माना जाता है।
+ @param _owner पता जिसके लिए शेष राशि की क्वेरी करनी है।
+ """
+```
+
+यह लाइन [जोर देती है](https://vyper.readthedocs.io/en/latest/statements.html#assert) कि `_owner` शून्य नहीं है। यदि ऐसा है, तो एक त्रुटि है और ऑपरेशन वापस कर दिया जाता है।
+
+```python
+ return self.ownerToNFTokenCount[_owner]
+
+@view
+@external
+def ownerOf(_tokenId: uint256) -> address:
+ """
+ @dev NFT के मालिक का पता लौटाता है।
+ यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
+ @param _tokenId एक NFT के लिए पहचानकर्ता।
+ """
+ owner: address = self.idToOwner[_tokenId]
+ # Throws if `_tokenId` is not a valid NFT
+ assert owner != ZERO_ADDRESS
+ return owner
+```
+
+एथेरियम वर्चुअल मशीन (evm) में कोई भी भंडारण जिसमें कोई मान संग्रहीत नहीं है, शून्य है।
+यदि `_tokenId` पर कोई टोकन नहीं है तो `self.idToOwner[_tokenId]` का मान शून्य है। उस स्थिति में फ़ंक्शन वापस आ जाता है।
+
+```python
+@view
+@external
+def getApproved(_tokenId: uint256) -> address:
+ """
+ @dev एक एकल NFT के लिए स्वीकृत पता प्राप्त करें।
+ यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
+ @param _tokenId NFT की आईडी जिसकी स्वीकृति की क्वेरी करनी है।
+ """
+ # Throws if `_tokenId` is not a valid NFT
+ assert self.idToOwner[_tokenId] != ZERO_ADDRESS
+ return self.idToApprovals[_tokenId]
+```
+
+ध्यान दें कि `getApproved` शून्य _वापस_ कर सकता है। यदि टोकन वैध है तो यह `self.idToApprovals[_tokenId]` लौटाता है।
+यदि कोई अनुमोदक नहीं है तो वह मान शून्य है।
+
+```python
+@view
+@external
+def isApprovedForAll(_owner: address, _operator: address) -> bool:
+ """
+ @dev जांचता है कि `_operator` `_owner` के लिए एक स्वीकृत ऑपरेटर है या नहीं।
+ @param _owner वह पता जो NFTs का मालिक है।
+ @param _operator वह पता जो मालिक की ओर से कार्य करता है।
+ """
+ return (self.ownerToOperators[_owner])[_operator]
+```
+
+यह फ़ंक्शन जांचता है कि क्या `_operator` को इस अनुबंध में `_owner` के सभी टोकन प्रबंधित करने की अनुमति है।
+क्योंकि कई ऑपरेटर हो सकते हैं, यह एक दो-स्तरीय HashMap है।
+
+#### सहायक फ़ंक्शन स्थानांतरित करें {#transfer-helpers}
+
+ये फ़ंक्शन उन परिचालनों को लागू करते हैं जो टोकन को स्थानांतरित करने या प्रबंधित करने का हिस्सा हैं।
+
+```python
+
+### TRANSFER FUNCTION HELPERS ###
+
+@view
+@internal
+```
+
+यह सजावट, `@internal`, का अर्थ है कि फ़ंक्शन केवल उसी अनुबंध के भीतर अन्य फ़ंक्शन से ही सुलभ है। परंपरा के अनुसार, इन फ़ंक्शन नामों की शुरुआत भी एक अंडरस्कोर (`_`) से होती है।
+
+```python
+def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
+ """
+ @dev लौटाता है कि दिया गया खर्च करने वाला किसी दिए गए टोकन आईडी को स्थानांतरित कर सकता है या नहीं
+ @param spender क्वेरी करने के लिए खर्च करने वाले का पता
+ @param tokenId स्थानांतरित किए जाने वाले टोकन की uint256 आईडी
+ @return bool कि msg.sender दिए गए टोकन आईडी के लिए स्वीकृत है या नहीं,
+ मालिक का एक ऑपरेटर है, या टोकन का मालिक है
+ """
+ owner: address = self.idToOwner[_tokenId]
+ spenderIsOwner: bool = owner == _spender
+ spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
+ spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
+ return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
+```
+
+किसी पते को टोकन स्थानांतरित करने की अनुमति देने के तीन तरीके हैं:
+
+1. पता टोकन का मालिक है
+2. पता उस टोकन को खर्च करने के लिए स्वीकृत है
+3. पता टोकन के मालिक के लिए एक ऑपरेटर है
+
+ऊपर दिया गया फ़ंक्शन एक व्यू हो सकता है क्योंकि यह स्थिति को नहीं बदलता है। परिचालन लागत को कम करने के लिए, कोई भी फ़ंक्शन जो _एक_ व्यू हो सकता है, _उसे_ एक व्यू _होना_ चाहिए।
+
+```python
+@internal
+def _addTokenTo(_to: address, _tokenId: uint256):
+ """
+ @dev दिए गए पते पर एक NFT जोड़ें
+ यदि `_tokenId` किसी के स्वामित्व में है तो फेंकता है।
+ """
+ # Throws if `_tokenId` is owned by someone
+ assert self.idToOwner[_tokenId] == ZERO_ADDRESS
+ # Change the owner
+ self.idToOwner[_tokenId] = _to
+ # Change count tracking
+ self.ownerToNFTokenCount[_to] += 1
+
+
+@internal
+def _removeTokenFrom(_from: address, _tokenId: uint256):
+ """
+ @dev दिए गए पते से एक NFT हटाएं
+ यदि `_from` वर्तमान स्वामी नहीं है तो फेंकता है।
+ """
+ # Throws if `_from` is not the current owner
+ assert self.idToOwner[_tokenId] == _from
+ # Change the owner
+ self.idToOwner[_tokenId] = ZERO_ADDRESS
+ # Change count tracking
+ self.ownerToNFTokenCount[_from] -= 1
+```
+
+जब स्थानांतरण में कोई समस्या होती है तो हम कॉल को वापस कर देते हैं।
+
+```python
+@internal
+def _clearApproval(_owner: address, _tokenId: uint256):
+ """
+ @dev दिए गए पते की स्वीकृति साफ़ करें
+ यदि `_owner` वर्तमान स्वामी नहीं है तो फेंकता है।
+ """
+ # Throws if `_owner` is not the current owner
+ assert self.idToOwner[_tokenId] == _owner
+ if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
+ # Reset approvals
+ self.idToApprovals[_tokenId] = ZERO_ADDRESS
+```
+
+केवल आवश्यक होने पर मान बदलें। स्टेट चर भंडारण में रहते हैं। भंडारण में लिखना EVM (Ethereum Virtual Machine) द्वारा किए जाने वाले सबसे महंगे परिचालनों में से एक है ([गैस](/developers/docs/gas/) के संदर्भ में)। इसलिए, इसे कम से कम करना एक अच्छा विचार है, यहां तक कि मौजूदा मूल्य लिखने की भी उच्च लागत होती है।
+
+```python
+@internal
+def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
+ """
+ @dev NFT का स्थानांतरण निष्पादित करें।
+ जब तक `msg.sender` वर्तमान स्वामी, एक अधिकृत ऑपरेटर, या इस NFT के लिए स्वीकृत पता न हो, तब तक फेंकता है। (नोट: निजी फ़ंक्शन में `msg.sender` की अनुमति नहीं है इसलिए `_sender` पास करें।)
+ यदि `_to` शून्य पता है तो फेंकता है।
+ यदि `_from` वर्तमान स्वामी नहीं है तो फेंकता है।
+ यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
+ """
+```
+
+हमारे पास यह आंतरिक फ़ंक्शन है क्योंकि टोकन स्थानांतरित करने के दो तरीके हैं (नियमित और सुरक्षित), लेकिन हम चाहते हैं कि कोड में केवल एक ही स्थान हो जहां हम इसे ऑडिटिंग को आसान बनाने के लिए करते हैं।
+
+```python
+ # Check requirements
+ assert self._isApprovedOrOwner(_sender, _tokenId)
+ # Throws if `_to` is the zero address
+ assert _to != ZERO_ADDRESS
+ # Clear approval. Throws if `_from` is not the current owner
+ self._clearApproval(_from, _tokenId)
+ # Remove NFT. Throws if `_tokenId` is not a valid NFT
+ self._removeTokenFrom(_from, _tokenId)
+ # Add NFT
+ self._addTokenTo(_to, _tokenId)
+ # Log the transfer
+ log Transfer(_from, _to, _tokenId)
+```
+
+Vyper में एक इवेंट उत्सर्जित करने के लिए आप एक `log` स्टेटमेंट का उपयोग करते हैं ([अधिक जानकारी के लिए यहां देखें](https://vyper.readthedocs.io/en/latest/event-logging.html#event-logging))।
+
+#### स्थानांतरण फ़ंक्शन {#transfer-funs}
+
+```python
+
+### TRANSFER FUNCTIONS ###
+
+@external
+def transferFrom(_from: address, _to: address, _tokenId: uint256):
+ """
+ @dev जब तक `msg.sender` वर्तमान स्वामी, एक अधिकृत ऑपरेटर, या इस NFT के लिए स्वीकृत पता न हो, तब तक फेंकता है।
+ यदि `_from` वर्तमान स्वामी नहीं है तो फेंकता है।
+ यदि `_to` शून्य पता है तो फेंकता है।
+ यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
+ @notice कॉलर यह पुष्टि करने के लिए ज़िम्मेदार है कि `_to` NFTs प्राप्त करने में सक्षम है अन्यथा वे स्थायी रूप से खो सकते हैं।
+ @param _from NFT का वर्तमान स्वामी।
+ @param _to नया स्वामी।
+ @param _tokenId स्थानांतरित करने के लिए NFT।
+ """
+ self._transferFrom(_from, _to, _tokenId, msg.sender)
+```
+
+यह फ़ंक्शन आपको एक मनमाने पते पर स्थानांतरित करने देता है। जब तक पता एक उपयोगकर्ता, या एक अनुबंध नहीं है जो टोकन स्थानांतरित करना जानता है, आपके द्वारा स्थानांतरित किया गया कोई भी टोकन उस पते में फंस जाएगा और बेकार हो जाएगा।
+
+```python
+@external
+def safeTransferFrom(
+ _from: address,
+ _to: address,
+ _tokenId: uint256,
+ _data: Bytes[1024]=b""
+ ):
+ """
+ @dev एक NFT के स्वामित्व को एक पते से दूसरे पते पर स्थानांतरित करता है।
+ जब तक `msg.sender` वर्तमान स्वामी, एक अधिकृत ऑपरेटर, या इस NFT के लिए स्वीकृत पता न हो, तब तक फेंकता है।
+ यदि `_from` वर्तमान स्वामी नहीं है तो फेंकता है।
+ यदि `_to` शून्य पता है तो फेंकता है।
+ यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
+ यदि `_to` एक स्मार्ट अनुबंध है, तो यह `_to` पर `onERC721Received` को कॉल करता है और यदि वापसी मान `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` नहीं है तो फेंकता है।
+ नोट: bytes4 को पैडिंग के साथ bytes32 द्वारा दर्शाया गया है
+ @param _from NFT का वर्तमान स्वामी।
+ @param _to नया स्वामी।
+ @param _tokenId स्थानांतरित करने के लिए NFT।
+ @param _data बिना किसी निर्दिष्ट प्रारूप के अतिरिक्त डेटा, `_to` पर कॉल में भेजा गया।
+ """
+ self._transferFrom(_from, _to, _tokenId, msg.sender)
+```
+
+पहले स्थानांतरण करना ठीक है क्योंकि यदि कोई समस्या होती है तो हम वैसे भी वापस आ जाएंगे, इसलिए कॉल में किया गया सब कुछ रद्द कर दिया जाएगा।
+
+```python
+ if _to.is_contract: # check if `_to` is a contract address
+```
+
+पहले जांच लें कि पता एक अनुबंध है या नहीं (यदि इसमें कोड है)। यदि नहीं, तो मान लें कि यह एक उपयोगकर्ता पता है और उपयोगकर्ता टोकन का उपयोग करने या इसे स्थानांतरित करने में सक्षम होगा। लेकिन इसे आपको सुरक्षा की झूठी भावना में नहीं आने देना चाहिए। आप `safeTransferFrom` के साथ भी टोकन खो सकते हैं, यदि आप उन्हें ऐसे पते पर स्थानांतरित करते हैं जिसके लिए किसी को निजी कुंजी नहीं पता है।
+
+```python
+ returnValue: bytes32 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
+```
+
+यह देखने के लिए लक्ष्य अनुबंध को कॉल करें कि क्या यह ERC-721 टोकन प्राप्त कर सकता है।
+
+```python
+ # Throws if transfer destination is a contract which does not implement 'onERC721Received'
+ assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes32)
+```
+
+यदि गंतव्य एक अनुबंध है, लेकिन एक ऐसा है जो ERC-721 टोकन स्वीकार नहीं करता है (या जिसने इस विशेष स्थानांतरण को स्वीकार नहीं करने का निर्णय लिया है), तो वापस आ जाएं।
+
+```python
+@external
+def approve(_approved: address, _tokenId: uint256):
+ """
+ @dev किसी NFT के लिए स्वीकृत पता सेट करें या उसकी पुष्टि करें। शून्य पता इंगित करता है कि कोई स्वीकृत पता नहीं है।
+ जब तक `msg.sender` वर्तमान NFT स्वामी, या वर्तमान स्वामी का अधिकृत ऑपरेटर न हो, तब तक फेंकता है।
+ यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है। (नोट: यह EIP में नहीं लिखा गया है)
+ यदि `_approved` वर्तमान स्वामी है तो फेंकता है। (नोट: यह EIP में नहीं लिखा गया है)
+ @param _approved दिए गए NFT आईडी के लिए स्वीकृत किए जाने वाला पता।
+ @param _tokenId स्वीकृत किए जाने वाले टोकन की आईडी।
+ """
+ owner: address = self.idToOwner[_tokenId]
+ # Throws if `_tokenId` is not a valid NFT
+ assert owner != ZERO_ADDRESS
+ # Throws if `_approved` is the current owner
+ assert _approved != owner
+```
+
+परंपरा के अनुसार यदि आप एक अनुमोदक नहीं चाहते हैं तो आप शून्य पते को नियुक्त करते हैं, न कि स्वयं को।
+
+```python
+ # Check requirements
+ senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
+ senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
+ assert (senderIsOwner or senderIsApprovedForAll)
+```
+
+अनुमोदन सेट करने के लिए आप या तो मालिक हो सकते हैं, या मालिक द्वारा अधिकृत ऑपरेटर हो सकते हैं।
+
+```python
+ # Set the approval
+ self.idToApprovals[_tokenId] = _approved
+ log Approval(owner, _approved, _tokenId)
+
+
+@external
+def setApprovalForAll(_operator: address, _approved: bool):
+ """
+ @dev किसी तीसरे पक्ष ("ऑपरेटर") के लिए `msg.sender` की सभी संपत्तियों का प्रबंधन करने के लिए अनुमोदन को सक्षम या अक्षम करता है। यह ApprovalForAll इवेंट भी उत्सर्जित करता है।
+ यदि `_operator` `msg.sender` है तो फेंकता है। (नोट: यह EIP में नहीं लिखा गया है)
+ @notice यह तब भी काम करता है जब प्रेषक के पास उस समय कोई टोकन न हो।
+ @param _operator अधिकृत ऑपरेटरों के सेट में जोड़ने के लिए पता।
+ @param _approved यदि ऑपरेटर स्वीकृत है तो सही, अनुमोदन रद्द करने के लिए गलत।
+ """
+ # Throws if `_operator` is the `msg.sender`
+ assert _operator != msg.sender
+ self.ownerToOperators[msg.sender][_operator] = _approved
+ log ApprovalForAll(msg.sender, _operator, _approved)
+```
+
+#### नए टोकन मिंट करें और मौजूदा को नष्ट करें {#mint-burn}
+
+जिस खाते ने अनुबंध बनाया है, वह `minter` है, जो नए NFTs को मिंट करने के लिए अधिकृत सुपर उपयोगकर्ता है। हालांकि, इसे मौजूदा टोकन को बर्न करने की भी अनुमति नहीं है। केवल मालिक, या मालिक द्वारा अधिकृत इकाई ही ऐसा कर सकती है।
+
+```python
+### MINT & BURN FUNCTIONS ###
+
+@external
+def mint(_to: address, _tokenId: uint256) -> bool:
+```
+
+यह फ़ंक्शन हमेशा `True` लौटाता है, क्योंकि यदि ऑपरेशन विफल हो जाता है तो इसे वापस कर दिया जाता है।
+
+```python
+ """
+ @dev टोकन मिंट करने के लिए फ़ंक्शन
+ यदि `msg.sender` मिंटर नहीं है तो फेंकता है।
+ यदि `_to` शून्य पता है तो फेंकता है।
+ यदि `_tokenId` किसी के स्वामित्व में है तो फेंकता है।
+ @param _to वह पता जो मिंट किए गए टोकन प्राप्त करेगा।
+ @param _tokenId मिंट करने के लिए टोकन आईडी।
+ @return एक बूलियन जो इंगित करता है कि ऑपरेशन सफल था या नहीं।
+ """
+ # Throws if `msg.sender` is not the minter
+ assert msg.sender == self.minter
+```
+
+केवल मिंटर (वह खाता जिसने ERC-721 अनुबंध बनाया है) ही नए टोकन मिंट कर सकता है। यह भविष्य में एक समस्या हो सकती है यदि हम मिंटर की पहचान बदलना चाहते हैं। एक उत्पादन अनुबंध में आप शायद एक ऐसा फ़ंक्शन चाहेंगे जो मिंटर को मिंटर विशेषाधिकार किसी और को स्थानांतरित करने की अनुमति दे।
+
+```python
+ # Throws if `_to` is zero address
+ assert _to != ZERO_ADDRESS
+ # Add NFT. Throws if `_tokenId` is owned by someone
+ self._addTokenTo(_to, _tokenId)
+ log Transfer(ZERO_ADDRESS, _to, _tokenId)
+ return True
+```
+
+परंपरा के अनुसार, नए टोकन का मिंटिंग शून्य पते से स्थानांतरण के रूप में गिना जाता है।
+
+```python
+
+@external
+def burn(_tokenId: uint256):
+ """
+ @dev एक विशिष्ट ERC721 टोकन को बर्न करता है।
+ जब तक `msg.sender` वर्तमान स्वामी, एक अधिकृत ऑपरेटर, या इस NFT के लिए स्वीकृत पता न हो, तब तक फेंकता है।
+ यदि `_tokenId` एक वैध NFT नहीं है तो फेंकता है।
+ @param _tokenId uint256 बर्न किए जाने वाले ERC721 टोकन की आईडी।
+ """
+ # Check requirements
+ assert self._isApprovedOrOwner(msg.sender, _tokenId)
+ owner: address = self.idToOwner[_tokenId]
+ # Throws if `_tokenId` is not a valid NFT
+ assert owner != ZERO_ADDRESS
+ self._clearApproval(owner, _tokenId)
+ self._removeTokenFrom(owner, _tokenId)
+ log Transfer(owner, ZERO_ADDRESS, _tokenId)
+```
+
+कोई भी जिसे टोकन स्थानांतरित करने की अनुमति है, उसे इसे बर्न करने की अनुमति है। जबकि एक बर्न शून्य पते पर स्थानांतरण के बराबर दिखाई देता है, शून्य पता वास्तव में टोकन प्राप्त नहीं करता है। यह हमें टोकन के लिए उपयोग किए गए सभी भंडारण को मुक्त करने की अनुमति देता है, जो लेनदेन की गैस लागत को कम कर सकता है।
+
+## इस अनुबंध का उपयोग करना {#using-contract}
+
+Solidity के विपरीत, Vyper में वंशानुक्रम नहीं है। यह कोड को स्पष्ट बनाने और इसलिए सुरक्षित करने के लिए एक जानबूझकर डिजाइन विकल्प है। तो अपना खुद का Vyper ERC-721 अनुबंध बनाने के लिए आप [यह अनुबंध](https://github.com/vyperlang/vyper/blob/master/examples/tokens/ERC721.vy) लेते हैं और इसे उस व्यावसायिक तर्क को लागू करने के लिए संशोधित करते हैं जो आप चाहते हैं।
+
+## निष्कर्ष {#conclusion}
+
+समीक्षा के लिए, इस अनुबंध के कुछ सबसे महत्वपूर्ण विचार यहां दिए गए हैं:
+
+- एक सुरक्षित स्थानांतरण के साथ ERC-721 टोकन प्राप्त करने के लिए, अनुबंधों को `ERC721Receiver` इंटरफ़ेस लागू करना होगा।
+- भले ही आप सुरक्षित स्थानांतरण का उपयोग करें, टोकन अभी भी फंस सकते हैं यदि आप उन्हें ऐसे पते पर भेजते हैं जिसकी निजी कुंजी अज्ञात है।
+- जब किसी ऑपरेशन में कोई समस्या होती है तो केवल एक विफलता मान वापस करने के बजाय कॉल को `revert` करना एक अच्छा विचार है।
+- ERC-721 टोकन तब मौजूद होते हैं जब उनका कोई मालिक होता है।
+- एक NFT स्थानांतरित करने के लिए अधिकृत होने के तीन तरीके हैं। आप मालिक हो सकते हैं, एक विशिष्ट टोकन के लिए अनुमोदित हो सकते हैं, या मालिक के सभी टोकन के लिए एक ऑपरेटर हो सकते हैं।
+- पिछले इवेंट्स केवल ब्लॉकचेन के बाहर दिखाई देते हैं। ब्लॉकचेन के अंदर चलने वाला कोड उन्हें देख नहीं सकता है।
+
+अब जाओ और सुरक्षित Vyper अनुबंध लागू करो।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
+
diff --git a/public/content/translations/hi/developers/tutorials/erc20-annotated-code/index.md b/public/content/translations/hi/developers/tutorials/erc20-annotated-code/index.md
new file mode 100644
index 00000000000..ab52d22a3dc
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/erc20-annotated-code/index.md
@@ -0,0 +1,926 @@
+---
+title: "ERC-20 कॉन्ट्रैक्ट वॉक-थ्रू"
+description: "OpenZeppelin ERC-20 कॉन्ट्रैक्ट में क्या है और यह वहां क्यों है?"
+author: "ओरी पोमेरेन्ट्ज़"
+lang: hi
+tags: [ "सोलिडीटी", "erc-20" ]
+skill: beginner
+published: 2021-03-09
+---
+
+## परिचय {#introduction}
+
+एथेरियम के लिए सबसे आम उपयोगों में से एक समूह के लिए एक व्यापार योग्य टोकन बनाना है, एक अर्थ में उनकी अपनी मुद्रा। ये टोकन आमतौर पर एक मानक का पालन करते हैं,
+[ERC-20](/developers/docs/standards/tokens/erc-20/)। यह मानक लिक्विडिटी पूल और वॉलेट जैसे उपकरण लिखना संभव बनाता है, जो सभी ERC-20
+टोकन के साथ काम करते हैं। इस लेख में हम
+[OpenZeppelin Solidity ERC20 इम्प्लीमेंटेशन](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol), और
+[इंटरफ़ेस परिभाषा](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) का विश्लेषण करेंगे।
+
+यह एनोटेटेड सोर्स कोड है। अगर आप ERC-20 लागू करना चाहते हैं, तो
+[यह ट्यूटोरियल पढ़ें](https://docs.openzeppelin.com/contracts/2.x/erc20-supply)।
+
+## इंटरफ़ेस {#the-interface}
+
+ERC-20 जैसे मानक का उद्देश्य कई टोकन कार्यान्वयनों को अनुमति देना है जो वॉलेट और विकेन्द्रीकृत एक्सचेंजों जैसे अनुप्रयोगों में इंटरऑपरेबल हैं। इसे प्राप्त करने के लिए, हम एक
+[इंटरफ़ेस](https://www.geeksforgeeks.org/solidity/solidity-basics-of-interface/) बनाते हैं। कोई भी कोड जिसे टोकन कॉन्ट्रैक्ट का उपयोग करने की आवश्यकता है, वह
+इंटरफ़ेस में समान परिभाषाओं का उपयोग कर सकता है और इसका उपयोग करने वाले सभी टोकन कॉन्ट्रैक्ट के साथ संगत हो सकता है, चाहे वह
+MetaMask जैसा वॉलेट हो, etherscan.io जैसा डैप हो, या लिक्विडिटी पूल जैसा कोई अलग कॉन्ट्रैक्ट हो।
+
+
+
+यदि आप एक अनुभवी प्रोग्रामर हैं, तो आपको शायद [जावा](https://www.w3schools.com/java/java_interface.asp)
+या यहां तक कि [C हेडर फ़ाइलों](https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html) में भी समान संरचनाएं देखने को याद होंगी।
+
+यह OpenZeppelin से [ERC-20 इंटरफेस](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol)
+की एक परिभाषा है। यह [मानव पठनीय मानक](https://eips.ethereum.org/EIPS/eip-20) का Solidity कोड में अनुवाद है। बेशक,
+इंटरफ़ेस स्वयं यह परिभाषित नहीं करता है कि कुछ _कैसे_ करना है। यह नीचे दिए गए कॉन्ट्रैक्ट सोर्स कोड में समझाया गया है।
+
+
+
+```solidity
+// SPDX-License-Identifier: MIT
+```
+
+Solidity फ़ाइलों में एक लाइसेंस पहचानकर्ता शामिल होना चाहिए। [आप यहां लाइसेंसों की सूची देख सकते हैं](https://spdx.org/licenses/)। यदि आपको एक अलग
+लाइसेंस की आवश्यकता है, तो बस इसे कमेंट में समझाएं।
+
+
+
+```solidity
+pragma solidity >=0.6.0 <0.8.0;
+```
+
+Solidity भाषा अभी भी तेजी से विकसित हो रही है, और नए संस्करण पुराने कोड के साथ संगत नहीं हो सकते हैं
+([यहां देखें](https://docs.soliditylang.org/en/v0.7.0/070-breaking-changes.html))। इसलिए, यह एक अच्छा विचार है कि न केवल भाषा का न्यूनतम
+संस्करण निर्दिष्ट किया जाए, बल्कि एक अधिकतम संस्करण भी, नवीनतम जिसके साथ आपने कोड का परीक्षण किया है।
+
+
+
+```solidity
+/**
+ * @dev EIP में परिभाषित ERC20 मानक का इंटरफ़ेस।
+ */
+```
+
+कमेंट में `@dev` [NatSpec फॉर्मेट](https://docs.soliditylang.org/en/develop/natspec-format.html) का हिस्सा है, जिसका उपयोग सोर्स कोड से
+प्रलेखन बनाने के लिए किया जाता है।
+
+
+
+```solidity
+interface IERC20 {
+```
+
+परंपरा के अनुसार, इंटरफ़ेस के नाम `I` से शुरू होते हैं।
+
+
+
+```solidity
+ /**
+ * @dev अस्तित्व में टोकन की मात्रा लौटाता है।
+ */
+ function totalSupply() external view returns (uint256);
+```
+
+यह फ़ंक्शन `external` है, जिसका अर्थ है [इसे केवल अनुबंध के बाहर से कॉल किया जा सकता है](https://docs.soliditylang.org/en/v0.7.0/cheatsheet.html#index-2)।
+यह कॉन्ट्रैक्ट में टोकन की कुल आपूर्ति लौटाता है। यह मान एथेरियम में सबसे सामान्य प्रकार, अनसाईंड 256 बिट्स का उपयोग करके लौटाया जाता है (256 बिट EVM का
+नेटिव शब्द आकार है)। यह फ़ंक्शन एक `view` भी है, जिसका अर्थ है कि यह स्टेट को नहीं बदलता है, इसलिए इसे ब्लॉकचेन के प्रत्येक नोड पर चलाने के बजाय
+एकल नोड पर निष्पादित किया जा सकता है। इस तरह का फ़ंक्शन लेनदेन उत्पन्न नहीं करता है और इसमें [गैस](/developers/docs/gas/) नहीं लगती है।
+
+**ध्यान दें:** सिद्धांत रूप में ऐसा लग सकता है कि किसी कॉन्ट्रैक्ट का निर्माता वास्तविक मूल्य से कम कुल आपूर्ति लौटाकर धोखा दे सकता है, जिससे प्रत्येक टोकन
+वास्तविक से अधिक मूल्यवान प्रतीत होता है। हालांकि, यह डर ब्लॉकचेन की वास्तविक प्रकृति को नजरअंदाज करता है। ब्लॉकचेन पर होने वाली हर चीज़ को
+हर नोड द्वारा सत्यापित किया जा सकता है। इसे प्राप्त करने के लिए, प्रत्येक कॉन्ट्रैक्ट का मशीन भाषा कोड और स्टोरेज हर नोड पर उपलब्ध है। हालांकि आपको अपने अनुबंध के लिए Solidity
+कोड प्रकाशित करने की आवश्यकता नहीं है, लेकिन कोई भी आपको गंभीरता से नहीं लेगा जब तक कि आप स्रोत कोड और Solidity का वह संस्करण प्रकाशित नहीं करते जिसके साथ इसे संकलित किया गया था, ताकि इसे
+आपके द्वारा प्रदान किए गए मशीन भाषा कोड के विरुद्ध सत्यापित किया जा सके।
+उदाहरण के लिए, [यह अनुबंध देखें](https://eth.blockscout.com/address/0xa530F85085C6FE2f866E7FdB716849714a89f4CD?tab=contract)।
+
+
+
+```solidity
+ /**
+ * @dev `खाते` के स्वामित्व वाले टोकन की राशि लौटाता है।
+ */
+ function balanceOf(address account) external view returns (uint256);
+```
+
+जैसा कि नाम से पता चलता है, `balanceOf` एक खाते का बैलेंस लौटाता है। एथेरियम खातों को `address` प्रकार का उपयोग करके Solidity में पहचाना जाता है, जो 160 बिट्स रखता है।
+यह `external` और `view` भी है।
+
+
+
+```solidity
+ /**
+ * @dev कॉलर के खाते से `recipient` को `राशि` टोकन ले जाता है।
+ *
+ * एक बूलियन मान लौटाता है जो यह दर्शाता है कि ऑपरेशन सफल हुआ या नहीं।
+ *
+ * {ट्रांसफर} इवेंट उत्सर्जित करता है।
+ */
+ function transfer(address recipient, uint256 amount) external returns (bool);
+```
+
+`transfer` फ़ंक्शन कॉलर से एक अलग पते पर टोकन स्थानांतरित करता है। इसमें स्टेट में बदलाव शामिल है, इसलिए यह `view` नहीं है।
+जब कोई यूज़र इस फ़ंक्शन को कॉल करता है तो यह एक लेनदेन बनाता है और इसमें गैस लगती है। यह एक इवेंट, `Transfer` भी उत्सर्जित करता है, ताकि
+ब्लॉकचेन पर सभी को इवेंट की सूचना दी जा सके।
+
+फ़ंक्शन में दो अलग-अलग प्रकार के कॉलर्स के लिए दो प्रकार के आउटपुट होते हैं:
+
+- उपयोगकर्ता जो सीधे उपयोगकर्ता इंटरफ़ेस से फ़ंक्शन को कॉल करते हैं। आमतौर पर उपयोगकर्ता एक लेनदेन सबमिट करता है
+ और प्रतिक्रिया की प्रतीक्षा नहीं करता है, जिसमें अनिश्चित काल तक का समय लग सकता है। उपयोगकर्ता यह देख सकता है कि क्या हुआ
+ लेनदेन रसीद (जिसे लेनदेन हैश द्वारा पहचाना जाता है) को देखकर या `ट्रांसफर` इवेंट को देखकर।
+- अन्य अनुबंध, जो समग्र लेनदेन के हिस्से के रूप में फ़ंक्शन को कॉल करते हैं। उन अनुबंधों को तुरंत परिणाम मिलता है,
+ क्योंकि वे एक ही लेनदेन में चलते हैं, इसलिए वे फ़ंक्शन वापसी मान का उपयोग कर सकते हैं।
+
+अनुबंध की स्थिति को बदलने वाले अन्य कार्यों द्वारा समान प्रकार का आउटपुट बनाया जाता है।
+
+
+
+अलाउंस एक खाते को कुछ ऐसे टोकन खर्च करने की अनुमति देते हैं जो एक अलग मालिक के हैं।
+यह उपयोगी है, उदाहरण के लिए, उन अनुबंधों के लिए जो विक्रेताओं के रूप में कार्य करते हैं। अनुबंध
+इवेंट के लिए मॉनिटर नहीं कर सकते हैं, इसलिए यदि कोई खरीदार सीधे विक्रेता अनुबंध को टोकन स्थानांतरित करता है
+तो उस अनुबंध को यह नहीं पता होगा कि इसका भुगतान किया गया था। इसके बजाय, खरीदार
+विक्रेता अनुबंध को एक निश्चित राशि खर्च करने की अनुमति देता है, और विक्रेता उस राशि को स्थानांतरित करता है।
+यह एक फ़ंक्शन के माध्यम से किया जाता है जिसे विक्रेता अनुबंध कॉल करता है, इसलिए विक्रेता अनुबंध
+जान सकता है कि यह सफल था या नहीं।
+
+```solidity
+ /**
+ * @dev टोकन की शेष संख्या लौटाता है जिसे `spender` को
+ * {transferFrom} के माध्यम से `owner` की ओर से खर्च करने की अनुमति दी जाएगी। यह
+ * डिफ़ॉल्ट रूप से शून्य है।
+ *
+ * जब {approve} या {transferFrom} को कॉल किया जाता है तो यह मान बदल जाता है।
+ */
+ function allowance(address owner, address spender) external view returns (uint256);
+```
+
+`allowance` फ़ंक्शन किसी को भी यह देखने के लिए क्वेरी करने देता है कि एक
+पता (`owner`) दूसरे पते (`spender`) को कितना खर्च करने देता है।
+
+
+
+```solidity
+ /**
+ * @dev कॉलर के टोकन पर `spender` के भत्ते के रूप में `राशि` सेट करता है।
+ *
+ * एक बूलियन मान लौटाता है जो यह दर्शाता है कि ऑपरेशन सफल हुआ या नहीं।
+ *
+ * महत्वपूर्ण: सावधान रहें कि इस पद्धति के साथ भत्ता बदलने से यह जोखिम होता है
+ * कि कोई दुर्भाग्यपूर्ण लेनदेन
+ * क्रम से पुराने और नए दोनों भत्तों का उपयोग कर सकता है। इस रेस कंडीशन को
+ * कम करने का एक संभावित समाधान यह है कि पहले खर्च करने वाले के भत्ते को 0 तक कम किया जाए और बाद में
+ * वांछित मान सेट किया जाए:
+ * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+ *
+ * एक {Approval} इवेंट उत्सर्जित करता है।
+ */
+ function approve(address spender, uint256 amount) external returns (bool);
+```
+
+`approve` फ़ंक्शन एक अलाउंस बनाता है। इसके
+दुरुपयोग के बारे में संदेश पढ़ना सुनिश्चित करें। एथेरियम में आप अपने स्वयं के लेनदेन के क्रम को नियंत्रित करते हैं,
+लेकिन आप उस क्रम को नियंत्रित नहीं कर सकते जिसमें अन्य लोगों के लेनदेन
+निष्पादित होंगे, जब तक कि आप अपना स्वयं का लेनदेन तब तक सबमिट नहीं करते जब तक आप यह नहीं देखते कि
+दूसरे पक्ष का लेनदेन हो गया है।
+
+
+
+```solidity
+ /**
+ * @dev `सेंडर` से `प्राप्तकर्ता` तक `राशि` टोकन को
+ * भत्ता तंत्र का उपयोग करके ले जाता है। `राशि` को फिर कॉलर के
+ * भत्ते से काट लिया जाता है।
+ *
+ * एक बूलियन मान लौटाता है जो यह दर्शाता है कि ऑपरेशन सफल हुआ या नहीं।
+ *
+ * एक {ट्रांसफर} इवेंट उत्सर्जित करता है।
+ */
+ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+```
+
+अंत में, `transferFrom` का उपयोग खर्च करने वाले द्वारा वास्तव में भत्ता खर्च करने के लिए किया जाता है।
+
+
+
+```solidity
+
+ /**
+ * @dev जब `मान` टोकन एक खाते (`from`) से
+ * दूसरे (`to`) में ले जाए जाते हैं तो उत्सर्जित होता है।
+ *
+ * ध्यान दें कि `मान` शून्य हो सकता है।
+ */
+ event Transfer(address indexed from, address indexed to, uint256 value);
+
+ /**
+ * @dev जब {approve} पर कॉल द्वारा `owner` के लिए `spender` का भत्ता सेट किया जाता है
+ * तो उत्सर्जित होता है। `value` नया भत्ता है।
+ */
+ event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+```
+
+ये इवेंट तब उत्सर्जित होते हैं जब ERC-20 अनुबंध की स्थिति बदल जाती है।
+
+## वास्तविक अनुबंध {#the-actual-contract}
+
+यह वास्तविक अनुबंध है जो ERC-20 मानक को लागू करता है,
+[यहां से लिया गया](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)।
+इसका उपयोग जैसा है वैसा करने के लिए नहीं है, लेकिन आप इसे कुछ प्रयोग करने योग्य बनाने के लिए इससे
+[इनहेरिट](https://www.tutorialspoint.com/solidity/solidity_inheritance.htm) कर सकते हैं।
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.0 <0.8.0;
+```
+
+
+
+### इंपोर्ट स्टेटमेंट {#import-statements}
+
+ऊपर दी गई इंटरफ़ेस परिभाषाओं के अलावा, अनुबंध परिभाषा दो अन्य फ़ाइलों को आयात करती है:
+
+```solidity
+
+import "../../GSN/Context.sol";
+import "./IERC20.sol";
+import "../../math/SafeMath.sol";
+```
+
+- `GSN/Context.sol` [OpenGSN](https://www.opengsn.org/) का उपयोग करने के लिए आवश्यक परिभाषाएं हैं, एक ऐसी प्रणाली जो ईथर के बिना उपयोगकर्ताओं को
+ ब्लॉकचेन का उपयोग करने की अनुमति देती है। ध्यान दें कि यह एक पुराना संस्करण है, यदि आप OpenGSN के साथ एकीकृत करना चाहते हैं
+ [इस ट्यूटोरियल का उपयोग करें](https://docs.opengsn.org/javascript-client/tutorial.html)।
+- [SafeMath लाइब्रेरी](https://ethereumdev.io/using-safe-math-library-to-prevent-from-overflows/), जो Solidity संस्करणों **<0.8.0** के लिए
+ अरिथमैटिक ओवरफ़्लो/अंडरफ़्लो को रोकती है। Solidity ≥0.8.0 में, अंकगणितीय संचालन स्वचालित रूप से
+ ओवरफ़्लो/अंडरफ़्लो पर वापस आ जाते हैं, जिससे SafeMath अनावश्यक हो जाता है। यह अनुबंध पुराने
+ संकलक संस्करणों के साथ पश्चगामी संगतता के लिए SafeMath का उपयोग करता है।
+
+
+
+यह टिप्पणी अनुबंध के उद्देश्य को बताती है।
+
+```solidity
+/**
+ * @dev {IERC20} इंटरफ़ेस का कार्यान्वयन।
+ *
+ * यह कार्यान्वयन उस तरीके से अज्ञेयवादी है जिस तरह से टोकन बनाए जाते हैं। इसका मतलब है
+ * कि {_mint} का उपयोग करके एक व्युत्पन्न अनुबंध में एक आपूर्ति तंत्र जोड़ा जाना है।
+ * एक सामान्य तंत्र के लिए {ERC20PresetMinterPauser} देखें।
+ *
+ * टिप: विस्तृत विवरण के लिए हमारी मार्गदर्शिका देखें
+ * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[कैसे
+ * आपूर्ति तंत्र लागू करें]।
+ *
+ * हमने सामान्य OpenZeppelin दिशानिर्देशों का पालन किया है: फ़ंक्शन विफलता पर
+ * `गलत` लौटाने के बजाय वापस आ जाते हैं। यह व्यवहार फिर भी पारंपरिक है
+ * और ERC20 अनुप्रयोगों की अपेक्षाओं के साथ टकराव नहीं करता है।
+ *
+ * इसके अतिरिक्त, {transferFrom} पर कॉल पर एक {Approval} इवेंट उत्सर्जित होता है।
+ * यह अनुप्रयोगों को केवल
+ * उक्त घटनाओं को सुनकर सभी खातों के लिए भत्ता फिर से बनाने की अनुमति देता है। EIP के अन्य कार्यान्वयन
+ * इन घटनाओं का उत्सर्जन नहीं कर सकते हैं, क्योंकि यह विनिर्देश द्वारा आवश्यक नहीं है।
+ *
+ * अंत में, गैर-मानक {decreaseAllowance} और {increaseAllowance}
+ * फ़ंक्शंस को भत्ता
+ * सेट करने के आसपास के प्रसिद्ध मुद्दों को कम करने के लिए जोड़ा गया है। {IERC20-approve} देखें।
+ */
+
+```
+
+### अनुबंध परिभाषा {#contract-definition}
+
+```solidity
+contract ERC20 is Context, IERC20 {
+```
+
+यह पंक्ति इनहेरिटेंस को निर्दिष्ट करती है, इस मामले में ऊपर से `IERC20` और `Context` से, OpenGSN के लिए।
+
+
+
+```solidity
+
+ using SafeMath for uint256;
+
+```
+
+यह पंक्ति `SafeMath` लाइब्रेरी को `uint256` प्रकार से जोड़ती है। आप इस लाइब्रेरी को
+[यहां](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol) पा सकते हैं।
+
+### वैरिएबल परिभाषाएं {#variable-definitions}
+
+ये परिभाषाएँ अनुबंध के स्टेट वैरिएबल को निर्दिष्ट करती हैं। इन वैरिएबल को `private` घोषित किया गया है, लेकिन
+इसका केवल यह मतलब है कि ब्लॉकचेन पर अन्य अनुबंध उन्हें नहीं पढ़ सकते हैं। _ब्लॉकचेन पर कोई
+राज नहीं है_, हर नोड पर सॉफ्टवेयर में हर ब्लॉक पर हर अनुबंध की स्टेट होती है। परंपरा के अनुसार, स्टेट वैरिएबल का नाम `_` होता है।
+
+पहले दो वैरिएबल [मैपिंग](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) हैं,
+मतलब वे मोटे तौर पर [एसोसिएटिव एरे](https://wikipedia.org/wiki/Associative_array) के समान व्यवहार करते हैं,
+सिवाय इसके कि कुंजी संख्यात्मक मान हैं। भंडारण केवल उन प्रविष्टियों के लिए आवंटित किया जाता है जिनके मान डिफ़ॉल्ट (शून्य) से
+अलग हैं।
+
+```solidity
+ mapping (address => uint256) private _balances;
+```
+
+पहली मैपिंग, `_balances`, इस टोकन के पते और उनके संबंधित बैलेंस हैं। बैलेंस तक पहुँचने के लिए,
+इस सिंटैक्स का उपयोग करें: `_balances[]`।
+
+
+
+```solidity
+ mapping (address => mapping (address => uint256)) private _allowances;
+```
+
+यह वैरिएबल, `_allowances`, पहले बताए गए अलाउंस को स्टोर करता है। पहला इंडेक्स टोकन का
+मालिक है, और दूसरा अलाउंस के साथ अनुबंध है। पता A पते B के खाते से
+कितनी राशि खर्च कर सकता है, यह जानने के लिए, `_allowances[B][A]` का उपयोग करें।
+
+
+
+```solidity
+ uint256 private _totalSupply;
+```
+
+जैसा कि नाम से पता चलता है, यह वैरिएबल टोकन की कुल आपूर्ति का ट्रैक रखता है।
+
+
+
+```solidity
+ string private _name;
+ string private _symbol;
+ uint8 private _decimals;
+```
+
+इन तीन वैरिएबल का उपयोग पठनीयता में सुधार के लिए किया जाता है। पहले दो स्व-व्याख्यात्मक हैं, लेकिन `_decimals`
+नहीं है।
+
+एक तरफ, एथेरियम में फ्लोटिंग पॉइंट या भिन्नात्मक वैरिएबल नहीं हैं। दूसरी ओर,
+मनुष्य टोकन को विभाजित करने में सक्षम होना पसंद करते हैं। लोगों द्वारा मुद्रा के लिए सोने को अपनाने का एक कारण यह था कि
+जब कोई गाय के मूल्य की बत्तख खरीदना चाहता था तो छुट्टे बनाना मुश्किल था।
+
+समाधान पूर्णांकों का ट्रैक रखना है, लेकिन वास्तविक टोकन के बजाय एक भिन्नात्मक टोकन की गणना करना है जो
+लगभग बेकार है। ईथर के मामले में, भिन्नात्मक टोकन को wei कहा जाता है, और 10^18 wei एक
+ETH के बराबर होता है। लिखते समय, 10,000,000,000,000 wei लगभग एक अमेरिकी या यूरो सेंट के बराबर है।
+
+एप्लिकेशन को यह जानना होगा कि टोकन बैलेंस कैसे प्रदर्शित करें। यदि किसी उपयोगकर्ता के पास 3,141,000,000,000,000,000 wei है, तो क्या वह
+3.14 ETH है? 31.41 ETH? 3,141 ETH? ईथर के मामले में इसे ETH के लिए 10^18 wei परिभाषित किया गया है, लेकिन अपने
+टोकन के लिए आप एक अलग मान चुन सकते हैं। यदि टोकन को विभाजित करने का कोई मतलब नहीं है, तो आप शून्य के `_decimals` मान का उपयोग कर सकते हैं। यदि आप ETH के समान मानक का उपयोग करना चाहते हैं, तो मान **18** का उपयोग करें।
+
+### कंस्ट्रक्टर {#the-constructor}
+
+```solidity
+ /**
+ * @dev {नाम} और {प्रतीक} के लिए मान सेट करता है, {दशमलव} को
+ * 18 के डिफ़ॉल्ट मान के साथ प्रारंभ करता है।
+ *
+ * {दशमलव} के लिए एक अलग मान का चयन करने के लिए, {_setupDecimals} का उपयोग करें।
+ *
+ * ये तीनों मान अपरिवर्तनीय हैं: इन्हें
+ * निर्माण के दौरान केवल एक बार सेट किया जा सकता है।
+ */
+ constructor (string memory name_, string memory symbol_) public {
+ // सॉलिडिटी ≥0.7.0 में, 'पब्लिक' अंतर्निहित है और इसे छोड़ा जा सकता है।
+
+ _name = name_;
+ _symbol = symbol_;
+ _decimals = 18;
+ }
+```
+
+कंस्ट्रक्टर को तब कॉल किया जाता है जब अनुबंध पहली बार बनाया जाता है। परंपरा के अनुसार, फ़ंक्शन पैरामीटर का नाम `_` होता है।
+
+### यूज़र इंटरफ़ेस फ़ंक्शंस {#user-interface-functions}
+
+```solidity
+ /**
+ * @dev टोकन का नाम लौटाता है।
+ */
+ function name() public view returns (string memory) {
+ return _name;
+ }
+
+ /**
+ * @dev टोकन का प्रतीक लौटाता है, जो आमतौर पर नाम का एक
+ * छोटा संस्करण होता है।
+ */
+ function symbol() public view returns (string memory) {
+ return _symbol;
+ }
+
+ /**
+ * @dev इसका उपयोगकर्ता प्रतिनिधित्व प्राप्त करने के लिए उपयोग किए जाने वाले दशमलव की संख्या लौटाता है।
+ * उदाहरण के लिए, यदि `दशमलव` `2` के बराबर है, तो `505` टोकन का बैलेंस
+ * उपयोगकर्ता को `5,05` (`505 / 10 ** 2`) के रूप में प्रदर्शित किया जाना चाहिए।
+ *
+ * टोकन आमतौर पर 18 के मान का विकल्प चुनते हैं, जो
+ * ईथर और वी के बीच के संबंध की नकल करता है। यह वह मान है जिसका उपयोग {ERC20} करता है, जब तक कि {_setupDecimals} को
+ * कॉल न किया जाए।
+ *
+ * ध्यान दें: यह जानकारी केवल _प्रदर्शन_ उद्देश्यों के लिए उपयोग की जाती है: यह
+ * अनुबंध के किसी भी अंकगणित को किसी भी तरह से प्रभावित नहीं करती है, जिसमें
+ * {IERC20-बैलेंसऑफ} और {IERC20-ट्रांसफर} शामिल हैं।
+ */
+ function decimals() public view returns (uint8) {
+ return _decimals;
+ }
+```
+
+ये फ़ंक्शन, `name`, `symbol`, और `decimals` उपयोगकर्ता इंटरफ़ेस को आपके अनुबंध के बारे में जानने में मदद करते हैं ताकि वे इसे ठीक से प्रदर्शित कर सकें।
+
+रिटर्न प्रकार `string memory` है, जिसका अर्थ है मेमोरी में संग्रहीत एक स्ट्रिंग लौटाना। वैरिएबल, जैसे
+स्ट्रिंग्स, तीन स्थानों पर संग्रहीत किए जा सकते हैं:
+
+| | जीवनकाल | अनुबंध एक्सेस | गैस लागत |
+| -------- | ----------- | ------------- | ------------------------------------------------------------------------------------ |
+| मेमोरी | फ़ंक्शन कॉल | पढ़ें/लिखें | दसियों या सैकड़ों (उच्च स्थानों के लिए उच्च) |
+| Calldata | फ़ंक्शन कॉल | केवल पढ़ें | रिटर्न प्रकार के रूप में उपयोग नहीं किया जा सकता है, केवल एक फ़ंक्शन पैरामीटर प्रकार |
+| स्टोरेज | बदलने तक | पढ़ें/लिखें | उच्च (पढ़ने के लिए 800, लिखने के लिए 20k) |
+
+इस मामले में, `memory` सबसे अच्छा विकल्प है।
+
+### टोकन जानकारी पढ़ें {#read-token-information}
+
+ये फ़ंक्शन हैं जो टोकन के बारे में जानकारी प्रदान करते हैं, या तो कुल आपूर्ति या किसी
+खाते का बैलेंस।
+
+```solidity
+ /**
+ * @dev {IERC20-totalSupply} देखें।
+ */
+ function totalSupply() public view override returns (uint256) {
+ return _totalSupply;
+ }
+```
+
+`totalSupply` फ़ंक्शन टोकन की कुल आपूर्ति लौटाता है।
+
+
+
+```solidity
+ /**
+ * @dev {IERC20-balanceOf} देखें।
+ */
+ function balanceOf(address account) public view override returns (uint256) {
+ return _balances[account];
+ }
+```
+
+किसी खाते का बैलेंस पढ़ें। ध्यान दें कि किसी को भी किसी और के खाते का
+बैलेंस प्राप्त करने की अनुमति है। इस जानकारी को छिपाने की कोशिश करने का कोई मतलब नहीं है, क्योंकि यह वैसे भी हर
+नोड पर उपलब्ध है। _ब्लॉकचेन पर कोई रहस्य नहीं है।_
+
+### टोकन स्थानांतरित करें {#transfer-tokens}
+
+```solidity
+ /**
+ * @dev {IERC20-ट्रांसफर} देखें।
+ *
+ * आवश्यकताएं:
+ *
+ * - `प्राप्तकर्ता` शून्य पता नहीं हो सकता है।
+ * - कॉलर के पास कम से कम `राशि` का बैलेंस होना चाहिए।
+ */
+ function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
+```
+
+`transfer` फ़ंक्शन को प्रेषक के खाते से किसी भिन्न खाते में टोकन स्थानांतरित करने के लिए कहा जाता है। ध्यान दें
+कि भले ही यह एक बूलियन मान लौटाता है, वह मान हमेशा **सत्य** होता है। यदि ट्रांसफर
+विफल हो जाता है तो अनुबंध कॉल को वापस कर देता है।
+
+
+
+```solidity
+ _transfer(_msgSender(), recipient, amount);
+ return true;
+ }
+```
+
+`_transfer` फ़ंक्शन वास्तविक कार्य करता है। यह एक निजी फ़ंक्शन है जिसे केवल
+अन्य अनुबंध कार्यों द्वारा ही कॉल किया जा सकता है। परंपरा के अनुसार निजी कार्यों का नाम `_` होता है, जो स्टेट
+वैरिएबल के समान है।
+
+आम तौर पर Solidity में हम संदेश भेजने वाले के लिए `msg.sender` का उपयोग करते हैं। हालांकि, यह
+[OpenGSN](http://opengsn.org/) को तोड़ता है। यदि हम अपने टोकन के साथ ईथरलेस लेनदेन की अनुमति देना चाहते हैं, तो हमें
+`_msgSender()` का उपयोग करने की आवश्यकता है। यह सामान्य लेनदेन के लिए `msg.sender` लौटाता है, लेकिन ईथरलेस के लिए
+मूल हस्ताक्षरकर्ता लौटाता है न कि उस अनुबंध को जिसने संदेश रिले किया था।
+
+### अलाउंस फ़ंक्शंस {#allowance-functions}
+
+ये फ़ंक्शन हैं जो अलाउंस की कार्यक्षमता को लागू करते हैं: `allowance`, `approve`, `transferFrom`,
+और `_approve`। इसके अतिरिक्त, OpenZeppelin कार्यान्वयन सुरक्षा में सुधार करने वाली कुछ सुविधाओं को शामिल करने के लिए मूल मानक से परे जाता है:
+`increaseAllowance`, और `decreaseAllowance`।
+
+#### अलाउंस फ़ंक्शन {#allowance}
+
+```solidity
+ /**
+ * @dev {IERC20-अलाउंस} देखें।
+ */
+ function allowance(address owner, address spender) public view virtual override returns (uint256) {
+ return _allowances[owner][spender];
+ }
+```
+
+`allowance` फ़ंक्शन सभी को किसी भी अलाउंस की जांच करने की अनुमति देता है।
+
+#### अप्रूव फ़ंक्शन {#approve}
+
+```solidity
+ /**
+ * @dev {IERC20-अनुमोदन} देखें।
+ *
+ * आवश्यकताएं:
+ *
+ * - `खर्च करने वाला` शून्य पता नहीं हो सकता।
+ */
+ function approve(address spender, uint256 amount) public virtual override returns (bool) {
+```
+
+इस फ़ंक्शन को अलाउंस बनाने के लिए कहा जाता है। यह ऊपर दिए गए `transfer` फ़ंक्शन के समान है:
+
+- फ़ंक्शन बस एक आंतरिक फ़ंक्शन (इस मामले में, `_approve`) को कॉल करता है जो वास्तविक कार्य करता है।
+- फ़ंक्शन या तो `true` (यदि सफल हो) लौटाता है या रिवर्ट करता है (यदि नहीं)।
+
+
+
+```solidity
+ _approve(_msgSender(), spender, amount);
+ return true;
+ }
+```
+
+हम उन जगहों की संख्या को कम करने के लिए आंतरिक कार्यों का उपयोग करते हैं जहां स्टेट परिवर्तन होते हैं। _कोई भी_ फ़ंक्शन जो
+स्टेट को बदलता है, एक संभावित सुरक्षा जोखिम है जिसकी सुरक्षा के लिए ऑडिट करने की आवश्यकता है। इस तरह हमारे गलत होने की संभावना कम होती है।
+
+#### transferFrom फ़ंक्शन {#transferFrom}
+
+यह वह फ़ंक्शन है जिसे एक स्पेंडर अलाउंस खर्च करने के लिए कॉल करता है। इसके लिए दो संचालन की आवश्यकता होती है: खर्च की जा रही राशि को
+स्थानांतरित करें और उस राशि से अलाउंस कम करें।
+
+```solidity
+ /**
+ * @dev {IERC20-transferFrom} देखें।
+ *
+ * अद्यतनित भत्ते को इंगित करने वाला एक {अनुमोदन} इवेंट उत्सर्जित करता है। यह
+ * EIP द्वारा आवश्यक नहीं है। {ERC20} की शुरुआत में नोट देखें।
+ *
+ * आवश्यकताएं:
+ *
+ * - `प्रेषक` और `प्राप्तकर्ता` शून्य पता नहीं हो सकते।
+ * - `प्रेषक` के पास कम से कम `राशि` का बैलेंस होना चाहिए।
+ * - कॉलर के पास कम से कम `राशि` के ``प्रेषक`` के टोकन के लिए भत्ता होना चाहिए।
+ */
+ function transferFrom(address sender, address recipient, uint256 amount) public virtual
+ override returns (bool) {
+ _transfer(sender, recipient, amount);
+```
+
+
+
+`a.sub(b, "संदेश")` फ़ंक्शन कॉल दो काम करता है। सबसे पहले, यह `a-b` की गणना करता है, जो नया अलाउंस है।
+दूसरा, यह जांचता है कि यह परिणाम नकारात्मक नहीं है। यदि यह नकारात्मक है तो कॉल दिए गए संदेश के साथ रिवर्ट हो जाता है। ध्यान दें कि जब कोई कॉल रिवर्ट होता है तो उस कॉल के दौरान पहले की गई कोई भी प्रोसेसिंग अनदेखा कर दी जाती है इसलिए हमें `_transfer` को
+पूर्ववत करने की आवश्यकता नहीं है।
+
+```solidity
+ _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount,
+ "ERC20: transfer amount exceeds allowance"));
+ return true;
+ }
+```
+
+#### OpenZeppelin सुरक्षा परिवर्धन {#openzeppelin-safety-additions}
+
+गैर-शून्य भत्ते को किसी अन्य गैर-शून्य मान पर सेट करना खतरनाक है,
+क्योंकि आप केवल अपने स्वयं के लेनदेन के क्रम को नियंत्रित करते हैं, किसी और के नहीं। कल्पना कीजिए कि आपके
+पास दो उपयोगकर्ता हैं, ऐलिस जो भोली है और बिल जो बेईमान है। ऐलिस बिल से कुछ सेवा चाहती है,
+जिसकी उसे लगता है कि कीमत पांच टोकन है - इसलिए वह बिल को पांच टोकन का भत्ता देती है।
+
+फिर कुछ बदलता है और बिल की कीमत दस टोकन तक बढ़ जाती है। ऐलिस, जो अभी भी सेवा चाहती है,
+एक लेनदेन भेजती है जो बिल के भत्ते को दस पर सेट करती है। जिस क्षण बिल इस नए लेनदेन को
+लेनदेन पूल में देखता है, वह एक लेनदेन भेजता है जो ऐलिस के पांच टोकन खर्च करता है और इसकी गैस
+कीमत बहुत अधिक होती है ताकि इसे तेजी से माइन किया जा सके। इस तरह बिल पहले पांच टोकन खर्च कर सकता है और फिर,
+एक बार जब ऐलिस का नया भत्ता माइन हो जाता है, तो पंद्रह टोकन की कुल कीमत के लिए दस और खर्च कर सकता है, जो ऐलिस
+द्वारा अधिकृत करने का इरादा था। इस तकनीक को
+[फ्रंट-रनिंग](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/#front-running) कहा जाता है
+
+| ऐलिस लेनदेन | ऐलिस नॉन्स | बिल लेनदेन | बिल नॉन्स | बिल का भत्ता | ऐलिस से बिल की कुल आय |
+| ------------------------------------ | ---------- | ------------------------------------------------ | --------- | ------------ | --------------------- |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| | | transferFrom(Alice, Bill, 5) | 10,123 | 0 | 5 |
+| approve(Bill, 10) | 11 | | | 10 | 5 |
+| | | transferFrom(Alice, Bill, 10) | 10,124 | 0 | 15 |
+
+इस समस्या से बचने के लिए, ये दो फ़ंक्शन (`increaseAllowance` और `decreaseAllowance`) आपको
+एक विशिष्ट राशि से भत्ते को संशोधित करने की अनुमति देते हैं। तो अगर बिल ने पहले ही पांच टोकन खर्च कर दिए थे, तो वह सिर्फ
+पांच और खर्च कर पाएगा। समय के आधार पर, यह दो तरीकों से काम कर सकता है, दोनों में
+बिल को केवल दस टोकन मिलते हैं:
+
+A:
+
+| ऐलिस लेनदेन | ऐलिस नॉन्स | बिल लेनदेन | बिल नॉन्स | बिल का भत्ता | ऐलिस से बिल की कुल आय |
+| --------------------------------------------- | ---------: | ----------------------------------------------- | --------: | -----------: | --------------------- |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| | | transferFrom(Alice, Bill, 5) | 10,123 | 0 | 5 |
+| increaseAllowance(Bill, 5) | 11 | | | 0+5 = 5 | 5 |
+| | | transferFrom(Alice, Bill, 5) | 10,124 | 0 | 10 |
+
+B:
+
+| ऐलिस लेनदेन | ऐलिस नॉन्स | बिल लेनदेन | बिल नॉन्स | बिल का भत्ता | ऐलिस से बिल की कुल आय |
+| --------------------------------------------- | ---------: | ------------------------------------------------ | --------: | -----------: | --------------------: |
+| approve(Bill, 5) | 10 | | | 5 | 0 |
+| increaseAllowance(Bill, 5) | 11 | | | 5+5 = 10 | 0 |
+| | | transferFrom(Alice, Bill, 10) | 10,124 | 0 | 10 |
+
+```solidity
+ /**
+ * @dev कॉलर द्वारा `spender` को दिए गए भत्ते को स्वचालित रूप से बढ़ाता है।
+ *
+ * यह {approve} का एक विकल्प है जिसका उपयोग {IERC20-approve} में वर्णित समस्याओं के शमन के रूप में किया जा सकता है।
+ *
+ * अद्यतनित भत्ते को इंगित करने वाला एक {अनुमोदन} इवेंट उत्सर्जित करता है।
+ *
+ * आवश्यकताएं:
+ *
+ * - `खर्च करने वाला` शून्य पता नहीं हो सकता।
+ */
+ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
+ _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
+ return true;
+ }
+```
+
+`a.add(b)` फ़ंक्शन एक सुरक्षित जोड़ है। इस असंभावित मामले में कि `a`+`b`>=`2^256` यह उस तरह से
+लपेटता नहीं है जिस तरह से सामान्य जोड़ होता है।
+
+```solidity
+
+ /**
+ * @dev कॉलर द्वारा `spender` को दिए गए भत्ते को स्वचालित रूप से घटाता है।
+ *
+ * यह {approve} का एक विकल्प है जिसका उपयोग {IERC20-approve} में वर्णित समस्याओं के शमन के रूप में किया जा सकता है।
+ *
+ * अद्यतनित भत्ते को इंगित करने वाला एक {अनुमोदन} इवेंट उत्सर्जित करता है।
+ *
+ * आवश्यकताएं:
+ *
+ * - `खर्च करने वाला` शून्य पता नहीं हो सकता।
+ * - `खर्च करने वाले` के पास कम से कम
+ * `घटाए गए मान` के कॉलर के लिए भत्ता होना चाहिए।
+ */
+ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
+ _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue,
+ "ERC20: शून्य से नीचे घटा हुआ भत्ता"));
+ return true;
+ }
+```
+
+### टोकन जानकारी को संशोधित करने वाले फ़ंक्शंस {#functions-that-modify-token-information}
+
+ये चार फ़ंक्शन हैं जो वास्तविक कार्य करते हैं: `_transfer`, `_mint`, `_burn`, और `_approve`।
+
+#### _transfer फ़ंक्शन {#_transfer}
+
+```solidity
+ /**
+ * @dev टोकन `राशि` को `प्रेषक` से `प्राप्तकर्ता` तक ले जाता है।
+ *
+ * यह आंतरिक फ़ंक्शन {ट्रांसफर} के बराबर है, और इसका उपयोग
+ * उदा., स्वचालित टोकन शुल्क, स्लेशिंग तंत्र, आदि को लागू करने के लिए किया जा सकता है।
+ *
+ * एक {ट्रांसफर} इवेंट उत्सर्जित करता है।
+ *
+ * आवश्यकताएं:
+ *
+ * - `प्रेषक` शून्य पता नहीं हो सकता।
+ * - `प्राप्तकर्ता` शून्य पता नहीं हो सकता।
+ * - `प्रेषक` के पास कम से कम `राशि` का बैलेंस होना चाहिए।
+ */
+ function _transfer(address sender, address recipient, uint256 amount) internal virtual {
+```
+
+यह फ़ंक्शन, `_transfer`, एक खाते से दूसरे खाते में टोकन स्थानांतरित करता है। इसे दोनों
+`transfer` (प्रेषक के अपने खाते से स्थानांतरण के लिए) और `transferFrom` (किसी और के खाते से स्थानांतरण के लिए भत्ते का उपयोग करने के लिए) द्वारा कॉल किया जाता है।
+
+
+
+```solidity
+ require(sender != address(0), "ERC20: transfer from the zero address");
+ require(recipient != address(0), "ERC20: transfer to the zero address");
+```
+
+एथेरियम में कोई भी वास्तव में शून्य पते का मालिक नहीं है (यानी, कोई भी ऐसी निजी कुंजी नहीं जानता है जिसकी मिलान सार्वजनिक कुंजी
+शून्य पते में बदल जाती है)। जब लोग उस पते का उपयोग करते हैं, तो यह आमतौर पर एक सॉफ्टवेयर बग होता है - इसलिए हम
+विफल हो जाते हैं यदि शून्य पते का उपयोग प्रेषक या प्राप्तकर्ता के रूप में किया जाता है।
+
+
+
+```solidity
+ _beforeTokenTransfer(sender, recipient, amount);
+
+```
+
+इस अनुबंध का उपयोग करने के दो तरीके हैं:
+
+1. इसे अपने स्वयं के कोड के लिए एक टेम्पलेट के रूप में उपयोग करें
+2. [इससे इनहेरिट करें](https://www.bitdegree.org/learn/solidity-inheritance), और केवल उन फ़ंक्शंस को ओवरराइड करें जिन्हें आपको संशोधित करने की आवश्यकता है
+
+दूसरा तरीका बहुत बेहतर है क्योंकि OpenZeppelin ERC-20 कोड का पहले ही ऑडिट किया जा चुका है और इसे सुरक्षित दिखाया गया है। जब आप इनहेरिटेंस का उपयोग करते हैं
+तो यह स्पष्ट होता है कि आप किन फ़ंक्शंस को संशोधित करते हैं, और आपके अनुबंध पर भरोसा करने के लिए लोगों को केवल उन विशिष्ट फ़ंक्शंस का ऑडिट करने की आवश्यकता होती है।
+
+हर बार जब टोकन का आदान-प्रदान होता है तो एक फ़ंक्शन करना अक्सर उपयोगी होता है। हालांकि, `_transfer` एक बहुत ही महत्वपूर्ण फ़ंक्शन है और इसे
+असुरक्षित रूप से लिखना संभव है (नीचे देखें), इसलिए इसे ओवरराइड न करना सबसे अच्छा है। समाधान `_beforeTokenTransfer` है, एक
+[हुक फ़ंक्शन](https://wikipedia.org/wiki/Hooking)। आप इस फ़ंक्शन को ओवरराइड कर सकते हैं, और इसे प्रत्येक ट्रांसफर पर कॉल किया जाएगा।
+
+
+
+```solidity
+ _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+ _balances[recipient] = _balances[recipient].add(amount);
+```
+
+ये वे पंक्तियाँ हैं जो वास्तव में स्थानांतरण करती हैं। ध्यान दें कि उनके बीच **कुछ भी नहीं** है, और हम प्राप्तकर्ता को जोड़ने से पहले प्रेषक से
+स्थानांतरित राशि घटाते हैं। यह महत्वपूर्ण है क्योंकि अगर बीच में किसी
+अलग अनुबंध को कॉल किया गया होता, तो इसका उपयोग इस अनुबंध को धोखा देने के लिए किया जा सकता था। इस तरह ट्रांसफर
+परमाणु होता है, इसके बीच में कुछ भी नहीं हो सकता है।
+
+
+
+```solidity
+ emit Transfer(sender, recipient, amount);
+ }
+```
+
+अंत में, एक `ट्रांसफर` इवेंट उत्सर्जित करें। इवेंट स्मार्ट अनुबंधों के लिए सुलभ नहीं हैं, लेकिन ब्लॉकचेन के बाहर चलने वाला कोड
+इवेंट को सुन सकता है और उन पर प्रतिक्रिया कर सकता है। उदाहरण के लिए, एक वॉलेट ट्रैक रख सकता है कि मालिक को अधिक टोकन कब मिलते हैं।
+
+#### _mint और _burn फ़ंक्शंस {#_mint-and-_burn}
+
+ये दो फ़ंक्शन (`_mint` और `_burn`) टोकन की कुल आपूर्ति को संशोधित करते हैं।
+वे आंतरिक हैं और इस अनुबंध में उन्हें कॉल करने वाला कोई फ़ंक्शन नहीं है,
+इसलिए वे केवल तभी उपयोगी होते हैं जब आप अनुबंध से इनहेरिट करते हैं और यह तय करने के लिए अपना स्वयं का
+तर्क जोड़ते हैं कि किन परिस्थितियों में नए टोकन मिंट करने हैं या मौजूदा
+को बर्न करना है।
+
+**ध्यान दें:** प्रत्येक ERC-20 टोकन का अपना व्यावसायिक तर्क होता है जो टोकन प्रबंधन को निर्धारित करता है।
+उदाहरण के लिए, एक निश्चित आपूर्ति अनुबंध केवल कंस्ट्रक्टर में
+`_mint` को कॉल कर सकता है और कभी भी `_burn` को कॉल नहीं कर सकता है। एक अनुबंध जो टोकन बेचता है,
+जब इसका भुगतान किया जाता है तो `_mint` को कॉल करेगा, और संभवतः किसी बिंदु पर `_burn` को कॉल करेगा
+ताकि भगोड़ा मुद्रास्फीति से बचा जा सके।
+
+```solidity
+ /** @dev `राशि` टोकन बनाता है और उन्हें `खाते` को सौंपता है, जिससे
+ * कुल आपूर्ति बढ़ जाती है।
+ *
+ * `from` को शून्य पते पर सेट करके एक {Transfer} इवेंट उत्सर्जित करता है।
+ *
+ * आवश्यकताएं:
+ *
+ * - `to` शून्य पता नहीं हो सकता है।
+ */
+ function _mint(address account, uint256 amount) internal virtual {
+ require(account != address(0), "ERC20: mint to the zero address");
+ _beforeTokenTransfer(address(0), account, amount);
+ _totalSupply = _totalSupply.add(amount);
+ _balances[account] = _balances[account].add(amount);
+ emit Transfer(address(0), account, amount);
+ }
+```
+
+जब टोकन की कुल संख्या बदलती है तो `_totalSupply` को अपडेट करना सुनिश्चित करें।
+
+
+
+```solidity
+ /**
+ * @dev `खाते` से `राशि` टोकन को नष्ट कर देता है, जिससे
+ * कुल आपूर्ति कम हो जाती है।
+ *
+ * `to` को शून्य पते पर सेट करके एक {Transfer} इवेंट उत्सर्जित करता है।
+ *
+ * आवश्यकताएं:
+ *
+ * - `खाता` शून्य पता नहीं हो सकता है।
+ * - `खाते` में कम से कम `राशि` टोकन होने चाहिए।
+ */
+ function _burn(address account, uint256 amount) internal virtual {
+ require(account != address(0), "ERC20: burn from the zero address");
+
+ _beforeTokenTransfer(account, address(0), amount);
+
+ _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
+ _totalSupply = _totalSupply.sub(amount);
+ emit Transfer(account, address(0), amount);
+ }
+```
+
+`_burn` फ़ंक्शन लगभग `_mint` के समान है, सिवाय इसके कि यह दूसरी दिशा में जाता है।
+
+#### _approve फ़ंक्शन {#_approve}
+
+यह वह फ़ंक्शन है जो वास्तव में अलाउंस निर्दिष्ट करता है। ध्यान दें कि यह एक मालिक को एक भत्ता निर्दिष्ट करने की अनुमति देता है
+जो मालिक के वर्तमान बैलेंस से अधिक है। यह ठीक है क्योंकि बैलेंस ट्रांसफर के समय जांचा जाता है,
+जब यह अलाउंस बनाए जाने पर बैलेंस से अलग हो सकता है।
+
+```solidity
+ /**
+ * @dev `मालिक` के टोकन पर `खर्च करने वाले` के भत्ते के रूप में `राशि` सेट करता है।
+ *
+ * यह आंतरिक फ़ंक्शन `approve` के बराबर है, और इसका उपयोग
+ * उदा., कुछ सबसिस्टम के लिए स्वचालित भत्ते सेट करने आदि के लिए किया जा सकता है।
+ *
+ * एक {Approval} इवेंट उत्सर्जित करता है।
+ *
+ * आवश्यकताएं:
+ *
+ * - `मालिक` शून्य पता नहीं हो सकता।
+ * - `खर्च करने वाला` शून्य पता नहीं हो सकता।
+ */
+ function _approve(address owner, address spender, uint256 amount) internal virtual {
+ require(owner != address(0), "ERC20: approve from the zero address");
+ require(spender != address(0), "ERC20: approve to the zero address");
+
+ _allowances[owner][spender] = amount;
+```
+
+
+
+`अनुमोदन` इवेंट उत्सर्जित करें। एप्लिकेशन कैसे लिखा जाता है, इसके आधार पर, खर्च करने वाले अनुबंध को
+अनुमोदन के बारे में या तो मालिक द्वारा या इन घटनाओं को सुनने वाले सर्वर द्वारा बताया जा सकता है।
+
+```solidity
+ emit Approval(owner, spender, amount);
+ }
+
+```
+
+### दशमलव वैरिएबल को संशोधित करें {#modify-the-decimals-variable}
+
+```solidity
+
+
+ /**
+ * @dev {दशमलव} को 18 के डिफ़ॉल्ट मान के अलावा किसी अन्य मान पर सेट करता है।
+ *
+ * चेतावनी: इस फ़ंक्शन को केवल कंस्ट्रक्टर से ही कॉल किया जाना चाहिए। अधिकांश
+ * एप्लिकेशन जो टोकन अनुबंधों के साथ इंटरैक्ट करते हैं, वे
+ * {दशमलव} के कभी भी बदलने की उम्मीद नहीं करेंगे, और यदि ऐसा होता है तो वे गलत तरीके से काम कर सकते हैं।
+ */
+ function _setupDecimals(uint8 decimals_) internal {
+ _decimals = decimals_;
+ }
+```
+
+यह फ़ंक्शन `_decimals` वैरिएबल को संशोधित करता है जिसका उपयोग उपयोगकर्ता इंटरफ़ेस को यह बताने के लिए किया जाता है कि राशि की व्याख्या कैसे करें।
+आपको इसे कंस्ट्रक्टर से कॉल करना चाहिए। किसी भी बाद के बिंदु पर इसे कॉल करना बेईमानी होगी, और एप्लिकेशन
+इसे संभालने के लिए डिज़ाइन नहीं किए गए हैं।
+
+### हुक्स {#hooks}
+
+```solidity
+
+ /**
+ * @dev टोकन के किसी भी हस्तांतरण से पहले कॉल किया जाने वाला हुक। इसमें
+ * मिंटिंग और बर्निंग शामिल है।
+ *
+ * कॉलिंग की शर्तें:
+ *
+ * - जब `from` और `to` दोनों गैर-शून्य हों, तो ``from`` के टोकन की `राशि`
+ * `to` को हस्तांतरित की जाएगी।
+ * - जब `from` शून्य हो, तो `to` के लिए `राशि` टोकन बनाए जाएंगे।
+ * - जब `to` शून्य हो, तो ``from`` के टोकन की `राशि` जला दी जाएगी।
+ * - `from` और `to` दोनों कभी भी शून्य नहीं होते हैं।
+ *
+ * हुक के बारे में अधिक जानने के लिए, xref:ROOT:extending-contracts.adoc#using-hooks[हुक का उपयोग करना] पर जाएं।
+ */
+ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
+}
+```
+
+यह ट्रांसफर के दौरान कॉल किया जाने वाला हुक फ़ंक्शन है। यह यहाँ खाली है, लेकिन अगर आपको इसकी
+आवश्यकता है तो आप इसे बस ओवरराइड करें।
+
+## निष्कर्ष {#conclusion}
+
+समीक्षा के लिए, यहां इस अनुबंध में कुछ सबसे महत्वपूर्ण विचार दिए गए हैं (मेरी राय में, आपका अलग होने की संभावना है):
+
+- यह कई मामलों में महत्वपूर्ण है, लेकिन यहां नहीं।ब्लॉकचेन पर कोई रहस्य नहीं हैं। कोई भी जानकारी जिसे एक स्मार्ट अनुबंध एक्सेस कर सकता है,
+ पूरी दुनिया के लिए उपलब्ध है।
+- आप अपने स्वयं के लेनदेन के क्रम को नियंत्रित कर सकते हैं, लेकिन यह नहीं कि दूसरे लोगों का लेनदेन
+ कब होता है। यही कारण है कि एक भत्ता बदलना खतरनाक हो सकता है, क्योंकि यह
+ खर्च करने वाले को दोनों भत्तों का योग खर्च करने देता है।
+- `uint256` प्रकार के मान रैप अराउंड होते हैं। दूसरे शब्दों में, _0-1=2^256-1_। यदि वह वांछित
+ व्यवहार नहीं है, तो आपको इसकी जांच करनी होगी (या SafeMath लाइब्रेरी का उपयोग करें जो आपके लिए ऐसा करती है)। ध्यान दें कि यह
+ [Solidity 0.8.0](https://docs.soliditylang.org/en/breaking/080-breaking-changes.html) में बदल गया।
+- एक विशिष्ट प्रकार के सभी स्टेट परिवर्तन एक विशिष्ट स्थान पर करें, क्योंकि इससे ऑडिटिंग आसान हो जाती है।
+ यही कारण है कि हमारे पास, उदाहरण के लिए, `_approve` है, जिसे `approve`, `transferFrom`,
+ `increaseAllowance`, और `decreaseAllowance` द्वारा कॉल किया जाता है।
+- स्टेट परिवर्तन परमाणु होने चाहिए, उनके बीच कोई अन्य क्रिया नहीं होनी चाहिए (जैसा कि आप
+ `_transfer` में देख सकते हैं)। ऐसा इसलिए है क्योंकि स्टेट परिवर्तन के दौरान आपकी एक असंगत स्टेट होती है। उदाहरण के लिए,
+ प्रेषक के बैलेंस से कटौती करने और
+ प्राप्तकर्ता के बैलेंस में जोड़ने के समय के बीच, अस्तित्व में होने चाहिए उससे कम टोकन होते हैं। इसका संभावित रूप से दुरुपयोग किया जा सकता है यदि उनके
+ बीच संचालन हों, विशेष रूप से एक अलग अनुबंध को कॉल।
+
+अब जब आपने देख लिया है कि OpenZeppelin ERC-20 अनुबंध कैसे लिखा जाता है, और विशेष रूप से इसे कैसे
+अधिक सुरक्षित बनाया जाता है, तो जाएं और अपने स्वयं के सुरक्षित अनुबंध और एप्लिकेशन लिखें।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/erc20-with-safety-rails/index.md b/public/content/translations/hi/developers/tutorials/erc20-with-safety-rails/index.md
new file mode 100644
index 00000000000..4a12b8c39bd
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/erc20-with-safety-rails/index.md
@@ -0,0 +1,217 @@
+---
+title: "सेफ्टी रेल्स के साथ ERC-20"
+description: "लोगों को मूर्खतापूर्ण गलतियों से बचने में कैसे मदद करें"
+author: "ओरी पोमेरेन्ट्ज़"
+lang: hi
+tags: [ "erc-20" ]
+skill: beginner
+published: 2022-08-15
+---
+
+## परिचय {#introduction}
+
+एथेरियम के बारे में एक बड़ी बात यह है कि कोई भी केंद्रीय प्राधिकरण नहीं है जो आपके लेनदेन को संशोधित या पूर्ववत कर सकता है। एथेरियम के साथ एक बड़ी समस्या यह है कि यूज़र की गलतियों या अवैध लेनदेन को पूर्ववत करने की शक्ति वाला कोई केंद्रीय प्राधिकरण नहीं है। इस लेख में आप उन कुछ सामान्य गलतियों के बारे में जानेंगे जो यूज़र [ERC-20](/developers/docs/standards/tokens/erc-20/) टोकन के साथ करते हैं, साथ ही यह भी जानेंगे कि ERC-20 अनुबंध कैसे बनाएं जो यूज़र को उन गलतियों से बचने में मदद करते हैं, या जो एक केंद्रीय प्राधिकरण को कुछ शक्ति देते हैं (उदाहरण के लिए खातों को फ्रीज करने के लिए)।
+
+ध्यान दें कि जब हम [OpenZeppelin ERC-20 टोकन अनुबंध](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20) का उपयोग करेंगे, तो यह लेख इसे बहुत विस्तार से नहीं समझाता है। आप यह जानकारी [यहां](/developers/tutorials/erc20-annotated-code) पा सकते हैं।
+
+यदि आप पूरा सोर्स कोड देखना चाहते हैं:
+
+1. [Remix IDE](https://remix.ethereum.org/) खोलें।
+2. क्लोन github आइकन () पर क्लिक करें।
+3. Github रिपॉजिटरी `https://github.com/qbzzt/20220815-erc20-safety-rails` को क्लोन करें।
+4. **contracts > erc20-safety-rails.sol** खोलें।
+
+## एक ERC-20 अनुबंध बनाना {#creating-an-erc-20-contract}
+
+इससे पहले कि हम सेफ्टी रेल कार्यक्षमता जोड़ सकें, हमें एक ERC-20 अनुबंध की आवश्यकता है। इस लेख में हम [the OpenZeppelin Contracts Wizard](https://docs.openzeppelin.com/contracts/5.x/wizard) का उपयोग करेंगे। इसे दूसरे ब्राउज़र में खोलें और इन निर्देशों का पालन करें:
+
+1. **ERC20** चुनें।
+
+2. ये सेटिंग्स दर्ज करें:
+
+ | पैरामीटर | मूल्य |
+ | -------------- | ---------------- |
+ | नाम | SafetyRailsToken |
+ | प्रतीक | SAFE |
+ | प्रीमिंट | 1000 |
+ | विशेषताएँ | कोई नहीं |
+ | एक्सेस कंट्रोल | Ownable |
+ | अपग्रेडेबिलिटी | कोई नहीं |
+
+3. ऊपर स्क्रॉल करें और **Remix में खोलें** (Remix के लिए) पर क्लिक करें या एक अलग वातावरण का उपयोग करने के लिए **डाउनलोड** करें। मैं यह मान लूंगा कि आप Remix का उपयोग कर रहे हैं, यदि आप कुछ और उपयोग करते हैं तो बस उपयुक्त परिवर्तन करें।
+
+4. अब हमारे पास एक पूरी तरह से कार्यात्मक ERC-20 अनुबंध है। आयातित कोड देखने के लिए आप `.deps` > `npm` का विस्तार कर सकते हैं।
+
+5. यह देखने के लिए अनुबंध को संकलित करें, डिप्लॉय करें और उसके साथ प्रयोग करें कि यह एक ERC-20 अनुबंध के रूप में कार्य करता है। अगर आपको Remix का उपयोग करना सीखना है, तो [इस ट्यूटोरियल का उपयोग करें](https://remix.ethereum.org/?#activate=udapp,solidity,LearnEth)।
+
+## आम गलतियाँ {#common-mistakes}
+
+### गलतियाँ {#the-mistakes}
+
+यूज़र कभी-कभी गलत पते पर टोकन भेज देते हैं। हालांकि हम यह जानने के लिए उनके मन को नहीं पढ़ सकते कि वे क्या करना चाहते थे, दो प्रकार की त्रुटियां हैं जो बहुत होती हैं और जिनका पता लगाना आसान है:
+
+1. टोकन को अनुबंध के अपने पते पर भेजना। उदाहरण के लिए, [Optimism का OP टोकन](https://optimism.mirror.xyz/qvd0WfuLKnePm1Gxb9dpGchPf5uDz5NSMEFdgirDS4c) दो महीने से भी कम समय में [120,000 से अधिक](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000042) OP टोकन जमा करने में कामयाब रहा। यह एक महत्वपूर्ण मात्रा में धन का प्रतिनिधित्व करता है जिसे संभवतः लोगों ने खो दिया है।
+
+2. टोकन को एक खाली पते पर भेजना, जो [बाहरी स्वामित्व वाले खाते](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs) या [स्मार्ट अनुबंध](/developers/docs/smart-contracts) से मेल नहीं खाता है। हालांकि मेरे पास इस बारे में आंकड़े नहीं हैं कि ऐसा कितनी बार होता है, [एक घटना में 20,000,000 टोकन की लागत आ सकती थी](https://gov.optimism.io/t/message-to-optimism-community-from-wintermute/2595)।
+
+### स्थानांतरण को रोकना {#preventing-transfers}
+
+OpenZeppelin ERC-20 अनुबंध में [एक हुक, `_beforeTokenTransfer`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol#L364-L368) शामिल है, जिसे टोकन स्थानांतरित होने से पहले कॉल किया जाता है। डिफ़ॉल्ट रूप से यह हुक कुछ भी नहीं करता है, लेकिन हम इस पर अपनी खुद की कार्यक्षमता लटका सकते हैं, जैसे कि जांच जो कोई समस्या होने पर रिवर्ट हो जाती है।
+
+हुक का उपयोग करने के लिए, कंस्ट्रक्टर के बाद इस फ़ंक्शन को जोड़ें:
+
+```solidity
+ function _beforeTokenTransfer(address from, address to, uint256 amount)
+ internal virtual
+ override(ERC20)
+ {
+ super._beforeTokenTransfer(from, to, amount);
+ }
+```
+
+यदि आप Solidity से बहुत परिचित नहीं हैं तो इस फ़ंक्शन के कुछ हिस्से नए हो सकते हैं:
+
+```solidity
+ internal virtual
+```
+
+`virtual` कीवर्ड का मतलब है कि जैसे हमने `ERC20` से कार्यक्षमता विरासत में ली है और इस फ़ंक्शन को ओवरराइड किया है, वैसे ही अन्य अनुबंध हमसे विरासत में ले सकते हैं और इस फ़ंक्शन को ओवरराइड कर सकते हैं।
+
+```solidity
+ override(ERC20)
+```
+
+हमें स्पष्ट रूप से निर्दिष्ट करना होगा कि हम `_beforeTokenTransfer` की ERC20 टोकन परिभाषा को [ओवरराइड](https://docs.soliditylang.org/en/v0.8.15/contracts.html#function-overriding) कर रहे हैं। सामान्य तौर पर, सुरक्षा के दृष्टिकोण से, स्पष्ट परिभाषाएँ अंतर्निहित परिभाषाओं की तुलना में बहुत बेहतर होती हैं - आप यह नहीं भूल सकते कि आपने कुछ किया है यदि यह आपके ठीक सामने है। यही कारण है कि हमें यह निर्दिष्ट करने की आवश्यकता है कि हम किस सुपरक्लास के `_beforeTokenTransfer` को ओवरराइड कर रहे हैं।
+
+```solidity
+ super._beforeTokenTransfer(from, to, amount);
+```
+
+यह लाइन उस अनुबंध या अनुबंधों के `_beforeTokenTransfer` फ़ंक्शन को कॉल करती है जिससे हमने इसे विरासत में लिया है। इस मामले में, वह केवल `ERC20` है, `Ownable` में यह हुक नहीं है। भले ही वर्तमान में `ERC20._beforeTokenTransfer` कुछ भी नहीं करता है, हम इसे भविष्य में कार्यक्षमता जोड़े जाने की स्थिति में कॉल करते हैं (और फिर हम अनुबंध को फिर से डिप्लॉय करने का निर्णय लेते हैं, क्योंकि डिप्लॉयमेंट के बाद अनुबंध नहीं बदलते हैं)।
+
+### आवश्यकताओं को कोडिंग करना {#coding-the-requirements}
+
+हम इन आवश्यकताओं को फ़ंक्शन में जोड़ना चाहते हैं:
+
+- `to` पता `address(this)` के बराबर नहीं हो सकता है, जो कि स्वयं ERC-20 अनुबंध का पता है।
+- `to` पता खाली नहीं हो सकता, यह या तो होना चाहिए:
+ - एक बाहरी स्वामित्व वाला खाता (EOA)। हम सीधे यह नहीं जांच सकते कि कोई पता EOA है या नहीं, लेकिन हम किसी पते का ETH बैलेंस देख सकते हैं। EOA में लगभग हमेशा एक बैलेंस होता है, भले ही उनका अब उपयोग नहीं किया जाता हो - उन्हें आखिरी wei तक साफ़ करना मुश्किल है।
+ - एक स्मार्ट अनुबंध। यह परीक्षण करना कि कोई पता स्मार्ट अनुबंध है या नहीं, थोड़ा कठिन है। एक ऑपकोड है जो बाहरी कोड की लंबाई की जांच करता है, जिसे [`EXTCODESIZE`](https://www.evm.codes/#3b) कहा जाता है, लेकिन यह सीधे Solidity में उपलब्ध नहीं है। इसके लिए हमें [Yul](https://docs.soliditylang.org/en/v0.8.15/yul.html) का उपयोग करना होगा, जो कि EVM असेंबली है। Solidity से अन्य मान हैं जिनका हम उपयोग कर सकते हैं ([`.code` और `.codehash`](https://docs.soliditylang.org/en/v0.8.15/units-and-global-variables.html#members-of-address-types)), लेकिन उनकी लागत अधिक है।
+
+आइए नए कोड को लाइन दर लाइन देखें:
+
+```solidity
+ require(to != address(this), "अनुबंध पते पर टोकन नहीं भेज सकते");
+```
+
+यह पहली आवश्यकता है, जांचें कि `to` और `this(address)` एक ही चीज़ नहीं हैं।
+
+```solidity
+ bool isToContract;
+ assembly {
+ isToContract := gt(extcodesize(to), 0)
+ }
+```
+
+इस तरह हम जांचते हैं कि कोई पता एक अनुबंध है या नहीं। हम सीधे Yul से आउटपुट प्राप्त नहीं कर सकते हैं, इसलिए इसके बजाय हम परिणाम रखने के लिए एक चर परिभाषित करते हैं (इस मामले में `isToContract`)। Yul के काम करने का तरीका यह है कि प्रत्येक ऑपकोड को एक फ़ंक्शन माना जाता है। तो पहले हम अनुबंध का आकार प्राप्त करने के लिए [`EXTCODESIZE`](https://www.evm.codes/#3b) को कॉल करते हैं, और फिर यह जांचने के लिए [`GT`](https://www.evm.codes/#11) का उपयोग करते हैं कि यह शून्य नहीं है (हम अहस्ताक्षरित पूर्णांकों के साथ काम कर रहे हैं, इसलिए निश्चित रूप से यह नकारात्मक नहीं हो सकता है)। फिर हम परिणाम को `isToContract` में लिखते हैं।
+
+```solidity
+ require(to.balance != 0 || isToContract, "खाली पते पर टोकन नहीं भेज सकते");
+```
+
+और अंत में, हमारे पास खाली पतों के लिए वास्तविक जांच है।
+
+## प्रशासनिक पहुंच {#admin-access}
+
+कभी-कभी एक प्रशासक होना उपयोगी होता है जो गलतियों को पूर्ववत कर सकता है। दुरुपयोग की संभावना को कम करने के लिए, यह प्रशासक एक [मल्टीसिग](https://blog.logrocket.com/security-choices-multi-signature-wallets/) हो सकता है ताकि कई लोगों को एक कार्रवाई पर सहमत होना पड़े। इस लेख में हमारे पास दो प्रशासनिक सुविधाएँ होंगी:
+
+1. खातों को फ्रीज और अनफ्रीज करना। यह उपयोगी हो सकता है, उदाहरण के लिए, जब कोई खाता हैक हो सकता है।
+2. संपत्ति की सफाई।
+
+ कभी-कभी धोखेबाज वैधता हासिल करने के लिए वास्तविक टोकन के अनुबंध में धोखाधड़ी वाले टोकन भेजते हैं। उदाहरण के लिए, [यहां देखें](https://optimism.blockscout.com/token/0x2348B1a1228DDCd2dB668c3d30207c3E1852fBbe?tab=holders)। वैध ERC-20 अनुबंध [0x4200....0042](https://optimism.blockscout.com/token/0x4200000000000000000000000000000000000042) है। घोटाला जो यह होने का नाटक करता है वह [0x234....bbe](https://optimism.blockscout.com/token/0x2348B1a1228DDCd2dB668c3d30207c3E1852fBbe) है।
+
+ यह भी संभव है कि लोग गलती से हमारे अनुबंध में वैध ERC-20 टोकन भेज दें, जो उन्हें बाहर निकालने का एक तरीका चाहने का एक और कारण है।
+
+OpenZeppelin प्रशासनिक पहुंच को सक्षम करने के लिए दो तंत्र प्रदान करता है:
+
+- [`Ownable`](https://docs.openzeppelin.com/contracts/5.x/access-control#ownership-and-ownable) अनुबंधों का एक ही मालिक होता है। जिन फ़ंक्शंस में `onlyOwner` [संशोधक](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) होता है, उन्हें केवल उस स्वामी द्वारा ही कॉल किया जा सकता है। मालिक किसी और को स्वामित्व हस्तांतरित कर सकते हैं या इसे पूरी तरह से त्याग सकते हैं। अन्य सभी खातों के अधिकार आमतौर पर समान होते हैं।
+- [`AccessControl`](https://docs.openzeppelin.com/contracts/5.x/access-control#role-based-access-control) अनुबंधों में [भूमिका आधारित अभिगम नियंत्रण (RBAC)](https://en.wikipedia.org/wiki/Role-based_access_control) होता है।
+
+सरलता के लिए, इस लेख में हम `Ownable` का उपयोग करते हैं।
+
+### अनुबंधों को फ्रीज और अनफ्रीज करना {#freezing-and-thawing-contracts}
+
+अनुबंधों को फ्रीज और अनफ्रीज करने के लिए कई बदलावों की आवश्यकता होती है:
+
+- [बूलियन](https://en.wikipedia.org/wiki/Boolean_data_type) के लिए पतों से एक [मैपिंग](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) यह ट्रैक करने के लिए कि कौन से पते फ्रीज हैं। सभी मान शुरू में शून्य होते हैं, जिसे बूलियन मानों के लिए गलत माना जाता है। यह वही है जो हम चाहते हैं क्योंकि डिफ़ॉल्ट रूप से खाते फ्रीज नहीं होते हैं।
+
+ ```solidity
+ mapping(address => bool) public frozenAccounts;
+ ```
+
+- [इवेंट्स](https://www.tutorialspoint.com/solidity/solidity_events.htm) किसी भी इच्छुक व्यक्ति को सूचित करने के लिए जब कोई खाता फ्रीज या अनफ्रीज किया जाता है। तकनीकी रूप से इन कार्यों के लिए इवेंट्स की आवश्यकता नहीं होती है, लेकिन यह ऑफ-चेन कोड को इन इवेंट्स को सुनने और यह जानने में मदद करता है कि क्या हो रहा है। जब कुछ ऐसा होता है जो किसी और के लिए प्रासंगिक हो सकता है तो स्मार्ट अनुबंध के लिए उन्हें उत्सर्जित करना अच्छा शिष्टाचार माना जाता है।
+
+ इवेंट्स को अनुक्रमित किया जाता है ताकि यह खोजना संभव हो सके कि किसी खाते को कितनी बार फ्रीज या अनफ्रीज किया गया है।
+
+ ```solidity
+ // जब खाते फ्रीज या अनफ्रीज हो जाते हैं
+ event AccountFrozen(address indexed _addr);
+ event AccountThawed(address indexed _addr);
+ ```
+
+- खातों को फ्रीज और अनफ्रीज करने के लिए फ़ंक्शंस। ये दो फ़ंक्शन लगभग समान हैं, इसलिए हम केवल फ्रीज फ़ंक्शन पर जाएंगे।
+
+ ```solidity
+ function freezeAccount(address addr)
+ public
+ onlyOwner
+ ```
+
+ [`public`](https://www.tutorialspoint.com/solidity/solidity_contracts.htm) के रूप में चिह्नित फ़ंक्शंस को अन्य स्मार्ट अनुबंधों से या सीधे एक लेनदेन द्वारा कॉल किया जा सकता है।
+
+ ```solidity
+ {
+ require(!frozenAccounts[addr], "खाता पहले से ही फ्रीज है");
+ frozenAccounts[addr] = true;
+ emit AccountFrozen(addr);
+ } // freezeAccount
+ ```
+
+ यदि खाता पहले से ही फ्रीज है, तो रिवर्ट करें। अन्यथा, इसे फ्रीज करें और एक इवेंट `emit` करें।
+
+- फ्रीज खाते से पैसे को स्थानांतरित होने से रोकने के लिए `_beforeTokenTransfer` बदलें। ध्यान दें कि फ्रीज खाते में अभी भी पैसा स्थानांतरित किया जा सकता है।
+
+ ```solidity
+ require(!frozenAccounts[from], "खाता फ्रीज है");
+ ```
+
+### संपत्ति की सफाई {#asset-cleanup}
+
+इस अनुबंध द्वारा रखे गए ERC-20 टोकन को जारी करने के लिए हमें उस टोकन अनुबंध पर एक फ़ंक्शन को कॉल करने की आवश्यकता है, जिससे वे संबंधित हैं, या तो [`transfer`](https://eips.ethereum.org/EIPS/eip-20#transfer) या [`approve`](https://eips.ethereum.org/EIPS/eip-20#approve)। इस मामले में भत्ते पर गैस बर्बाद करने का कोई मतलब नहीं है, हम सीधे स्थानांतरण भी कर सकते हैं।
+
+```solidity
+ function cleanupERC20(
+ address erc20,
+ address dest
+ )
+ public
+ onlyOwner
+ {
+ IERC20 token = IERC20(erc20);
+```
+
+जब हम पता प्राप्त करते हैं तो यह एक अनुबंध के लिए एक ऑब्जेक्ट बनाने के लिए सिंटैक्स है। हम ऐसा इसलिए कर सकते हैं क्योंकि हमारे पास सोर्स कोड के हिस्से के रूप में ERC20 टोकन के लिए परिभाषा है (लाइन 4 देखें), और उस फ़ाइल में [IERC20 के लिए परिभाषा](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) शामिल है, जो एक OpenZeppelin ERC-20 अनुबंध के लिए इंटरफ़ेस है।
+
+```solidity
+ uint balance = token.balanceOf(address(this));
+ token.transfer(dest, balance);
+ }
+```
+
+यह एक सफाई फ़ंक्शन है, इसलिए संभवतः हम कोई टोकन नहीं छोड़ना चाहते हैं। यूज़र से मैन्युअल रूप से बैलेंस प्राप्त करने के बजाय, हम प्रक्रिया को स्वचालित भी कर सकते हैं।
+
+## निष्कर्ष {#conclusion}
+
+यह एक आदर्श समाधान नहीं है - "यूज़र ने गलती की" समस्या का कोई आदर्श समाधान नहीं है। हालांकि, इस तरह की जांच का उपयोग करने से कम से कम कुछ गलतियों को रोका जा सकता है। खातों को फ्रीज करने की क्षमता, जबकि खतरनाक है, हैकर को चोरी किए गए धन से वंचित करके कुछ हैक के नुकसान को सीमित करने के लिए इस्तेमाल किया जा सकता है।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/ethereum-for-web2-auth/index.md b/public/content/translations/hi/developers/tutorials/ethereum-for-web2-auth/index.md
new file mode 100644
index 00000000000..40c325a4953
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/ethereum-for-web2-auth/index.md
@@ -0,0 +1,886 @@
+---
+title: "वेब2 प्रमाणीकरण के लिए एथेरियम का उपयोग करना"
+description: "इस ट्यूटोरियल को पढ़ने के बाद, एक डेवलपर एथेरियम लॉगिन (वेब3) को SAML लॉगिन के साथ एकीकृत करने में सक्षम हो जाएगा, जो वेब2 में एकल साइन-ऑन और अन्य संबंधित सेवाएं प्रदान करने के लिए उपयोग किया जाने वाला एक मानक है। यह एथेरियम हस्ताक्षरों के माध्यम से वेब2 संसाधनों तक पहुंच को प्रमाणित करने की अनुमति देता है, जिसमें यूज़र की विशेषताएं साक्षियों से आती हैं।"
+author: "ओरी पोमेरेन्ट्ज़"
+tags: [ "web2", "प्रमाणीकरण", "ईएएस" ]
+skill: beginner
+lang: hi
+published: 2025-04-30
+---
+
+## परिचय
+
+[SAML](https://www.onelogin.com/learn/saml) वेब2 पर इस्तेमाल किया जाने वाला एक मानक है जो एक [पहचान प्रदाता (IdP)](https://en.wikipedia.org/wiki/Identity_provider#SAML_identity_provider) को [सेवा प्रदाताओं (SP)](https://en.wikipedia.org/wiki/Service_provider_\(SAML\)) के लिए यूज़र जानकारी प्रदान करने की अनुमति देता है।
+
+इस ट्यूटोरियल में आप सीखेंगे कि एथेरियम हस्ताक्षरों को SAML के साथ कैसे एकीकृत किया जाए ताकि यूज़र अपने एथेरियम वॉलेट का उपयोग उन वेब2 सेवाओं में खुद को प्रमाणित करने के लिए कर सकें जो अभी तक एथेरियम को मूल रूप से समर्थन नहीं करती हैं।
+
+ध्यान दें कि यह ट्यूटोरियल दो अलग-अलग दर्शकों के लिए लिखा गया है:
+
+- एथेरियम से जुड़े लोग जो एथेरियम को समझते हैं और जिन्हें SAML सीखने की ज़रूरत है
+- वेब2 से जुड़े लोग जो SAML और वेब2 प्रमाणीकरण को समझते हैं और जिन्हें एथेरियम सीखने की ज़रूरत है
+
+परिणामस्वरूप, इसमें बहुत सारी परिचयात्मक सामग्री होने वाली है जिसे आप पहले से जानते हैं। इसे छोड़ने के लिए स्वतंत्र महसूस करें।
+
+### एथेरियम लोगों के लिए SAML
+
+SAML एक केंद्रीकृत प्रोटोकॉल है। एक सेवा प्रदाता (SP) किसी पहचान प्रदाता (IdP) से केवल तभी दावे (जैसे "यह मेरा यूज़र जॉन है, उसके पास A, B, और C करने की अनुमति होनी चाहिए") स्वीकार करता है, जब उसका या तो उसके साथ या उस [प्रमाणपत्र प्राधिकारी](https://www.ssl.com/article/what-is-a-certificate-authority-ca/) के साथ पहले से मौजूद विश्वास संबंध हो, जिसने उस IdP के प्रमाणपत्र पर हस्ताक्षर किए हों।
+
+उदाहरण के लिए, SP एक ट्रैवल एजेंसी हो सकती है जो कंपनियों को यात्रा सेवाएं प्रदान करती है, और IdP एक कंपनी की आंतरिक वेब साइट हो सकती है। जब कर्मचारियों को व्यावसायिक यात्रा बुक करने की आवश्यकता होती है, तो ट्रैवल एजेंसी उन्हें वास्तव में यात्रा बुक करने देने से पहले प्रमाणीकरण के लिए कंपनी के पास भेजती है।
+
+
+
+यह वह तरीका है जिससे तीन संस्थाएँ, ब्राउज़र, SP, और IdP, पहुँच के लिए बातचीत करती हैं। SP को ब्राउज़र का उपयोग करने वाले यूज़र के बारे में पहले से कुछ भी जानने की आवश्यकता नहीं है, बस IdP पर भरोसा करना है।
+
+### SAML लोगों के लिए एथेरियम
+
+एथेरियम एक विकेंद्रीकृत प्रणाली है।
+
+
+
+यूज़र्स के पास एक निजी चाबी होती है (आमतौर पर एक ब्राउज़र एक्सटेंशन में रखी जाती है)। निजी चाबी से आप एक सार्वजनिक कुंजी प्राप्त कर सकते हैं, और उससे एक 20-बाइट का पता। जब यूज़र्स को किसी सिस्टम में लॉग इन करने की आवश्यकता होती है, तो उन्हें एक नॉन्स (एकल-उपयोग मान) के साथ एक संदेश पर हस्ताक्षर करने के लिए अनुरोध किया जाता है। सर्वर यह सत्यापित कर सकता है कि हस्ताक्षर उस पते द्वारा बनाया गया था।
+
+
+
+हस्ताक्षर केवल एथेरियम पते की पुष्टि करता है। अन्य यूज़र विशेषताओं को प्राप्त करने के लिए, आप आमतौर पर [साक्षियों](https://attest.org/) का उपयोग करते हैं। एक साक्षी में आमतौर पर ये फ़ील्ड होती हैं:
+
+- **साक्षीकर्ता**, वह पता जिसने साक्षी बनाई
+- **प्राप्तकर्ता**, वह पता जिस पर साक्षी लागू होती है
+- **डेटा**, प्रमाणित किया जा रहा डेटा, जैसे नाम, अनुमतियाँ, आदि।
+- **स्कीमा**, डेटा की व्याख्या के लिए उपयोग किए गए स्कीमा की ID।
+
+एथेरियम की विकेन्द्रीकृत प्रकृति के कारण, कोई भी यूज़र साक्षी बना सकता है। साक्षीकर्ता की पहचान यह पहचानने के लिए महत्वपूर्ण है कि हम किन साक्षियों को विश्वसनीय मानते हैं।
+
+## सेटअप
+
+पहला कदम एक SAML SP और एक SAML IdP का आपस में संचार करना है।
+
+1. सॉफ़्टवेयर डाउनलोड करें। इस लेख के लिए नमूना सॉफ़्टवेयर [github पर](https://github.com/qbzzt/250420-saml-ethereum) है। विभिन्न चरण विभिन्न शाखाओं में संग्रहीत हैं, इस चरण के लिए आप `saml-only` चाहते हैं
+
+ ```sh
+ git clone https://github.com/qbzzt/250420-saml-ethereum -b saml-only
+ cd 250420-saml-ethereum
+ pnpm install
+ ```
+
+2. स्व-हस्ताक्षरित प्रमाणपत्रों के साथ कुंजियाँ बनाएँ। इसका मतलब है कि कुंजी इसका अपना प्रमाणपत्र प्राधिकारी है, और इसे सेवा प्रदाता में मैन्युअल रूप से आयात करने की आवश्यकता है। अधिक जानकारी के लिए [OpenSSL दस्तावेज़](https://docs.openssl.org/master/man1/openssl-req/) देखें।
+
+ ```sh
+ mkdir keys
+ cd keys
+ openssl req -new -x509 -days 365 -nodes -sha256 -out saml-sp.crt -keyout saml-sp.pem -subj /CN=sp/
+ openssl req -new -x509 -days 365 -nodes -sha256 -out saml-idp.crt -keyout saml-idp.pem -subj /CN=idp/
+ cd ..
+ ```
+
+3. सर्वर प्रारंभ करें (SP और IdP दोनों)
+
+ ```sh
+ pnpm start
+ ```
+
+4. URL [http://localhost:3000/](http://localhost:3000/) पर SP पर ब्राउज़ करें और IdP (पोर्ट 3001) पर रीडायरेक्ट होने के लिए बटन पर क्लिक करें।
+
+5. IdP को अपना ईमेल पता प्रदान करें और **सेवा प्रदाता में लॉगिन करें** पर क्लिक करें। देखें कि आपको सेवा प्रदाता (पोर्ट 3000) पर वापस रीडायरेक्ट कर दिया गया है और यह आपको आपके ईमेल पते से जानता है।
+
+### विस्तृत व्याख्या
+
+यह चरण-दर-चरण होता है:
+
+
+
+#### src/config.mts
+
+इस फ़ाइल में पहचान प्रदाता और सेवा प्रदाता दोनों के लिए कॉन्फ़िगरेशन शामिल है। आम तौर पर ये दोनों अलग-अलग संस्थाएँ होंगी, लेकिन यहाँ हम सरलता के लिए कोड साझा कर सकते हैं।
+
+```typescript
+const fs = await import("fs")
+
+const protocol="http"
+```
+
+अभी के लिए हम सिर्फ़ परीक्षण कर रहे हैं, इसलिए HTTP का उपयोग करना ठीक है।
+
+```typescript
+export const spCert = fs.readFileSync("keys/saml-sp.crt").toString()
+export const idpCert = fs.readFileSync("keys/saml-idp.crt").toString()
+```
+
+सार्वजनिक कुंजियों को पढ़ें, जो आम तौर पर दोनों घटकों के लिए उपलब्ध होती हैं (और या तो सीधे विश्वसनीय होती हैं, या एक विश्वसनीय प्रमाणपत्र प्राधिकारी द्वारा हस्ताक्षरित होती हैं)।
+
+```typescript
+export const spPort = 3000
+export const spHostname = "localhost"
+export const spDir = "sp"
+
+export const idpPort = 3001
+export const idpHostname = "localhost"
+export const idpDir = "idp"
+
+export const spUrl = `${protocol}://${spHostname}:${spPort}/${spDir}`
+export const idpUrl = `${protocol}://${idpHostname}:${idpPort}/${idpDir}`
+```
+
+दोनों घटकों के लिए URL।
+
+```typescript
+export const spPublicData = {
+```
+
+सेवा प्रदाता के लिए सार्वजनिक डेटा।
+
+```typescript
+ entityID: `${spUrl}/metadata`,
+```
+
+परंपरा के अनुसार, SAML में `entityID` वह URL है जहाँ इकाई का मेटाडेटा उपलब्ध होता है। यह मेटाडेटा यहाँ सार्वजनिक डेटा से मेल खाता है, सिवाय इसके कि यह XML रूप में है।
+
+```typescript
+ wantAssertionsSigned: true,
+ authnRequestsSigned: false,
+ signingCert: spCert,
+ allowCreate: true,
+ assertionConsumerService: [{
+ Binding: 'urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST',
+ Location: `${spUrl}/assertion`,
+ }]
+ }
+```
+
+हमारे उद्देश्यों के लिए सबसे महत्वपूर्ण परिभाषा `assertionConsumerServer` है। इसका मतलब है कि सेवा प्रदाता को कुछ दावा करने के लिए (उदाहरण के लिए, "यह जानकारी भेजने वाला यूज़र somebody@example.com है") हमें URL `http://localhost:3000/sp/assertion` पर [HTTP POST](https://www.w3schools.com/tags/ref_httpmethods.asp) का उपयोग करने की आवश्यकता है।
+
+```typescript
+export const idpPublicData = {
+ entityID: `${idpUrl}/metadata`,
+ signingCert: idpCert,
+ wantAuthnRequestsSigned: false,
+ singleSignOnService: [{
+ Binding: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+ Location: `${idpUrl}/login`
+ }],
+ singleLogoutService: [{
+ Binding: "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+ Location: `${idpUrl}/logout`
+ }],
+ }
+```
+
+पहचान प्रदाता के लिए सार्वजनिक डेटा समान है। यह निर्दिष्ट करता है कि किसी यूज़र को लॉग इन करने के लिए आप `http://localhost:3001/idp/login` पर पोस्ट करते हैं और किसी यूज़र को लॉग आउट करने के लिए आप `http://localhost:3001/idp/logout` पर पोस्ट करते हैं।
+
+#### src/sp.mts
+
+यह वह कोड है जो एक सेवा प्रदाता को लागू करता है।
+
+```typescript
+import * as config from "./config.mts"
+const fs = await import("fs")
+const saml = await import("samlify")
+```
+
+हम SAML को लागू करने के लिए [`samlify`](https://www.npmjs.com/package/samlify) लाइब्रेरी का उपयोग करते हैं।
+
+```typescript
+import * as validator from "@authenio/samlify-node-xmllint"
+saml.setSchemaValidator(validator)
+```
+
+`samlify` लाइब्रेरी यह उम्मीद करती है कि एक पैकेज यह सत्यापित करेगा कि XML सही है, अपेक्षित सार्वजनिक कुंजी के साथ हस्ताक्षरित है, आदि। हम इस उद्देश्य के लिए [`@authenio/samlify-node-xmllint`](https://www.npmjs.com/package/@authenio/samlify-node-xmllint) का उपयोग करते हैं।
+
+```typescript
+const express = (await import("express")).default
+const spRouter = express.Router()
+const app = express()
+```
+
+एक [`express`](https://expressjs.com/) [`Router`](https://expressjs.com/en/5x/api.html#router) एक "मिनी वेब साइट" है जिसे एक वेब साइट के अंदर माउंट किया जा सकता है। इस मामले में, हम इसका उपयोग सभी सेवा प्रदाता परिभाषाओं को एक साथ समूहित करने के लिए करते हैं।
+
+```typescript
+const spPrivateKey = fs.readFileSync("keys/saml-sp.pem").toString()
+
+const sp = saml.ServiceProvider({
+ privateKey: spPrivateKey,
+ ...config.spPublicData
+})
+```
+
+सेवा प्रदाता का स्वयं का प्रतिनिधित्व सभी सार्वजनिक डेटा है, और वह निजी चाबी है जिसका उपयोग वह जानकारी पर हस्ताक्षर करने के लिए करता है।
+
+```typescript
+const idp = saml.IdentityProvider(config.idpPublicData);
+```
+
+सार्वजनिक डेटा में वह सब कुछ होता है जो सेवा प्रदाता को पहचान प्रदाता के बारे में जानने की आवश्यकता होती है।
+
+```typescript
+spRouter.get(`/metadata`,
+ (req, res) => res.header("Content-Type", "text/xml").send(sp.getMetadata())
+)
+```
+
+अन्य SAML घटकों के साथ अंतर-संचालनीयता को सक्षम करने के लिए, सेवा और पहचान प्रदाताओं के पास `/metadata` में XML प्रारूप में उनका सार्वजनिक डेटा (मेटाडेटा कहा जाता है) उपलब्ध होना चाहिए।
+
+```typescript
+spRouter.post(`/assertion`,
+```
+
+यह वह पृष्ठ है जिस पर ब्राउज़र अपनी पहचान बनाने के लिए पहुँचता है। दावे में यूज़र पहचानकर्ता (यहाँ हम ईमेल पते का उपयोग करते हैं) शामिल है, और इसमें अतिरिक्त विशेषताएँ शामिल हो सकती हैं। यह ऊपर के अनुक्रम आरेख में चरण 7 के लिए हैंडलर है।
+
+```typescript
+ async (req, res) => {
+ // console.log(`SAML response:\n${Buffer.from(req.body.SAMLResponse, 'base64').toString('utf-8')}`)
+```
+
+आप दावे में प्रदान किए गए XML डेटा को देखने के लिए टिप्पणी की गई कमांड का उपयोग कर सकते हैं। यह [base64 एन्कोडेड](https://en.wikipedia.org/wiki/Base64) है।
+
+```typescript
+ try {
+ const loginResponse = await sp.parseLoginResponse(idp, 'post', req);
+```
+
+पहचान सर्वर से लॉगिन अनुरोध को पार्स करें।
+
+```typescript
+ res.send(`
+
+
+ Hello ${loginResponse.extract.nameID}
+
+
+ `)
+ res.send();
+```
+
+एक HTML प्रतिक्रिया भेजें, बस यूज़र को यह दिखाने के लिए कि हमें लॉगिन मिल गया है।
+
+```typescript
+ } catch (err) {
+ console.error('Error processing SAML response:', err);
+ res.status(400).send('SAML authentication failed');
+ }
+ }
+)
+```
+
+विफलता की स्थिति में यूज़र को सूचित करें।
+
+```typescript
+spRouter.get('/login',
+```
+
+जब ब्राउज़र इस पृष्ठ को प्राप्त करने का प्रयास करता है तो एक लॉगिन अनुरोध बनाएँ। यह ऊपर के अनुक्रम आरेख में चरण 1 के लिए हैंडलर है।
+
+```typescript
+ async (req, res) => {
+ const loginRequest = await sp.createLoginRequest(idp, "post")
+```
+
+लॉगिन अनुरोध पोस्ट करने के लिए जानकारी प्राप्त करें।
+
+```typescript
+ res.send(`
+
+
+
+```
+
+यह पृष्ठ फ़ॉर्म (नीचे देखें) को स्वचालित रूप से सबमिट करता है। इस तरह यूज़र को रीडायरेक्ट होने के लिए कुछ भी करने की ज़रूरत नहीं है। यह ऊपर के अनुक्रम आरेख में चरण 2 है।
+
+```typescript
+
+
+
+ `)
+ }
+)
+
+app.use(express.urlencoded({extended: true}))
+```
+
+[यह मिडलवेयर](https://expressjs.com/en/5x/api.html#express.urlencoded) [HTTP अनुरोध](https://www.tutorialspoint.com/http/http_requests.htm) के मुख्य भाग को पढ़ता है। डिफ़ॉल्ट रूप से एक्सप्रेस इसे अनदेखा करता है, क्योंकि अधिकांश अनुरोधों के लिए इसकी आवश्यकता नहीं होती है। हमें इसकी आवश्यकता है क्योंकि POST मुख्य भाग का उपयोग करता है।
+
+```typescript
+app.use(`/${config.spDir}`, spRouter)
+```
+
+सेवा प्रदाता निर्देशिका (`/sp`) में राउटर को माउंट करें।
+
+```typescript
+app.get("/", (req, res) => {
+ res.send(`
+
+
+
+
+
+ `)
+})
+```
+
+यदि कोई ब्राउज़र रूट निर्देशिका प्राप्त करने का प्रयास करता है, तो उसे लॉगिन पृष्ठ का एक लिंक प्रदान करें।
+
+```typescript
+app.listen(config.spPort, () => {
+ console.log(`service provider is running on http://${config.spHostname}:${config.spPort}`)
+})
+```
+
+इस एक्सप्रेस एप्लिकेशन के साथ `spPort` को सुनें।
+
+#### src/idp.mts
+
+यह पहचान प्रदाता है। यह सेवा प्रदाता के बहुत समान है, नीचे दी गई व्याख्याएँ उन हिस्सों के लिए हैं जो अलग हैं।
+
+```typescript
+const xmlParser = new (await import("fast-xml-parser")).XMLParser(
+ {
+ ignoreAttributes: false, // Preserve attributes
+ attributeNamePrefix: "@_", // Prefix for attributes
+ }
+)
+```
+
+हमें सेवा प्रदाता से प्राप्त XML अनुरोध को पढ़ने और समझने की आवश्यकता है।
+
+```typescript
+const getLoginPage = requestId => `
+```
+
+यह फ़ंक्शन स्वचालित रूप से सबमिट किए गए फ़ॉर्म के साथ पृष्ठ बनाता है जो ऊपर अनुक्रम आरेख के चरण 4 में लौटाया जाता है।
+
+```typescript
+
+
+ लॉगिन पेज
+
+
+ लॉगिन पेज
+
+
+
+
+const idpRouter = express.Router()
+
+idpRouter.post("/loginSubmitted", async (req, res) => {
+ const loginResponse = await idp.createLoginResponse(
+```
+
+यह ऊपर के अनुक्रम आरेख में चरण 5 के लिए हैंडलर है। [`idp.createLoginResponse`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L73-L125) लॉगिन प्रतिक्रिया बनाता है।
+
+```typescript
+ sp,
+ {
+ authnContextClassRef: 'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport',
+ audience: sp.entityID,
+```
+
+दर्शक सेवा प्रदाता है।
+
+```typescript
+ extract: {
+ request: {
+ id: req.body.requestId
+ }
+ },
+```
+
+अनुरोध से निकाली गई जानकारी। अनुरोध में जिस एक पैरामीटर की हमें परवाह है, वह है requestId, जो सेवा प्रदाता को अनुरोधों और उनकी प्रतिक्रियाओं का मिलान करने देता है।
+
+```typescript
+ signingKey: { privateKey: idpPrivateKey, publicKey: config.idpCert } // Ensure signing
+```
+
+हमें प्रतिक्रिया पर हस्ताक्षर करने के लिए डेटा रखने के लिए `signingKey` की आवश्यकता है। सेवा प्रदाता अहस्ताक्षरित अनुरोधों पर भरोसा नहीं करता है।
+
+```typescript
+ },
+ "post",
+ {
+ email: req.body.email
+```
+
+यह यूज़र जानकारी वाला फ़ील्ड है जिसे हम सेवा प्रदाता को वापस भेजते हैं।
+
+```typescript
+ }
+ );
+
+ res.send(`
+
+
+
+
+
+
+
+ `)
+})
+```
+
+फिर से, एक ऑटो-सबमिट किए गए फ़ॉर्म का उपयोग करें। यह ऊपर के अनुक्रम आरेख में चरण 6 है।
+
+```typescript
+
+// IdP endpoint for login requests
+idpRouter.post(`/login`,
+```
+
+यह वह एंडपॉइंट है जो सेवा प्रदाता से लॉगिन अनुरोध प्राप्त करता है। यह ऊपर के अनुक्रम आरेख के चरण 3 के लिए हैंडलर है।
+
+```typescript
+ async (req, res) => {
+ try {
+ // Workaround because I couldn't get parseLoginRequest to work.
+ // const loginRequest = await idp.parseLoginRequest(sp, 'post', req)
+ const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8'))
+ res.send(getLoginPage(samlRequest["samlp:AuthnRequest"]["@_ID"]))
+```
+
+हमें प्रमाणीकरण अनुरोध की ID पढ़ने के लिए [`idp.parseLoginRequest`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L127-L144) का उपयोग करने में सक्षम होना चाहिए। हालाँकि, मैं इसे काम नहीं करवा सका और इस पर बहुत समय खर्च करना उचित नहीं था इसलिए मैं बस एक [सामान्य-उद्देश्य XML पार्सर](https://www.npmjs.com/package/fast-xml-parser) का उपयोग करता हूँ। हमें जिस जानकारी की आवश्यकता है, वह `` टैग के अंदर `ID` विशेषता है, जो XML के शीर्ष स्तर पर है।
+
+## एथेरियम हस्ताक्षरों का उपयोग करना
+
+अब जब हम सेवा प्रदाता को यूज़र की पहचान भेज सकते हैं, तो अगला कदम एक विश्वसनीय तरीके से यूज़र की पहचान प्राप्त करना है। Viem हमें वॉलेट से यूज़र के पते के लिए पूछने की अनुमति देता है, लेकिन इसका मतलब ब्राउज़र से जानकारी मांगना है। हम ब्राउज़र को नियंत्रित नहीं करते हैं, इसलिए हम इससे मिलने वाली प्रतिक्रिया पर स्वचालित रूप से भरोसा नहीं कर सकते हैं।
+
+इसके बजाय, IdP ब्राउज़र को हस्ताक्षर करने के लिए एक स्ट्रिंग भेजेगा। यदि ब्राउज़र में वॉलेट इस स्ट्रिंग पर हस्ताक्षर करता है, तो इसका मतलब है कि यह वास्तव में वह पता है (यानी, यह उस पते से मेल खाने वाली निजी चाबी जानता है)।
+
+इसे क्रिया में देखने के लिए, मौजूदा IdP और SP को रोकें और इन कमांड को चलाएँ:
+
+```sh
+git checkout eth-signatures
+pnpm install
+pnpm start
+```
+
+फिर [SP](http://localhost:3000) पर ब्राउज़ करें और निर्देशों का पालन करें।
+
+ध्यान दें कि इस समय हम यह नहीं जानते हैं कि एथेरियम पते से ईमेल पता कैसे प्राप्त करें, इसलिए इसके बजाय हम SP को `@bad.email.address` रिपोर्ट करते हैं।
+
+### विस्तृत व्याख्या
+
+परिवर्तन पिछले आरेख में चरण 4-5 में हैं।
+
+
+
+हमने जिस एकमात्र फ़ाइल को बदला है वह `idp.mts` है। यहाँ बदले हुए भाग हैं।
+
+```typescript
+import { v4 as uuidv4 } from 'uuid'
+import { verifyMessage } from 'viem'
+```
+
+हमें इन दो अतिरिक्त पुस्तकालयों की आवश्यकता है। हम [नॉन्स](https://en.wikipedia.org/wiki/Cryptographic_nonce) मान बनाने के लिए [`uuid`](https://www.npmjs.com/package/uuid) का उपयोग करते हैं। मान स्वयं मायने नहीं रखता है, बस यह तथ्य है कि इसका उपयोग केवल एक बार किया जाता है।
+
+[`viem`](https://viem.sh/) लाइब्रेरी हमें एथेरियम परिभाषाओं का उपयोग करने देती है। यहाँ हमें यह सत्यापित करने की आवश्यकता है कि हस्ताक्षर वास्तव में मान्य है।
+
+```typescript
+const loginPrompt = "सेवा प्रदाता तक पहुँचने के लिए, इस नॉन्स पर हस्ताक्षर करें: "
+```
+
+वॉलेट यूज़र से संदेश पर हस्ताक्षर करने की अनुमति मांगता है। एक संदेश जो केवल एक नॉन्स है, यूज़र्स को भ्रमित कर सकता है, इसलिए हम इस प्रॉम्प्ट को शामिल करते हैं।
+
+```typescript
+// Keep requestIDs here
+let nonces = {}
+```
+
+हमें इसका जवाब देने में सक्षम होने के लिए अनुरोध जानकारी की आवश्यकता है। हम इसे अनुरोध (चरण 4) के साथ भेज सकते हैं, और इसे वापस प्राप्त कर सकते हैं (चरण 5)। हालाँकि, हम ब्राउज़र से मिलने वाली जानकारी पर भरोसा नहीं कर सकते, जो संभावित रूप से शत्रुतापूर्ण यूज़र के नियंत्रण में है। तो इसे यहाँ संग्रहीत करना बेहतर है, कुंजी के रूप में नॉन्स के साथ।
+
+ध्यान दें कि हम इसे यहाँ सरलता के लिए एक चर के रूप में कर रहे हैं। हालाँकि, इसके कई नुकसान हैं:
+
+- हम सेवा से इनकार के हमले के प्रति संवेदनशील हैं। एक दुर्भावनापूर्ण यूज़र कई बार लॉग ऑन करने का प्रयास कर सकता है, जिससे हमारी मेमोरी भर जाएगी।
+- यदि IdP प्रक्रिया को पुनरारंभ करने की आवश्यकता है, तो हम मौजूदा मान खो देते हैं।
+- हम कई प्रक्रियाओं में लोड को संतुलित नहीं कर सकते हैं, क्योंकि प्रत्येक का अपना चर होगा।
+
+एक उत्पादन प्रणाली पर हम एक डेटाबेस का उपयोग करेंगे और किसी प्रकार की समाप्ति तंत्र लागू करेंगे।
+
+```typescript
+const getSignaturePage = requestId => {
+ const nonce = uuidv4()
+ nonces[nonce] = requestId
+```
+
+एक नॉन्स बनाएँ, और भविष्य में उपयोग के लिए `requestId` को संग्रहीत करें।
+
+```typescript
+ return `
+
+
+
+
+
+ कृपया हस्ताक्षर करें
+
+
+
+
+
+`
+}
+```
+
+बाकी सब मानक HTML है।
+
+```typescript
+idpRouter.get("/signature/:nonce/:account/:signature", async (req, res) => {
+```
+
+यह अनुक्रम आरेख में चरण 5 के लिए हैंडलर है।
+
+```typescript
+ const requestId = nonces[req.params.nonce]
+ if (requestId === undefined) {
+ res.send("Bad nonce")
+ return ;
+ }
+
+ nonces[req.params.nonce] = undefined
+```
+
+अनुरोध ID प्राप्त करें, और यह सुनिश्चित करने के लिए कि इसका पुन: उपयोग नहीं किया जा सकता है, `nonces` से नॉन्स को हटा दें।
+
+```typescript
+ try {
+```
+
+क्योंकि हस्ताक्षर के अमान्य होने के इतने सारे तरीके हैं, हम इसे एक `try ...` में लपेटते हैं। `catch` ब्लॉक किसी भी फेंकी गई त्रुटियों को पकड़ने के लिए।
+
+```typescript
+ const validSignature = await verifyMessage({
+ address: req.params.account,
+ message: `${loginPrompt}${req.params.nonce}`,
+ signature: req.params.signature
+ })
+```
+
+अनुक्रम आरेख में चरण 5.5 को लागू करने के लिए [`verifyMessage`](https://viem.sh/docs/actions/public/verifyMessage#verifymessage) का उपयोग करें।
+
+```typescript
+ if (!validSignature)
+ throw("Bad signature")
+ } catch (err) {
+ res.send("Error:" + err)
+ return ;
+ }
+```
+
+हैंडलर का बाकी हिस्सा `/loginSubmitted` हैंडलर में पहले किए गए काम के बराबर है, सिवाय एक छोटे से बदलाव के।
+
+```typescript
+ const loginResponse = await idp.createLoginResponse(
+ .
+ .
+ .
+ {
+ email: req.params.account + "@bad.email.address"
+ }
+ );
+```
+
+हमारे पास वास्तविक ईमेल पता नहीं है (हम इसे अगले अनुभाग में प्राप्त करेंगे), इसलिए अभी के लिए हम एथेरियम पता लौटाते हैं और इसे स्पष्ट रूप से एक ईमेल पते के रूप में चिह्नित नहीं करते हैं।
+
+```typescript
+// IdP endpoint for login requests
+idpRouter.post(`/login`,
+ async (req, res) => {
+ try {
+ // Workaround because I couldn't get parseLoginRequest to work.
+ // const loginRequest = await idp.parseLoginRequest(sp, 'post', req)
+ const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8'))
+ res.send(getSignaturePage(samlRequest["samlp:AuthnRequest"]["@_ID"]))
+ } catch (err) {
+ console.error('Error processing SAML response:', err);
+ res.status(400).send('SAML authentication failed');
+ }
+ }
+)
+```
+
+`getLoginPage` के बजाय, अब चरण 3 हैंडलर में `getSignaturePage` का उपयोग करें।
+
+## ईमेल पता प्राप्त करना
+
+अगला कदम ईमेल पता प्राप्त करना है, जो सेवा प्रदाता द्वारा अनुरोधित पहचानकर्ता है। ऐसा करने के लिए, हम [एथेरियम साक्षी सेवा (EAS)](https://attest.org/) का उपयोग करते हैं।
+
+साक्षियाँ प्राप्त करने का सबसे आसान तरीका [GraphQL API](https://docs.attest.org/docs/developer-tools/api) का उपयोग करना है। हम इस क्वेरी का उपयोग करते हैं:
+
+```
+query GetAttestationsByRecipient {
+ attestations(
+ where: {
+ recipient: { equals: "${getAddress(ethAddr)}" }
+ schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" }
+ }
+ take: 1
+ ) {
+ data
+ id
+ attester
+ }
+}
+```
+
+इस [`schemaId`](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977) में केवल एक ई-मेल पता शामिल है। यह क्वेरी इस स्कीमा की साक्षियों के लिए पूछती है। साक्षी का विषय `recipient` कहलाता है। यह हमेशा एक एथेरियम पता होता है।
+
+चेतावनी: जिस तरह से हम यहाँ साक्षियाँ प्राप्त कर रहे हैं, उसमें दो सुरक्षा मुद्दे हैं।
+
+- हम API एंडपॉइंट, `https://optimism.easscan.org/graphql` पर जा रहे हैं, जो एक केंद्रीकृत घटक है। हम `id` विशेषता प्राप्त कर सकते हैं और फिर यह सत्यापित करने के लिए ऑन-चेन लुकअप कर सकते हैं कि एक साक्षी वास्तविक है, लेकिन API एंडपॉइंट अभी भी हमें उनके बारे में न बताकर साक्षियों को सेंसर कर सकता है।
+
+ इस समस्या को हल करना असंभव नहीं है, हम अपना स्वयं का GraphQL एंडपॉइंट चला सकते हैं और चेन लॉग से साक्षियाँ प्राप्त कर सकते हैं, लेकिन यह हमारे उद्देश्यों के लिए अत्यधिक है।
+
+- हम साक्षीकर्ता की पहचान को नहीं देखते हैं। कोई भी हमें झूठी जानकारी दे सकता है। एक वास्तविक दुनिया के कार्यान्वयन में हमारे पास विश्वसनीय साक्षीकर्ताओं का एक सेट होगा और केवल उनकी साक्षियों को देखेंगे।
+
+इसे क्रिया में देखने के लिए, मौजूदा IdP और SP को रोकें और इन कमांड को चलाएँ:
+
+```sh
+git checkout email-address
+pnpm install
+pnpm start
+```
+
+फिर अपना ई-मेल पता प्रदान करें। ऐसा करने के आपके पास दो तरीके हैं:
+
+- एक निजी चाबी का उपयोग करके एक वॉलेट आयात करें, और परीक्षण निजी चाबी `0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80` का उपयोग करें।
+
+- अपने स्वयं के ई-मेल पते के लिए एक साक्षी जोड़ें:
+
+ 1. [साक्षी एक्सप्लोरर में स्कीमा](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977) पर ब्राउज़ करें।
+
+ 2. **स्कीमा के साथ साक्षी दें** पर क्लिक करें।
+
+ 3. प्राप्तकर्ता के रूप में अपना एथेरियम पता, ईमेल पते के रूप में अपना ई-मेल पता दर्ज करें, और **ऑनचेन** चुनें। फिर **साक्षी बनाएँ** पर क्लिक करें।
+
+ 4. अपने वॉलेट में लेनदेन को स्वीकृत करें। गैस का भुगतान करने के लिए आपको [ऑप्टिमिज्म ब्लॉकचेन](https://app.optimism.io/bridge/deposit) पर कुछ ETH की आवश्यकता होगी।
+
+किसी भी तरह, ऐसा करने के बाद [http://localhost:3000](http://localhost:3000) पर ब्राउज़ करें और निर्देशों का पालन करें। यदि आपने परीक्षण निजी चाबी आयात की है, तो आपको मिलने वाला ई-मेल `test_addr_0@example.com` है। यदि आपने अपने स्वयं के पते का उपयोग किया है, तो यह वह होना चाहिए जो आपने प्रमाणित किया है।
+
+### विस्तृत व्याख्या
+
+
+
+नए चरण GraphQL संचार हैं, चरण 5.6 और 5.7।
+
+फिर से, यहाँ `idp.mts` के बदले हुए भाग हैं।
+
+```typescript
+import { GraphQLClient } from 'graphql-request'
+import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk'
+```
+
+हमें जिन पुस्तकालयों की आवश्यकता है, उन्हें आयात करें।
+
+```typescript
+const graphqlEndpointUrl = "https://optimism.easscan.org/graphql"
+```
+
+[प्रत्येक ब्लॉकचेन के लिए एक अलग एंडपॉइंट](https://docs.attest.org/docs/developer-tools/api) है।
+
+```typescript
+const graphqlClient = new GraphQLClient(graphqlEndpointUrl, { fetch })
+```
+
+एक नया `GraphQLClient` क्लाइंट बनाएँ जिसका उपयोग हम एंडपॉइंट की क्वेरी के लिए कर सकते हैं।
+
+```typescript
+const graphqlSchema = 'string emailAddress'
+const graphqlEncoder = new SchemaEncoder(graphqlSchema)
+```
+
+GraphQL हमें केवल बाइट्स के साथ एक अपारदर्शी डेटा ऑब्जेक्ट देता है। इसे समझने के लिए हमें स्कीमा की आवश्यकता है।
+
+```typescript
+const ethereumAddressToEmail = async ethAddr => {
+```
+
+एक एथेरियम पते से एक ई-मेल पते पर जाने के लिए एक फ़ंक्शन।
+
+```typescript
+ const query = `
+ query GetAttestationsByRecipient {
+```
+
+यह एक GraphQL क्वेरी है।
+
+```typescript
+ attestations(
+```
+
+हम साक्षियों की तलाश कर रहे हैं।
+
+```typescript
+ where: {
+ recipient: { equals: "${getAddress(ethAddr)}" }
+ schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" }
+ }
+```
+
+हम जो साक्षियाँ चाहते हैं, वे हमारे स्कीमा में हैं, जहाँ प्राप्तकर्ता `getAddress(ethAddr)` है। [`getAddress`](https://viem.sh/docs/utilities/getAddress#getaddress) फ़ंक्शन यह सुनिश्चित करता है कि हमारे पते में सही [चेकसम](https://github.com/ethereum/ercs/blob/master/ERCS/erc-55.md) है। यह आवश्यक है क्योंकि GraphQL केस-महत्वपूर्ण है। "0xBAD060A7", "0xBad060A7", और "0xbad060a7" अलग-अलग मान हैं।
+
+```typescript
+ take: 1
+```
+
+चाहे हमें कितनी भी साक्षियाँ मिलें, हम केवल पहली वाली चाहते हैं।
+
+```typescript
+ ) {
+ data
+ id
+ attester
+ }
+ }`
+```
+
+वे फ़ील्ड जिन्हें हम प्राप्त करना चाहते हैं।
+
+- `attester`: वह पता जिसने साक्षी सबमिट की। आम तौर पर इसका उपयोग यह तय करने के लिए किया जाता है कि साक्षी पर भरोसा किया जाए या नहीं।
+- `id`: साक्षी ID। आप इस मान का उपयोग [साक्षी को ऑन-चेन पढ़ने](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000021?tab=read_proxy&source_address=0x4E0275Ea5a89e7a3c1B58411379D1a0eDdc5b088#0xa3112a64) के लिए कर सकते हैं ताकि यह सत्यापित हो सके कि GraphQL क्वेरी से जानकारी सही है।
+- `data`: स्कीमा डेटा (इस मामले में, ई-मेल पता)।
+
+```typescript
+ const queryResult = await graphqlClient.request(query)
+
+ if (queryResult.attestations.length == 0)
+ return "no_address@available.is"
+```
+
+यदि कोई साक्षी नहीं है, तो एक मान लौटाएँ जो स्पष्ट रूप से गलत है, लेकिन जो सेवा प्रदाता के लिए मान्य दिखाई देगा।
+
+```typescript
+ const attestationDataFields = graphqlEncoder.decodeData(queryResult.attestations[0].data)
+ return attestationDataFields[0].value.value
+}
+```
+
+यदि कोई मान है, तो डेटा को डिकोड करने के लिए `decodeData` का उपयोग करें। हमें इसके द्वारा प्रदान किए गए मेटाडेटा की आवश्यकता नहीं है, बस मान ही चाहिए।
+
+```typescript
+ const loginResponse = await idp.createLoginResponse(
+ sp,
+ {
+ .
+ .
+ .
+ },
+ "post",
+ {
+ email: await ethereumAddressToEmail(req.params.account)
+ }
+ );
+```
+
+ई-मेल पता प्राप्त करने के लिए नए फ़ंक्शन का उपयोग करें।
+
+## विकेंद्रीकरण के बारे में क्या?
+
+इस कॉन्फ़िगरेशन में यूज़र वह व्यक्ति होने का दिखावा नहीं कर सकते जो वे नहीं हैं, जब तक कि हम एथेरियम से ई-मेल पता मैपिंग के लिए भरोसेमंद साक्षीकर्ताओं पर भरोसा करते हैं। हालाँकि, हमारा पहचान प्रदाता अभी भी एक केंद्रीकृत घटक है। जिसके पास भी पहचान प्रदाता की निजी चाबी है, वह सेवा प्रदाता को झूठी जानकारी भेज सकता है।
+
+[मल्टी-पार्टी कंप्यूटेशन (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation) का उपयोग करके एक समाधान हो सकता है। मुझे उम्मीद है कि मैं भविष्य के ट्यूटोरियल में इसके बारे में लिखूँगा।
+
+## निष्कर्ष
+
+एक लॉग ऑन मानक, जैसे कि एथेरियम हस्ताक्षर, को अपनाने में चिकन और अंडे की समस्या का सामना करना पड़ता है। सेवा प्रदाता व्यापक संभव बाजार को आकर्षित करना चाहते हैं। यूज़र अपने लॉग ऑन मानक का समर्थन करने की चिंता किए बिना सेवाओं तक पहुँचने में सक्षम होना चाहते हैं।
+एडेप्टर बनाना, जैसे कि एथेरियम IdP, हमें इस बाधा को दूर करने में मदद कर सकता है।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md b/public/content/translations/hi/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
new file mode 100644
index 00000000000..5b4f9c59b42
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md
@@ -0,0 +1,156 @@
+---
+title: "एथेरियम डेवलपमेंट के साथ शुरुआत"
+description: "यह एथेरियम डेवलपमेंट के साथ शुरुआत करने के लिए एक शुरुआती गाइड है। हम आपको एक API एंडपॉइंट बनाने, कमांड लाइन अनुरोध करने, से लेकर आपकी पहली वेब3 स्क्रिप्ट लिखने तक ले जाएंगे! ब्लॉकचेन डेवलपमेंट अनुभव आवश्यक नहीं है!"
+author: "एलन हैल्पर्न"
+tags:
+ [
+ "javascript",
+ "ethers.js",
+ "नोड्स",
+ "क्वेरी करना",
+ "एल्केमी"
+ ]
+skill: beginner
+lang: hi
+published: 2020-10-30
+source: "मध्यम"
+sourceUrl: https://medium.com/alchemy-api/getting-started-with-ethereum-development-using-alchemy-c3d6a45c567f
+---
+
+
+
+यह एथेरियम डेवलपमेंट के साथ शुरुआत करने के लिए एक शुरुआती गाइड है। इस ट्यूटोरियल के लिए हम [Alchemy](https://alchemyapi.io/) का उपयोग करेंगे, जो Maker, 0x, MyEtherWallet, Dharma, और Kyber सहित शीर्ष ब्लॉकचेन ऐप्स के 70% से लाखों यूज़र्स को शक्ति प्रदान करने वाला प्रमुख ब्लॉकचेन डेवलपर प्लेटफॉर्म है। Alchemy हमें एथेरियम श्रृंखला पर एक API एंडपॉइंट तक पहुंच प्रदान करेगा ताकि हम ट्रांज़ैक्शन को पढ़ और लिख सकें।
+
+हम आपको Alchemy के साथ साइन अप करने से लेकर आपकी पहली वेब3 स्क्रिप्ट लिखने तक ले जाएंगे! ब्लॉकचेन डेवलपमेंट अनुभव आवश्यक नहीं है!
+
+## 1. एक मुफ़्त Alchemy खाते के लिए साइन अप करें {#sign-up-for-a-free-alchemy-account}
+
+Alchemy के साथ खाता बनाना आसान है, [यहां निःशुल्क साइन अप करें](https://auth.alchemy.com/)।
+
+## २. एक Alchemy ऐप बनाएं {#create-an-alchemy-app}
+
+एथेरियम चेन के साथ संवाद करने और Alchemy के उत्पादों का उपयोग करने के लिए, आपको अपने अनुरोधों को प्रमाणित करने के लिए एक API की की आवश्यकता है।
+
+आप [डैशबोर्ड से API कीज़ बना सकते हैं](https://dashboard.alchemy.com/)। एक नई की बनाने के लिए, नीचे दिखाए अनुसार “Create App” पर नेविगेट करें:
+
+_हमें अपना डैशबोर्ड दिखाने की अनुमति देने के लिए [_ShapeShift_](https://shapeshift.com/) का विशेष धन्यवाद!_
+
+
+
+अपनी नई की प्राप्त करने के लिए "Create App" के अंतर्गत विवरण भरें। आप यहां पहले बनाए गए ऐप्स और अपनी टीम द्वारा बनाए गए ऐप्स भी देख सकते हैं। किसी भी ऐप के लिए "View Key" पर क्लिक करके मौजूदा कीज़ प्राप्त करें।
+
+
+
+आप "Apps" पर होवर करके और किसी एक का चयन करके मौजूदा API कीज़ भी निकाल सकते हैं। आप यहां "View Key" देख सकते हैं, साथ ही विशिष्ट डोमेन को व्हाइटलिस्ट करने के लिए "Edit App" कर सकते हैं, कई डेवलपर उपकरण देख सकते हैं, और एनालिटिक्स देख सकते हैं।
+
+
+
+## 3. कमांड लाइन से एक अनुरोध करें {#make-a-request-from-the-command-line}
+
+JSON-RPC और curl का उपयोग करके Alchemy के माध्यम से एथेरियम ब्लॉकचेन के साथ इंटरैक्ट करें।
+
+मैन्युअल अनुरोधों के लिए, हम `POST` अनुरोधों के माध्यम से `JSON-RPC` के साथ इंटरैक्ट करने की सलाह देते हैं। बस `Content-Type: application/json` हेडर और निम्नलिखित फ़ील्ड के साथ अपनी क्वेरी को `POST` बॉडी के रूप में पास करें:
+
+- `jsonrpc`: JSON-RPC संस्करण—वर्तमान में, केवल `2.0` समर्थित है।
+- `method`: ETH API विधि। [API संदर्भ देखें।](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc)
+- `params`: विधि को पास करने के लिए मापदंडों की एक सूची।
+- `id`: आपके अनुरोध की ID। प्रतिक्रिया द्वारा वापस किया जाएगा ताकि आप ट्रैक कर सकें कि प्रतिक्रिया किस अनुरोध से संबंधित है।
+
+यहां एक उदाहरण है जिसे आप वर्तमान गैस मूल्य प्राप्त करने के लिए कमांड लाइन से चला सकते हैं:
+
+```bash
+curl https://eth-mainnet.alchemyapi.io/v2/demo \
+-X POST \
+-H "Content-Type: application/json" \
+-d '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}'
+```
+
+_**ध्यान दें:** [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) को अपनी API की `https://eth-mainnet.alchemyapi.io/v2/**your-api-key` से बदलें।_
+
+**परिणाम:**
+
+```json
+{ "id": 73,"jsonrpc": "2.0","result": "0x09184e72a000" // 10000000000000 }
+```
+
+## 4. अपना Web3 क्लाइंट सेट करें {#set-up-your-web3-client}
+
+**यदि आपके पास मौजूदा क्लाइंट है,** तो अपने वर्तमान नोड प्रदाता URL को अपनी API की के साथ एक Alchemy URL में बदलें: `“https://eth-mainnet.alchemyapi.io/v2/your-api-key"`
+
+**_ध्यान दें:_** नीचे दी गई स्क्रिप्ट को **नोड संदर्भ** में चलाने या **एक फ़ाइल में सहेजने** की आवश्यकता है, कमांड लाइन से नहीं। यदि आपके पास पहले से Node या npm स्थापित नहीं है, तो macs के लिए इस त्वरित [सेट-अप गाइड](https://app.gitbook.com/@alchemyapi/s/alchemy/guides/alchemy-for-macs) को देखें।
+
+बहुत सारी [Web3 लाइब्रेरीज़](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries) हैं जिन्हें आप Alchemy के साथ एकीकृत कर सकते हैं, हालांकि, हम [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) का उपयोग करने की सलाह देते हैं, जो web3.js के लिए एक ड्रॉप-इन प्रतिस्थापन है, जिसे Alchemy के साथ निर्बाध रूप से काम करने के लिए बनाया और कॉन्फ़िगर किया गया है। यह स्वचालित रिट्राई और मजबूत WebSocket समर्थन जैसे कई फायदे प्रदान करता है।
+
+AlchemyWeb3.js इंस्टॉल करने के लिए, **अपनी प्रोजेक्ट डायरेक्टरी पर नेविगेट करें** और चलाएं:
+
+**Yarn के साथ:**
+
+```
+yarn add @alch/alchemy-web3
+```
+
+**NPM के साथ:**
+
+```
+npm install @alch/alchemy-web3
+```
+
+Alchemy के नोड इन्फ्रास्ट्रक्चर के साथ इंटरैक्ट करने के लिए, NodeJS में चलाएं या इसे एक जावास्क्रिप्ट फ़ाइल में जोड़ें:
+
+```js
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(
+ "https://eth-mainnet.alchemyapi.io/v2/your-api-key"
+)
+```
+
+## 5. अपनी पहली Web3 स्क्रिप्ट लिखें! {#write-your-first-web3-script}
+
+अब थोड़ी वेब3 प्रोग्रामिंग के साथ अपने हाथ गंदे करने के लिए हम एक सरल स्क्रिप्ट लिखेंगे जो एथेरियम मेननेट से नवीनतम ब्लॉक नंबर प्रिंट करती है।
+
+**1.** यदि आपने पहले से नहीं किया है, तो अपने टर्मिनल में एक नई प्रोजेक्ट डायरेक्टरी बनाएं और उसमें cd करें:\*\*
+
+```
+mkdir web3-example
+cd web3-example
+```
+
+**2.** यदि आपने पहले से नहीं किया है तो Alchemy वेब3 (या कोई भी वेब3) निर्भरता को अपने प्रोजेक्ट में स्थापित करें:\*\*
+
+```
+npm install @alch/alchemy-web3
+```
+
+**3.** `index.js` नामक एक फ़ाइल बनाएं और निम्नलिखित सामग्री जोड़ें:\*\*
+
+> आपको अंततः `demo` को अपनी Alchemy HTTP API की से बदलना चाहिए।
+
+```js
+async function main() {
+ const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+ const web3 = createAlchemyWeb3("https://eth-mainnet.alchemyapi.io/v2/demo")
+ const blockNumber = await web3.eth.getBlockNumber()
+ console.log("नवीनतम ब्लॉक नंबर है " + blockNumber)
+}
+main()
+```
+
+async स्टफ से अपरिचित हैं? इस [मीडियम पोस्ट](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c) को देखें।
+
+**4. इसे अपने टर्मिनल में नोड का उपयोग करके चलाएं**
+
+```
+node index.js
+```
+
+**5. अब आपको अपने कंसोल में नवीनतम ब्लॉक नंबर आउटपुट देखना चाहिए!**
+
+```
+नवीनतम ब्लॉक नंबर 11043912 है
+```
+
+**वाह!** बधाई हो! आपने अभी-अभी Alchemy 🎉 का उपयोग करके अपनी पहली वेब3 स्क्रिप्ट लिखी है
+
+निश्चित नहीं हैं कि आगे क्या करें? हमारे [हैलो वर्ल्ड स्मार्ट कॉन्ट्रैक्ट गाइड](https://www.alchemy.com/docs/hello-world-smart-contract) में अपना पहला स्मार्ट अनुबंध डिप्लॉय करने का प्रयास करें और कुछ सॉलिडिटी प्रोग्रामिंग के साथ अपने हाथ गंदे करें, या [डैशबोर्ड डेमो ऐप](https://docs.alchemyapi.io/tutorials/demo-app) के साथ अपने डैशबोर्ड ज्ञान का परीक्षण करें!
+
+_[Alchemy के साथ निःशुल्क साइन अप करें](https://auth.alchemy.com/), हमारे [प्रलेखन](https://www.alchemy.com/docs/) देखें, और नवीनतम समाचारों के लिए, हमें [Twitter](https://twitter.com/AlchemyPlatform) पर फॉलो करें।_
diff --git a/public/content/translations/hi/developers/tutorials/guide-to-smart-contract-security-tools/index.md b/public/content/translations/hi/developers/tutorials/guide-to-smart-contract-security-tools/index.md
new file mode 100644
index 00000000000..cf1e033e768
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/guide-to-smart-contract-security-tools/index.md
@@ -0,0 +1,102 @@
+---
+title: "स्मार्ट अनुबंध सुरक्षा उपकरणों के लिए एक गाइड"
+description: "तीन विभिन्न परीक्षण और प्रोग्राम विश्लेषण तकनीकों का एक अवलोकन"
+author: "Trailofbits"
+lang: hi
+tags: [ "सोलिडीटी", "स्मार्ट अनुबंध", "सुरक्षा" ]
+skill: intermediate
+published: 2020-09-07
+source: "सुरक्षित अनुबंध बनाना"
+sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis
+---
+
+हम तीन विशिष्ट परीक्षण और प्रोग्राम विश्लेषण तकनीकों का उपयोग करने जा रहे हैं:
+
+- **[Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) के साथ स्थैतिक विश्लेषण।** प्रोग्राम के सभी पथों का अनुमान लगाया जाता है और विभिन्न प्रोग्राम प्रस्तुतियों (जैसे, नियंत्रण-प्रवाह-ग्राफ) के माध्यम से एक ही समय में विश्लेषण किया जाता है।
+- **[Echidna](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/) के साथ फ़ज़िंग।** कोड को लेनदेन की छद्म-यादृच्छिक पीढ़ी के साथ निष्पादित किया जाता है। फ़ज़र दी गई संपत्ति का उल्लंघन करने के लिए लेनदेन का एक क्रम खोजने का प्रयास करेगा।
+- **[Manticore](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/) के साथ प्रतीकात्मक निष्पादन।** एक औपचारिक सत्यापन तकनीक, जो प्रत्येक निष्पादन पथ को एक गणितीय सूत्र में अनुवादित करती है, जिस पर शीर्ष बाधाओं की जाँच की जा सकती है।
+
+प्रत्येक तकनीक के फायदे और नुकसान हैं, और यह [विशिष्ट मामलों](#determining-security-properties) में उपयोगी होगी:
+
+| तकनीक | उपकरण | उपयोग | गति | चूके हुए बग | झूठे अलार्म |
+| -------------------- | --------- | ------------------------- | ----- | ----------- | ----------- |
+| स्थैतिक विश्लेषण | Slither | CLI और स्क्रिप्ट | सेकंड | मध्यम | कम |
+| फ़ज़िंग | Echidna | Solidity गुण | मिनट | कम | कोई नहीं |
+| प्रतीकात्मक निष्पादन | Manticore | Solidity गुण और स्क्रिप्ट | घंटे | कोई नहीं\* | कोई नहीं |
+
+\* यदि सभी पथ बिना टाइमआउट के खोजे जाते हैं
+
+**Slither** सेकंड के भीतर अनुबंधों का विश्लेषण करता है, हालांकि, स्थैतिक विश्लेषण से झूठे अलार्म हो सकते हैं और जटिल जांच (जैसे, अंकगणितीय जांच) के लिए कम उपयुक्त होगा। बिल्ट-इन डिटेक्टरों तक पुश-बटन पहुंच के लिए API के माध्यम से या उपयोगकर्ता-परिभाषित जांच के लिए API के माध्यम से Slither चलाएं।
+
+**Echidna** को कई मिनट तक चलने की आवश्यकता है और यह केवल सही सकारात्मक परिणाम देगा। Echidna Solidity में लिखे गए उपयोगकर्ता-प्रदत्त सुरक्षा गुणों की जाँच करता है। यह बग्स को छोड़ सकता है क्योंकि यह यादृच्छिक अन्वेषण पर आधारित है।
+
+**Manticore** "सबसे भारी वजन" विश्लेषण करता है। Echidna की तरह, Manticore उपयोगकर्ता-प्रदत्त गुणों को सत्यापित करता है। इसे चलाने में अधिक समय लगेगा, लेकिन यह किसी संपत्ति की वैधता साबित कर सकता है और झूठे अलार्म की रिपोर्ट नहीं करेगा।
+
+## सुझाया गया वर्कफ़्लो {#suggested-workflow}
+
+यह सुनिश्चित करने के लिए कि अब कोई साधारण बग मौजूद नहीं है या बाद में पेश किया जाएगा, Slither के अंतर्निहित डिटेक्टरों से शुरू करें। विरासत, चर निर्भरता और संरचनात्मक मुद्दों से संबंधित गुणों की जांच के लिए Slither का उपयोग करें। जैसे-जैसे कोडबेस बढ़ता है, स्टेट मशीन के अधिक जटिल गुणों का परीक्षण करने के लिए Echidna का उपयोग करें। Solidity से अनुपलब्ध सुरक्षा के लिए कस्टम चेक विकसित करने के लिए Slither पर फिर से जाएं, जैसे कि किसी फ़ंक्शन को ओवरराइड करने से बचाना। अंत में, महत्वपूर्ण सुरक्षा गुणों के लक्षित सत्यापन के लिए Manticore का उपयोग करें, जैसे, अंकगणितीय संचालन।
+
+- सामान्य समस्याओं को पकड़ने के लिए Slither के CLI का उपयोग करें
+- अपने अनुबंध के उच्च-स्तरीय सुरक्षा गुणों का परीक्षण करने के लिए Echidna का उपयोग करें
+- कस्टम स्थैतिक जांच लिखने के लिए Slither का उपयोग करें
+- एक बार जब आप महत्वपूर्ण सुरक्षा गुणों का गहन आश्वासन चाहते हैं तो Manticore का उपयोग करें
+
+**इकाई परीक्षणों पर एक नोट**। उच्च-गुणवत्ता वाले सॉफ्टवेयर बनाने के लिए इकाई परीक्षण आवश्यक हैं। हालांकि, ये तकनीकें सुरक्षा खामियों को खोजने के लिए सबसे उपयुक्त नहीं हैं। वे आम तौर पर कोड के सकारात्मक व्यवहार का परीक्षण करने के लिए उपयोग किए जाते हैं (यानी, कोड सामान्य संदर्भ में अपेक्षा के अनुरूप काम करता है), जबकि सुरक्षा खामियां उन मामलों में रहती हैं जिन पर डेवलपर्स ने विचार नहीं किया। दर्जनों स्मार्ट अनुबंध सुरक्षा समीक्षाओं के हमारे अध्ययन में, [इकाई परीक्षण कवरेज का हमारे क्लाइंट के कोड में पाई गई सुरक्षा खामियों की संख्या या गंभीरता पर कोई प्रभाव नहीं पड़ा](https://blog.trailofbits.com/2019/08/08/246-findings-from-our-smart-contract-audits-an-executive-summary/)।
+
+## सुरक्षा गुणों का निर्धारण {#determining-security-properties}
+
+अपने कोड का प्रभावी ढंग से परीक्षण और सत्यापन करने के लिए, आपको उन क्षेत्रों की पहचान करनी होगी जिन पर ध्यान देने की आवश्यकता है। चूंकि सुरक्षा पर खर्च किए गए आपके संसाधन सीमित हैं, इसलिए अपने प्रयास को अनुकूलित करने के लिए अपने कोडबेस के कमजोर या उच्च-मूल्य वाले हिस्सों को निर्धारित करना महत्वपूर्ण है। खतरा मॉडलिंग मदद कर सकता है। समीक्षा करने पर विचार करें:
+
+- [रैपिड रिस्क असेसमेंट](https://infosec.mozilla.org/guidelines/risk/rapid_risk_assessment.html) (समय कम होने पर हमारा पसंदीदा दृष्टिकोण)
+- [डेटा-केंद्रित सिस्टम थ्रेट मॉडलिंग के लिए गाइड](https://csrc.nist.gov/pubs/sp/800/154/ipd) (उर्फ NIST 800-154)
+- [Shostack थ्रेट मॉडलिंग](https://www.amazon.com/Threat-Modeling-Designing-Adam-Shostack/dp/1118809998)
+- [STRIDE](https://wikipedia.org/wiki/STRIDE_\(security\)) / [DREAD](https://wikipedia.org/wiki/DREAD_\(risk_assessment_model\))
+- [PASTA](https://wikipedia.org/wiki/Threat_model#P.A.S.T.A.)
+- [दावों का उपयोग](https://blog.regehr.org/archives/1091)
+
+### घटक {#components}
+
+यह जानना कि आप क्या जाँचना चाहते हैं, आपको सही उपकरण चुनने में भी मदद करेगा।
+
+स्मार्ट अनुबंधों के लिए अक्सर प्रासंगिक व्यापक क्षेत्रों में शामिल हैं:
+
+- **स्टेट मशीन।** अधिकांश अनुबंधों को स्टेट मशीन के रूप में दर्शाया जा सकता है। यह जांचने पर विचार करें कि (1) कोई अमान्य स्थिति तक नहीं पहुंचा जा सकता है, (2) यदि कोई स्थिति मान्य है तो उस तक पहुंचा जा सकता है, और (3) कोई भी स्थिति अनुबंध को फंसाती नहीं है।
+
+ - Echidna और Manticore स्टेट-मशीन विनिर्देशों का परीक्षण करने के लिए पसंदीदा उपकरण हैं।
+
+- **एक्सेस कंट्रोल।** यदि आपके सिस्टम में विशेषाधिकार प्राप्त उपयोगकर्ता हैं (उदाहरण के लिए, एक मालिक, नियंत्रक, ...) आपको यह सुनिश्चित करना होगा कि (1) प्रत्येक उपयोगकर्ता केवल अधिकृत कार्य कर सकता है और (2) कोई भी उपयोगकर्ता अधिक विशेषाधिकार प्राप्त उपयोगकर्ता से कार्यों को ब्लॉक नहीं कर सकता है।
+
+ - Slither, Echidna और Manticore सही एक्सेस कंट्रोल की जांच कर सकते हैं। उदाहरण के लिए, Slither यह जांच सकता है कि केवल श्वेतसूचीबद्ध फ़ंक्शन में onlyOwner संशोधक की कमी है। Echidna और Manticore अधिक जटिल एक्सेस कंट्रोल के लिए उपयोगी हैं, जैसे कि केवल तभी अनुमति दी जाती है जब अनुबंध किसी दी गई स्थिति में पहुंचता है।
+
+- **अंकगणितीय संचालन।** अंकगणितीय संचालन की सुदृढ़ता की जाँच करना महत्वपूर्ण है। `SafeMath` का हर जगह उपयोग करना ओवरफ़्लो/अंडरफ़्लो को रोकने के लिए एक अच्छा कदम है, हालांकि, आपको अभी भी अन्य अंकगणितीय खामियों पर विचार करना चाहिए, जिसमें राउंडिंग मुद्दे और अनुबंध को फंसाने वाली खामियां शामिल हैं।
+
+ - Manticore यहाँ सबसे अच्छा विकल्प है। Echidna का उपयोग तब किया जा सकता है जब अंकगणित SMT सॉल्वर के दायरे से बाहर हो।
+
+- **विरासत की शुद्धता।** Solidity अनुबंध कई विरासतों पर बहुत अधिक निर्भर करते हैं। `super` कॉल से गायब शैडोइंग फ़ंक्शन और गलत व्याख्या किए गए c3 रैखिककरण क्रम जैसी गलतियाँ आसानी से पेश की जा सकती हैं।
+
+ - Slither इन मुद्दों का पता लगाने को सुनिश्चित करने वाला उपकरण है।
+
+- **बाहरी इंटरैक्शन।** अनुबंध एक दूसरे के साथ इंटरैक्ट करते हैं, और कुछ बाहरी अनुबंधों पर भरोसा नहीं किया जाना चाहिए। उदाहरण के लिए, यदि आपका अनुबंध बाहरी ओरेकल पर निर्भर करता है, तो क्या यह सुरक्षित रहेगा यदि आधे उपलब्ध ओरेकल से समझौता किया जाता है?
+
+ - Manticore और Echidna आपके अनुबंधों के साथ बाहरी इंटरैक्शन का परीक्षण करने के लिए सबसे अच्छा विकल्प हैं। Manticore में बाहरी अनुबंधों को स्टब करने के लिए एक अंतर्निहित तंत्र है।
+
+- **मानक अनुरूपता।** एथेरियम मानकों (उदाहरण के लिए, ERC20) के डिजाइन में खामियों का इतिहास है। जिस मानक पर आप निर्माण कर रहे हैं, उसकी सीमाओं से अवगत रहें।
+ - Slither, Echidna और Manticore आपको किसी दिए गए मानक से विचलन का पता लगाने में मदद करेंगे।
+
+### उपकरण चयन चीटशीट {#tool-selection-cheatsheet}
+
+| घटक | उपकरण | उदाहरण |
+| ----------------- | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| स्टेट मशीन | Echidna, Manticore | |
+| एक्सेस कंट्रोल | Slither, Echidna, Manticore | [Slither अभ्यास 2](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise2.md), [Echidna अभ्यास 2](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-2.md) |
+| अंकगणितीय संचालन | Manticore, Echidna | [Echidna अभ्यास 1](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-1.md), [Manticore अभ्यास 1 - 3](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore/exercises) |
+| विरासत की शुद्धता | Slither | [Slither अभ्यास 1](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise1.md) |
+| बाहरी इंटरैक्शन | Manticore, Echidna | |
+| मानक अनुरूपता | Slither, Echidna, Manticore | [`slither-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) |
+
+आपके लक्ष्यों के आधार पर अन्य क्षेत्रों की जाँच करने की आवश्यकता होगी, लेकिन फोकस के ये मोटे-दाने वाले क्षेत्र किसी भी स्मार्ट अनुबंध प्रणाली के लिए एक अच्छी शुरुआत हैं।
+
+हमारे सार्वजनिक ऑडिट में सत्यापित या परीक्षण किए गए गुणों के उदाहरण हैं। वास्तविक दुनिया की सुरक्षा संपत्तियों की समीक्षा करने के लिए निम्नलिखित रिपोर्टों के `स्वचालित परीक्षण और सत्यापन` अनुभागों को पढ़ने पर विचार करें:
+
+- [0x](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf)
+- [Balancer](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf)
diff --git a/public/content/translations/hi/developers/tutorials/hello-world-smart-contract-fullstack/index.md b/public/content/translations/hi/developers/tutorials/hello-world-smart-contract-fullstack/index.md
new file mode 100644
index 00000000000..abdaa8ed9fa
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/hello-world-smart-contract-fullstack/index.md
@@ -0,0 +1,1540 @@
+---
+title: "शुरुआती लोगों के लिए हैलो वर्ल्ड स्मार्ट अनुबंध - फुलस्टैक"
+description: "एथेरियम पर एक सरल स्मार्ट अनुबंध लिखने और तैनात करने पर परिचयात्मक ट्यूटोरियल।"
+author: "nstrike2"
+tags:
+ [
+ "सोलिडीटी",
+ "हार्डहैट",
+ "एल्केमी",
+ "स्मार्ट अनुबंध",
+ "परिनियोजित करना",
+ "ब्लॉक खोजकर्ता",
+ "frontend",
+ "लेनदेन"
+ ]
+skill: beginner
+lang: hi
+published: 2021-10-25
+---
+
+यह गाइड आपके लिए है यदि आप ब्लॉकचेन डेवलपमेंट में नए हैं और नहीं जानते कि कहां से शुरू करें या स्मार्ट अनुबंधों को कैसे डिप्लॉय और उनके साथ कैसे इंटरैक्ट करें। हम [MetaMask](https://metamask.io), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org), और [Alchemy](https://alchemy.com/eth) का उपयोग करके Goerli टेस्ट नेटवर्क पर एक सरल, स्मार्ट अनुबंध बनाने और डिप्लॉय करने के बारे में बताएंगे।
+
+इस ट्यूटोरियल को पूरा करने के लिए आपको एक Alchemy खाते की आवश्यकता होगी। [एक मुफ्त खाते के लिए साइन अप करें](https://www.alchemy.com/)।
+
+यदि आपके पास किसी भी समय कोई प्रश्न है, तो बेझिझक [Alchemy Discord](https://discord.gg/gWuC7zB) में संपर्क करें!
+
+## भाग 1 - Hardhat का उपयोग करके अपना स्मार्ट अनुबंध बनाएं और डिप्लॉय करें {#part-1}
+
+### एथेरियम नेटवर्क से कनेक्ट करें {#connect-to-the-ethereum-network}
+
+एथेरियम श्रृंखला के लिए अनुरोध करने के कई तरीके हैं। सरलता के लिए, हम Alchemy पर एक मुफ्त खाते का उपयोग करेंगे, जो एक ब्लॉकचेन डेवलपर प्लेटफ़ॉर्म और API है जो हमें खुद एक नोड चलाए बिना एथेरियम श्रृंखला के साथ संचार करने की अनुमति देता है। Alchemy में निगरानी और विश्लेषण के लिए डेवलपर टूल भी हैं; हम इस ट्यूटोरियल में इनका लाभ उठाएंगे ताकि यह समझ सकें कि हमारे स्मार्ट अनुबंध डिप्लॉयमेंट में क्या हो रहा है।
+
+### अपना ऐप और API कुंजी बनाएं {#create-your-app-and-api-key}
+
+एक बार जब आप एक Alchemy खाता बना लेते हैं, तो आप एक ऐप बनाकर एक API कुंजी उत्पन्न कर सकते हैं। यह आपको Goerli टेस्टनेट पर अनुरोध करने की अनुमति देगा। यदि आप टेस्टनेट से परिचित नहीं हैं तो आप [एक नेटवर्क चुनने के लिए Alchemy की गाइड पढ़ सकते हैं](https://www.alchemy.com/docs/choosing-a-web3-network)।
+
+Alchemy डैशबोर्ड पर, नेविगेशन बार में **Apps** ड्रॉपडाउन ढूंढें और **Create App** पर क्लिक करें।
+
+
+
+अपने ऐप को '_Hello World_' नाम दें और एक संक्षिप्त विवरण लिखें। अपने परिवेश के रूप में **स्टेजिंग** और अपने नेटवर्क के रूप में **Goerli** का चयन करें।
+
+
+
+_नोट: **Goerli** का चयन करना सुनिश्चित करें, अन्यथा यह ट्यूटोरियल काम नहीं करेगा।_
+
+**Create app** पर क्लिक करें। आपका ऐप नीचे दी गई तालिका में दिखाई देगा।
+
+### एक एथेरियम खाता बनाएं {#create-an-ethereum-account}
+
+लेन-देन भेजने और प्राप्त करने के लिए आपको एक एथेरियम खाते की आवश्यकता है। हम MetaMask का उपयोग करेंगे, जो ब्राउज़र में एक वर्चुअल वॉलेट है जो यूज़र्स को अपना एथेरियम खाता पता प्रबंधित करने देता है।
+
+आप [यहां](https://metamask.io/download) मुफ्त में MetaMask खाता डाउनलोड और बना सकते हैं। जब आप एक खाता बना रहे हों, या यदि आपके पास पहले से ही एक खाता है, तो ऊपरी दाएं कोने में "Goerli टेस्ट नेटवर्क" पर स्विच करना सुनिश्चित करें (ताकि हम असली पैसे से काम न कर रहे हों)।
+
+### चरण 4: एक फोसेट से ईथर जोड़ें {#step-4-add-ether-from-a-faucet}
+
+अपने स्मार्ट अनुबंध को टेस्ट नेटवर्क पर डिप्लॉय करने के लिए, आपको कुछ नकली ETH की आवश्यकता होगी। Goerli नेटवर्क पर ETH प्राप्त करने के लिए, Goerli फॉसेट पर जाएं और अपना Goerli खाता पता दर्ज करें। ध्यान दें कि Goerli फॉसेट हाल ही में थोड़े अविश्वसनीय हो सकते हैं - आज़माने के लिए विकल्पों की सूची के लिए [टेस्ट नेटवर्क पेज](/developers/docs/networks/#goerli) देखें:
+
+_नोट: नेटवर्क संकुलन के कारण, इसमें कुछ समय लग सकता है।_
+``
+
+### चरण 5: अपना बैलेंस जांचें {#step-5-check-your-balance}
+
+यह दोबारा जांचने के लिए कि ETH आपके वॉलेट में है, आइए [Alchemy के कंपोजर टूल](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D) का उपयोग करके एक [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) अनुरोध करें। यह हमारे वॉलेट में ETH की राशि वापस कर देगा। अधिक जानने के लिए [कंपोजर टूल का उपयोग कैसे करें पर Alchemy का छोटा ट्यूटोरियल](https://youtu.be/r6sjRxBZJuU) देखें।
+
+अपना MetaMask खाता पता दर्ज करें और **अनुरोध भेजें** पर क्लिक करें। आपको एक प्रतिक्रिया दिखाई देगी जो नीचे दिए गए कोड स्निपेट की तरह दिखती है।
+
+```json
+{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
+```
+
+> _नोट: यह परिणाम wei में है, ETH में नहीं। Wei का उपयोग ईथर के सबसे छोटे मूल्यवर्ग के रूप में किया जाता है।_
+
+उफ्फ! हमारे नकली पैसे पूरे हैं।
+
+### चरण 6: हमारे प्रोजेक्ट को शुरू करें {#step-6-initialize-our-project}
+
+सबसे पहले, हमें अपने प्रोजेक्ट के लिए एक फ़ोल्डर बनाना होगा। अपनी कमांड लाइन पर नेविगेट करें और निम्नलिखित इनपुट करें।
+
+```
+mkdir hello-world
+cd hello-world
+```
+
+अब जब हम अपने प्रोजेक्ट फ़ोल्डर के अंदर हैं, तो हम प्रोजेक्ट को प्रारंभ करने के लिए `npm init` का उपयोग करेंगे।
+
+> यदि आपके पास अभी तक npm स्थापित नहीं है, तो [Node.js और npm स्थापित करने के लिए इन निर्देशों का पालन करें](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm)।
+
+इस ट्यूटोरियल के उद्देश्य के लिए, इससे कोई फर्क नहीं पड़ता कि आप आरंभीकरण प्रश्नों का उत्तर कैसे देते हैं। यहां संदर्भ के लिए बताया गया है कि हमने इसे कैसे किया:
+
+```
+पैकेज का नाम: (hello-world)
+संस्करण: (1.0.0)
+विवरण: हैलो वर्ल्ड स्मार्ट अनुबंध
+एंट्री पॉइंट: (index.js)
+टेस्ट कमांड:
+गिट रिपॉजिटरी:
+कीवर्ड:
+लेखक:
+लाइसेंस: (ISC)
+
+/Users/.../.../.../hello-world/package.json पर लिखने वाला है:
+
+{
+ "name": "hello-world",
+ "version": "1.0.0",
+ "description": "हैलो वर्ल्ड स्मार्ट अनुबंध",
+ "main": "index.js",
+ "scripts": {
+ "test": "echo \"Error: no test specified\" && exit 1"
+ },
+ "author": "",
+ "license": "ISC"
+}
+```
+
+package.json को स्वीकृत करें और हम जाने के लिए तैयार हैं!
+
+### चरण 7: Hardhat डाउनलोड करें {#step-7-download-hardhat}
+
+Hardhat आपके एथेरियम सॉफ्टवेयर को कंपाइल, डिप्लॉय, टेस्ट और डीबग करने के लिए एक डेवलपमेंट वातावरण है। यह डेवलपर्स को लाइव चेन पर डिप्लॉय करने से पहले स्थानीय रूप से स्मार्ट अनुबंध और डैप्स बनाने में मदद करता है।
+
+हमारे `hello-world` प्रोजेक्ट के अंदर चलाएं:
+
+```
+npm install --save-dev hardhat
+```
+
+[इंस्टॉलेशन निर्देशों](https://hardhat.org/getting-started/#overview) पर अधिक जानकारी के लिए यह पेज देखें।
+
+### चरण 8: Hardhat प्रोजेक्ट बनाएं {#step-8-create-hardhat-project}
+
+हमारे `hello-world` प्रोजेक्ट फ़ोल्डर के अंदर, चलाएँ:
+
+```
+npx hardhat
+```
+
+इसके बाद आपको एक स्वागत संदेश और यह चुनने का विकल्प देखना चाहिए कि आप क्या करना चाहते हैं। “create an empty hardhat.config.js” चुनें:
+
+```
+888 888 888 888 888
+888 888 888 888 888
+888 888 888 888 888
+8888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888
+888 888 "88b 888P" d88" 888 888 "88b "88b 888
+888 888 .d888888 888 888 888 888 888 .d888888 888
+888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
+888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
+
+👷 Hardhat v2.0.11 में आपका स्वागत है 👷
+
+आप क्या करना चाहते हैं? …
+एक नमूना प्रोजेक्ट बनाएं
+❯ एक खाली hardhat.config.js बनाएं
+छोड़ें
+```
+
+यह प्रोजेक्ट में एक `hardhat.config.js` फ़ाइल उत्पन्न करेगा। हम इसका उपयोग बाद में ट्यूटोरियल में अपने प्रोजेक्ट के सेटअप को निर्दिष्ट करने के लिए करेंगे।
+
+### चरण 9: प्रोजेक्ट फ़ोल्डर जोड़ें {#step-9-add-project-folders}
+
+प्रोजेक्ट को व्यवस्थित रखने के लिए, आइए दो नए फ़ोल्डर बनाएं। कमांड लाइन में, अपने `hello-world` प्रोजेक्ट की रूट डायरेक्टरी पर नेविगेट करें और टाइप करें:
+
+```
+mkdir contracts
+mkdir scripts
+```
+
+- `contracts/` वह जगह है जहाँ हम अपनी हैलो वर्ल्ड स्मार्ट अनुबंध कोड फ़ाइल रखेंगे
+- `scripts/` वह जगह है जहाँ हम अपने अनुबंध को तैनात करने और उसके साथ बातचीत करने के लिए स्क्रिप्ट रखेंगे
+
+### चरण 10: हमारा अनुबंध लिखें {#step-10-write-our-contract}
+
+आप खुद से पूछ रहे होंगे कि हम कोड कब लिखेंगे? यही समय है!
+
+अपने पसंदीदा संपादक में हैलो-वर्ल्ड प्रोजेक्ट खोलें। स्मार्ट अनुबंध आमतौर पर Solidity में लिखे जाते हैं, जिसका उपयोग हम अपना स्मार्ट अनुबंध लिखने के लिए करेंगे।
+
+1. `contracts` फ़ोल्डर में नेविगेट करें और `HelloWorld.sol` नामक एक नई फ़ाइल बनाएं
+2. नीचे एक नमूना हैलो वर्ल्ड स्मार्ट अनुबंध है जिसका उपयोग हम इस ट्यूटोरियल के लिए करेंगे। नीचे दी गई सामग्री को `HelloWorld.sol` फ़ाइल में कॉपी करें।
+
+_नोट: यह अनुबंध क्या करता है यह समझने के लिए टिप्पणियों को पढ़ना सुनिश्चित करें।_
+
+```
+// सिमेंटिक वर्जनिंग का उपयोग करके, सॉलिडिटी के संस्करण को निर्दिष्ट करता है।
+// और जानें: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+pragma solidity >=0.7.3;
+
+// 'HelloWorld' नामक एक अनुबंध को परिभाषित करता है।
+// एक अनुबंध कार्यों और डेटा (इसकी स्थिति) का एक संग्रह है। एक बार डिप्लॉय होने के बाद, एक अनुबंध एथेरियम ब्लॉकचेन पर एक विशिष्ट पते पर रहता है। और जानें: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+contract HelloWorld {
+
+ //अपडेट फ़ंक्शन कॉल होने पर उत्सर्जित होता है
+ //स्मार्ट अनुबंध इवेंट आपके अनुबंध के लिए यह संवाद करने का एक तरीका है कि ब्लॉकचेन पर आपके ऐप फ्रंट-एंड में कुछ हुआ है, जो कुछ इवेंट्स को 'सुन' सकता है और उनके होने पर कार्रवाई कर सकता है।
+ event UpdatedMessages(string oldStr, string newStr);
+
+ // 'स्ट्रिंग' प्रकार के एक स्टेट चर 'संदेश' की घोषणा करता है।
+ // स्टेट चर वे चर होते हैं जिनके मान अनुबंध भंडारण में स्थायी रूप से संग्रहीत होते हैं। कीवर्ड 'पब्लिक' चर को अनुबंध के बाहर से सुलभ बनाता है और एक फ़ंक्शन बनाता है जिसे अन्य अनुबंध या क्लाइंट मान तक पहुंचने के लिए कॉल कर सकते हैं।
+ string public message;
+
+ // कई वर्ग-आधारित ऑब्जेक्ट-ओरिएंटेड भाषाओं के समान, एक कंस्ट्रक्टर एक विशेष फ़ंक्शन है जो केवल अनुबंध निर्माण पर निष्पादित होता है।
+ // कंस्ट्रक्टर का उपयोग अनुबंध के डेटा को आरंभ करने के लिए किया जाता है। और जानें: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ constructor(string memory initMessage) {
+
+ // एक स्ट्रिंग तर्क 'initMessage' स्वीकार करता है और अनुबंध के 'संदेश' भंडारण चर में मान सेट करता है)।
+ message = initMessage;
+ }
+
+ // एक सार्वजनिक फ़ंक्शन जो एक स्ट्रिंग तर्क स्वीकार करता है और 'संदेश' भंडारण चर को अपडेट करता है।
+ function update(string memory newMessage) public {
+ string memory oldMsg = message;
+ message = newMessage;
+ emit UpdatedMessages(oldMsg, newMessage);
+ }
+}
+```
+
+यह एक बुनियादी स्मार्ट अनुबंध है जो निर्माण पर एक संदेश संग्रहीत करता है। इसे `update` फ़ंक्शन को कॉल करके अपडेट किया जा सकता है।
+
+### चरण 11: MetaMask और Alchemy को अपने प्रोजेक्ट से कनेक्ट करें {#step-11-connect-metamask-alchemy-to-your-project}
+
+हमने एक MetaMask वॉलेट, Alchemy खाता बनाया है, और अपना स्मार्ट अनुबंध लिखा है, अब तीनों को जोड़ने का समय है।
+
+आपके वॉलेट से भेजे गए प्रत्येक लेनदेन के लिए आपकी अद्वितीय निजी कुंजी का उपयोग करके एक हस्ताक्षर की आवश्यकता होती है। हमारे प्रोग्राम को यह अनुमति प्रदान करने के लिए, हम अपनी निजी कुंजी को एक पर्यावरण फ़ाइल में सुरक्षित रूप से संग्रहीत कर सकते हैं। हम यहां Alchemy के लिए एक API कुंजी भी संग्रहीत करेंगे।
+
+> लेन-देन भेजने के बारे में अधिक जानने के लिए, वेब3 का उपयोग करके लेन-देन भेजने पर [यह ट्यूटोरियल](https://www.alchemy.com/docs/hello-world-smart-contract#step-11-connect-metamask--alchemy-to-your-project) देखें।
+
+सबसे पहले, अपने प्रोजेक्ट डायरेक्टरी में dotenv पैकेज इंस्टॉल करें:
+
+```
+npm install dotenv --save
+```
+
+फिर, प्रोजेक्ट की रूट डायरेक्टरी में एक `.env` फ़ाइल बनाएं। अपनी MetaMask निजी कुंजी और HTTP Alchemy API URL इसमें जोड़ें।
+
+आपकी पर्यावरण फ़ाइल का नाम `.env` होना चाहिए या इसे पर्यावरण फ़ाइल के रूप में नहीं पहचाना जाएगा।
+
+इसे `process.env` या `.env-custom` या कुछ और नाम न दें।
+
+- अपनी निजी कुंजी निर्यात करने के लिए [इन निर्देशों](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) का पालन करें
+- HTTP Alchemy API URL प्राप्त करने के लिए नीचे देखें
+
+
+
+आपका `.env` इस तरह दिखना चाहिए:
+
+```
+API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
+PRIVATE_KEY = "your-metamask-private-key"
+```
+
+वास्तव में इन्हें हमारे कोड से जोड़ने के लिए, हम इन चरों को अपनी `hardhat.config.js` फ़ाइल में चरण 13 पर संदर्भित करेंगे।
+
+### चरण 12: Ethers.js इंस्टॉल करें {#step-12-install-ethersjs}
+
+Ethers.js एक लाइब्रेरी है जो अधिक उपयोगकर्ता अनुकूल तरीकों के साथ [मानक JSON-RPC विधियों](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc) को लपेटकर एथेरियम से इंटरैक्ट करना और अनुरोध करना आसान बनाती है।
+
+Hardhat हमें अतिरिक्त टूलींग और विस्तारित कार्यक्षमता के लिए [प्लगइन्स](https://hardhat.org/plugins/) को एकीकृत करने की अनुमति देता है। हम अनुबंध डिप्लॉयमेंट के लिए [ईथर प्लगइन](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) का लाभ उठाएंगे।
+
+अपनी प्रोजेक्ट डायरेक्टरी में टाइप करें:
+
+```bash
+npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
+```
+
+### चरण 13: hardhat.config.js को अपडेट करें {#step-13-update-hardhat-configjs}
+
+हमने अब तक कई निर्भरताएँ और प्लगइन्स जोड़े हैं, अब हमें `hardhat.config.js` को अपडेट करने की आवश्यकता है ताकि हमारी परियोजना उन सभी के बारे में जान सके।
+
+अपने `hardhat.config.js` को इस तरह दिखने के लिए अपडेट करें:
+
+```javascript
+/**
+ * @type import('hardhat/config').HardhatUserConfig
+ */
+
+require("dotenv").config()
+require("@nomiclabs/hardhat-ethers")
+
+const { API_URL, PRIVATE_KEY } = process.env
+
+module.exports = {
+ solidity: "0.7.3",
+ defaultNetwork: "goerli",
+ networks: {
+ hardhat: {},
+ goerli: {
+ url: API_URL,
+ accounts: [`0x${PRIVATE_KEY}`],
+ },
+ },
+}
+```
+
+### चरण 14: हमारे अनुबंध को संकलित करें {#step-14-compile-our-contract}
+
+यह सुनिश्चित करने के लिए कि अब तक सब कुछ काम कर रहा है, आइए हम अपने अनुबंध को कंपाइल करें। `compile` कार्य अंतर्निहित हार्डहैट कार्यों में से एक है।
+
+कमांड लाइन से चलाएं:
+
+```bash
+npx hardhat compile
+```
+
+आपको `SPDX लाइसेंस पहचानकर्ता स्रोत फ़ाइल में प्रदान नहीं किया गया है` के बारे में एक चेतावनी मिल सकती है, लेकिन इसके बारे में चिंता करने की कोई आवश्यकता नहीं है - उम्मीद है कि बाकी सब कुछ अच्छा लगेगा! यदि नहीं, तो आप हमेशा [Alchemy discord](https://discord.gg/u72VCg3) में संदेश भेज सकते हैं।
+
+### चरण 15: हमारी डिप्लॉय स्क्रिप्ट लिखें {#step-15-write-our-deploy-script}
+
+अब जब हमारा अनुबंध लिखा गया है और हमारी कॉन्फ़िगरेशन फ़ाइल तैयार है, तो हमारी अनुबंध डिप्लॉय स्क्रिप्ट लिखने का समय आ गया है।
+
+`scripts/` फ़ोल्डर पर नेविगेट करें और `deploy.js` नामक एक नई फ़ाइल बनाएं, जिसमें निम्नलिखित सामग्री जोड़ें:
+
+```javascript
+async function main() {
+ const HelloWorld = await ethers.getContractFactory("HelloWorld")
+
+ // परिनियोजन शुरू करें, एक वादा लौटाते हुए जो एक अनुबंध वस्तु में हल हो जाता है
+ const hello_world = await HelloWorld.deploy("Hello World!")
+ console.log("अनुबंध पते पर तैनात किया गया:", hello_world.address)
+}
+
+main()
+ .then(() => process.exit(0))
+ .catch((error) => {
+ console.error(error)
+ process.exit(1)
+ })
+```
+
+Hardhat अपने [अनुबंध ट्यूटोरियल](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) में कोड की इन पंक्तियों में से प्रत्येक क्या करता है, यह समझाने का एक अद्भुत काम करता है, हमने यहां उनकी व्याख्याओं को अपनाया है।
+
+```javascript
+const HelloWorld = await ethers.getContractFactory("HelloWorld")
+```
+
+ethers.js में एक `ContractFactory` नए स्मार्ट अनुबंधों को डिप्लॉय करने के लिए उपयोग किया जाने वाला एक सार है, इसलिए `HelloWorld` यहां हमारे हैलो वर्ल्ड अनुबंध के उदाहरणों के लिए एक [फ़ैक्टरी](https://en.wikipedia.org/wiki/Factory_\(object-oriented_programming\)) है। `hardhat-ethers` प्लगइन `ContractFactory` और `Contract` का उपयोग करते समय, उदाहरण डिफ़ॉल्ट रूप से पहले हस्ताक्षरकर्ता (स्वामी) से जुड़े होते हैं।
+
+```javascript
+const hello_world = await HelloWorld.deploy()
+```
+
+`ContractFactory` पर `deploy()` को कॉल करने से परिनियोजन शुरू हो जाएगा, और एक `Promise` वापस आ जाएगी जो `Contract` ऑब्जेक्ट में हल हो जाएगी। यह वह ऑब्जेक्ट है जिसमें हमारे प्रत्येक स्मार्ट अनुबंध फ़ंक्शन के लिए एक विधि है।
+
+### चरण 16: हमारे अनुबंध को तैनात करें {#step-16-deploy-our-contract}
+
+हम अंततः अपने स्मार्ट अनुबंध को डिप्लॉय करने के लिए तैयार हैं! कमांड लाइन पर नेविगेट करें और चलाएं:
+
+```bash
+npx hardhat run scripts/deploy.js --network goerli
+```
+
+इसके बाद आपको कुछ इस तरह देखना चाहिए:
+
+```bash
+अनुबंध पते पर तैनात: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
+```
+
+**कृपया इस पते को सेव करें**। हम इसका उपयोग बाद में ट्यूटोरियल में करेंगे।
+
+यदि हम [Goerli etherscan](https://goerli.etherscan.io) पर जाते हैं और अपने अनुबंध पते की खोज करते हैं तो हमें यह देखने में सक्षम होना चाहिए कि इसे सफलतापूर्वक डिप्लॉय किया गया है। लेनदेन कुछ इस तरह दिखेगा:
+
+
+
+`From` पता आपके MetaMask खाता पते से मेल खाना चाहिए और `To` पता **अनुबंध निर्माण** कहेगा। यदि हम लेनदेन में क्लिक करते हैं तो हम `To` फ़ील्ड में अपना अनुबंध पता देखेंगे।
+
+
+
+बधाई हो! आपने अभी-अभी एक एथेरियम टेस्टनेट पर एक स्मार्ट अनुबंध डिप्लॉय किया है।
+
+यह समझने के लिए कि हुड के नीचे क्या हो रहा है, आइए हमारे [Alchemy डैशबोर्ड](https://dashboard.alchemy.com/explorer) में एक्सप्लोरर टैब पर नेविगेट करें। यदि आपके पास कई Alchemy ऐप्स हैं तो ऐप द्वारा फ़िल्टर करना सुनिश्चित करें और **हैलो वर्ल्ड** का चयन करें।
+
+
+
+यहां आपको कुछ JSON-RPC विधियां दिखाई देंगी जो Hardhat/Ethers ने हमारे लिए तब बनाई थीं जब हमने `.deploy()` फ़ंक्शन को कॉल किया था। यहां दो महत्वपूर्ण विधियां हैं [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), जो हमारे अनुबंध को Goerli श्रृंखला पर लिखने का अनुरोध है, और [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash), जो हैश दिए जाने पर हमारे लेनदेन के बारे में जानकारी पढ़ने का अनुरोध है। लेन-देन भेजने के बारे में अधिक जानने के लिए, [वेब3 का उपयोग करके लेन-देन भेजने पर हमारा ट्यूटोरियल](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) देखें।
+
+## भाग 2: अपने स्मार्ट अनुबंध के साथ सहभागिता करें {#part-2-interact-with-your-smart-contract}
+
+अब जब हमने Goerli नेटवर्क पर एक स्मार्ट अनुबंध सफलतापूर्वक तैनात कर लिया है, तो आइए जानें कि इसके साथ कैसे इंटरैक्ट किया जाए।
+
+### एक interact.js फ़ाइल बनाएँ {#create-a-interactjs-file}
+
+यह वह फ़ाइल है जहाँ हम अपनी इंटरैक्शन स्क्रिप्ट लिखेंगे। हम Ethers.js लाइब्रेरी का उपयोग करेंगे जिसे आपने पहले भाग 1 में स्थापित किया था।
+
+`scripts/`फ़ोल्डर के अंदर, `interact.js` नामक एक नई फ़ाइल बनाएँ, निम्नलिखित कोड जोड़ें:
+
+```javascript
+// interact.js
+
+const API_KEY = process.env.API_KEY
+const PRIVATE_KEY = process.env.PRIVATE_KEY
+const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS
+```
+
+### अपनी .env फ़ाइल अपडेट करें {#update-your-env-file}
+
+हम नए पर्यावरण चर का उपयोग करेंगे, इसलिए हमें उन्हें `.env` फ़ाइल में परिभाषित करने की आवश्यकता है जिसे [हमने पहले बनाया था](#step-11-connect-metamask-&-alchemy-to-your-project)।
+
+हमें अपने Alchemy `API_KEY` और `CONTRACT_ADDRESS` के लिए एक परिभाषा जोड़ने की आवश्यकता होगी जहाँ आपका स्मार्ट अनुबंध डिप्लॉय किया गया था।
+
+आपकी `.env` फ़ाइल कुछ इस तरह दिखनी चाहिए:
+
+```bash
+# .env
+
+API_URL = "https://eth-goerli.alchemyapi.io/v2/"
+API_KEY = ""
+PRIVATE_KEY = ""
+CONTRACT_ADDRESS = "0x"
+```
+
+### अपना अनुबंध ABI प्राप्त करें {#grab-your-contract-ABI}
+
+हमारा अनुबंध [ABI (एप्लिकेशन बाइनरी इंटरफ़ेस)](/glossary/#abi) हमारे स्मार्ट अनुबंध के साथ इंटरैक्ट करने का इंटरफ़ेस है। Hardhat स्वचालित रूप से एक ABI उत्पन्न करता है और इसे `HelloWorld.json` में सहेजता है। ABI का उपयोग करने के लिए, हमें अपनी `interact.js` फ़ाइल में कोड की निम्नलिखित पंक्तियाँ जोड़कर सामग्री को पार्स करना होगा:
+
+```javascript
+// interact.js
+const contract = require("../artifacts/contracts/HelloWorld.sol/HelloWorld.json")
+```
+
+यदि आप ABI देखना चाहते हैं तो आप इसे अपने कंसोल पर प्रिंट कर सकते हैं:
+
+```javascript
+console.log(JSON.stringify(contract.abi))
+```
+
+कंसोल में अपना ABI मुद्रित देखने के लिए, अपने टर्मिनल पर नेविगेट करें और चलाएँ:
+
+```bash
+npx hardhat run scripts/interact.js
+```
+
+### अपने अनुबंध का एक उदाहरण बनाएँ {#create-an-instance-of-your-contract}
+
+हमारे अनुबंध के साथ इंटरैक्ट करने के लिए, हमें अपने कोड में एक अनुबंध उदाहरण बनाने की आवश्यकता है। Ethers.js के साथ ऐसा करने के लिए, हमें तीन अवधारणाओं के साथ काम करने की आवश्यकता होगी:
+
+1. प्रदाता - एक नोड प्रदाता जो आपको ब्लॉकचेन तक पढ़ने और लिखने की सुविधा देता है
+2. हस्ताक्षरकर्ता - एक एथेरियम खाते का प्रतिनिधित्व करता है जो लेनदेन पर हस्ताक्षर कर सकता है
+3. अनुबंध - ऑनचेन तैनात एक विशिष्ट अनुबंध का प्रतिनिधित्व करने वाली एक Ethers.js ऑब्जेक्ट
+
+हम अनुबंध का उदाहरण बनाने के लिए पिछले चरण से अनुबंध ABI का उपयोग करेंगे:
+
+```javascript
+// interact.js
+
+// प्रदाता
+const alchemyProvider = new ethers.providers.AlchemyProvider(
+ (network = "goerli"),
+ API_KEY
+)
+
+// हस्ताक्षरकर्ता
+const signer = new ethers.Wallet(PRIVATE_KEY, alchemyProvider)
+
+// अनुबंध
+const helloWorldContract = new ethers.Contract(
+ CONTRACT_ADDRESS,
+ contract.abi,
+ signer
+)
+```
+
+[ethers.js प्रलेखन](https://docs.ethers.io/v5/) में प्रदाताओं, हस्ताक्षरकर्ताओं और अनुबंधों के बारे में अधिक जानें।
+
+### प्रारंभिक संदेश पढ़ें {#read-the-init-message}
+
+याद रखें जब हमने `initMessage = "Hello world!"` के साथ अपना अनुबंध डिप्लॉय किया था? अब हम अपने स्मार्ट अनुबंध में संग्रहीत उस संदेश को पढ़ने और उसे कंसोल पर प्रिंट करने जा रहे हैं।
+
+जावास्क्रिप्ट में, नेटवर्क के साथ इंटरैक्ट करते समय अतुल्यकालिक कार्यों का उपयोग किया जाता है। अतुल्यकालिक कार्यों के बारे में अधिक जानने के लिए, [यह मध्यम लेख पढ़ें](https://blog.bitsrc.io/understanding-asynchronous-javascript-the-event-loop-74cd408419ff)।
+
+हमारे स्मार्ट अनुबंध में `message` फ़ंक्शन को कॉल करने और प्रारंभ संदेश को पढ़ने के लिए नीचे दिए गए कोड का उपयोग करें:
+
+```javascript
+// interact.js
+
+// ...
+
+async function main() {
+ const message = await helloWorldContract.message()
+ console.log("The message is: " + message)
+}
+main()
+```
+
+टर्मिनल में `npx hardhat run scripts/interact.js` का उपयोग करके फ़ाइल चलाने के बाद हमें यह प्रतिक्रिया देखनी चाहिए:
+
+```
+संदेश है: हैलो वर्ल्ड!
+```
+
+बधाई हो! आपने अभी-अभी एथेरियम ब्लॉकचेन से स्मार्ट अनुबंध डेटा सफलतापूर्वक पढ़ा है, बहुत बढ़िया!
+
+### संदेश अपडेट करें {#update-the-message}
+
+सिर्फ संदेश पढ़ने के बजाय, हम `update` फ़ंक्शन का उपयोग करके अपने स्मार्ट अनुबंध में सहेजे गए संदेश को भी अपडेट कर सकते हैं! बहुत बढ़िया, है ना?
+
+संदेश को अपडेट करने के लिए, हम सीधे अपने इंस्टेंटिएटेड अनुबंध ऑब्जेक्ट पर `update` फ़ंक्शन को कॉल कर सकते हैं:
+
+```javascript
+// interact.js
+
+// ...
+
+async function main() {
+ const message = await helloWorldContract.message()
+ console.log("The message is: " + message)
+
+ console.log("Updating the message...")
+ const tx = await helloWorldContract.update("This is the new message.")
+ await tx.wait()
+}
+main()
+```
+
+ध्यान दें कि पंक्ति 11 पर, हम लौटाए गए लेनदेन ऑब्जेक्ट पर `.wait()` पर कॉल करते हैं। यह सुनिश्चित करता है कि हमारी स्क्रिप्ट फ़ंक्शन से बाहर निकलने से पहले ब्लॉकचेन पर लेनदेन के खनन की प्रतीक्षा करती है। यदि `.wait()` कॉल शामिल नहीं है, तो स्क्रिप्ट अनुबंध में अपडेट किए गए `message` मान को नहीं देख सकती है।
+
+### नया संदेश पढ़ें {#read-the-new-message}
+
+आपको अपडेट किए गए `message` मान को पढ़ने के लिए [पिछला चरण](#read-the-init-message) दोहराने में सक्षम होना चाहिए। एक क्षण लें और देखें कि क्या आप उस नए मान को प्रिंट करने के लिए आवश्यक परिवर्तन कर सकते हैं!
+
+यदि आपको किसी संकेत की आवश्यकता है, तो यहां बताया गया है कि आपकी `interact.js` फ़ाइल इस बिंदु पर कैसी दिखनी चाहिए:
+
+```javascript
+// interact.js
+
+const API_KEY = process.env.API_KEY
+const PRIVATE_KEY = process.env.PRIVATE_KEY
+const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS
+
+const contract = require("../artifacts/contracts/HelloWorld.sol/HelloWorld.json")
+
+// प्रदाता - Alchemy
+const alchemyProvider = new ethers.providers.AlchemyProvider(
+ (network = "goerli"),
+ API_KEY
+)
+
+// हस्ताक्षरकर्ता - आप
+const signer = new ethers.Wallet(PRIVATE_KEY, alchemyProvider)
+
+// अनुबंध उदाहरण
+const helloWorldContract = new ethers.Contract(
+ CONTRACT_ADDRESS,
+ contract.abi,
+ signer
+)
+
+async function main() {
+ const message = await helloWorldContract.message()
+ console.log("The message is: " + message)
+
+ console.log("Updating the message...")
+ const tx = await helloWorldContract.update("this is the new message")
+ await tx.wait()
+
+ const newMessage = await helloWorldContract.message()
+ console.log("The new message is: " + newMessage)
+}
+
+main()
+```
+
+अब बस स्क्रिप्ट चलाएं और आपको पुराना संदेश, अपडेटिंग स्थिति और नया संदेश अपने टर्मिनल पर मुद्रित होना चाहिए!
+
+`npx hardhat run scripts/interact.js --network goerli`
+
+```
+संदेश है: हैलो वर्ल्ड!
+संदेश अपडेट हो रहा है...
+नया संदेश है: यह नया संदेश है।
+```
+
+उस स्क्रिप्ट को चलाते समय, आप देख सकते हैं कि नया संदेश लोड होने से पहले `Updating the message...` चरण लोड होने में कुछ समय लगता है। यह खनन प्रक्रिया के कारण है; यदि आप लेन-देन को ट्रैक करने के बारे में उत्सुक हैं, जबकि वे खनन किए जा रहे हैं, तो लेन-देन की स्थिति देखने के लिए [Alchemy mempool](https://dashboard.alchemyapi.io/mempool) पर जाएं। यदि लेन-देन गिरा दिया जाता है, तो [Goerli Etherscan](https://goerli.etherscan.io) की जाँच करना और अपने लेन-देन हैश की खोज करना भी सहायक होता है।
+
+## भाग 3: अपने स्मार्ट अनुबंध को Etherscan पर प्रकाशित करें {#part-3-publish-your-smart-contract-to-etherscan}
+
+आपने अपने स्मार्ट अनुबंध को जीवंत करने की सारी मेहनत की; अब इसे दुनिया के साथ साझा करने का समय है!
+
+Etherscan पर अपने स्मार्ट अनुबंध को सत्यापित करके, कोई भी आपके स्रोत कोड को देख सकता है और आपके स्मार्ट अनुबंध के साथ इंटरैक्ट कर सकता है। चलिए शुरू करते हैं!
+
+### चरण 1: अपने Etherscan खाते पर एक API कुंजी उत्पन्न करें {#step-1-generate-an-api-key-on-your-etherscan-account}
+
+एक Etherscan API कुंजी यह सत्यापित करने के लिए आवश्यक है कि आप जिस स्मार्ट अनुबंध को प्रकाशित करने का प्रयास कर रहे हैं, उसके स्वामी हैं।
+
+यदि आपके पास पहले से Etherscan खाता नहीं है, तो [एक खाते के लिए साइन अप करें](https://etherscan.io/register)।
+
+लॉग इन करने के बाद, नेविगेशन बार में अपना उपयोगकर्ता नाम ढूंढें, उस पर होवर करें और **मेरी प्रोफ़ाइल** बटन का चयन करें।
+
+आपके प्रोफ़ाइल पृष्ठ पर, आपको एक साइड नेविगेशन बार देखना चाहिए। साइड नेविगेशन बार से, **API कुंजियाँ** चुनें। अगला, एक नई API कुंजी बनाने के लिए "जोड़ें" बटन दबाएं, अपने ऐप को **hello-world** नाम दें और **नई API कुंजी बनाएं** बटन दबाएं।
+
+आपकी नई API कुंजी API कुंजी तालिका में दिखाई देनी चाहिए। API कुंजी को अपने क्लिपबोर्ड पर कॉपी करें।
+
+इसके बाद, हमें अपनी `.env` फ़ाइल में Etherscan API कुंजी जोड़नी होगी।
+
+इसे जोड़ने के बाद, आपकी `.env` फ़ाइल इस तरह दिखनी चाहिए:
+
+```javascript
+API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key"
+PUBLIC_KEY = "your-public-account-address"
+PRIVATE_KEY = "your-private-account-address"
+CONTRACT_ADDRESS = "your-contract-address"
+ETHERSCAN_API_KEY = "your-etherscan-key"
+```
+
+### Hardhat-डिप्लॉयड स्मार्ट अनुबंध {#hardhat-deployed-smart-contracts}
+
+#### hardhat-etherscan स्थापित करें {#install-hardhat-etherscan}
+
+Hardhat का उपयोग करके Etherscan पर अपना अनुबंध प्रकाशित करना सीधा है। शुरू करने के लिए आपको पहले `hardhat-etherscan` प्लगइन स्थापित करना होगा। `hardhat-etherscan` स्वचालित रूप से स्मार्ट अनुबंध के स्रोत कोड और Etherscan पर ABI को सत्यापित करेगा। इसे जोड़ने के लिए, `hello-world` निर्देशिका में चलाएँ:
+
+```text
+npm install --save-dev @nomiclabs/hardhat-etherscan
+```
+
+एक बार स्थापित हो जाने के बाद, अपनी `hardhat.config.js` के शीर्ष पर निम्नलिखित कथन शामिल करें, और Etherscan कॉन्फ़िगरेशन विकल्प जोड़ें:
+
+```javascript
+// hardhat.config.js
+
+require("dotenv").config()
+require("@nomiclabs/hardhat-ethers")
+require("@nomiclabs/hardhat-etherscan")
+
+const { API_URL, PRIVATE_KEY, ETHERSCAN_API_KEY } = process.env
+
+module.exports = {
+ solidity: "0.7.3",
+ defaultNetwork: "goerli",
+ networks: {
+ hardhat: {},
+ goerli: {
+ url: API_URL,
+ accounts: [`0x${PRIVATE_KEY}`],
+ },
+ },
+ etherscan: {
+ // Etherscan के लिए आपकी API कुंजी
+ // https://etherscan.io/ पर एक प्राप्त करें
+ apiKey: ETHERSCAN_API_KEY,
+ },
+}
+```
+
+#### Etherscan पर अपने स्मार्ट अनुबंध को सत्यापित करें {#verify-your-smart-contract-on-etherscan}
+
+सुनिश्चित करें कि सभी फाइलें सहेजी गई हैं और सभी `.env` चर सही ढंग से कॉन्फ़िगर किए गए हैं।
+
+`verify` कार्य चलाएँ, अनुबंध पता पास करें, और वह नेटवर्क जहाँ यह डिप्लॉय किया गया है:
+
+```text
+npx hardhat verify --network goerli DEPLOYED_CONTRACT_ADDRESS 'Hello World!'
+```
+
+सुनिश्चित करें कि `DEPLOYED_CONTRACT_ADDRESS` Goerli टेस्ट नेटवर्क पर आपके डिप्लॉयड स्मार्ट अनुबंध का पता है। इसके अलावा, अंतिम तर्क (`'Hello World!'`) वही स्ट्रिंग मान होना चाहिए जिसका उपयोग [भाग 1 में डिप्लॉय चरण के दौरान](#write-our-deploy-script) किया गया था।
+
+यदि सब कुछ ठीक रहा, तो आपको अपने टर्मिनल में निम्नलिखित संदेश दिखाई देगा:
+
+```text
+अनुबंध के लिए स्रोत कोड सफलतापूर्वक सबमिट किया गया
+contracts/HelloWorld.sol:HelloWorld at 0xdeployed-contract-address
+Etherscan पर सत्यापन के लिए। सत्यापन परिणाम की प्रतीक्षा में...
+
+
+Etherscan पर HelloWorld अनुबंध सफलतापूर्वक सत्यापित किया गया।
+https://goerli.etherscan.io/address/#contracts
+```
+
+बधाई हो! आपका स्मार्ट अनुबंध कोड Etherscan पर है!
+
+### Etherscan पर अपना स्मार्ट अनुबंध देखें! {#check-out-your-smart-contract-on-etherscan}
+
+जब आप अपने टर्मिनल में दिए गए लिंक पर नेविगेट करते हैं, तो आपको अपना स्मार्ट अनुबंध कोड और ABI Etherscan पर प्रकाशित होना चाहिए!
+
+**बहुत बढ़िया - आपने कर दिखाया, चैंपियन! अब कोई भी आपके स्मार्ट अनुबंध को कॉल या लिख सकता है! हम यह देखने के लिए इंतजार नहीं कर सकते कि आप आगे क्या बनाते हैं!**
+
+## भाग 4 - अपने स्मार्ट अनुबंध को फ्रंटएंड के साथ एकीकृत करना {#part-4-integrating-your-smart-contract-with-the-frontend}
+
+इस ट्यूटोरियल के अंत तक, आप जानेंगे कि कैसे:
+
+- एक MetaMask वॉलेट को अपने डैप से कनेक्ट करें
+- [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) API का उपयोग करके अपने स्मार्ट अनुबंध से डेटा पढ़ें
+- MetaMask का उपयोग करके एथेरियम लेनदेन पर हस्ताक्षर करें
+
+इस डैप के लिए, हम [React](https://react.dev/) को अपने फ्रंटएंड फ्रेमवर्क के रूप में उपयोग करेंगे; हालांकि, यह ध्यान रखना महत्वपूर्ण है कि हम इसकी बुनियादी बातों को तोड़ने में ज्यादा समय नहीं बिताएंगे, क्योंकि हम ज्यादातर अपने प्रोजेक्ट में वेब3 कार्यक्षमता लाने पर ध्यान केंद्रित करेंगे।
+
+एक शर्त के रूप में, आपको React की शुरुआती स्तर की समझ होनी चाहिए। यदि नहीं, तो हम आधिकारिक [Intro to React tutorial](https://react.dev/learn) को पूरा करने की सलाह देते हैं।
+
+### स्टार्टर फ़ाइलों को क्लोन करें {#clone-the-starter-files}
+
+सबसे पहले, इस प्रोजेक्ट के लिए स्टार्टर फ़ाइलों को प्राप्त करने के लिए [hello-world-part-four GitHub repository](https://github.com/alchemyplatform/hello-world-part-four-tutorial) पर जाएँ और इस रिपॉजिटरी को अपनी स्थानीय मशीन पर क्लोन करें।
+
+स्थानीय रूप से क्लोन किए गए भंडार को खोलें। ध्यान दें कि इसमें दो फ़ोल्डर हैं: `starter-files` और `completed`।
+
+- `starter-files`- **हम इस डायरेक्टरी में काम करेंगे**, हम UI को आपके एथेरियम वॉलेट और [भाग 3](#part-3) में Etherscan पर प्रकाशित स्मार्ट अनुबंध से जोड़ेंगे।
+- `completed` में पूरा ट्यूटोरियल शामिल है और इसे केवल संदर्भ के रूप में उपयोग किया जाना चाहिए यदि आप फंस जाते हैं।
+
+अगला, `starter-files` की अपनी प्रति को अपने पसंदीदा कोड संपादक में खोलें, और फिर `src` फ़ोल्डर में नेविगेट करें।
+
+हम जो भी कोड लिखेंगे वह `src` फोल्डर के अंतर्गत रहेगा। हम अपने प्रोजेक्ट को वेब3 कार्यक्षमता देने के लिए `HelloWorld.js` घटक और `util/interact.js` जावास्क्रिप्ट फ़ाइलों को संपादित करेंगे।
+
+### स्टार्टर फ़ाइलों की जाँच करें {#check-out-the-starter-files}
+
+कोडिंग शुरू करने से पहले, आइए जानें कि हमें स्टार्टर फ़ाइलों में क्या प्रदान किया गया है।
+
+#### अपना react प्रोजेक्ट चलाएँ {#get-your-react-project-running}
+
+आइए अपने ब्राउज़र में React प्रोजेक्ट चलाकर शुरू करें। React की खूबी यह है कि एक बार जब हमारा प्रोजेक्ट हमारे ब्राउज़र में चल रहा होता है, तो हमारे द्वारा सहेजे गए कोई भी परिवर्तन हमारे ब्राउज़र में लाइव अपडेट हो जाएँगे।
+
+प्रोजेक्ट को चलाने के लिए, `starter-files` फ़ोल्डर की रूट डायरेक्टरी पर नेविगेट करें, और प्रोजेक्ट की निर्भरता को स्थापित करने के लिए अपने टर्मिनल में `npm install` चलाएँ:
+
+```bash
+cd starter-files
+npm install
+```
+
+एक बार वे स्थापित हो जाने के बाद, अपने टर्मिनल में `npm start` चलाएँ:
+
+```bash
+npm start
+```
+
+ऐसा करने से आपके ब्राउज़र में [http://localhost:3000/](http://localhost:3000/) खुल जाना चाहिए, जहाँ आपको हमारे प्रोजेक्ट का फ्रंटएंड दिखाई देगा। इसमें एक फ़ील्ड (आपके स्मार्ट अनुबंध में संग्रहीत संदेश को अपडेट करने के लिए एक जगह), एक "वॉलेट कनेक्ट करें" बटन, और एक "अपडेट करें" बटन होना चाहिए।
+
+यदि आप किसी भी बटन पर क्लिक करने का प्रयास करते हैं, तो आप देखेंगे कि वे काम नहीं करते हैं - ऐसा इसलिए है क्योंकि हमें अभी भी उनकी कार्यक्षमता को प्रोग्राम करने की आवश्यकता है।
+
+#### The `HelloWorld.js` घटक {#the-helloworld-js-component}
+
+आइए अपने संपादक में `src` फ़ोल्डर में वापस जाएं और `HelloWorld.js` फ़ाइल खोलें। यह बहुत महत्वपूर्ण है कि हम इस फ़ाइल में सब कुछ समझें, क्योंकि यह प्राथमिक React घटक है जिस पर हम काम करेंगे।
+
+इस फ़ाइल के शीर्ष पर, आप देखेंगे कि हमारे पास कई आयात कथन हैं जो हमारे प्रोजेक्ट को चलाने के लिए आवश्यक हैं, जिनमें React लाइब्रेरी, useEffect और useState हुक, `./util/interact.js` से कुछ आइटम (हम उन्हें जल्द ही और विस्तार से वर्णित करेंगे!), और Alchemy लोगो शामिल हैं।
+
+```javascript
+// HelloWorld.js
+
+import React from "react"
+import { useEffect, useState } from "react"
+import {
+ helloWorldContract,
+ connectWallet,
+ updateMessage,
+ loadCurrentMessage,
+ getCurrentWalletConnected,
+} from "./util/interact.js"
+
+import alchemylogo from "./alchemylogo.svg"
+```
+
+अगला, हमारे पास हमारे स्टेट चर हैं जिन्हें हम विशिष्ट घटनाओं के बाद अपडेट करेंगे।
+
+```javascript
+// HelloWorld.js
+
+//स्टेट चर
+const [walletAddress, setWallet] = useState("")
+const [status, setStatus] = useState("")
+const [message, setMessage] = useState("नेटवर्क से कोई कनेक्शन नहीं है।")
+const [newMessage, setNewMessage] = useState("")
+```
+
+यहाँ प्रत्येक चर का प्रतिनिधित्व क्या है:
+
+- `walletAddress` - एक स्ट्रिंग जो यूज़र के वॉलेट पते को संग्रहीत करती है
+- `status`- एक स्ट्रिंग जो एक उपयोगी संदेश संग्रहीत करती है जो उपयोगकर्ता को डैप के साथ इंटरैक्ट करने के तरीके पर मार्गदर्शन करती है
+- `message` - एक स्ट्रिंग जो स्मार्ट अनुबंध में वर्तमान संदेश को संग्रहीत करती है
+- `newMessage` - एक स्ट्रिंग जो नया संदेश संग्रहीत करती है जिसे स्मार्ट अनुबंध में लिखा जाएगा
+
+स्टेट चर के बाद, आपको पाँच गैर-कार्यान्वित फ़ंक्शन दिखाई देंगे: `useEffect`, `addSmartContractListener`, `addWalletListener`, `connectWalletPressed`, और `onUpdatePressed`। हम नीचे बताएंगे कि वे क्या करते हैं:
+
+```javascript
+// HelloWorld.js
+
+//केवल एक बार कॉल किया गया
+useEffect(async () => {
+ //TODO: लागू करें
+}, [])
+
+function addSmartContractListener() {
+ //TODO: लागू करें
+}
+
+function addWalletListener() {
+ //TODO: लागू करें
+}
+
+const connectWalletPressed = async () => {
+ //TODO: लागू करें
+}
+
+const onUpdatePressed = async () => {
+ //TODO: लागू करें
+}
+```
+
+- [`useEffect`](https://legacy.reactjs.org/docs/hooks-effect.html)- यह एक React हुक है जिसे आपके घटक के प्रस्तुत होने के बाद कॉल किया जाता है। क्योंकि इसमें एक खाली ऐरे `[]` प्रोप पास किया गया है (पंक्ति 4 देखें), इसे केवल घटक के _पहले_ रेंडर पर कॉल किया जाएगा। यहां हम अपने स्मार्ट अनुबंध में संग्रहीत वर्तमान संदेश को लोड करेंगे, अपने स्मार्ट अनुबंध और वॉलेट श्रोताओं को कॉल करेंगे, और यह प्रतिबिंबित करने के लिए कि क्या कोई वॉलेट पहले से जुड़ा हुआ है, अपनी UI को अपडेट करेंगे।
+- `addSmartContractListener`- यह फ़ंक्शन एक श्रोता स्थापित करता है जो हमारे HelloWorld अनुबंध के `UpdatedMessages` इवेंट को देखेगा और हमारे स्मार्ट अनुबंध में संदेश बदलने पर हमारी UI को अपडेट करेगा।
+- `addWalletListener`- यह फ़ंक्शन एक श्रोता स्थापित करता है जो उपयोगकर्ता के MetaMask वॉलेट की स्थिति में बदलाव का पता लगाता है, जैसे कि जब उपयोगकर्ता अपने वॉलेट को डिस्कनेक्ट करता है या पते बदलता है।
+- `connectWalletPressed`- इस फ़ंक्शन को उपयोगकर्ता के MetaMask वॉलेट को हमारे डैप से जोड़ने के लिए कॉल किया जाएगा।
+- `onUpdatePressed` - इस फ़ंक्शन को तब कॉल किया जाएगा जब उपयोगकर्ता स्मार्ट अनुबंध में संग्रहीत संदेश को अपडेट करना चाहता है।
+
+इस फ़ाइल के अंत के पास, हमारे पास हमारे घटक का UI है।
+
+```javascript
+// HelloWorld.js
+
+//हमारे घटक का UI
+return (
+
+ 
+
+
+ Current Message:
+ {message}
+
+ New Message:
+
+
+ setNewMessage(e.target.value)}
+ value={newMessage}
+ />
+ {status}
+
+
+
+
+
+)
+```
+
+यदि आप इस कोड को ध्यान से स्कैन करते हैं, तो आप देखेंगे कि हम अपनी UI में अपने विभिन्न स्टेट चर का उपयोग कहाँ करते हैं:
+
+- पंक्ति 6-12 पर, यदि उपयोगकर्ता का वॉलेट जुड़ा हुआ है (यानी, `walletAddress.length > 0`), तो हम आईडी "walletButton" के साथ बटन में उपयोगकर्ता `walletAddress` का एक छोटा संस्करण प्रदर्शित करते हैं; अन्यथा यह बस "कनेक्ट वॉलेट" कहता है।
+- पंक्ति 17 पर, हम स्मार्ट अनुबंध में संग्रहीत वर्तमान संदेश प्रदर्शित करते हैं, जिसे `message` स्ट्रिंग में कैप्चर किया जाता है।
+- पंक्ति 23-26 पर, हम पाठ फ़ील्ड में इनपुट बदलने पर हमारे `newMessage` स्टेट चर को अपडेट करने के लिए एक [नियंत्रित घटक](https://legacy.reactjs.org/docs/forms.html#controlled-components) का उपयोग करते हैं।
+
+हमारे स्टेट चर के अलावा, आप यह भी देखेंगे कि `connectWalletPressed` और `onUpdatePressed` फ़ंक्शन को तब कॉल किया जाता है जब क्रमशः `publishButton` और `walletButton` आईडी वाले बटन पर क्लिक किया जाता है।
+
+अंत में, आइए संबोधित करें कि यह `HelloWorld.js` घटक कहाँ जोड़ा गया है।
+
+यदि आप `App.js` फ़ाइल पर जाते हैं, जो React में मुख्य घटक है जो अन्य सभी घटकों के लिए एक कंटेनर के रूप में कार्य करता है, तो आप देखेंगे कि हमारा `HelloWorld.js` घटक पंक्ति 7 पर इंजेक्ट किया गया है।
+
+अंतिम लेकिन कम से कम नहीं, आइए आपके लिए प्रदान की गई एक और फ़ाइल देखें, `interact.js` फ़ाइल।
+
+#### `interact.js` फ़ाइल {#the-interact-js-file}
+
+क्योंकि हम [M-V-C](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) प्रतिमान का पालन करना चाहते हैं, हम एक अलग फ़ाइल चाहेंगे जिसमें हमारे डैप के तर्क, डेटा और नियमों का प्रबंधन करने के लिए हमारे सभी फ़ंक्शन हों, और फिर उन फ़ंक्शन को हमारे फ्रंटएंड (हमारे `HelloWorld.js` घटक) में निर्यात करने में सक्षम हों।
+
+👆🏽यही हमारी `interact.js` फ़ाइल का सटीक उद्देश्य है!
+
+अपनी `src` डायरेक्टरी में `util` फ़ोल्डर पर नेविगेट करें, और आप देखेंगे कि हमने `interact.js` नामक एक फ़ाइल शामिल की है जिसमें हमारे सभी स्मार्ट अनुबंध इंटरैक्शन और वॉलेट फ़ंक्शन और चर होंगे।
+
+```javascript
+// interact.js
+
+//export const helloWorldContract;
+
+export const loadCurrentMessage = async () => {}
+
+export const connectWallet = async () => {}
+
+const getCurrentWalletConnected = async () => {}
+
+export const updateMessage = async (message) => {}
+```
+
+आप फ़ाइल के शीर्ष पर देखेंगे कि हमने `helloWorldContract` ऑब्जेक्ट पर टिप्पणी की है। बाद में इस ट्यूटोरियल में, हम इस ऑब्जेक्ट पर से टिप्पणी हटा देंगे और इस चर में अपने स्मार्ट अनुबंध को इंस्टेंटिएट करेंगे, जिसे हम फिर अपने `HelloWorld.js` घटक में निर्यात करेंगे।
+
+हमारे `helloWorldContract` ऑब्जेक्ट के बाद चार गैर-कार्यान्वित फ़ंक्शन निम्नलिखित करते हैं:
+
+- `loadCurrentMessage` - यह फ़ंक्शन स्मार्ट अनुबंध में संग्रहीत वर्तमान संदेश को लोड करने के तर्क को संभालता है। यह [Alchemy Web3 API](https://github.com/alchemyplatform/alchemy-web3) का उपयोग करके हैलो वर्ल्ड स्मार्ट अनुबंध को एक _read_ कॉल करेगा।
+- `connectWallet` - यह फ़ंक्शन उपयोगकर्ता के MetaMask को हमारे डैप से जोड़ेगा।
+- `getCurrentWalletConnected` - यह फ़ंक्शन जाँच करेगा कि क्या कोई एथेरियम खाता पहले से ही हमारे डैप से पृष्ठ लोड पर जुड़ा हुआ है और तदनुसार हमारी UI को अपडेट करेगा।
+- `updateMessage` - यह फ़ंक्शन स्मार्ट अनुबंध में संग्रहीत संदेश को अपडेट करेगा। यह हैलो वर्ल्ड स्मार्ट अनुबंध को एक _write_ कॉल करेगा, इसलिए उपयोगकर्ता के MetaMask वॉलेट को संदेश को अपडेट करने के लिए एक एथेरियम लेनदेन पर हस्ताक्षर करना होगा।
+
+अब जब हम समझते हैं कि हम किसके साथ काम कर रहे हैं, तो आइए जानें कि हमारे स्मार्ट अनुबंध से कैसे पढ़ा जाए!
+
+### चरण 3: अपने स्मार्ट अनुबंध से पढ़ें {#step-3-read-from-your-smart-contract}
+
+अपने स्मार्ट अनुबंध से पढ़ने के लिए, आपको सफलतापूर्वक सेट अप करना होगा:
+
+- एथेरियम श्रृंखला के लिए एक API कनेक्शन
+- आपके स्मार्ट अनुबंध का एक लोड किया गया उदाहरण
+- आपके स्मार्ट अनुबंध फ़ंक्शन को कॉल करने के लिए एक फ़ंक्शन
+- स्मार्ट अनुबंध से पढ़े जा रहे डेटा के बदलने पर अपडेट देखने के लिए एक श्रोता
+
+यह बहुत सारे चरणों की तरह लग सकता है, लेकिन चिंता न करें! हम आपको बताएंगे कि उनमें से प्रत्येक को चरण-दर-चरण कैसे करना है! :\)
+
+#### एथेरियम श्रृंखला के लिए एक API कनेक्शन स्थापित करें {#establish-an-api-connection-to-the-ethereum-chain}
+
+तो याद रखें कि इस ट्यूटोरियल के भाग 2 में, हमने अपने स्मार्ट अनुबंध से पढ़ने के लिए अपनी [Alchemy Web3 कुंजी का उपयोग किया था](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library)? श्रृंखला से पढ़ने के लिए आपको अपने डैप में एक Alchemy Web3 कुंजी की भी आवश्यकता होगी।
+
+यदि आपके पास यह पहले से नहीं है, तो पहले [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) को अपने `starter-files` की रूट डायरेक्टरी पर नेविगेट करके और अपने टर्मिनल में निम्नलिखित चलाकर स्थापित करें:
+
+```text
+npm install @alch/alchemy-web3
+```
+
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) [Web3.js](https://docs.web3js.org/) के चारों ओर एक रैपर है, जो उन्नत API विधियों और अन्य महत्वपूर्ण लाभ प्रदान करता है ताकि आपका जीवन एक web3 डेवलपर के रूप में आसान हो सके। इसे न्यूनतम कॉन्फ़िगरेशन की आवश्यकता के लिए डिज़ाइन किया गया है ताकि आप इसे अपने ऐप में तुरंत उपयोग करना शुरू कर सकें!
+
+फिर, अपने प्रोजेक्ट डायरेक्टरी में [dotenv](https://www.npmjs.com/package/dotenv) पैकेज स्थापित करें, ताकि हमारे पास अपनी API कुंजी प्राप्त करने के बाद उसे संग्रहीत करने के लिए एक सुरक्षित स्थान हो।
+
+```text
+npm install dotenv --save
+```
+
+हमारे डैप के लिए, **हम अपनी HTTP API कुंजी के बजाय अपनी Websockets API कुंजी का उपयोग करेंगे**, क्योंकि यह हमें एक श्रोता स्थापित करने की अनुमति देगा जो यह पता लगाता है कि स्मार्ट अनुबंध में संग्रहीत संदेश कब बदलता है।
+
+एक बार जब आपके पास अपनी API कुंजी हो, तो अपनी रूट डायरेक्टरी में एक `.env` फ़ाइल बनाएं और उसमें अपना Alchemy Websockets url जोड़ें। इसके बाद, आपकी `.env` फ़ाइल इस तरह दिखनी चाहिए:
+
+```javascript
+REACT_APP_ALCHEMY_KEY = wss://eth-goerli.ws.alchemyapi.io/v2/
+```
+
+अब, हम अपने डैप में अपना Alchemy Web3 एंडपॉइंट सेट करने के लिए तैयार हैं! आइए हमारी `interact.js` पर वापस जाएं, जो हमारे `util` फ़ोल्डर के अंदर नेस्टेड है और फ़ाइल के शीर्ष पर निम्नलिखित कोड जोड़ें:
+
+```javascript
+// interact.js
+
+require("dotenv").config()
+const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(alchemyKey)
+
+//export const helloWorldContract;
+```
+
+ऊपर, हमने पहले अपनी `.env` फ़ाइल से Alchemy कुंजी आयात की और फिर अपना Alchemy Web3 एंडपॉइंट स्थापित करने के लिए `createAlchemyWeb3` को अपनी `alchemyKey` पास की।
+
+इस एंडपॉइंट के तैयार होने के साथ, यह हमारे स्मार्ट अनुबंध को लोड करने का समय है!
+
+#### अपने हैलो वर्ल्ड स्मार्ट अनुबंध को लोड करना {#loading-your-hello-world-smart-contract}
+
+अपने हैलो वर्ल्ड स्मार्ट अनुबंध को लोड करने के लिए, आपको इसके अनुबंध पते और ABI की आवश्यकता होगी, दोनों ही Etherscan पर मिल सकते हैं यदि आपने [इस ट्यूटोरियल का भाग 3](/developers/tutorials/hello-world-smart-contract-fullstack/#part-3-publish-your-smart-contract-to-etherscan-part-3-publish-your-smart-contract-to-etherscan) पूरा कर लिया है।
+
+#### Etherscan से अपना अनुबंध ABI कैसे प्राप्त करें {#how-to-get-your-contract-abi-from-etherscan}
+
+यदि आपने इस ट्यूटोरियल का भाग 3 छोड़ दिया है, तो आप पते [0x6f3f635A9762B47954229Ea479b4541eAF402A6A](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code) के साथ HelloWorld अनुबंध का उपयोग कर सकते हैं। इसका ABI [यहां](https://goerli.etherscan.io/address/0x6f3f635a9762b47954229ea479b4541eaf402a6a#code) पाया जा सकता है।
+
+एक अनुबंध ABI यह निर्दिष्ट करने के लिए आवश्यक है कि कोई अनुबंध किस फ़ंक्शन को लागू करेगा और यह सुनिश्चित करने के लिए कि फ़ंक्शन आपके द्वारा अपेक्षित प्रारूप में डेटा लौटाएगा। एक बार जब हम अपना अनुबंध ABI कॉपी कर लेते हैं, तो आइए इसे अपनी `src` डायरेक्टरी में `contract-abi.json` नामक JSON फ़ाइल के रूप में सहेजें।
+
+आपकी contract-abi.json आपकी src फ़ोल्डर में संग्रहीत होनी चाहिए।
+
+हमारे अनुबंध पते, ABI, और Alchemy Web3 एंडपॉइंट से लैस, हम अपने स्मार्ट अनुबंध का एक उदाहरण लोड करने के लिए [अनुबंध विधि](https://docs.web3js.org/api/web3-eth-contract/class/Contract) का उपयोग कर सकते हैं। अपने अनुबंध ABI को `interact.js` फ़ाइल में आयात करें और अपना अनुबंध पता जोड़ें।
+
+```javascript
+// interact.js
+
+const contractABI = require("../contract-abi.json")
+const contractAddress = "0x6f3f635A9762B47954229Ea479b4541eAF402A6A"
+```
+
+अब हम अंततः अपने `helloWorldContract` चर पर से टिप्पणी हटा सकते हैं, और अपने AlchemyWeb3 एंडपॉइंट का उपयोग करके स्मार्ट अनुबंध को लोड कर सकते हैं:
+
+```javascript
+// interact.js
+export const helloWorldContract = new web3.eth.Contract(
+ contractABI,
+ contractAddress
+)
+```
+
+संक्षेप में, आपकी `interact.js` की पहली 12 पंक्तियाँ अब इस तरह दिखनी चाहिए:
+
+```javascript
+// interact.js
+
+require("dotenv").config()
+const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(alchemyKey)
+
+const contractABI = require("../contract-abi.json")
+const contractAddress = "0x6f3f635A9762B47954229Ea479b4541eAF402A6A"
+
+export const helloWorldContract = new web3.eth.Contract(
+ contractABI,
+ contractAddress
+)
+```
+
+अब जब हमने अपना अनुबंध लोड कर लिया है, तो हम अपने `loadCurrentMessage` फ़ंक्शन को लागू कर सकते हैं!
+
+#### अपनी `interact.js` फ़ाइल में `loadCurrentMessage` लागू करना {#implementing-loadCurrentMessage-in-your-interact-js-file}
+
+यह फ़ंक्शन बहुत सरल है। हम अपने अनुबंध से पढ़ने के लिए एक सरल अतुल्यकालिक वेब3 कॉल करने जा रहे हैं। हमारा फ़ंक्शन स्मार्ट अनुबंध में संग्रहीत संदेश लौटाएगा:
+
+अपनी `interact.js` फ़ाइल में `loadCurrentMessage` को निम्नलिखित में अपडेट करें:
+
+```javascript
+// interact.js
+
+export const loadCurrentMessage = async () => {
+ const message = await helloWorldContract.methods.message().call()
+ return message
+}
+```
+
+चूंकि हम इस स्मार्ट अनुबंध को अपनी UI में प्रदर्शित करना चाहते हैं, आइए अपने `HelloWorld.js` घटक में `useEffect` फ़ंक्शन को निम्नलिखित में अपडेट करें:
+
+```javascript
+// HelloWorld.js
+
+//केवल एक बार कॉल किया गया
+useEffect(async () => {
+ const message = await loadCurrentMessage()
+ setMessage(message)
+}, [])
+```
+
+ध्यान दें, हम चाहते हैं कि हमारा `loadCurrentMessage` केवल घटक के पहले रेंडर के दौरान एक बार कॉल किया जाए। हम जल्द ही `addSmartContractListener` को लागू करेंगे ताकि स्मार्ट अनुबंध में संदेश बदलने के बाद UI स्वचालित रूप से अपडेट हो जाए।
+
+हमारे श्रोता में गोता लगाने से पहले, आइए देखें कि हमारे पास अब तक क्या है! अपनी `HelloWorld.js` और `interact.js` फ़ाइलों को सहेजें, और फिर [http://localhost:3000/](http://localhost:3000/) पर जाएं
+
+आप देखेंगे कि वर्तमान संदेश अब "नेटवर्क से कोई कनेक्शन नहीं है" नहीं कहता है। इसके बजाय यह स्मार्ट अनुबंध में संग्रहीत संदेश को दर्शाता है। बहुत बढ़िया!
+
+#### आपकी UI अब स्मार्ट अनुबंध में संग्रहीत संदेश को प्रतिबिंबित करनी चाहिए {#your-UI-should-now-reflect-the-message-stored-in-the-smart-contract}
+
+अब उस श्रोता की बात करते हैं...
+
+#### `addSmartContractListener` लागू करें {#implement-addsmartcontractlistener}
+
+यदि आप [इस ट्यूटोरियल श्रृंखला के भाग 1](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract#step-10-write-our-contract) में लिखी गई `HelloWorld.sol` फ़ाइल के बारे में सोचते हैं, तो आपको याद होगा कि `UpdatedMessages` नामक एक स्मार्ट अनुबंध इवेंट है जो हमारे स्मार्ट अनुबंध के `update` फ़ंक्शन को लागू करने के बाद उत्सर्जित होता है (पंक्ति 9 और 27 देखें):
+
+```javascript
+// HelloWorld.sol
+
+// सिमेंटिक वर्जनिंग का उपयोग करके, सॉलिडिटी के संस्करण को निर्दिष्ट करता है।
+// और जानें: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+pragma solidity ^0.7.3;
+
+// 'HelloWorld' नामक एक अनुबंध को परिभाषित करता है।
+// एक अनुबंध कार्यों और डेटा (इसकी स्थिति) का एक संग्रह है। एक बार डिप्लॉय होने के बाद, एक अनुबंध एथेरियम ब्लॉकचेन पर एक विशिष्ट पते पर रहता है। और जानें: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+contract HelloWorld {
+
+ //अपडेट फ़ंक्शन कॉल होने पर उत्सर्जित होता है
+ //स्मार्ट अनुबंध इवेंट आपके अनुबंध के लिए यह संवाद करने का एक तरीका है कि ब्लॉकचेन पर आपके ऐप फ्रंट-एंड में कुछ हुआ है, जो कुछ इवेंट्स को 'सुन' सकता है और उनके होने पर कार्रवाई कर सकता है।
+ event UpdatedMessages(string oldStr, string newStr);
+
+ // 'स्ट्रिंग' प्रकार के एक स्टेट चर 'संदेश' की घोषणा करता है।
+ // स्टेट चर वे चर होते हैं जिनके मान अनुबंध भंडारण में स्थायी रूप से संग्रहीत होते हैं। कीवर्ड 'पब्लिक' चर को अनुबंध के बाहर से सुलभ बनाता है और एक फ़ंक्शन बनाता है जिसे अन्य अनुबंध या क्लाइंट मान तक पहुंचने के लिए कॉल कर सकते हैं।
+ string public message;
+
+ // कई वर्ग-आधारित ऑब्जेक्ट-ओरिएंटेड भाषाओं के समान, एक कंस्ट्रक्टर एक विशेष फ़ंक्शन है जो केवल अनुबंध निर्माण पर निष्पादित होता है।
+ // कंस्ट्रक्टर का उपयोग अनुबंध के डेटा को आरंभ करने के लिए किया जाता है। और जानें: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ constructor(string memory initMessage) {
+
+ // एक स्ट्रिंग तर्क 'initMessage' स्वीकार करता है और अनुबंध के 'संदेश' भंडारण चर में मान सेट करता है)।
+ message = initMessage;
+ }
+
+ // एक सार्वजनिक फ़ंक्शन जो एक स्ट्रिंग तर्क स्वीकार करता है और 'संदेश' भंडारण चर को अपडेट करता है।
+ function update(string memory newMessage) public {
+ string memory oldMsg = message;
+ message = newMessage;
+ emit UpdatedMessages(oldMsg, newMessage);
+ }
+}
+```
+
+स्मार्ट अनुबंध इवेंट आपके अनुबंध के लिए यह संवाद करने का एक तरीका है कि ब्लॉकचेन पर आपके फ्रंट-एंड एप्लिकेशन में कुछ हुआ है (यानी, एक _इवेंट_ हुआ था), जो विशिष्ट इवेंट के लिए 'सुन' सकता है और उनके होने पर कार्रवाई कर सकता है।
+
+`addSmartContractListener` फ़ंक्शन विशेष रूप से हमारे हैलो वर्ल्ड स्मार्ट अनुबंध के `UpdatedMessages` इवेंट को सुनेगा, और नए संदेश को प्रदर्शित करने के लिए हमारी UI को अपडेट करेगा।
+
+`addSmartContractListener` को निम्नलिखित में संशोधित करें:
+
+```javascript
+// HelloWorld.js
+
+function addSmartContractListener() {
+ helloWorldContract.events.UpdatedMessages({}, (error, data) => {
+ if (error) {
+ setStatus("😥 " + error.message)
+ } else {
+ setMessage(data.returnValues[1])
+ setNewMessage("")
+ setStatus("🎉 आपका संदेश अपडेट कर दिया गया है!")
+ }
+ })
+}
+```
+
+आइए तोड़ते हैं कि जब श्रोता एक घटना का पता लगाता है तो क्या होता है:
+
+- यदि घटना उत्सर्जित होने पर कोई त्रुटि होती है, तो यह हमारे `status` स्टेट चर के माध्यम से UI में परिलक्षित होगी।
+- अन्यथा, हम लौटाए गए `data` ऑब्जेक्ट का उपयोग करेंगे। `data.returnValues` शून्य पर अनुक्रमित एक सरणी है जहां सरणी में पहला तत्व पिछला संदेश संग्रहीत करता है और दूसरा तत्व अद्यतन एक को संग्रहीत करता है। कुल मिलाकर, एक सफल घटना पर हम अपनी `message` स्ट्रिंग को अपडेट किए गए संदेश पर सेट करेंगे, `newMessage` स्ट्रिंग को साफ़ करेंगे, और यह दर्शाने के लिए कि हमारे स्मार्ट अनुबंध पर एक नया संदेश प्रकाशित किया गया है, अपने `status` स्टेट चर को अपडेट करेंगे।
+
+अंत में, आइए अपने श्रोता को हमारे `useEffect` फ़ंक्शन में कॉल करें ताकि यह `HelloWorld.js` घटक के पहले रेंडर पर आरंभ हो जाए। कुल मिलाकर, आपका `useEffect` फ़ंक्शन इस तरह दिखना चाहिए:
+
+```javascript
+// HelloWorld.js
+
+useEffect(async () => {
+ const message = await loadCurrentMessage()
+ setMessage(message)
+ addSmartContractListener()
+}, [])
+```
+
+अब जब हम अपने स्मार्ट अनुबंध से पढ़ने में सक्षम हैं, तो यह पता लगाना बहुत अच्छा होगा कि इसे कैसे लिखा जाए! हालाँकि, हमारे डैप पर लिखने के लिए, हमारे पास पहले इससे जुड़ा एक एथेरियम वॉलेट होना चाहिए।
+
+तो, आगे हम अपना एथेरियम वॉलेट (MetaMask) सेट करेंगे और फिर इसे अपने डैप से जोड़ेंगे!
+
+### चरण 4: अपना एथेरियम वॉलेट सेट करें {#step-4-set-up-your-ethereum-wallet}
+
+एथेरियम श्रृंखला पर कुछ भी लिखने के लिए, उपयोगकर्ताओं को अपने वर्चुअल वॉलेट की निजी कुंजी का उपयोग करके लेनदेन पर हस्ताक्षर करना होगा। इस ट्यूटोरियल के लिए, हम [MetaMask](https://metamask.io/) का उपयोग करेंगे, जो ब्राउज़र में एक वर्चुअल वॉलेट है जिसका उपयोग आपके एथेरियम खाता पते को प्रबंधित करने के लिए किया जाता है, क्योंकि यह अंतिम-उपयोगकर्ता के लिए इस लेनदेन पर हस्ताक्षर करना बहुत आसान बनाता है।
+
+यदि आप यह समझना चाहते हैं कि एथेरियम पर लेनदेन कैसे काम करते हैं, तो Ethereum फाउंडेशन से [यह पेज](/developers/docs/transactions/) देखें।
+
+#### MetaMask डाउनलोड करें {#download-metamask}
+
+आप [यहां](https://metamask.io/download) मुफ्त में MetaMask खाता डाउनलोड और बना सकते हैं। जब आप एक खाता बना रहे हों, या यदि आपके पास पहले से ही एक खाता है, तो ऊपरी दाएं कोने में "Goerli टेस्ट नेटवर्क" पर स्विच करना सुनिश्चित करें (ताकि हम असली पैसे से काम न कर रहे हों)।
+
+#### एक फॉसेट से ईथर जोड़ें {#add-ether-from-a-faucet}
+
+एथेरियम ब्लॉकचेन पर एक लेनदेन पर हस्ताक्षर करने के लिए, हमें कुछ नकली Eth की आवश्यकता होगी। Eth प्राप्त करने के लिए आप [FaucETH](https://fauceth.komputing.org) पर जा सकते हैं और अपना Goerli खाता पता दर्ज कर सकते हैं, "फंड का अनुरोध करें" पर क्लिक करें, फिर ड्रॉपडाउन में "एथेरियम टेस्टनेट Goerli" का चयन करें और अंत में फिर से "फंड का अनुरोध करें" बटन पर क्लिक करें। आपको जल्द ही अपने MetaMask खाते में Eth दिखना चाहिए!
+
+#### अपना बैलेंस जांचें {#check-your-balance}
+
+यह सुनिश्चित करने के लिए कि हमारा बैलेंस वहाँ है, चलिए [Alchemy के कंपोजर टूल](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D) का उपयोग करके एक [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) अनुरोध करें। यह हमारे वॉलेट में Eth की मात्रा लौटाएगा। जब आप अपना MetaMask खाता पता इनपुट करते हैं और "Send Request" पर क्लिक करते हैं, तो आपको इस तरह का एक जवाब देखना चाहिए:
+
+```text
+{\"jsonrpc\": \"2.0\", \"id\": 0, \"result\": \"0xde0b6b3a7640000\"}
+```
+
+**ध्यान दें:** यह परिणाम eth में नहीं, wei में है। Wei का उपयोग ईथर के सबसे छोटे मूल्यवर्ग के रूप में किया जाता है। wei से eth में रूपांतरण है: 1 eth = 10¹⁸ wei। तो अगर हम 0xde0b6b3a7640000 को दशमलव में बदलते हैं तो हमें 1\*10¹⁸ मिलता है जो 1 eth के बराबर है।
+
+उफ्फ! हमारा नकली पैसा सब वहाँ है! 🤑
+
+### चरण 5: MetaMask को अपनी UI से कनेक्ट करें {#step-5-connect-metamask-to-your-UI}
+
+अब जब हमारा MetaMask वॉलेट सेट हो गया है, तो चलिए अपने डैप को इससे कनेक्ट करते हैं!
+
+#### `connectWallet` फ़ंक्शन {#the-connectWallet-function}
+
+हमारी `interact.js` फ़ाइल में, आइए `connectWallet` फ़ंक्शन को लागू करें, जिसे हम फिर अपने `HelloWorld.js` घटक में कॉल कर सकते हैं।
+
+आइए `connectWallet` को निम्नलिखित में संशोधित करें:
+
+```javascript
+// interact.js
+
+export const connectWallet = async () => {
+ if (window.ethereum) {
+ try {
+ const addressArray = await window.ethereum.request({
+ method: "eth_requestAccounts",
+ })
+ const obj = {
+ status: "👆🏽 ऊपर दिए गए टेक्स्ट-फील्ड में एक संदेश लिखें।",
+ address: addressArray[0],
+ }
+ return obj
+ } catch (err) {
+ return {
+ address: "",
+ status: "😥 " + err.message,
+ }
+ }
+ } else {
+ return {
+ address: "",
+ status: (
+
+
+ {" "}
+ 🦊
+ आपको अपने ब्राउज़र में MetaMask, एक वर्चुअल एथेरियम वॉलेट स्थापित करना होगा।
+
+
+
+ ),
+ }
+ }
+}
+```
+
+तो कोड का यह विशाल ब्लॉक वास्तव में क्या करता है?
+
+खैर, सबसे पहले, यह जांचता है कि आपके ब्राउज़र में `window.ethereum` सक्षम है या नहीं।
+
+`window.ethereum` MetaMask और अन्य वॉलेट प्रदाताओं द्वारा इंजेक्ट किया गया एक वैश्विक API है जो वेबसाइटों को यूज़र्स के एथेरियम खातों का अनुरोध करने की अनुमति देता है। यदि अनुमोदित हो, तो यह उन ब्लॉकचेन से डेटा पढ़ सकता है जिनसे उपयोगकर्ता जुड़ा हुआ है, और सुझाव दे सकता है कि उपयोगकर्ता संदेशों और लेनदेन पर हस्ताक्षर करे। अधिक जानकारी के लिए [MetaMask दस्तावेज़](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) देखें!
+
+यदि `window.ethereum` मौजूद _नहीं_ है, तो इसका मतलब है कि MetaMask इंस्टॉल नहीं है। इसके परिणामस्वरूप एक JSON ऑब्जेक्ट वापस कर दिया जाता है, जहाँ लौटाया गया `address` एक खाली स्ट्रिंग है, और `status` JSX ऑब्जेक्ट यह बताता है कि यूज़र को MetaMask इंस्टॉल करना होगा।
+
+अब यदि `window.ethereum` मौजूद _है_, तो चीजें दिलचस्प हो जाती हैं।
+
+एक try/catch लूप का उपयोग करके, हम [`window.ethereum.request({ method: \"eth_requestAccounts\" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts) को कॉल करके MetaMask से कनेक्ट करने का प्रयास करेंगे। इस फ़ंक्शन को कॉल करने से ब्राउज़र में MetaMask खुल जाएगा, जिससे यूज़र को अपने वॉलेट को आपके डैप से कनेक्ट करने के लिए प्रेरित किया जाएगा।
+
+- यदि उपयोगकर्ता कनेक्ट करने का विकल्प चुनता है, तो `method: "eth_requestAccounts"` एक सरणी लौटाएगा जिसमें डैप से जुड़े उपयोगकर्ता के सभी खाता पते होंगे। कुल मिलाकर, हमारा `connectWallet` फ़ंक्शन एक JSON ऑब्जेक्ट लौटाएगा जिसमें इस ऐरे में _पहला_ `पता` (पंक्ति 9 देखें) और एक `स्थिति` संदेश होगा जो यूज़र को स्मार्ट अनुबंध को एक संदेश लिखने के लिए प्रेरित करता है।
+- यदि यूज़र कनेक्शन को अस्वीकार कर देता है, तो JSON ऑब्जेक्ट में लौटाए गए `पते` के लिए एक खाली स्ट्रिंग और एक `स्थिति` संदेश होगा जो यह दर्शाता है कि यूज़र ने कनेक्शन को अस्वीकार कर दिया है।
+
+अब जब हमने यह `connectWallet` फ़ंक्शन लिख लिया है, तो अगला चरण इसे हमारे `HelloWorld.js` घटक पर कॉल करना है।
+
+#### `connectWallet` फ़ंक्शन को अपने `HelloWorld.js` UI घटक में जोड़ें {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component}
+
+`HelloWorld.js` में `connectWalletPressed` फ़ंक्शन पर नेविगेट करें, और इसे निम्नलिखित में अपडेट करें:
+
+```javascript
+// HelloWorld.js
+
+const connectWalletPressed = async () => {
+ const walletResponse = await connectWallet()
+ setStatus(walletResponse.status)
+ setWallet(walletResponse.address)
+}
+```
+
+ध्यान दें कि हमारी अधिकांश कार्यक्षमता `interact.js` फ़ाइल से हमारे `HelloWorld.js` घटक से कैसे दूर कर दी गई है? यह इसलिए है ताकि हम M-V-C प्रतिमान का अनुपालन करें!
+
+`connectWalletPressed` में, हम बस अपने आयातित `connectWallet` फ़ंक्शन को एक await कॉल करते हैं, और इसकी प्रतिक्रिया का उपयोग करके, हम अपने `status` और `walletAddress` चर को उनके स्थिति हुक के माध्यम से अपडेट करते हैं।
+
+अब, आइए दोनों फ़ाइलों (`HelloWorld.js` और `interact.js`) को सहेजें और अब तक हमारी UI का परीक्षण करें।
+
+[http://localhost:3000/](http://localhost:3000/) पृष्ठ पर अपना ब्राउज़र खोलें, और पृष्ठ के ऊपरी दाएं कोने में "कनेक्ट वॉलेट" बटन दबाएं।
+
+यदि आपने MetaMask इंस्टॉल किया है, तो आपको अपने वॉलेट को अपने डैप से कनेक्ट करने के लिए प्रेरित किया जाना चाहिए। कनेक्ट करने के लिए निमंत्रण स्वीकार करें।
+
+आपको देखना चाहिए कि वॉलेट बटन अब यह दर्शाता है कि आपका पता जुड़ा हुआ है! यस 🔥
+
+अगला, पृष्ठ को रीफ्रेश करने का प्रयास करें... यह अजीब है। हमारा वॉलेट बटन हमें MetaMask से कनेक्ट करने के लिए कह रहा है, भले ही यह पहले से ही जुड़ा हुआ है...
+
+हालाँकि, कोई डर नहीं! हम आसानी से इसका समाधान कर सकते हैं (समझ गए?) `getCurrentWalletConnected` को लागू करके, जो जांच करेगा कि क्या कोई पता पहले से ही हमारे डैप से जुड़ा हुआ है और तदनुसार हमारी UI को अपडेट करेगा!
+
+#### `getCurrentWalletConnected` फ़ंक्शन {#the-getcurrentwalletconnected-function}
+
+`interact.js` फ़ाइल में अपने `getCurrentWalletConnected` फ़ंक्शन को निम्नलिखित में अपडेट करें:
+
+```javascript
+// interact.js
+
+export const getCurrentWalletConnected = async () => {
+ if (window.ethereum) {
+ try {
+ const addressArray = await window.ethereum.request({
+ method: "eth_accounts",
+ })
+ if (addressArray.length > 0) {
+ return {
+ address: addressArray[0],
+ status: "👆🏽 ऊपर दिए गए टेक्स्ट-फील्ड में एक संदेश लिखें।",
+ }
+ } else {
+ return {
+ address: "",
+ status: "🦊 ऊपरी दाएं बटन का उपयोग करके MetaMask से कनेक्ट करें।",
+ }
+ }
+ } catch (err) {
+ return {
+ address: "",
+ status: "😥 " + err.message,
+ }
+ }
+ } else {
+ return {
+ address: "",
+ status: (
+
+
+ {" "}
+ 🦊
+ आपको अपने ब्राउज़र में MetaMask, एक वर्चुअल एथेरियम वॉलेट स्थापित करना होगा।
+
+
+
+ ),
+ }
+ }
+}
+```
+
+यह कोड पिछले चरण में लिखे गए `connectWallet` फ़ंक्शन के _बहुत_ समान है।
+
+मुख्य अंतर यह है कि `eth_requestAccounts` विधि को कॉल करने के बजाय, जो यूज़र को अपने वॉलेट को कनेक्ट करने के लिए MetaMask खोलता है, यहाँ हम `eth_accounts` विधि को कॉल करते हैं, जो बस एक ऐरे लौटाता है जिसमें वर्तमान में हमारे डैप से जुड़े MetaMask पते होते हैं।
+
+इस फ़ंक्शन को क्रिया में देखने के लिए, आइए इसे हमारे `HelloWorld.js` घटक के `useEffect` फ़ंक्शन में कॉल करें:
+
+```javascript
+// HelloWorld.js
+
+useEffect(async () => {
+ const message = await loadCurrentMessage()
+ setMessage(message)
+ addSmartContractListener()
+
+ const { address, status } = await getCurrentWalletConnected()
+ setWallet(address)
+ setStatus(status)
+}, [])
+```
+
+ध्यान दें, हम अपने `walletAddress` और `status` स्थिति चर को अपडेट करने के लिए `getCurrentWalletConnected` पर हमारी कॉल की प्रतिक्रिया का उपयोग करते हैं।
+
+अब जब आपने यह कोड जोड़ लिया है, तो आइए अपनी ब्राउज़र विंडो को रीफ्रेश करने का प्रयास करें।
+
+बहुत बढ़िया! बटन को कहना चाहिए कि आप जुड़े हुए हैं, और अपने जुड़े हुए वॉलेट के पते का पूर्वावलोकन दिखाएं - भले ही आप रीफ्रेश करें!
+
+#### `addWalletListener` लागू करें {#implement-addwalletlistener}
+
+हमारे डैप वॉलेट सेटअप में अंतिम चरण वॉलेट श्रोता को लागू करना है ताकि हमारा UI तब अपडेट हो जब हमारे वॉलेट की स्थिति बदल जाए, जैसे कि जब यूज़र डिस्कनेक्ट हो जाता है या खाते बदलता है।
+
+अपनी `HelloWorld.js` फ़ाइल में, अपने `addWalletListener` फ़ंक्शन को इस प्रकार संशोधित करें:
+
+```javascript
+// HelloWorld.js
+
+function addWalletListener() {
+ if (window.ethereum) {
+ window.ethereum.on("accountsChanged", (accounts) => {
+ if (accounts.length > 0) {
+ setWallet(accounts[0])
+ setStatus("👆🏽 ऊपर दिए गए टेक्स्ट-फील्ड में एक संदेश लिखें।")
+ } else {
+ setWallet("")
+ setStatus("🦊 ऊपरी दाएं बटन का उपयोग करके MetaMask से कनेक्ट करें।")
+ }
+ })
+ } else {
+ setStatus(
+
+ {" "}
+ 🦊
+ आपको अपने ब्राउज़र में MetaMask, एक वर्चुअल एथेरियम वॉलेट स्थापित करना होगा।
+
+
+ )
+ }
+}
+```
+
+मुझे यकीन है कि आपको इस बिंदु पर यह समझने के लिए हमारी मदद की भी आवश्यकता नहीं है कि यहाँ क्या हो रहा है, लेकिन पूरी तरह से उद्देश्यों के लिए, आइए इसे जल्दी से तोड़ दें:
+
+- सबसे पहले, हमारा फ़ंक्शन जांचता है कि क्या `window.ethereum` सक्षम है (यानी, MetaMask इंस्टॉल है)।
+ - यदि यह नहीं है, तो हम बस अपने `status` स्थिति चर को एक JSX स्ट्रिंग पर सेट करते हैं जो यूज़र को MetaMask इंस्टॉल करने के लिए प्रेरित करता है।
+ - यदि यह सक्षम है, तो हम श्रोता `window.ethereum.on("accountsChanged")` को लाइन 3 पर सेट करते हैं जो MetaMask वॉलेट में स्थिति परिवर्तनों को सुनता है, जिसमें जब यूज़र डैप में एक अतिरिक्त खाता जोड़ता है, खाते बदलता है, या एक खाता डिस्कनेक्ट करता है। यदि कम से कम एक खाता जुड़ा हुआ है, तो `walletAddress` स्थिति चर को श्रोता द्वारा लौटाए गए `accounts` ऐरे में पहले खाते के रूप में अपडेट किया जाता है। अन्यथा, `walletAddress` को एक खाली स्ट्रिंग के रूप में सेट किया जाता है।
+
+अंतिम लेकिन कम से कम नहीं, हमें इसे अपने `useEffect` फ़ंक्शन में कॉल करना होगा:
+
+```javascript
+// HelloWorld.js
+
+useEffect(async () => {
+ const message = await loadCurrentMessage()
+ setMessage(message)
+ addSmartContractListener()
+
+ const { address, status } = await getCurrentWalletConnected()
+ setWallet(address)
+ setStatus(status)
+
+ addWalletListener()
+}, [])
+```
+
+और बस इतना ही! हमने अपनी सभी वॉलेट कार्यक्षमता को सफलतापूर्वक प्रोग्राम कर लिया है! अब हमारे अंतिम कार्य पर: हमारे स्मार्ट अनुबंध में संग्रहीत संदेश को अपडेट करना!
+
+### चरण 6: `updateMessage` फ़ंक्शन लागू करें {#step-6-implement-the-updateMessage-function}
+
+ठीक है दोस्तों, हम अंतिम चरण पर आ गए हैं! आपकी `interact.js` फ़ाइल के `updateMessage` में, हम निम्नलिखित करने जा रहे हैं:
+
+1. सुनिश्चित करें कि हम अपने स्मार्ट संपर्क में जो संदेश प्रकाशित करना चाहते हैं, वह मान्य है
+2. MetaMask का उपयोग करके हमारे लेनदेन पर हस्ताक्षर करें
+3. इस फ़ंक्शन को हमारे `HelloWorld.js` फ्रंटएंड घटक से कॉल करें
+
+इसमें ज्यादा समय नहीं लगेगा; आइए इस डैप को पूरा करें!
+
+#### इनपुट त्रुटि हैंडलिंग {#input-error-handling}
+
+स्वाभाविक रूप से, फ़ंक्शन की शुरुआत में किसी प्रकार का इनपुट त्रुटि प्रबंधन होना समझ में आता है।
+
+हम चाहेंगे कि हमारा फ़ंक्शन जल्दी लौट आए यदि कोई MetaMask एक्सटेंशन स्थापित नहीं है, कोई वॉलेट जुड़ा नहीं है (यानी, पास किया गया `address` एक खाली स्ट्रिंग है), या `message` एक खाली स्ट्रिंग है। आइए `updateMessage` में निम्नलिखित त्रुटि प्रबंधन जोड़ें:
+
+```javascript
+// interact.js
+
+export const updateMessage = async (address, message) => {
+ if (!window.ethereum || address === null) {
+ return {
+ status:
+ "💡 ब्लॉकचेन पर संदेश को अपडेट करने के लिए अपना MetaMask वॉलेट कनेक्ट करें।",
+ }
+ }
+
+ if (message.trim() === "") {
+ return {
+ status: "❌ आपका संदेश एक खाली स्ट्रिंग नहीं हो सकता है।",
+ }
+ }
+}
+```
+
+अब जब इसमें उचित इनपुट त्रुटि प्रबंधन है, तो MetaMask के माध्यम से लेनदेन पर हस्ताक्षर करने का समय है!
+
+#### हमारे लेनदेन पर हस्ताक्षर करना {#signing-our-transaction}
+
+यदि आप पहले से ही पारंपरिक वेब3 एथेरियम लेनदेन से सहज हैं, तो हम जो कोड आगे लिखेंगे वह बहुत परिचित होगा। अपने इनपुट त्रुटि प्रबंधन कोड के नीचे, `updateMessage` में निम्नलिखित जोड़ें:
+
+```javascript
+// interact.js
+
+//लेनदेन पैरामीटर सेट करें
+const transactionParameters = {
+ to: contractAddress, // अनुबंध प्रकाशनों के दौरान छोड़कर आवश्यक है।
+ from: address, // उपयोगकर्ता के सक्रिय पते से मेल खाना चाहिए।
+ data: helloWorldContract.methods.update(message).encodeABI(),
+}
+
+//लेनदेन पर हस्ताक्षर करें
+try {
+ const txHash = await window.ethereum.request({
+ method: "eth_sendTransaction",
+ params: [transactionParameters],
+ })
+ return {
+ status: (
+
+ ✅{" "}
+
+ Etherscan पर अपने लेनदेन की स्थिति देखें!
+
+
+ ℹ️ एक बार नेटवर्क द्वारा लेनदेन सत्यापित हो जाने पर, संदेश स्वचालित रूप से अपडेट हो जाएगा।
+
+ ),
+ }
+} catch (error) {
+ return {
+ status: "😥 " + error.message,
+ }
+}
+```
+
+आइए तोड़ते हैं कि क्या हो रहा है। सबसे पहले, हम अपने लेनदेन पैरामीटर सेट करते हैं, जहाँ:
+
+- `to` प्राप्तकर्ता का पता निर्दिष्ट करता है (हमारा स्मार्ट अनुबंध)
+- `from` लेनदेन के हस्ताक्षरकर्ता को निर्दिष्ट करता है, `address` चर हमने अपने फ़ंक्शन में पास किया है
+- `data` में हमारे हैलो वर्ल्ड स्मार्ट अनुबंध के `update` विधि के लिए कॉल होता है, जो इनपुट के रूप में हमारे `message` स्ट्रिंग चर को प्राप्त करता है
+
+फिर, हम एक await कॉल, `window.ethereum.request` करते हैं, जहाँ हम MetaMask से लेनदेन पर हस्ताक्षर करने के लिए कहते हैं। ध्यान दें, पंक्तियों 11 और 12 पर, हम अपनी eth विधि, `eth_sendTransaction` निर्दिष्ट कर रहे हैं और अपने `transactionParameters` में पास कर रहे हैं।
+
+इस बिंदु पर, MetaMask ब्राउज़र में खुल जाएगा, और यूज़र को लेनदेन पर हस्ताक्षर करने या अस्वीकार करने के लिए प्रेरित करेगा।
+
+- यदि लेनदेन सफल होता है, तो फ़ंक्शन एक JSON ऑब्जेक्ट लौटाएगा जहाँ `status` JSX स्ट्रिंग उपयोगकर्ता को उनके लेनदेन के बारे में अधिक जानकारी के लिए Etherscan देखने के लिए प्रेरित करती है।
+- यदि लेनदेन विफल हो जाता है, तो फ़ंक्शन एक JSON ऑब्जेक्ट लौटाएगा जहाँ `status` स्ट्रिंग त्रुटि संदेश को रिले करती है।
+
+कुल मिलाकर, हमारा `updateMessage` फ़ंक्शन इस तरह दिखना चाहिए:
+
+```javascript
+// interact.js
+
+export const updateMessage = async (address, message) => {
+ //इनपुट त्रुटि प्रबंधन
+ if (!window.ethereum || address === null) {
+ return {
+ status:
+ "💡 ब्लॉकचेन पर संदेश को अपडेट करने के लिए अपना MetaMask वॉलेट कनेक्ट करें।",
+ }
+ }
+
+ if (message.trim() === "") {
+ return {
+ status: "❌ आपका संदेश एक खाली स्ट्रिंग नहीं हो सकता है।",
+ }
+ }
+
+ //लेनदेन पैरामीटर सेट करें
+ const transactionParameters = {
+ to: contractAddress, // अनुबंध प्रकाशनों के दौरान छोड़कर आवश्यक है।
+ from: address, // उपयोगकर्ता के सक्रिय पते से मेल खाना चाहिए।
+ data: helloWorldContract.methods.update(message).encodeABI(),
+ }
+
+ //लेनदेन पर हस्ताक्षर करें
+ try {
+ const txHash = await window.ethereum.request({
+ method: "eth_sendTransaction",
+ params: [transactionParameters],
+ })
+ return {
+ status: (
+
+ ✅{" "}
+
+ Etherscan पर अपने लेनदेन की स्थिति देखें!
+
+
+ ℹ️ एक बार नेटवर्क द्वारा लेनदेन सत्यापित हो जाने पर, संदेश स्वचालित रूप से अपडेट हो जाएगा।
+
+ ),
+ }
+ } catch (error) {
+ return {
+ status: "😥 " + error.message,
+ }
+ }
+}
+```
+
+अंतिम लेकिन कम से कम नहीं, हमें अपने `updateMessage` फ़ंक्शन को हमारे `HelloWorld.js` घटक से कनेक्ट करने की आवश्यकता है।
+
+#### `updateMessage` को `HelloWorld.js` फ्रंटएंड से कनेक्ट करें {#connect-updatemessage-to-the-helloworld-js-frontend}
+
+हमारे `onUpdatePressed` फ़ंक्शन को आयातित `updateMessage` फ़ंक्शन पर एक await कॉल करना चाहिए और `status` स्टेट चर को यह दर्शाने के लिए संशोधित करना चाहिए कि हमारा लेनदेन सफल हुआ या विफल:
+
+```javascript
+// HelloWorld.js
+
+const onUpdatePressed = async () => {
+ const { status } = await updateMessage(walletAddress, newMessage)
+ setStatus(status)
+}
+```
+
+यह बहुत साफ और सरल है। और अनुमान लगाओ क्या... आपका डैप पूरा हो गया है!!!
+
+आगे बढ़ें और **अपडेट करें** बटन का परीक्षण करें!
+
+### अपना खुद का कस्टम डैप बनाएं {#make-your-own-custom-dapp}
+
+वाह, आप ट्यूटोरियल के अंत तक पहुंच गए! संक्षेप में, आपने सीखा कि कैसे:
+
+- अपने डैप प्रोजेक्ट से एक MetaMask वॉलेट कनेक्ट करें
+- [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) API का उपयोग करके अपने स्मार्ट अनुबंध से डेटा पढ़ें
+- MetaMask का उपयोग करके एथेरियम लेनदेन पर हस्ताक्षर करें
+
+अब आप इस ट्यूटोरियल से अपने खुद के कस्टम डैप प्रोजेक्ट को बनाने के लिए कौशल लागू करने के लिए पूरी तरह से सुसज्जित हैं! हमेशा की तरह, यदि आपके कोई प्रश्न हैं, तो [Alchemy Discord](https://discord.gg/gWuC7zB) में मदद के लिए हमसे संपर्क करने में संकोच न करें। 🧙♂️
+
+एक बार जब आप यह ट्यूटोरियल पूरा कर लेते हैं, तो हमें बताएं कि आपका अनुभव कैसा रहा या यदि आपके पास कोई प्रतिक्रिया है तो हमें ट्विटर पर [@alchemyplatform](https://twitter.com/AlchemyPlatform) टैग करके बताएं!
diff --git a/public/content/translations/hi/developers/tutorials/hello-world-smart-contract/index.md b/public/content/translations/hi/developers/tutorials/hello-world-smart-contract/index.md
new file mode 100644
index 00000000000..28ff7366cd8
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/hello-world-smart-contract/index.md
@@ -0,0 +1,366 @@
+---
+title: "शुरुआती लोगों के लिए हैलो वर्ल्ड स्मार्ट अनुबंध"
+description: "एथेरियम पर एक सरल स्मार्ट अनुबंध लिखने और तैनात करने पर परिचयात्मक ट्यूटोरियल।"
+author: "elanh"
+tags:
+ [
+ "सोलिडीटी",
+ "हार्डहैट",
+ "एल्केमी",
+ "स्मार्ट अनुबंध",
+ "परिनियोजित करना"
+ ]
+skill: beginner
+lang: hi
+published: 2021-03-31
+---
+
+यदि आप ब्लॉकचेन विकास में नए हैं और नहीं जानते कि कहां से शुरू करें, या यदि आप सिर्फ यह समझना चाहते हैं कि स्मार्ट अनुबंधों को कैसे तैनात और इंटरैक्ट किया जाए, तो यह गाइड आपके लिए है। हम वर्चुअल वॉलेट [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/), और [Alchemy](https://www.alchemy.com/eth) का उपयोग करके Sepolia टेस्ट नेटवर्क पर एक सरल स्मार्ट अनुबंध बनाने और तैनात करने के माध्यम से चलेंगे (चिंता न करें यदि आप नहीं समझते हैं कि इसका क्या मतलब है, हम इसे समझाएंगे)।
+
+इस ट्यूटोरियल के [भाग 2](https://docs.alchemy.com/docs/interacting-with-a-smart-contract) में हम देखेंगे कि एक बार यहां तैनात होने के बाद हम अपने स्मार्ट अनुबंध के साथ कैसे इंटरैक्ट कर सकते हैं, और [भाग 3](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) में हम इसे Etherscan पर कैसे प्रकाशित करें, इसे कवर करेंगे।
+
+यदि आपके पास किसी भी समय कोई प्रश्न हैं, तो बेझिझक [Alchemy Discord](https://discord.gg/gWuC7zB) में संपर्क करें!
+
+## चरण 1: एथेरियम नेटवर्क से कनेक्ट करें {#step-1}
+
+एथेरियम श्रृंखला के लिए अनुरोध करने के कई तरीके हैं। सरलता के लिए, हम Alchemy पर एक मुफ्त खाते का उपयोग करेंगे, जो एक ब्लॉकचेन डेवलपर प्लेटफ़ॉर्म और API है जो हमें अपने स्वयं के नोड्स को चलाने के बिना एथेरियम श्रृंखला के साथ संवाद करने की अनुमति देता है। प्लेटफॉर्म में निगरानी और एनालिटिक्स के लिए डेवलपर उपकरण भी हैं जिनका हम इस ट्यूटोरियल में लाभ उठाएंगे ताकि यह समझ सकें कि हमारे स्मार्ट अनुबंध की तैनाती में क्या हो रहा है। यदि आपके पास पहले से Alchemy खाता नहीं है, तो [आप यहां मुफ्त में साइन अप कर सकते हैं](https://dashboard.alchemy.com/signup)।
+
+## चरण 2: अपना ऐप (और API कुंजी) बनाएं {#step-2}
+
+एक बार जब आप एक Alchemy खाता बना लेते हैं, तो आप एक ऐप बनाकर एक API कुंजी उत्पन्न कर सकते हैं। यह हमें Sepolia टेस्टनेट से अनुरोध करने की अनुमति देगा। यदि आप टेस्टनेट से परिचित नहीं हैं, तो [यह पृष्ठ](/developers/docs/networks/) देखें।
+
+1. नेव बार में "एक ऐप चुनें" का चयन करके और "नया ऐप बनाएं" पर क्लिक करके अपने Alchemy डैशबोर्ड में "नया ऐप बनाएं" पृष्ठ पर नेविगेट करें
+
+
+
+2. अपने ऐप को “Hello World” नाम दें, एक संक्षिप्त विवरण दें, और एक उपयोग मामला चुनें, उदाहरण के लिए, "इन्फ्रा और टूलींग।" अगला, "Ethereum" खोजें और नेटवर्क चुनें।
+
+
+
+3. आगे बढ़ने के लिए "अगला" पर क्लिक करें, फिर "ऐप बनाएं" और बस हो गया! आपका ऐप नेव बार ड्रॉपडाउन मेनू में दिखाई देना चाहिए, जिसमें कॉपी करने के लिए एक API कुंजी उपलब्ध है।
+
+## चरण 3: एक एथेरियम खाता (पता) बनाएं {#step-3}
+
+हमें लेनदेन भेजने और प्राप्त करने के लिए एक एथेरियम खाते की आवश्यकता है। इस ट्यूटोरियल के लिए, हम MetaMask का उपयोग करेंगे, जो ब्राउज़र में एक वर्चुअल वॉलेट है जिसका उपयोग आपके एथेरियम खाते के पते को प्रबंधित करने के लिए किया जाता है। [लेन-देन](/developers/docs/transactions/) पर और जानें।
+
+आप MetaMask डाउनलोड कर सकते हैं और [यहां](https://metamask.io/download) मुफ्त में एक एथेरियम खाता बना सकते हैं। जब आप एक खाता बना रहे हों, या यदि आपके पास पहले से ही एक खाता है, तो नेटवर्क ड्रॉपडाउन मेनू का उपयोग करके "Sepolia" टेस्ट नेटवर्क पर स्विच करना सुनिश्चित करें (ताकि हम वास्तविक धन से निपट नहीं रहे हैं)।
+
+यदि आपको सेपोलिया सूचीबद्ध नहीं दिखाई देता है, तो मेनू में जाएं, फिर उन्नत और "टेस्ट नेटवर्क दिखाएं" को चालू करने के लिए नीचे स्क्रॉल करें। नेटवर्क चयन मेनू में, टेस्टनेट की सूची खोजने के लिए "कस्टम" टैब चुनें और "सेपोलिया" चुनें।
+
+
+
+## चरण 4: एक फोसेट से ईथर जोड़ें {#step-4}
+
+हमारे स्मार्ट अनुबंध को टेस्ट नेटवर्क पर तैनात करने के लिए, हमें कुछ नकली Eth की आवश्यकता होगी। सेपोलिया ETH प्राप्त करने के लिए आप विभिन्न फोसेट की सूची देखने के लिए [सेपोलिया नेटवर्क विवरण](/developers/docs/networks/#sepolia) पर जा सकते हैं। यदि एक काम नहीं करता है, तो दूसरा प्रयास करें क्योंकि वे कभी-कभी सूख सकते हैं। नेटवर्क ट्रैफिक के कारण आपको अपना नकली ETH प्राप्त करने में कुछ समय लग सकता है। आपको इसके तुरंत बाद अपने मेटामास्क खाते में ETH दिखना चाहिए!
+
+## चरण 5: अपनी शेष राशि की जाँच करें {#step-5}
+
+यह सुनिश्चित करने के लिए कि हमारी शेष राशि है, आइए [Alchemy के कंपोजर टूल](https://sandbox.alchemy.com/?network=ETH_SEPOLIA&method=eth_getBalance&body.id=1&body.jsonrpc=2.0&body.method=eth_getBalance&body.params%5B0%5D=&body.params%5B1%5D=latest) का उपयोग करके एक [eth_getBalance](/developers/docs/apis/json-rpc/#eth_getbalance) अनुरोध करें। यह हमारे वॉलेट में ETH की राशि वापस कर देगा। जब आप अपना MetaMask खाता पता इनपुट करते हैं और "Send Request" पर क्लिक करते हैं, तो आपको इस तरह का एक जवाब देखना चाहिए:
+
+```json
+{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" }
+```
+
+> **नोट:** यह परिणाम ETH में नहीं, wei में है। Wei का उपयोग ईथर के सबसे छोटे मूल्यवर्ग के रूप में किया जाता है। wei से ETH में रूपांतरण है: 1 eth = 1018 wei। तो यदि हम 0x2B5E3AF16B1880000 को दशमलव में बदलते हैं तो हमें 5\*10¹⁸ मिलता है जो 5 ETH के बराबर है।
+>
+> उफ्फ! हमारा नकली पैसा सब यहाँ है
+
+
+.env को कमिट न करें! कृपया यह सुनिश्चित कर लें कि आप अपनी .env फ़ाइल को किसी के साथ साझा या उजागर न करें, क्योंकि ऐसा करने से आप अपने रहस्यों से समझौता कर रहे हैं। यदि आप संस्करण नियंत्रण का उपयोग कर रहे हैं, तो अपनी .env को gitignore फ़ाइल में जोड़ें।
+
+
+
+
+## चरण 12: Ethers.js इंस्टॉल करें {#step-12-install-ethersjs}
+
+Ethers.js एक लाइब्रेरी है जो अधिक उपयोगकर्ता-अनुकूल तरीकों के साथ [मानक JSON-RPC तरीकों](/developers/docs/apis/json-rpc/) को रैप करके एथेरियम के साथ इंटरैक्ट करना और अनुरोध करना आसान बनाती है।
+
+Hardhat अतिरिक्त टूलिंग और विस्तारित कार्यक्षमता के लिए [प्लगइन्स](https://hardhat.org/plugins/) को एकीकृत करना बेहद आसान बनाता है। हम अनुबंध परिनियोजन के लिए [Ethers प्लगइन](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) का लाभ उठाएंगे ([Ethers.js](https://github.com/ethers-io/ethers.js/) में कुछ बहुत ही स्वच्छ अनुबंध परिनियोजन विधियाँ हैं)।
+
+अपनी प्रोजेक्ट डायरेक्टरी में टाइप करें:
+
+```
+npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0"
+```
+
+हम अगले चरण में अपनी `hardhat.config.js` में ईथर की भी आवश्यकता होगी।
+
+## चरण 13: hardhat.config.js को अपडेट करें {#step-13-update-hardhatconfigjs}
+
+हमने अब तक कई निर्भरताएँ और प्लगइन्स जोड़े हैं, अब हमें `hardhat.config.js` को अपडेट करने की आवश्यकता है ताकि हमारी परियोजना उन सभी के बारे में जान सके।
+
+अपने `hardhat.config.js` को इस तरह दिखने के लिए अपडेट करें:
+
+```
+require('dotenv').config();
+
+require("@nomiclabs/hardhat-ethers");
+const { API_URL, PRIVATE_KEY } = process.env;
+
+/**
+* @type import('hardhat/config').HardhatUserConfig
+*/
+module.exports = {
+ solidity: "0.7.3",
+ defaultNetwork: "sepolia",
+ networks: {
+ hardhat: {},
+ sepolia: {
+ url: API_URL,
+ accounts: [`0x${PRIVATE_KEY}`]
+ }
+ },
+}
+```
+
+## चरण 14: हमारे अनुबंध को संकलित करें {#step-14-compile-our-contracts}
+
+यह सुनिश्चित करने के लिए कि अब तक सब कुछ काम कर रहा है, आइए हम अपने अनुबंध को कंपाइल करें। `compile` कार्य अंतर्निहित हार्डहैट कार्यों में से एक है।
+
+कमांड लाइन से चलाएं:
+
+```
+npx hardhat compile
+```
+
+आपको `SPDX license identifier not provided in source file` के बारे में एक चेतावनी मिल सकती है, लेकिन इसके बारे में चिंता करने की कोई आवश्यकता नहीं है — उम्मीद है कि बाकी सब कुछ अच्छा लग रहा है! यदि नहीं, तो आप हमेशा [Alchemy discord](https://discord.gg/u72VCg3) में संदेश भेज सकते हैं।
+
+## चरण 15: हमारी परिनियोजन स्क्रिप्ट लिखें {#step-15-write-our-deploy-scripts}
+
+अब जब हमारा अनुबंध लिखा गया है और हमारी कॉन्फ़िगरेशन फ़ाइल तैयार है, तो हमारी अनुबंध डिप्लॉय स्क्रिप्ट लिखने का समय आ गया है।
+
+`scripts/` फ़ोल्डर पर नेविगेट करें और `deploy.js` नामक एक नई फ़ाइल बनाएं, जिसमें निम्नलिखित सामग्री जोड़ें:
+
+```
+async function main() {
+ const HelloWorld = await ethers.getContractFactory("HelloWorld");
+
+ // परिनियोजन शुरू करें, एक वादा लौटाते हुए जो एक अनुबंध वस्तु को हल करता है
+ const hello_world = await HelloWorld.deploy("हैलो वर्ल्ड!");
+ console.log("अनुबंध पते पर तैनात:", hello_world.address);}
+
+main()
+ .then(() => process.exit(0))
+ .catch(error => {
+ console.error(error);
+ process.exit(1);
+ });
+```
+
+Hardhat अपने [अनुबंध ट्यूटोरियल](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) में कोड की इन पंक्तियों में से प्रत्येक क्या करता है, यह समझाने का एक अद्भुत काम करता है, हमने यहां उनकी व्याख्याओं को अपनाया है।
+
+```
+const HelloWorld = await ethers.getContractFactory("HelloWorld");
+```
+
+ethers.js में एक `ContractFactory` नए स्मार्ट अनुबंधों को तैनात करने के लिए उपयोग किया जाने वाला एक एब्स्ट्रेक्शन है, इसलिए यहाँ `HelloWorld` हमारे हैलो वर्ल्ड अनुबंध के उदाहरणों के लिए एक फैक्ट्री है। `hardhat-ethers` प्लगइन का उपयोग करते समय `ContractFactory` और `Contract` उदाहरण डिफ़ॉल्ट रूप से पहले हस्ताक्षरकर्ता से जुड़े होते हैं।
+
+```
+const hello_world = await HelloWorld.deploy();
+```
+
+`ContractFactory` पर `deploy()` को कॉल करने से परिनियोजन शुरू हो जाएगा, और एक `Promise` लौटाएगा जो एक `Contract` में हल हो जाता है। यह वह ऑब्जेक्ट है जिसमें हमारे प्रत्येक स्मार्ट अनुबंध फ़ंक्शन के लिए एक विधि है।
+
+## चरण 16: हमारे अनुबंध को तैनात करें {#step-16-deploy-our-contract}
+
+हम अंततः अपने स्मार्ट अनुबंध को डिप्लॉय करने के लिए तैयार हैं! कमांड लाइन पर नेविगेट करें और चलाएं:
+
+```
+npx hardhat run scripts/deploy.js --network sepolia
+```
+
+इसके बाद आपको कुछ इस तरह देखना चाहिए:
+
+```
+अनुबंध पते पर तैनात: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570
+```
+
+यदि हम [Sepolia etherscan](https://sepolia.etherscan.io/) पर जाते हैं और अपने अनुबंध पते की खोज करते हैं तो हम देख पाएंगे कि यह सफलतापूर्वक तैनात हो गया है। लेनदेन कुछ इस तरह दिखेगा:
+
+
+
+`From` पता आपके MetaMask खाते के पते से मेल खाना चाहिए और To पता “Contract Creation” कहेगा, लेकिन यदि हम लेनदेन में क्लिक करते हैं तो हम `To` फ़ील्ड में अपना अनुबंध पता देखेंगे:
+
+
+
+बधाई हो! आपने अभी-अभी एथेरियम श्रृंखला पर एक स्मार्ट अनुबंध तैनात किया है 🎉
+
+पर्दे के पीछे क्या हो रहा है, यह समझने के लिए, आइए हमारे [Alchemy डैशबोर्ड](https://dashboard.alchemyapi.io/explorer) में एक्सप्लोरर टैब पर नेविगेट करें। यदि आपके पास कई Alchemy ऐप हैं, तो ऐप द्वारा फ़िल्टर करना और “Hello World” का चयन करना सुनिश्चित करें।
+
+
+यहां आपको कुछ JSON-RPC कॉल दिखाई देंगे जो Hardhat/Ethers ने हमारे लिए पर्दे के पीछे से किए थे जब हमने `.deploy()` फ़ंक्शन को कॉल किया था। यहाँ दो महत्वपूर्ण बातें हैं [`eth_sendRawTransaction`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-send-raw-transaction), जो वास्तव में हमारे अनुबंध को सेपोलिया श्रृंखला पर लिखने का अनुरोध है, और [`eth_getTransactionByHash`](https://www.alchemy.com/docs/node/abstract/abstract-api-endpoints/eth-get-transaction-by-hash) जो हैश दिए जाने पर हमारे लेनदेन के बारे में जानकारी पढ़ने का अनुरोध है (लेन-देन के समय एक विशिष्ट पैटर्न)। लेन-देन भेजने के बारे में अधिक जानने के लिए, [Web3 का उपयोग करके लेन-देन भेजने](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) पर इस ट्यूटोरियल को देखें
+
+इस ट्यूटोरियल के भाग 1 के लिए बस इतना ही, भाग 2 में हम वास्तव में अपने प्रारंभिक संदेश को अपडेट करके [अपने स्मार्ट अनुबंध के साथ बातचीत करेंगे](https://www.alchemy.com/docs/interacting-with-a-smart-contract), और भाग 3 में हम [अपने स्मार्ट अनुबंध को Etherscan पर प्रकाशित करेंगे](https://www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) ताकि हर कोई जान सके कि इसके साथ कैसे बातचीत करनी है।
+
+**Alchemy के बारे में और जानना चाहते हैं?** हमारी [वेबसाइट](https://www.alchemy.com/eth) देखें। कभी कोई अपडेट मिस नहीं करना चाहते? हमारे न्यूज़लेटर को [यहां](https://www.alchemy.com/newsletter) सब्सक्राइब करें! हमारे [Discord](https://discord.gg/u72VCg3) से भी जुड़ना सुनिश्चित करें।\*\*।
diff --git a/public/content/translations/hi/developers/tutorials/how-to-implement-an-erc721-market/index.md b/public/content/translations/hi/developers/tutorials/how-to-implement-an-erc721-market/index.md
new file mode 100644
index 00000000000..50a01332bae
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/how-to-implement-an-erc721-market/index.md
@@ -0,0 +1,145 @@
+---
+title: "ERC-721 बाजार कैसे लागू करें"
+description: "विकेंद्रीकृत वर्गीकृत बोर्ड पर बिक्री के लिए टोकनयुक्त आइटम कैसे डालें"
+author: "Alberto Cuesta Cañada"
+tags: [ "स्मार्ट अनुबंध", "erc-721", "सोलिडीटी", "टोकन" ]
+skill: intermediate
+lang: hi
+published: 2020-03-19
+source: Hackernoon
+sourceUrl: https://hackernoon.com/how-to-implement-an-erc721-market-1e1a32j9
+---
+
+इस लेख में, मैं आपको दिखाने जा रहा हूं कि Ethereum ब्लॉकचेन के लिए Craigslist को कैसे कोड किया जाए।
+
+Gumtree, Ebay और Craigslist से पहले, वर्गीकृत बोर्ड ज़्यादातर कॉर्क या कागज के बने होते थे। स्कूल के गलियारों, समाचार पत्रों, स्ट्रीटलाइट्स, स्टोरफ्रंट्स में वर्गीकृत बोर्ड होते थे।
+
+इंटरनेट के साथ यह सब बदल गया। एक विशिष्ट वर्गीकृत बोर्ड को देख सकने वाले लोगों की संख्या कई गुना बढ़ गई। इसके साथ, वे जिन बाजारों का प्रतिनिधित्व करते हैं, वे कहीं अधिक कुशल हो गए और वैश्विक आकार तक पहुंच गए। Ebay एक बहुत बड़ा व्यवसाय है जिसकी उत्पत्ति इन भौतिक वर्गीकृत बोर्डों से हुई है।
+
+ब्लॉकचेन के साथ ये बाज़ार एक बार फिर बदलने के लिए तैयार हैं, मैं आपको दिखाता हूँ कैसे।
+
+## मुद्रीकरण {#monetization}
+
+एक सार्वजनिक ब्लॉकचेन वर्गीकृत बोर्ड का व्यवसाय मॉडल Ebay और कंपनी से अलग होना होगा।
+
+सबसे पहले, [विकेंद्रीकरण का कोण](/developers/docs/web2-vs-web3/) है। मौजूदा प्लेटफ़ॉर्मों को अपने स्वयं के सर्वर बनाए रखने की ज़रूरत होती है। एक विकेंद्रीकृत प्लेटफ़ॉर्म को उसके यूज़र्स द्वारा बनाए रखा जाता है, इसलिए कोर प्लेटफ़ॉर्म चलाने की लागत प्लेटफ़ॉर्म मालिक के लिए शून्य हो जाती है।
+
+फिर फ्रंट एंड है, वेबसाइट या इंटरफ़ेस जो प्लेटफ़ॉर्म तक पहुंच प्रदान करता है। यहां कई विकल्प हैं। प्लेटफ़ॉर्म मालिक पहुंच को प्रतिबंधित कर सकते हैं और शुल्क लगाकर सभी को अपने इंटरफ़ेस का उपयोग करने के लिए मजबूर कर सकते हैं। प्लेटफ़ॉर्म के मालिक पहुंच को खोलने का भी निर्णय ले सकते हैं (ताकत लोगों के हाथ में!) और किसी को भी प्लेटफ़ॉर्म के लिए इंटरफेस बनाने की सुविधा दे सकते हैं। या मालिक उन चरम सीमाओं के बीच किसी भी दृष्टिकोण का निर्णय ले सकते हैं।
+
+_मुझसे ज़्यादा दूरदृष्टि वाले व्यावसायिक नेता जानेंगे कि इसका मुद्रीकरण कैसे किया जाए। _मैं बस इतना देख रहा हूं कि यह यथास्थिति से अलग है और शायद लाभदायक है।_
+
+इसके अलावा, स्वचालन और भुगतान का पहलू है। कुछ चीज़ों को बहुत [प्रभावी ढंग से टोकनयुक्त](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com) किया जा सकता है और एक वर्गीकृत बोर्ड में ट्रे़ड किया जा सकता है। टोकनयुक्त परिसंपत्तियां एक ब्लॉकचेन में आसानी से स्थानांतरित हो जाती हैं। अत्यधिक जटिल भुगतान विधियों को एक ब्लॉकचेन में आसानी से लागू किया जा सकता है।
+
+मुझे यहां एक व्यावसायिक अवसर की गंध आ रही है। बिना किसी चालू लागत वाला एक वर्गीकृत बोर्ड आसानी से लागू किया जा सकता है, जिसमें प्रत्येक लेन-देन में जटिल भुगतान पथ शामिल हों। मुझे यकीन है कि कोई इस विचार के साथ आएगा कि इसका उपयोग किस लिए करना है।
+
+मैं इसे बनाकर ही खुश हूं। आइए कोड पर एक नज़र डालें।
+
+## कार्यान्वयन {#implementation}
+
+कुछ समय पहले हमने व्यावसायिक मामले के उदाहरण कार्यान्वयन और अन्य उपहारों के साथ एक [ओपन सोर्स रिपॉजिटरी](https://github.com/HQ20/contracts?ref=hackernoon.com) शुरू की थी, कृपया एक नज़र डालें।
+
+इस [Ethereum वर्गीकृत बोर्ड](https://github.com/HQ20/contracts/tree/master/contracts/classifieds?ref=hackernoon.com) का कोड वहां है, कृपया इसका इस्तेमाल करें और इसका भरपूर इस्तेमाल करें। बस इस बात से अवगत रहें कि कोड का ऑडिट नहीं किया गया है और इसमें पैसा लगाने से पहले आपको अपना उचित परिश्रम करना होगा।
+
+बोर्ड की मूल बातें जटिल नहीं हैं। बोर्ड में सभी विज्ञापन कुछ क्षेत्रों के साथ सिर्फ एक स्ट्रक्चर होंगे:
+
+```solidity
+struct Trade {
+ address poster;
+ uint256 item;
+ uint256 price;
+ bytes32 status; // खुला, निष्पादित, रद्द
+}
+```
+
+तो कोई है जो विज्ञापन पोस्ट कर रहा है। बिक्री के लिए एक वस्तु। वस्तु के लिए एक मूल्य। ट्रेड की स्थिति जो खुली, निष्पादित या रद्द की जा सकती है।
+
+इन सभी ट्रेडों को एक मैपिंग में रखा जाएगा। क्योंकि Solidity में सब कुछ एक मैपिंग लगता है। इसलिए भी क्योंकि यह सुविधाजनक है।
+
+```solidity
+mapping(uint256 => Trade) public trades;
+```
+
+मैपिंग का उपयोग करने का मतलब सिर्फ यह है कि हमें इसे पोस्ट करने से पहले प्रत्येक विज्ञापन के लिए एक आईडी बनानी होगी, और इस पर काम करने से पहले हमें एक विज्ञापन की आईडी जानने की आवश्यकता होगी। इससे निपटने के कई तरीके हैं, या तो स्मार्ट अनुबंध में या फ्रंट-एंड में। यदि आपको कुछ संकेत चाहिए तो कृपया पूछें।
+
+अगला सवाल यह है कि वे कौन सी वस्तुएं हैं जिनसे हम निपटते हैं, और यह कौन सी मुद्रा है जिसका उपयोग लेन-देन के लिए भुगतान करने के लिए किया जाता है।
+
+आइटम के लिए, हम बस यह पूछने जा रहे हैं कि वे [ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol?ref=hackernoon.com) इंटरफ़ेस लागू करें, जो वास्तव में एक ब्लॉकचेन में वास्तविक दुनिया की वस्तुओं का प्रतिनिधित्व करने का एक तरीका है, हालांकि यह [डिजिटल संपत्तियों के साथ सबसे अच्छा काम करता है](https://hackernoon.com/tokenization-of-digital-assets-g0ffk3v8s?ref=hackernoon.com)। हम कंस्ट्रक्टर में अपने स्वयं के ERC721 अनुबंध को निर्दिष्ट करने जा रहे हैं, जिसका अर्थ है कि हमारे वर्गीकृत बोर्ड में किसी भी संपत्ति को पहले से टोकनयुक्त होना चाहिए।
+
+भुगतान के लिए, हम कुछ इसी तरह का करने जा रहे हैं। अधिकांश ब्लॉकचेन परियोजनाएं अपनी स्वयं की [ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol?ref=hackernoon.com) क्रिप्टोकरेंसी परिभाषित करती हैं। कुछ अन्य लोग DAI जैसी मुख्यधारा की मुद्रा का उपयोग करना पसंद करते हैं। इस वर्गीकृत बोर्ड में, आपको केवल निर्माण पर यह तय करने की आवश्यकता है कि आपकी मुद्रा क्या होगी। आसान।
+
+```solidity
+constructor (
+ address _currencyTokenAddress, address _itemTokenAddress
+) public {
+ currencyToken = IERC20(_currencyTokenAddress);
+ itemToken = IERC721(_itemTokenAddress);
+ tradeCounter = 0;
+}
+```
+
+हम वहां पहुंच रहे हैं। हमारे पास विज्ञापन, ट्रे़ड के लिए आइटम और भुगतान के लिए एक मुद्रा है। एक विज्ञापन बनाने का मतलब है एक आइटम को एस्क्रो में रखना यह दिखाने के लिए कि आपके पास वह है और आपने इसे दो बार पोस्ट नहीं किया है, संभवतः एक अलग बोर्ड में।
+
+नीचे दिया गया कोड ठीक यही करता है। आइटम को एस्क्रो में रखता है, विज्ञापन बनाता है, कुछ हाउसकीपिंग करता है।
+
+```solidity
+function openTrade(uint256 _item, uint256 _price)
+ public
+{
+ itemToken.transferFrom(msg.sender, address(this), _item);
+ trades[tradeCounter] = Trade({
+ poster: msg.sender,
+ item: _item,
+ price: _price,
+ status: "Open"
+ });
+ tradeCounter += 1;
+ emit TradeStatusChange(tradeCounter - 1, "Open");
+}
+```
+
+ट्रे़ड स्वीकार करने का मतलब है एक विज्ञापन (ट्रे़ड) चुनना, कीमत चुकाना, आइटम प्राप्त करना। नीचे दिया गया कोड एक ट्रे़ड पुनर्प्राप्त करता है। जांचता है कि यह उपलब्ध है या नहीं। आइटम का भुगतान करता है। आइटम को पुनः प्राप्त करता है। विज्ञापन को अपडेट करता है।
+
+```solidity
+function executeTrade(uint256 _trade)
+ public
+{
+ Trade memory trade = trades[_trade];
+ require(trade.status == "Open", "ट्रेड खुला नहीं है।");
+ currencyToken.transferFrom(msg.sender, trade.poster, trade.price);
+ itemToken.transferFrom(address(this), msg.sender, trade.item);
+ trades[_trade].status = "Executed";
+ emit TradeStatusChange(_trade, "Executed");
+}
+```
+
+अंत में, हमारे पास विक्रेताओं के लिए एक विकल्प है कि वे किसी खरीदार के इसे स्वीकार करने से पहले एक ट्रे़ड से पीछे हट जाएं। कुछ मॉडलों में, विज्ञापन समाप्त होने से पहले कुछ समय के लिए लाइव रहेंगे। आपकी पसंद, आपके बाज़ार के डिज़ाइन पर निर्भर करती है।
+
+कोड एक ट्रे़ड को निष्पादित करने के लिए उपयोग किए जाने वाले कोड के समान है, सिवाय इसके कि कोई मुद्रा हाथ नहीं बदल रही है और आइटम विज्ञापन पोस्टर के पास वापस चला जाता है।
+
+```solidity
+function cancelTrade(uint256 _trade)
+ public
+{
+ Trade memory trade = trades[_trade];
+ require(
+ msg.sender == trade.poster,
+ "ट्रेड केवल पोस्टर द्वारा ही रद्द किया जा सकता है।"
+ );
+ require(trade.status == "Open", "ट्रेड खुला नहीं है।");
+ itemToken.transferFrom(address(this), trade.poster, trade.item);
+ trades[_trade].status = "Cancelled";
+ emit TradeStatusChange(_trade, "Cancelled");
+}
+```
+
+बस इतना ही। आप कार्यान्वयन के अंत तक पहुँच गए हैं। यह काफी आश्चर्यजनक है कि जब कोड में व्यक्त किया जाता है तो कुछ व्यावसायिक अवधारणाएं कितनी संक्षिप्त होती हैं, और यह उन मामलों में से एक है। पूरे अनुबंध को [हमारी रेपो में](https://github.com/HQ20/contracts/blob/master/contracts/classifieds/Classifieds.sol) देखें।
+
+## निष्कर्ष {#conclusion}
+
+वर्गीकृत बोर्ड एक सामान्य बाज़ार विन्यास हैं जो इंटरनेट के साथ बड़े पैमाने पर बढ़े, और कुछ एकाधिकार विजेताओं के साथ एक बेहद लोकप्रिय व्यवसाय मॉडल बन गए।
+
+वर्गीकृत बोर्ड एक ब्लॉकचेन वातावरण में दोहराने के लिए एक आसान उपकरण भी हैं, जिसमें बहुत विशिष्ट विशेषताएं हैं जो मौजूदा दिग्गजों के लिए एक चुनौती को संभव बनाएंगी।
+
+इस लेख में, मैंने एक वर्गीकृत बोर्ड व्यवसाय की व्यावसायिक वास्तविकता को तकनीकी कार्यान्वयन के साथ पाटने का प्रयास किया है। यदि आपके पास सही कौशल है तो यह ज्ञान आपको कार्यान्वयन के लिए एक दृष्टि और एक रोडमैप बनाने में मदद करेगा।
+
+हमेशा की तरह, यदि आप कुछ मजेदार बनाने जा रहे हैं और कुछ सलाह का स्वागत करेंगे, तो कृपया [मुझे एक संदेश भेजें](https://albertocuesta.es/)! मुझे मदद करने में हमेशा खुशी होती है।
diff --git a/public/content/translations/hi/developers/tutorials/how-to-mint-an-nft/index.md b/public/content/translations/hi/developers/tutorials/how-to-mint-an-nft/index.md
new file mode 100644
index 00000000000..4411a4da2d8
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/how-to-mint-an-nft/index.md
@@ -0,0 +1,329 @@
+---
+title: "NFT की टकसाल कैसे करें (NFT ट्यूटोरियल सीरीज़ का भाग 2/3)"
+description: "यह ट्यूटोरियल बताता है कि हमारे स्मार्ट अनुबंध और Web3 का उपयोग करके एथेरियम ब्लॉकचेन पर NFT की टकसाल कैसे करें।"
+author: "सुमी मुदगिल"
+tags: [ "ERC-721", "एल्केमी", "सोलिडीटी", "स्मार्ट अनुबंध" ]
+skill: beginner
+lang: hi
+published: 2021-04-22
+---
+
+[Beeple](https://www.nytimes.com/2021/03/11/arts/design/nft-auction-christies-beeple.html): $69 मिलियन
+[3LAU](https://www.forbes.com/sites/abrambrown/2021/03/03/3lau-nft-nonfungible-tokens-justin-blau/?sh=5f72ef64643b): $11 मिलियन
+[Grimes](https://www.theguardian.com/music/2021/mar/02/grimes-sells-digital-art-collection-non-fungible-tokens): $6 मिलियन
+
+उन सभी ने Alchemy के शक्तिशाली API का उपयोग करके अपने NFTs की टकसाल की। इस ट्यूटोरियल में, हम आपको सिखाएंगे कि \<10 मिनट में यही कैसे करें।
+
+"NFT की टकसाल करना" ब्लॉकचेन पर आपके ERC-721 टोकन के एक अद्वितीय उदाहरण को प्रकाशित करने की प्रक्रिया है। [इस NFT ट्यूटोरियल सीरीज़ के भाग 1](/developers/tutorials/how-to-write-and-deploy-an-nft/) से हमारे स्मार्ट अनुबंध का उपयोग करके, आइए अपने Web3 कौशल को प्रदर्शित करें और एक NFT की टकसाल करें। इस ट्यूटोरियल के अंत में, आप उतने NFT की टकसाल कर पाएँगे जितने आपका दिल (और वॉलेट) चाहे!
+
+आइए शुरू करते हैं!
+
+## चरण 1: Web3 इंस्टॉल करें {#install-web3}
+
+यदि आपने अपना NFT स्मार्ट अनुबंध बनाने के लिए पहले ट्यूटोरियल का पालन किया है, तो आपके पास पहले से ही Ethers.js का उपयोग करने का अनुभव है। Web3, Ethers के समान है, क्योंकि यह एक लाइब्रेरी है जिसका उपयोग एथेरियम ब्लॉकचेन से अनुरोध करना आसान बनाने के लिए किया जाता है। इस ट्यूटोरियल में हम [Alchemy Web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3) का उपयोग करेंगे, जो एक उन्नत Web3 लाइब्रेरी है जो स्वचालित री-ट्राई और मजबूत वेबसॉकेट सहायता प्रदान करती है।
+
+अपनी प्रोजेक्ट होम डायरेक्टरी में चलाएँ:
+
+```
+npm install @alch/alchemy-web3
+```
+
+## चरण 2: एक `mint-nft.js` फ़ाइल बनाएँ {#create-mintnftjs}
+
+अपनी स्क्रिप्ट डायरेक्टरी के अंदर, एक `mint-nft.js` फ़ाइल बनाएँ और कोड की निम्नलिखित पंक्तियाँ जोड़ें:
+
+```js
+require("dotenv").config()
+const API_URL = process.env.API_URL
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(API_URL)
+```
+
+## चरण 3: अपना अनुबंध ABI प्राप्त करें {#contract-abi}
+
+हमारा अनुबंध ABI (एप्लिकेशन बाइनरी इंटरफ़ेस) हमारे स्मार्ट अनुबंध के साथ इंटरैक्ट करने का इंटरफ़ेस है। आप अनुबंध ABI के बारे में [यहाँ](https://docs.alchemyapi.io/alchemy/guides/eth_getlogs#what-are-ab-is) और जान सकते हैं। Hardhat स्वचालित रूप से हमारे लिए एक ABI जेनरेट करता है और इसे `MyNFT.json` फ़ाइल में सेव करता है। इसका उपयोग करने के लिए हमें अपनी `mint-nft.js` फ़ाइल में कोड की निम्नलिखित पंक्तियों को जोड़कर सामग्री को पार्स करने की आवश्यकता होगी:
+
+```js
+const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
+```
+
+यदि आप ABI देखना चाहते हैं तो आप इसे अपने कंसोल पर प्रिंट कर सकते हैं:
+
+```js
+console.log(JSON.stringify(contract.abi))
+```
+
+`mint-nft.js` चलाने और अपने ABI को कंसोल पर प्रिंट हुआ देखने के लिए, अपने टर्मिनल पर नेविगेट करें और चलाएँ:
+
+```js
+node scripts/mint-nft.js
+```
+
+## चरण 4: IPFS का उपयोग करके अपने NFT के लिए मेटाडेटा कॉन्फ़िगर करें {#config-meta}
+
+यदि आपको भाग 1 के हमारे ट्यूटोरियल से याद है, तो हमारा `mintNFT` स्मार्ट अनुबंध फ़ंक्शन एक tokenURI पैरामीटर लेता है जिसे NFT के मेटाडेटा का वर्णन करने वाले JSON दस्तावेज़ में रिज़ाॅल्व होना चाहिए— जो वास्तव में NFT को जीवंत बनाता है, जिससे इसमें नाम, विवरण, छवि और अन्य विशेषताओं जैसे कॉन्फ़िगर करने योग्य गुण होते हैं।
+
+> _इंटरप्लेनेटरी फ़ाइल सिस्टम (IPFS) एक वितरित फ़ाइल सिस्टम में डेटा को संग्रहीत और साझा करने के लिए एक विकेन्द्रीकृत प्रोटोकॉल और पीयर-टू-पीयर नेटवर्क है।_
+
+हम अपने NFT एसेट और मेटाडेटा को स्टोर करने के लिए Pinata, एक सुविधाजनक IPFS API और टूलकिट का उपयोग करेंगे, ताकि यह सुनिश्चित हो सके कि हमारा NFT वास्तव में विकेंद्रीकृत है। यदि आपके पास Pinata खाता नहीं है, तो [यहाँ](https://app.pinata.cloud) एक निःशुल्क खाते के लिए साइन अप करें और अपना ईमेल सत्यापित करने के लिए चरणों को पूरा करें।
+
+एक बार जब आप एक खाता बना लेते हैं:
+
+- "फ़ाइलें" पेज पर जाएँ और पेज के ऊपर-बाईं ओर नीले "अपलोड" बटन पर क्लिक करें।
+
+- Pinata पर एक छवि अपलोड करें — यह आपके NFT के लिए छवि संपत्ति होगी। आप एसेट का जो भी चाहें नाम रख सकते हैं
+
+- अपलोड करने के बाद, आप "फ़ाइलें" पेज पर तालिका में फ़ाइल की जानकारी देखेंगे। आपको एक CID कॉलम भी दिखाई देगा। आप इसके आगे वाले कॉपी बटन पर क्लिक करके CID कॉपी कर सकते हैं। आप अपना अपलोड यहाँ देख सकते हैं: `https://gateway.pinata.cloud/ipfs/`। उदाहरण के लिए, हमारे द्वारा IPFS पर उपयोग की गई छवि आप [यहाँ](https://gateway.pinata.cloud/ipfs/QmZdd5KYdCFApWn7eTZJ1qgJu18urJrP9Yh1TZcZrZxxB5) देख सकते हैं।
+
+विज़ुअल शिक्षार्थियों के लिए, उपरोक्त चरणों का सारांश यहाँ दिया गया है:
+
+
+
+अब, हम Pinata पर एक और दस्तावेज़ अपलोड करेंगे। लेकिन ऐसा करने से पहले, हमें इसे बनाना होगा!
+
+अपनी रूट डायरेक्टरी में, `nft-metadata.json` नामक एक नई फ़ाइल बनाएँ और निम्नलिखित json कोड जोड़ें:
+
+```json
+{
+ "attributes": [
+ {
+ "trait_type": "नस्ल",
+ "value": "Maltipoo"
+ },
+ {
+ "trait_type": "आंखों का रंग",
+ "value": "Mocha"
+ }
+ ],
+ "description": "दुनिया का सबसे प्यारा और संवेदनशील पिल्ला।",
+ "image": "ipfs://QmWmvTJmJU3pozR9ZHFmQC2DNDwi2XJtf3QGyYiiagFSWb",
+ "name": "Ramses"
+}
+```
+
+आप json में डेटा बदलने के लिए स्वतंत्र हैं। आप एट्रिब्यूट सेक्शन को हटा या उसमें जोड़ सकते हैं। सबसे महत्वपूर्ण बात, यह सुनिश्चित करें कि छवि फ़ील्ड आपकी IPFS छवि के स्थान को इंगित करता है — अन्यथा, आपके NFT में एक (बहुत प्यारे!) की तस्वीर शामिल होगी कुत्ते की।
+
+एक बार जब आप JSON फ़ाइल का संपादन कर लें, तो उसे सेव कर लें और छवि अपलोड करने के लिए हमने जो चरण अपनाए थे, उन्हीं का पालन करते हुए उसे Pinata पर अपलोड करें।
+
+
+
+## चरण 5: अपने अनुबंध का एक उदाहरण बनाएँ {#instance-contract}
+
+अब, हमारे अनुबंध के साथ इंटरैक्ट करने के लिए, हमें अपने कोड में इसका एक उदाहरण बनाने की आवश्यकता है। ऐसा करने के लिए हमें अपने अनुबंध पते की आवश्यकता होगी जिसे हम डिप्लॉयमेंट से या [Blockscout](https://eth-sepolia.blockscout.com/) से अनुबंध डिप्लॉय करने के लिए आपके द्वारा उपयोग किए गए पते को देखकर प्राप्त कर सकते हैं।
+
+
+
+उपरोक्त उदाहरण में, हमारा अनुबंध पता 0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778 है।
+
+इसके बाद हम ABI और पते का उपयोग करके अपना अनुबंध बनाने के लिए Web3 [अनुबंध विधि](https://docs.web3js.org/api/web3-eth-contract/class/Contract) का उपयोग करेंगे। अपनी `mint-nft.js` फ़ाइल में, निम्नलिखित जोड़ें:
+
+```js
+const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
+
+const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
+```
+
+## चरण 6: `.env` फ़ाइल को अपडेट करें {#update-env}
+
+अब, एथेरियम चेन पर लेनदेन बनाने और भेजने के लिए, हम खाते का नॉन्स (नीचे समझाएँगे) प्राप्त करने के लिए आपके सार्वजनिक एथेरियम खाते के पते का उपयोग करेंगे।
+
+अपनी सार्वजनिक कुंजी को अपनी `.env` फ़ाइल में जोड़ें — यदि आपने ट्यूटोरियल का भाग 1 पूरा कर लिया है, तो हमारी `.env` फ़ाइल अब इस तरह दिखनी चाहिए:
+
+```js
+API_URL = "https://eth-sepolia.g.alchemy.com/v2/your-api-key"
+PRIVATE_KEY = "your-private-account-address"
+PUBLIC_KEY = "your-public-account-address"
+```
+
+## चरण 7: अपना लेनदेन बनाएँ {#create-txn}
+
+सबसे पहले, आइए `mintNFT(tokenData)` नामक एक फ़ंक्शन को परिभाषित करें और निम्नलिखित करके अपना लेनदेन बनाएँ:
+
+1. `.env` फ़ाइल से अपनी _PRIVATE_KEY_ और _PUBLIC_KEY_ प्राप्त करें।
+
+2. इसके बाद, हमें खाते का नॉन्स पता लगाना होगा। नॉन्स विनिर्देश का उपयोग आपके पते से भेजे गए लेन-देन की संख्या का ट्रैक रखने के लिए किया जाता है — जिसकी हमें सुरक्षा उद्देश्यों के लिए और [रीप्ले हमलों](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce) को रोकने के लिए आवश्यकता है। आपके पते से भेजे गए लेन-देनों की संख्या प्राप्त करने के लिए, हम [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount) का उपयोग करते हैं।
+
+3. अंत में हम निम्नलिखित जानकारी के साथ अपना लेनदेन स्थापित करेंगे:
+
+- `'from': PUBLIC_KEY` — हमारे लेनदेन का मूल हमारा सार्वजनिक पता है
+
+- `'to': contractAddress` — वह अनुबंध जिसके साथ हम इंटरैक्ट करना और लेनदेन भेजना चाहते हैं
+
+- `'nonce': nonce` — हमारे पते से भेजे गए लेनदेन की संख्या वाला खाता नॉन्स
+
+- `'gas': estimatedGas` — लेनदेन को पूरा करने के लिए आवश्यक अनुमानित गैस
+
+- `'data': nftContract.methods.mintNFT(PUBLIC_KEY, md).encodeABI()` — वह गणना जो हम इस लेनदेन में करना चाहते हैं — जो इस मामले में एक NFT की टकसाल है
+
+अब आपकी `mint-nft.js` फ़ाइल इस तरह दिखनी चाहिए:
+
+```js
+ require('dotenv').config();
+ const API_URL = process.env.API_URL;
+ const PUBLIC_KEY = process.env.PUBLIC_KEY;
+ const PRIVATE_KEY = process.env.PRIVATE_KEY;
+
+ const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
+ const web3 = createAlchemyWeb3(API_URL);
+
+ const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json");
+ const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778";
+ const nftContract = new web3.eth.Contract(contract.abi, contractAddress);
+
+ async function mintNFT(tokenURI) {
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, 'latest'); //नवीनतम नॉन्स प्राप्त करें
+
+ //लेनदेन
+ const tx = {
+ 'from': PUBLIC_KEY,
+ 'to': contractAddress,
+ 'nonce': nonce,
+ 'gas': 500000,
+ 'data': nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI()
+ };
+ }
+```
+
+## चरण 8: लेनदेन पर हस्ताक्षर करें {#sign-txn}
+
+अब जब हमने अपना लेनदेन बना लिया है, तो इसे भेजने के लिए हमें इस पर हस्ताक्षर करने की आवश्यकता है। यहाँ हम अपनी निजी कुंजी का उपयोग करेंगे।
+
+`web3.eth.sendSignedTransaction` हमें लेनदेन हैश देगा, जिसका उपयोग हम यह सुनिश्चित करने के लिए कर सकते हैं कि हमारा लेनदेन माइन हो गया था और नेटवर्क द्वारा ड्रॉप नहीं किया गया था। आप देखेंगे कि लेनदेन पर हस्ताक्षर करने वाले सेक्शन में, हमने कुछ त्रुटि जाँच जोड़ी है ताकि हम जान सकें कि हमारा लेनदेन सफलतापूर्वक पूरा हुआ है या नहीं।
+
+```js
+require("dotenv").config()
+const API_URL = process.env.API_URL
+const PUBLIC_KEY = process.env.PUBLIC_KEY
+const PRIVATE_KEY = process.env.PRIVATE_KEY
+
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(API_URL)
+
+const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
+const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
+const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
+
+async function mintNFT(tokenURI) {
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //नवीनतम नॉन्स प्राप्त करें
+
+ //लेनदेन
+ const tx = {
+ from: PUBLIC_KEY,
+ to: contractAddress,
+ nonce: nonce,
+ gas: 500000,
+ data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
+ }
+
+ const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
+ signPromise
+ .then((signedTx) => {
+ web3.eth.sendSignedTransaction(
+ signedTx.rawTransaction,
+ function (err, hash) {
+ if (!err) {
+ console.log(
+ "आपके लेनदेन का हैश है: ",
+ hash,
+ "\nअपने लेनदेन की स्थिति देखने के लिए Alchemy के मेमपूल की जाँच करें!"
+ )
+ } else {
+ console.log(
+ "आपका लेनदेन सबमिट करते समय कुछ गलत हो गया:",
+ err
+ )
+ }
+ }
+ )
+ })
+ .catch((err) => {
+ console.log(" वादा विफल हुआ:", err)
+ })
+}
+```
+
+## चरण 9: `mintNFT` को कॉल करें और नोड `mint-nft.js` चलाएँ {#call-mintnft-fn}
+
+आपको वह `metadata.json` याद है जिसे आपने Pinata पर अपलोड किया था? Pinata से इसका हैशकोड प्राप्त करें और निम्नलिखित को `mintNFT` फ़ंक्शन में पैरामीटर के रूप में पास करें `https://gateway.pinata.cloud/ipfs/`
+
+हैशकोड प्राप्त करने का तरीका यहाँ दिया गया है:
+
+_Pinata पर अपना nft मेटाडेटा हैशकोड कैसे प्राप्त करें_
+
+> `https://gateway.pinata.cloud/ipfs/` को एक अलग विंडो में लोड करके दोबारा जाँच लें कि आपके द्वारा कॉपी किया गया हैशकोड आपकी **metadata.json** से लिंक है या नहीं। पेज नीचे दिए गए स्क्रीनशॉट के समान दिखना चाहिए:
+
+_आपके पेज पर json मेटाडेटा प्रदर्शित होना चाहिए_
+
+कुल मिलाकर, आपका कोड कुछ इस तरह दिखना चाहिए:
+
+```js
+require("dotenv").config()
+const API_URL = process.env.API_URL
+const PUBLIC_KEY = process.env.PUBLIC_KEY
+const PRIVATE_KEY = process.env.PRIVATE_KEY
+
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(API_URL)
+
+const contract = require("../artifacts/contracts/MyNFT.sol/MyNFT.json")
+const contractAddress = "0x5a738a5c5fe46a1fd5ee7dd7e38f722e2aef7778"
+const nftContract = new web3.eth.Contract(contract.abi, contractAddress)
+
+async function mintNFT(tokenURI) {
+ const nonce = await web3.eth.getTransactionCount(PUBLIC_KEY, "latest") //नवीनतम नॉन्स प्राप्त करें
+
+ //लेनदेन
+ const tx = {
+ from: PUBLIC_KEY,
+ to: contractAddress,
+ nonce: nonce,
+ gas: 500000,
+ data: nftContract.methods.mintNFT(PUBLIC_KEY, tokenURI).encodeABI(),
+ }
+
+ const signPromise = web3.eth.accounts.signTransaction(tx, PRIVATE_KEY)
+ signPromise
+ .then((signedTx) => {
+ web3.eth.sendSignedTransaction(
+ signedTx.rawTransaction,
+ function (err, hash) {
+ if (!err) {
+ console.log(
+ "आपके लेनदेन का हैश है: ",
+ hash,
+ "\nअपने लेनदेन की स्थिति देखने के लिए Alchemy के मेमपूल की जाँच करें!"
+ )
+ } else {
+ console.log(
+ "आपका लेनदेन सबमिट करते समय कुछ गलत हो गया:",
+ err
+ )
+ }
+ }
+ )
+ })
+ .catch((err) => {
+ console.log("वादा विफल हुआ:", err)
+ })
+}
+
+mintNFT("ipfs://QmYueiuRNmL4MiA2GwtVMm6ZagknXnSpQnB3z2gWbz36hP")
+```
+
+अब, अपना NFT डिप्लॉय करने के लिए `node scripts/mint-nft.js` चलाएँ। कुछ सेकंड के बाद, आपको अपने टर्मिनल में इस तरह की प्रतिक्रिया दिखनी चाहिए:
+
+ ```
+ आपके लेनदेन का हैश है: 0x301791fdf492001fcd9d5e5b12f3aa1bbbea9a88ed24993a8ab2cdae2d06e1e8
+
+ अपने लेनदेन की स्थिति देखने के लिए Alchemy के मेमपूल की जाँच करें!
+ ```
+
+इसके बाद, अपने लेनदेन की स्थिति देखने के लिए अपने [Alchemy मेमपूल](https://dashboard.alchemyapi.io/mempool) पर जाएँ (चाहे वह लंबित हो, माइन किया गया हो, या नेटवर्क द्वारा ड्रॉप कर दिया गया हो)। यदि आपका लेनदेन ड्रॉप हो गया है, तो [Blockscout](https://eth-sepolia.blockscout.com/) की जाँच करना और अपने लेनदेन हैश को खोजना भी सहायक है।
+
+_Etherscan पर अपना NFT लेनदेन हैश देखें_
+
+और बस हो गया! अब आपने एथेरियम ब्लॉकचेन पर एक NFT डिप्लॉय और उसकी टकसाल कर ली है `](https://any.site/ipfs/bafybeifqka2odrne5b6l5guthqvbxu4pujko2i6rx2zslvr3qxs6u5o7im) पर जा सकते हैं और आपको वह सामग्री विकेंद्रीकृत तरीके से मिल जाएगी।
+
+## कमियां {#drawbacks}
+
+आप IPFS फ़ाइलों को मज़बूती से डिलीट नहीं कर सकते हैं, इसलिए जब तक आप अपने यूजर इंटरफेस को संशोधित कर रहे हैं, तब तक शायद यह सबसे अच्छा है कि या तो इसे केंद्रीकृत छोड़ दें, या [इंटरप्लेनेटरी नेम सिस्टम (IPNS)](https://docs.ipfs.tech/concepts/ipns/#mutability-in-ipfs) का उपयोग करें, जो IPFS के ऊपर परिवर्तनशीलता प्रदान करने वाली एक प्रणाली है। बेशक, जो कुछ भी परिवर्तनशील है उसे सेंसर किया जा सकता है, IPNS के मामले में उस व्यक्ति पर दबाव डालकर जिसके पास संबंधित निजी कुंजी है।
+
+इसके अतिरिक्त, कुछ पैकेजों को IPFS से समस्या होती है, इसलिए यदि आपकी वेब साइट बहुत जटिल है तो यह एक अच्छा समाधान नहीं हो सकता है। और निश्चित रूप से, सर्वर एकीकरण पर निर्भर किसी भी चीज़ को केवल क्लाइंट साइड को IPFS पर रखकर विकेंद्रीकृत नहीं किया जा सकता है।
+
+## निष्कर्ष {#conclusion}
+
+जिस तरह एथेरियम आपको अपने डैप के डेटाबेस और व्यावसायिक तर्क पहलुओं को विकेंद्रीकृत करने देता है, उसी तरह IPFS आपको यूजर इंटरफेस को विकेंद्रीकृत करने देता है। यह आपको अपने डैप के खिलाफ एक और हमले के वेक्टर को बंद करने देता है।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md b/public/content/translations/hi/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
new file mode 100644
index 00000000000..30b8ad3e74f
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/index.md
@@ -0,0 +1,111 @@
+---
+title: "create-eth-app के साथ अपने डैप फ्रंटएंड डेवलपमेंट की शुरूआत करें"
+description: "create-eth-app का उपयोग कैसे करें और इसकी विशेषताओं का अवलोकन"
+author: "Markus Waas"
+tags:
+ [
+ "frontend",
+ "javascript",
+ "ethers.js",
+ "द ग्राफ़",
+ "defi"
+ ]
+skill: beginner
+lang: hi
+published: 2020-04-27
+source: soliditydeveloper.com
+sourceUrl: https://soliditydeveloper.com/create-eth-app
+---
+
+पिछली बार हमने [Solidity की बड़ी तस्वीर](https://soliditydeveloper.com/solidity-overview-2020) को देखा और पहले ही [create-eth-app](https://github.com/PaulRBerg/create-eth-app) का उल्लेख किया था। अब आप जानेंगे कि इसका उपयोग कैसे करें, कौन सी सुविधाएँ एकीकृत हैं और इस पर विस्तार करने के लिए अतिरिक्त विचार। [Sablier](http://sablier.com/) के संस्थापक पॉल रेज़वान बर्ग द्वारा शुरू किया गया यह ऐप, आपके फ्रंटएंड डेवलपमेंट की शुरूआत करेगा और चुनने के लिए कई वैकल्पिक एकीकरणों के साथ आता है।
+
+## इंस्टॉलेशन {#installation}
+
+इंस्टॉलेशन के लिए Yarn 0.25 या उच्चतर (`npm install yarn --global`) की आवश्यकता है। यह रन करने जितना आसान है:
+
+```bash
+yarn create eth-app my-eth-app
+cd my-eth-app
+yarn react-app:start
+```
+
+यह आंतरिक रूप से [create-react-app](https://github.com/facebook/create-react-app) का उपयोग कर रहा है। अपने ऐप को देखने के लिए, `http://localhost:3000/` खोलें। जब आप प्रोडक्शन में डिप्लॉय करने के लिए तैयार हों, तो yarn build के साथ एक मिनिफाइड बंडल बनाएं। इसे होस्ट करने का एक आसान तरीका [Netlify](https://www.netlify.com/) होगा। आप एक GitHub रेपो बना सकते हैं, इसे Netlify में जोड़ सकते हैं, बिल्ड कमांड सेटअप कर सकते हैं और आपका काम हो गया! आपका ऐप होस्ट किया जाएगा और सभी के लिए प्रयोग करने योग्य होगा। और यह सब निःशुल्क है।
+
+## विशेषताएँ {#features}
+
+### React & create-react-app {#react--create-react-app}
+
+सबसे पहले ऐप का दिल: React और _create-react-app_ के साथ आने वाली सभी अतिरिक्त सुविधाएँ। केवल इसका उपयोग करना एक बढ़िया विकल्प है यदि आप एथेरियम को एकीकृत नहीं करना चाहते हैं। [React](https://react.dev/) स्वयं इंटरैक्टिव UI बनाना वास्तव में आसान बनाता है। यह [Vue](https://vuejs.org/) जितना शुरुआती-अनुकूल नहीं हो सकता है, लेकिन यह अभी भी अधिकतर उपयोग किया जाता है, इसमें अधिक सुविधाएँ हैं और सबसे महत्वपूर्ण बात यह है कि चुनने के लिए हजारों अतिरिक्त लाइब्रेरी हैं। _create-react-app_ इसके साथ शुरू करना भी वास्तव में आसान बनाता है और इसमें शामिल हैं:
+
+- React, JSX, ES6, TypeScript, Flow सिंटैक्स समर्थन।
+- ES6 से परे भाषा अतिरिक्त जैसे ऑब्जेक्ट स्प्रेड ऑपरेटर।
+- ऑटोप्रीफिक्स्ड CSS, इसलिए आपको -webkit- या अन्य प्रीफिक्स की आवश्यकता नहीं है।
+- कवरेज रिपोर्टिंग के लिए अंतर्निहित समर्थन के साथ एक तेज़ इंटरैक्टिव यूनिट टेस्ट रनर।
+- एक लाइव डेवलपमेंट सर्वर जो सामान्य गलतियों के बारे में चेतावनी देता है।
+- प्रोडक्शन के लिए JS, CSS, और छवियों को बंडल करने के लिए एक बिल्ड स्क्रिप्ट, जिसमें हैश और सोर्समैप हों।
+
+विशेष रूप से _create-eth-app_ नए [hooks effects](https://legacy.reactjs.org/docs/hooks-effect.html) का उपयोग कर रहा है। शक्तिशाली, फिर भी बहुत छोटे तथाकथित कार्यात्मक घटकों को लिखने की एक विधि। _create-eth-app_ में उनका उपयोग कैसे किया जाता है, इसके लिए Apollo के बारे में नीचे दिया गया अनुभाग देखें।
+
+### Yarn Workspaces {#yarn-workspaces}
+
+[Yarn Workspaces](https://classic.yarnpkg.com/en/docs/workspaces/) आपको कई पैकेज रखने की अनुमति देते हैं, लेकिन उन सभी को रूट फ़ोल्डर से प्रबंधित करने और `yarn install` का उपयोग करके एक साथ सभी के लिए निर्भरताएँ स्थापित करने में सक्षम होते हैं। यह विशेष रूप से स्मार्ट अनुबंध पते/ABI प्रबंधन (यह जानकारी कि आपने कौन से स्मार्ट अनुबंध कहाँ डिप्लॉय किए हैं और उनके साथ कैसे संवाद करें) या ग्राफ़ एकीकरण जैसे छोटे अतिरिक्त पैकेजों के लिए मायने रखता है, दोनों `create-eth-app` का हिस्सा हैं।
+
+### ethers.js {#ethersjs}
+
+हालांकि [Web3](https://docs.web3js.org/) अभी भी ज़्यादातर उपयोग किया जाता है, [ethers.js](https://docs.ethers.io/) को पिछले साल एक विकल्प के रूप में बहुत अधिक कर्षण मिल रहा है और यह _create-eth-app_ में एकीकृत है। आप इसके साथ काम कर सकते हैं, इसे Web3 में बदल सकते हैं या [ethers.js v5](https://docs.ethers.org/v5/) में अपग्रेड करने पर विचार कर सकते हैं जो लगभग बीटा से बाहर है।
+
+### द ग्राफ़ {#the-graph}
+
+[GraphQL](https://graphql.org/) [रेस्टफुल API](https://restfulapi.net/) की तुलना में डेटा को संभालने का एक वैकल्पिक तरीका है। रेस्टफुल Apis पर उनके कई फायदे हैं, विशेष रूप से विकेंद्रीकृत ब्लॉकचेन डेटा के लिए। यदि आप इसके पीछे के तर्क में रुचि रखते हैं, तो [GraphQL विल पावर द डिसेंट्रलाइज्ड वेब](https://medium.com/graphprotocol/graphql-will-power-the-decentralized-web-d7443a69c69a) पर एक नज़र डालें।
+
+आमतौर पर आप सीधे अपने स्मार्ट अनुबंध से डेटा प्राप्त करेंगे। नवीनतम ट्रेड का समय पढ़ना चाहते हैं? बस `MyContract.methods.latestTradeTime().call()` को कॉल करें जो आपके डैप में एथेरियम नोड से डेटा प्राप्त करता है। लेकिन क्या होगा यदि आपको सैकड़ों अलग-अलग डेटा बिंदुओं की आवश्यकता है? इसके परिणामस्वरूप नोड में सैकड़ों डेटा फ़ेच होंगे, हर बार [RTT](https://wikipedia.org/wiki/Round-trip_delay_time) की आवश्यकता होती है जिससे आपका डैप धीमा और अक्षम हो जाता है। एक समाधान आपके अनुबंध के अंदर एक फ़ेचर कॉल फ़ंक्शन हो सकता है जो एक साथ कई डेटा लौटाता है। हालांकि यह हमेशा आदर्श नहीं होता है।
+
+और फिर आप ऐतिहासिक डेटा में भी रुचि ले सकते हैं। आप न केवल अंतिम ट्रेड का समय जानना चाहते हैं, बल्कि उन सभी ट्रेडों का समय भी जानना चाहते हैं जो आपने स्वयं किए हैं। _create-eth-app_ सबग्राफ पैकेज का उपयोग करें, [प्रलेखन](https://thegraph.com/docs/en/subgraphs/developing/creating/starting-your-subgraph) पढ़ें और इसे अपने स्वयं के अनुबंधों के अनुकूल बनाएं। यदि आप लोकप्रिय स्मार्ट अनुबंधों की तलाश में हैं, तो पहले से ही एक सबग्राफ हो सकता है। [सबग्राफ एक्सप्लोरर](https://thegraph.com/explorer/) देखें।
+
+एक बार जब आपके पास एक सबग्राफ हो जाता है, तो यह आपको अपने डैप में एक सरल क्वेरी लिखने की अनुमति देता है जो आपको आवश्यक ऐतिहासिक सहित सभी महत्वपूर्ण ब्लॉकचेन डेटा को पुनः प्राप्त करता है, केवल एक फ़ेच की आवश्यकता होती है।
+
+### Apollo {#apollo}
+
+[Apollo Boost](https://www.apollographql.com/docs/react/get-started/) एकीकरण के लिए धन्यवाद, आप अपने React डैप में ग्राफ़ को आसानी से एकीकृत कर सकते हैं। विशेष रूप से [React हुक और Apollo](https://www.apollographql.com/blog/apollo-client-now-with-react-hooks) का उपयोग करते समय, डेटा प्राप्त करना आपके घटक में एक एकल GraphQl क्वेरी लिखने जितना आसान है:
+
+```js
+const { loading, error, data } = useQuery(myGraphQlQuery)
+
+React.useEffect(() => {
+ if (!loading && !error && data) {
+ console.log({ data })
+ }
+}, [loading, error, data])
+```
+
+## टेम्पलेट्स {#templates}
+
+इसके अतिरिक्त आप कई अलग-अलग टेम्पलेट्स में से चुन सकते हैं। अब तक आप Aave, Compound, UniSwap या sablier एकीकरण का उपयोग कर सकते हैं। वे सभी पूर्व-निर्मित सबग्राफ एकीकरणों के साथ महत्वपूर्ण सेवा स्मार्ट अनुबंध पते जोड़ते हैं। बस `yarn create eth-app my-eth-app --with-template aave` जैसे निर्माण कमांड में टेम्पलेट जोड़ें।
+
+### Aave {#aave}
+
+[Aave](https://aave.com/) एक विकेन्द्रीकृत धन उधार बाजार है। जमाकर्ता निष्क्रिय आय अर्जित करने के लिए बाजार को लिक्विडिटी प्रदान करते हैं, जबकि उधारकर्ता कोलेटरल का उपयोग करके उधार ले सकते हैं। Aave की एक अनूठी विशेषता वे [फ्लैश ऋण](https://aave.com/docs/developers/flash-loans) हैं जो आपको बिना किसी कोलेटरल के पैसे उधार लेने की अनुमति देते हैं, जब तक आप एक ट्रांज़ैक्शन के भीतर ऋण वापस कर देते हैं। यह आर्बिट्रेज ट्रेडिंग पर आपको अतिरिक्त नकदी देने के लिए उपयोगी हो सकता है।
+
+ट्रेड किए गए टोकन जो आपको ब्याज अर्जित करते हैं, _aTokens_ कहलाते हैं।
+
+जब आप _create-eth-app_ के साथ Aave को एकीकृत करना चुनते हैं, तो आपको एक [सबग्राफ एकीकरण](https://docs.aave.com/developers/getting-started/using-graphql) मिलेगा। Aave द ग्राफ़ का उपयोग करता है और पहले से ही आपको [Ropsten](https://thegraph.com/explorer/subgraph/aave/protocol-ropsten) और [मेननेट](https://thegraph.com/explorer/subgraph/aave/protocol) पर [रॉ](https://thegraph.com/explorer/subgraph/aave/protocol-raw) या [स्वरूपित](https://thegraph.com/explorer/subgraph/aave/protocol) रूप में कई उपयोग के लिए तैयार सबग्राफ प्रदान करता है।
+
+
+
+### Compound {#compound}
+
+[Compound](https://compound.finance/) Aave के समान है। एकीकरण में पहले से ही नया [Compound v2 सबग्राफ](https://medium.com/graphprotocol/https-medium-com-graphprotocol-compound-v2-subgraph-highlight-a5f38f094195) शामिल है। यहाँ ब्याज अर्जित करने वाले टोकन आश्चर्यजनक रूप से _cTokens_ कहलाते हैं।
+
+### Uniswap {#uniswap}
+
+[Uniswap](https://uniswap.exchange/) एक विकेंद्रीकृत विनिमय केंद्र (DEX) है। लिक्विडिटी प्रदाता एक ट्रेड के दोनों पक्षों के लिए आवश्यक टोकन या ईथर प्रदान करके शुल्क अर्जित कर सकते हैं। इसका व्यापक रूप से उपयोग किया जाता है और इसलिए इसमें बहुत विस्तृत श्रृंखला के टोकन के लिए उच्चतम लिक्विडिटी में से एक है। आप इसे आसानी से अपने डैप में एकीकृत कर सकते हैं, उदाहरण के लिए, यूज़र को अपने ETH को DAI के लिए स्वैप करने की अनुमति देने के लिए।
+
+दुर्भाग्य से, इस लेखन के समय एकीकरण केवल Uniswap v1 के लिए है, न कि [अभी-अभी जारी किए गए v2](https://uniswap.org/blog/uniswap-v2/) के लिए।
+
+### Sablier {#sablier}
+
+[Sablier](https://sablier.com/) यूज़र को धन भुगतान स्ट्रीमिंग करने की अनुमति देता है। एक ही payday के बजाय, प्रारंभिक सेटअप के बाद बिना किसी और प्रशासन के आपको वास्तव में लगातार अपना पैसा मिलता है। एकीकरण में इसका [अपना सबग्राफ](https://thegraph.com/explorer/subgraph/sablierhq/sablier) शामिल है।
+
+## आगे क्या है? {#whats-next}
+
+यदि आपके पास _create-eth-app_ के बारे में प्रश्न हैं, तो [Sablier समुदाय सर्वर](https://discord.gg/bsS8T47) पर जाएं, जहां आप _create-eth-app_ के लेखकों से संपर्क कर सकते हैं। कुछ पहले अगले कदमों के रूप में आप चाहें तो [Material UI](https://mui.com/material-ui/) जैसे UI फ्रेमवर्क को एकीकृत करें, वास्तव में आवश्यक डेटा के लिए GraphQL क्वेरी लिखें और डिप्लॉयमेंट सेटअप करें।
diff --git a/public/content/translations/hi/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md b/public/content/translations/hi/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
new file mode 100644
index 00000000000..69fdd6df193
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/learn-foundational-ethereum-topics-with-sql/index.md
@@ -0,0 +1,269 @@
+---
+title: "SQL के साथ मूलभूत एथेरियम विषय सीखें"
+description: "यह ट्यूटोरियल पाठकों को स्ट्रक्चर्ड क्वेरी लैंग्वेज (SQL) के साथ ऑन-चेन डेटा की क्वेरी करके लेनदेन, ब्लोक और गैस सहित मूलभूत एथेरियम अवधारणाओं को समझने में मदद करता है।"
+author: "पॉल एपिवत"
+tags: [ "SQL", "क्वेरी करना", "ट्रांसक्शन्स" ]
+skill: beginner
+lang: hi
+published: 2021-05-11
+source: paulapivat.com
+sourceUrl: https://paulapivat.com/post/query_ethereum/
+---
+
+कई एथेरियम ट्यूटोरियल डिवेलपर को लक्षित करते हैं, लेकिन डेटा विश्लेषकों या उन लोगों के लिए शैक्षिक संसाधनों की कमी है जो क्लाइंट या नोड चलाए बिना ऑन-चेन डेटा देखना चाहते हैं।
+
+यह ट्यूटोरियल पाठकों को [Dune Analytics](https://dune.com/) द्वारा प्रदान किए गए इंटरफ़ेस के माध्यम से स्ट्रक्चर्ड क्वेरी लैंग्वेज (SQL) के साथ ऑन-चेन डेटा की क्वेरी करके लेनदेन, ब्लोक और गैस सहित मूलभूत एथेरियम अवधारणाओं को समझने में मदद करता है।
+
+ऑन-चेन डेटा हमें एथेरियम, नेटवर्क और कंप्यूटिंग शक्ति के लिए एक अर्थव्यवस्था को समझने में मदद कर सकता है और इसे आज एथेरियम के सामने आने वाली चुनौतियों (यानी, बढ़ती गैस कीमतें) और, इससे भी महत्वपूर्ण बात, स्केलिंग समाधानों के आसपास की चर्चाओं को समझने के लिए एक आधार के रूप में काम करना चाहिए।
+
+### लेनदेन {#transactions}
+
+एथेरियम पर एक यूज़र की यात्रा एक यूज़र-नियंत्रित खाता या ETH बैलेंस वाली एक इकाई को शुरू करने के साथ शुरू होती है। दो प्रकार के खाते होते हैं - उपयोगकर्ता-नियंत्रित या एक स्मार्ट अनुबंध ([ethereum.org](/developers/docs/accounts/) देखें)।
+
+किसी भी खाते को [Etherscan](https://etherscan.io/) या [Blockscout](https://eth.blockscout.com/) जैसे ब्लॉक खोजकर्ता पर देखा जा सकता है। ब्लॉक खोजकर्ता एथेरियम के डेटा का एक पोर्टल हैं। वे वास्तविक समय में, ब्लोक, लेनदेन, माईनर, खाते और अन्य ऑन-चेन गतिविधि पर डेटा प्रदर्शित करते हैं ([यहां](/developers/docs/data-and-analytics/block-explorers/) देखें)।
+
+हालांकि, एक यूज़र बाहरी ब्लॉक खोजकर्ताओं द्वारा प्रदान की गई जानकारी का मिलान करने के लिए सीधे डेटा की क्वेरी करना चाह सकता है। [Dune Analytics](https://dune.com/) SQL के कुछ ज्ञान वाले किसी भी व्यक्ति को यह क्षमता प्रदान करता है।
+
+संदर्भ के लिए, Ethereum फाउंडेशन (EF) के लिए स्मार्ट अनुबंध खाते को [Blockscout](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe) पर देखा जा सकता है।
+
+ध्यान देने वाली एक बात यह है कि EF सहित सभी खातों में, एक सार्वजनिक पता होता है जिसका उपयोग लेनदेन भेजने और प्राप्त करने के लिए किया जा सकता है।
+
+Etherscan पर खाता बैलेंस में नियमित लेनदेन और आंतरिक लेनदेन शामिल हैं। आंतरिक लेनदेन, नाम के बावजूद, _वास्तविक_ लेनदेन नहीं हैं जो श्रृंखला की स्थिति को बदलते हैं। वे मूल्य हस्तांतरण हैं जो एक अनुबंध को निष्पादित करके शुरू किए जाते हैं ([स्रोत](https://ethereum.stackexchange.com/questions/3417/how-to-get-contract-internal-transactions))। चूंकि आंतरिक लेनदेन में कोई हस्ताक्षर नहीं होता है, इसलिए वे ब्लॉकचेन पर शामिल **नहीं** होते हैं और Dune Analytics के साथ क्वेरी नहीं किए जा सकते।
+
+इसलिए, यह ट्यूटोरियल नियमित लेनदेन पर ध्यान केंद्रित करेगा। इसे इस तरह से क्वेरी किया जा सकता है:
+
+```sql
+WITH temp_table AS (
+SELECT
+ hash,
+ block_number,
+ block_time,
+ "from",
+ "to",
+ value / 1e18 AS ether,
+ gas_used,
+ gas_price / 1e9 AS gas_price_gwei
+FROM ethereum."transactions"
+WHERE "to" = '\xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
+ORDER BY block_time DESC
+)
+SELECT
+ hash,
+ block_number,
+ block_time,
+ "from",
+ "to",
+ ether,
+ (gas_used * gas_price_gwei) / 1e9 AS txn_fee
+FROM temp_table
+```
+
+यह वही जानकारी देगा जो Etherscan के लेनदेन पृष्ठ पर प्रदान की गई है। तुलना के लिए, यहां दो स्रोत दिए गए हैं:
+
+#### Etherscan {#etherscan}
+
+
+
+[Blockscout पर EF का अनुबंध पृष्ठ।](https://eth.blockscout.com/address/0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe)
+
+#### डून एनालिटिक्स {#dune-analytics}
+
+
+
+आप डैशबोर्ड [यहां](https://dune.com/paulapivat/Learn-Ethereum) पा सकते हैं। क्वेरी देखने के लिए तालिका पर क्लिक करें (ऊपर भी देखें)।
+
+### लेनदेन को तोड़ना {#breaking_down_transactions}
+
+एक प्रस्तुत लेनदेन में कई जानकारी शामिल होती है ([स्रोत](/developers/docs/transactions/)):
+
+- **प्राप्तकर्ता**: प्राप्तकर्ता पता ("to" के रूप में क्वेरी किया गया)
+- **हस्ताक्षर**: जबकि एक प्रेषक की निजी चाबी एक लेनदेन पर हस्ताक्षर करती है, हम SQL के साथ जो क्वेरी कर सकते हैं वह प्रेषक का सार्वजनिक पता ("from") है।
+- **मान**: यह हस्तांतरित ETH की राशि है (`ether` कॉलम देखें)।
+- **डेटा**: यह मनमाना डेटा है जिसे हैश किया गया है (`data` कॉलम देखें)
+- **gasLimit** – गैस इकाइयों की अधिकतम मात्रा जो लेनदेन द्वारा उपभोग की जा सकती है। गैस की इकाइयां कम्प्यूटेशनल चरणों का प्रतिनिधित्व करती हैं
+- **maxPriorityFeePerGas** - माईनर को टिप के रूप में शामिल की जाने वाली गैस की अधिकतम राशि
+- **maxFeePerGas** - लेनदेन के लिए भुगतान की जाने वाली गैस की अधिकतम राशि (baseFeePerGas और maxPriorityFeePerGas सहित)
+
+हम Ethereum फाउंडेशन के सार्वजनिक पते पर किए गए लेनदेन के लिए इस विशिष्ट जानकारी की क्वेरी कर सकते हैं:
+
+```sql
+SELECT
+ "to",
+ "from",
+ value / 1e18 AS ether,
+ data,
+ gas_limit,
+ gas_price / 1e9 AS gas_price_gwei,
+ gas_used,
+ ROUND(((gas_used / gas_limit) * 100),2) AS gas_used_pct
+FROM ethereum."transactions"
+WHERE "to" = '\xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
+ORDER BY block_time DESC
+```
+
+### ब्लॉक {#blocks}
+
+प्रत्येक लेनदेन एथेरियम वर्चुअल मशीन ([EVM](/developers/docs/evm/)) की स्थिति को बदल देगा ([स्रोत](/developers/docs/transactions/))। लेनदेन को सत्यापित होने और एक ब्लोक में शामिल होने के लिए नेटवर्क पर प्रसारित किया जाता है। प्रत्येक लेनदेन एक ब्लोक संख्या से जुड़ा होता है। डेटा देखने के लिए, हम एक विशिष्ट ब्लोक संख्या: 12396854 की क्वेरी कर सकते हैं (इस लेखन के समय, 11/5/21 तक Ethereum फाउंडेशन लेनदेन के बीच सबसे हालिया ब्लोक)।
+
+इसके अलावा, जब हम अगले दो ब्लोक की क्वेरी करते हैं, तो हम देख सकते हैं कि प्रत्येक ब्लोक में पिछले ब्लोक का हैश होता है (यानी, पैरेंट हैश), यह दर्शाता है कि ब्लॉकचेन कैसे बनता है।
+
+प्रत्येक ब्लोक में इसके पैरेंट ब्लोक का एक संदर्भ होता है। यह नीचे `hash` और `parent_hash` कॉलम के बीच दिखाया गया है ([स्रोत](/developers/docs/blocks/)):
+
+
+
+Dune Analytics पर [क्वेरी](https://dune.com/queries/44856/88292) यहां दी गई है:
+
+```sql
+SELECT
+ time,
+ number,
+ hash,
+ parent_hash,
+ nonce
+FROM ethereum."blocks"
+WHERE "number" = 12396854 OR "number" = 12396855 OR "number" = 12396856
+LIMIT 10
+```
+
+हम समय, ब्लोक संख्या, कठिनाई, हैश, पैरेंट हैश और नॉन्स की क्वेरी करके एक ब्लोक की जांच कर सकते हैं।
+
+यह क्वेरी केवल _लेनदेन की सूची_ को कवर नहीं करती है जिसके लिए नीचे एक अलग क्वेरी और _स्टेट रूट_ की आवश्यकता होती है। एक पूर्ण या अभिलेखीय नोड सभी लेनदेन और स्थिति संक्रमणों को संग्रहीत करेगा, जो क्लाइंट को किसी भी समय श्रृंखला की स्थिति की क्वेरी करने की अनुमति देता है। क्योंकि इसके लिए बड़े भंडारण स्थान की आवश्यकता होती है, हम श्रृंखला डेटा को स्थिति डेटा से अलग कर सकते हैं:
+
+- श्रृंखला डेटा (ब्लोक की सूची, लेनदेन)
+- स्थिति डेटा (प्रत्येक लेनदेन के स्थिति संक्रमण का परिणाम)
+
+स्टेट रूट बाद वाले में आता है और यह _अंतर्निहित_ डेटा है (ऑन-चेन संग्रहीत नहीं है), जबकि श्रृंखला डेटा स्पष्ट है और स्वयं श्रृंखला पर संग्रहीत है ([स्रोत](https://ethereum.stackexchange.com/questions/359/where-is-the-state-data-stored))।
+
+इस ट्यूटोरियल के लिए, हम ऑन-चेन डेटा पर ध्यान केंद्रित करेंगे जिसे Dune Analytics के माध्यम से SQL के साथ क्वेरी _किया जा सकता_ है।
+
+जैसा कि ऊपर कहा गया है, प्रत्येक ब्लोक में लेनदेन की एक सूची होती है, हम एक विशिष्ट ब्लोक के लिए फ़िल्टर करके इसे क्वेरी कर सकते हैं। हम सबसे हालिया ब्लोक, 12396854 का प्रयास करेंगे:
+
+```sql
+SELECT * FROM ethereum."transactions"
+WHERE block_number = 12396854
+ORDER BY block_time DESC`
+```
+
+Dune पर SQL आउटपुट यहां दिया गया है:
+
+
+
+श्रृंखला में जोड़े जाने वाला यह एकल ब्लोक एथेरियम वर्चुअल मशीन ([EVM](/developers/docs/evm/)) की स्थिति को बदलता है। दर्जनों कभी-कभी, सैकड़ों लेनदेन एक साथ सत्यापित किए जाते हैं। इस विशिष्ट मामले में, 222 लेनदेन शामिल थे।
+
+यह देखने के लिए कि वास्तव में कितने सफल हुए, हम सफल लेनदेन की गणना करने के लिए एक और फ़िल्टर जोड़ेंगे:
+
+```sql
+WITH temp_table AS (
+ SELECT * FROM ethereum."transactions"
+ WHERE block_number = 12396854 AND success = true
+ ORDER BY block_time DESC
+)
+SELECT
+ COUNT(success) AS num_successful_txn
+FROM temp_table
+```
+
+ब्लोक 12396854 के लिए, कुल 222 लेनदेन में से, 204 को सफलतापूर्वक सत्यापित किया गया:
+
+
+
+लेनदेन अनुरोध प्रति सेकंड दर्जनों बार होते हैं, लेकिन ब्लोक लगभग हर 15 सेकंड में एक बार प्रतिबद्ध होते हैं ([स्रोत](/developers/docs/blocks/))।
+
+यह देखने के लिए कि लगभग हर 15 सेकंड में एक ब्लोक का उत्पादन होता है, हम प्रति दिन ब्लोक की अनुमानित औसत संख्या (~ 5760) प्राप्त करने के लिए एक दिन में सेकंड की संख्या (86400) को 15 से विभाजित कर सकते हैं।
+
+प्रति दिन उत्पादित एथेरियम ब्लोक के लिए चार्ट (2016 - वर्तमान) है:
+
+
+
+इस समयावधि में प्रतिदिन उत्पादित ब्लोक की औसत संख्या ~5,874 है:
+
+
+
+क्वेरी हैं:
+
+```sql
+# 2016 से प्रतिदिन उत्पादित ब्लोक की संख्या की कल्पना करने के लिए क्वेरी
+
+SELECT
+ DATE_TRUNC('day', time) AS dt,
+ COUNT(*) AS block_count
+FROM ethereum."blocks"
+GROUP BY dt
+OFFSET 1
+
+# प्रति दिन उत्पादित ब्लोक की औसत संख्या
+
+WITH temp_table AS (
+SELECT
+ DATE_TRUNC('day', time) AS dt,
+ COUNT(*) AS block_count
+FROM ethereum."blocks"
+GROUP BY dt
+OFFSET 1
+)
+SELECT
+ AVG(block_count) AS avg_block_count
+FROM temp_table
+```
+
+2016 से प्रति दिन उत्पादित ब्लोक की औसत संख्या उस संख्या से थोड़ी अधिक 5,874 है। वैकल्पिक रूप से, 86400 सेकंड को 5874 औसत ब्लोक से विभाजित करने पर 14.7 सेकंड या लगभग हर 15 सेकंड में एक ब्लोक आता है।
+
+### गैस {#gas}
+
+ब्लोक आकार में सीमित हैं। अधिकतम ब्लोक आकार गतिशील है और नेटवर्क मांग के अनुसार 12,500,000 और 25,000,000 इकाइयों के बीच बदलता रहता है। मनमाने ढंग से बड़े ब्लोक आकार को रोकने के लिए सीमाएं आवश्यक हैं जो डिस्क स्थान और गति आवश्यकताओं के मामले में पूर्ण नोड पर दबाव डालते हैं ([स्रोत](/developers/docs/blocks/))।
+
+ब्लोक गैस सीमा की अवधारणा का एक तरीका इसे उपलब्ध ब्लोक स्थान की **आपूर्ति** के रूप में सोचना है जिसमें लेनदेन को बैच किया जाता है। ब्लोक गैस सीमा को 2016 से आज तक क्वेरी और विज़ुअलाइज़ किया जा सकता है:
+
+
+
+```sql
+SELECT
+ DATE_TRUNC('day', time) AS dt,
+ AVG(gas_limit) AS avg_block_gas_limit
+FROM ethereum."blocks"
+GROUP BY dt
+OFFSET 1
+```
+
+फिर एथेरियम श्रृंखला पर किए गए कंप्यूटिंग के लिए भुगतान करने के लिए दैनिक रूप से उपयोग की जाने वाली वास्तविक गैस है (यानी, लेनदेन भेजना, स्मार्ट अनुबंध को कॉल करना, एक NFT का टकसाल बनाना)। यह उपलब्ध एथेरियम ब्लोक स्थान के लिए **मांग** है:
+
+
+
+```sql
+SELECT
+ DATE_TRUNC('day', time) AS dt,
+ AVG(gas_used) AS avg_block_gas_used
+FROM ethereum."blocks"
+GROUP BY dt
+OFFSET 1
+```
+
+हम इन दोनों चार्ट को एक साथ रखकर यह भी देख सकते हैं कि **मांग और आपूर्ति** कैसे मिलती है:
+
+
+
+इसलिए हम उपलब्ध आपूर्ति को देखते हुए, एथेरियम ब्लोक स्थान की मांग के एक कार्य के रूप में गैस की कीमतों को समझ सकते हैं।
+
+अंत में, हम एथेरियम श्रृंखला के लिए औसत दैनिक गैस कीमतों की क्वेरी करना चाह सकते हैं, हालांकि, ऐसा करने से क्वेरी का समय विशेष रूप से लंबा होगा, इसलिए हम अपनी क्वेरी को Ethereum फाउंडेशन द्वारा प्रति लेनदेन भुगतान की गई गैस की औसत राशि पर फ़िल्टर करेंगे।
+
+
+
+हम वर्षों से Ethereum फाउंडेशन के पते पर किए गए सभी लेनदेन के लिए भुगतान की गई गैस की कीमतें देख सकते हैं। यहां क्वेरी है:
+
+```sql
+SELECT
+ block_time,
+ gas_price / 1e9 AS gas_price_gwei,
+ value / 1e18 AS eth_sent
+FROM ethereum."transactions"
+WHERE "to" = '\xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe'
+ORDER BY block_time DESC
+```
+
+### सारांश {#summary}
+
+इस ट्यूटोरियल के साथ, हम ऑन-चेन डेटा की क्वेरी करके और उसका अनुभव करके मूलभूत एथेरियम अवधारणाओं को और एथेरियम ब्लॉकचेन कैसे काम करता है, को समझते हैं।
+
+इस ट्यूटोरियल में उपयोग किए गए सभी कोड वाला डैशबोर्ड [यहां](https://dune.com/paulapivat/Learn-Ethereum) पाया जा सकता है।
+
+web3 का पता लगाने के लिए डेटा के अधिक उपयोग के लिए [मुझे Twitter पर खोजें](https://twitter.com/paulapivat)।
diff --git a/public/content/translations/hi/developers/tutorials/logging-events-smart-contracts/index.md b/public/content/translations/hi/developers/tutorials/logging-events-smart-contracts/index.md
new file mode 100644
index 00000000000..558918c8422
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/logging-events-smart-contracts/index.md
@@ -0,0 +1,62 @@
+---
+title: "इवेंट्स के साथ स्मार्ट अनुबंधों से डेटा लॉगिंग"
+description: "स्मार्ट अनुबंध इवेंट्स का परिचय और आप डेटा लॉग करने के लिए उनका उपयोग कैसे कर सकते हैं।"
+author: "jdourlens"
+tags: [ "स्मार्ट अनुबंध", "remix", "सोलिडीटी", "इवेंट्स" ]
+skill: intermediate
+lang: hi
+published: 2020-04-03
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/logging-data-with-events/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+सॉलिडिटी में, [इवेंट्स](/developers/docs/smart-contracts/anatomy/#events-and-logs) ऐसे सिग्नल होते हैं जिन्हें स्मार्ट अनुबंध फायर कर सकते हैं। डैप्स, या एथेरियम JSON-RPC API से जुड़ी कोई भी चीज़, इन इवेंट्स को सुन सकती है और तदनुसार कार्य कर सकती है। एक इवेंट को अनुक्रमित भी किया जा सकता है ताकि इवेंट हिस्ट्री बाद में खोजने योग्य हो।
+
+## घटनाएँ {#events}
+
+इस लेख को लिखने के समय एथेरियम ब्लॉकचेन पर सबसे आम इवेंट Transfer इवेंट है, जो किसी के द्वारा टोकन ट्रांसफर करने पर ERC20 टोकन द्वारा उत्सर्जित किया जाता है।
+
+```solidity
+event Transfer(address indexed from, address indexed to, uint256 value);
+```
+
+इवेंट सिग्नेचर अनुबंध कोड के अंदर घोषित किया गया है और इसे `emit` कीवर्ड के साथ उत्सर्जित किया जा सकता है। उदाहरण के लिए, ट्रांसफर इवेंट लॉग करता है कि ट्रांसफर किसने भेजा (_from_), किसे भेजा (_to_), और कितने टोकन ट्रांसफर किए गए (_value_)।
+
+अगर हम अपने Counter स्मार्ट अनुबंध पर वापस जाएं और हर बार मान बदलने पर लॉग करने का निर्णय लें। चूंकि यह अनुबंध डिप्लॉय करने के लिए नहीं है, बल्कि इसे विस्तारित करके एक और अनुबंध बनाने के लिए एक आधार के रूप में काम करने के लिए है: इसे एक एब्स्ट्रेक्ट अनुबंध कहा जाता है। हमारे काउंटर उदाहरण के मामले में, यह इस तरह दिखेगा:
+
+```solidity
+pragma solidity 0.5.17;
+
+contract Counter {
+
+ event ValueChanged(uint oldValue, uint256 newValue);
+
+ // गणनाओं की संख्या रखने के लिए अहस्ताक्षरित पूर्णांक प्रकार का निजी चर
+ uint256 private count = 0;
+
+ // हमारे काउंटर को बढ़ाने वाला फ़ंक्शन
+ function increment() public {
+ count += 1;
+ emit ValueChanged(count - 1, count);
+ }
+
+ // गणना मान प्राप्त करने के लिए गेटर
+ function getCount() public view returns (uint256) {
+ return count;
+ }
+
+}
+```
+
+ध्यान दें कि:
+
+- **पंक्ति 5**: हम अपने इवेंट की घोषणा करते हैं और उसमें क्या है—पुराना मान और नया मान।
+
+- **पंक्ति 13**: जब हम अपने काउंट चर को बढ़ाते हैं, तो हम इवेंट उत्सर्जित करते हैं।
+
+यदि हम अब अनुबंध डिप्लॉय करते हैं और इंक्रीमेंट फ़ंक्शन को कॉल करते हैं, तो हम देखेंगे कि `logs` नामक ऐरे के अंदर नए लेनदेन पर क्लिक करने पर Remix इसे स्वचालित रूप से प्रदर्शित करेगा।
+
+
+
+लॉग आपके स्मार्ट अनुबंधों को डीबग करने के लिए वास्तव में उपयोगी हैं, लेकिन यदि आप विभिन्न लोगों द्वारा उपयोग किए जाने वाले एप्लिकेशन बनाते हैं, तो वे महत्वपूर्ण भी हैं और वे आपके स्मार्ट अनुबंध के उपयोग को ट्रैक करने और समझने के लिए एनालिटिक्स बनाना आसान बनाते हैं। लेनदेन द्वारा उत्पन्न लॉग लोकप्रिय ब्लॉक खोजकर्ताओं में प्रदर्शित होते हैं और आप उनका उपयोग, उदाहरण के लिए, विशिष्ट इवेंट्स सुनने और उनके होने पर कार्रवाई करने के लिए ऑफ-चेन स्क्रिप्ट बनाने के लिए भी कर सकते हैं।
diff --git a/public/content/translations/hi/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md b/public/content/translations/hi/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
new file mode 100644
index 00000000000..23bc376e830
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/merkle-proofs-for-offline-data-integrity/index.md
@@ -0,0 +1,246 @@
+---
+title: "ऑफ़लाइन डेटा अखंडता के लिए मर्कल प्रमाण"
+description: "डेटा अखंडता ऑन-चेन सुनिश्चित करना, उस डेटा के लिए जो ज़्यादातर ऑफ़-चेन संग्रहीत होता है"
+author: "ओरी पोमेरेन्ट्ज़"
+tags: [ "स्टोरेज" ]
+skill: advanced
+lang: hi
+published: 2021-12-30
+---
+
+## परिचय {#introduction}
+
+आदर्श रूप से हम सब कुछ एथेरियम स्टोरेज में स्टोर करना चाहेंगे, जो हजारों कंप्यूटरों में संग्रहीत है और इसमें अत्यधिक उच्च उपलब्धता (डेटा को सेंसर नहीं किया जा सकता है) और अखंडता (डेटा को अनधिकृत तरीके से संशोधित नहीं किया जा सकता है) है, लेकिन 32-बाइट शब्द को संग्रहीत करने में आमतौर पर 20,000 गैस लगती है। जब मैं यह लिख रहा हूँ, तो वह लागत $6.60 के बराबर है। 21 सेंट प्रति बाइट पर यह कई उपयोगों के लिए बहुत महंगा है।
+
+इस समस्या को हल करने के लिए एथेरियम इकोसिस्टम ने [डेटा को विकेंद्रीकृत तरीके से स्टोर करने के कई वैकल्पिक तरीके विकसित किए](/developers/docs/storage/)। आमतौर पर उनमें उपलब्धता और कीमत के बीच एक ट्रेडऑफ़ शामिल होता है। हालांकि, अखंडता आमतौर पर सुनिश्चित की जाती है।
+
+इस लेख में आप सीखेंगे कि ब्लॉकचेन पर डेटा संग्रहीत किए बिना डेटा अखंडता कैसे सुनिश्चित की जाए, [मर्कल प्रमाण](https://computersciencewiki.org/index.php/Merkle_proof) का उपयोग करके।
+
+## यह कैसे काम करता है? {#how-does-it-work}
+
+सिद्धांत रूप में हम डेटा का हैश ऑन-चेन संग्रहीत कर सकते हैं, और उन ट्रांजेक्शन में सभी डेटा भेज सकते हैं जिनकी इसे आवश्यकता है। हालांकि, यह अभी भी बहुत महंगा है। एक ट्रांजेक्शन के लिए डेटा के एक बाइट की लागत लगभग 16 गैस होती है, वर्तमान में लगभग आधा सेंट, या लगभग $5 प्रति किलोबाइट। $5000 प्रति मेगाबाइट पर, यह कई उपयोगों के लिए अभी भी बहुत महंगा है, यहां तक कि डेटा को हैश करने की अतिरिक्त लागत के बिना भी।
+
+इसका समाधान डेटा के विभिन्न सबसेट को बार-बार हैश करना है, इसलिए जिस डेटा को आपको भेजने की आवश्यकता नहीं है, उसके लिए आप बस एक हैश भेज सकते हैं। आप यह एक मर्कल ट्री का उपयोग करके करते हैं, एक ट्री डेटा संरचना जहां प्रत्येक नोड उसके नीचे के नोड्स का एक हैश है:
+
+
+
+रूट हैश एकमात्र हिस्सा है जिसे ऑन-चेन संग्रहीत करने की आवश्यकता है। एक निश्चित मूल्य साबित करने के लिए, आप वे सभी हैश प्रदान करते हैं जिन्हें रूट प्राप्त करने के लिए इसके साथ संयोजित करने की आवश्यकता होती है। उदाहरण के लिए, `C` को साबित करने के लिए आप `D`, `H(A-B)`, और `H(E-H)` प्रदान करते हैं।
+
+
+
+## कार्यान्वयन {#implementation}
+
+[नमूना कोड यहाँ प्रदान किया गया है](https://github.com/qbzzt/merkle-proofs-for-offline-data-integrity)।
+
+### ऑफ़-चेन कोड {#offchain-code}
+
+इस लेख में हम ऑफ़-चेन संगणना के लिए JavaScript का उपयोग करते हैं। अधिकांश विकेंद्रीकृत अनुप्रयोगों में उनका ऑफ़-चेन घटक JavaScript में होता है।
+
+#### मर्कल रूट बनाना {#creating-the-merkle-root}
+
+सबसे पहले हमें चेन को मर्कल रूट प्रदान करने की आवश्यकता है।
+
+```javascript
+const ethers = require("ethers")
+```
+
+[हम ethers पैकेज से हैश फ़ंक्शन का उपयोग करते हैं](https://docs.ethers.io/v5/api/utils/hashing/#utils-keccak256)।
+
+```javascript
+// वह कच्चा डेटा जिसकी अखंडता हमें सत्यापित करनी है। पहले दो बाइट्स एक
+// यूज़र पहचानकर्ता हैं, और अंतिम दो बाइट्स वर्तमान में यूज़र के स्वामित्व वाले
+// टोकन की राशि हैं।
+const dataArray = [
+ 0x0bad0010, 0x60a70020, 0xbeef0030, 0xdead0040, 0xca110050, 0x0e660060,
+ 0xface0070, 0xbad00080, 0x060d0091,
+]
+```
+
+प्रत्येक प्रविष्टि को एक एकल 256-बिट पूर्णांक में एन्कोड करने से उदाहरण के लिए, JSON का उपयोग करने की तुलना में कम पठनीय कोड बनता है। हालांकि, इसका मतलब अनुबंध में डेटा पुनर्प्राप्त करने के लिए काफी कम प्रसंस्करण है, इसलिए गैस की लागत बहुत कम है। [आप JSON ऑन-चेन पढ़ सकते हैं](https://github.com/chrisdotn/jsmnSol), यह केवल एक बुरा विचार है यदि टाला जा सके।
+
+```javascript
+// हैश मानों की सरणी, BigInts के रूप में
+const hashArray = dataArray
+```
+
+इस मामले में हमारा डेटा शुरू करने के लिए 256-बिट मान है, इसलिए किसी प्रसंस्करण की आवश्यकता नहीं है। यदि हम स्ट्रिंग्स जैसी अधिक जटिल डेटा संरचना का उपयोग करते हैं, तो हमें यह सुनिश्चित करने की आवश्यकता है कि हम हैश की एक सरणी प्राप्त करने के लिए पहले डेटा को हैश करें। ध्यान दें कि यह इसलिए भी है क्योंकि हमें इस बात की परवाह नहीं है कि यूज़र दूसरे यूज़रों की जानकारी जानते हैं। अन्यथा हमें हैश करना पड़ता ताकि यूज़र 1 को यूज़र 0 के लिए मान का पता न चले, यूज़र 2 को यूज़र 3 के लिए मान का पता न चले, इत्यादि।
+
+```javascript
+// स्ट्रिंग जिसे हैश फ़ंक्शन उम्मीद करता है और
+// BigInt जिसे हम बाकी हर जगह उपयोग करते हैं, के बीच कन्वर्ट करें।
+const hash = (x) =>
+ BigInt(ethers.utils.keccak256("0x" + x.toString(16).padStart(64, 0)))
+```
+
+ethers हैश फ़ंक्शन को `0x60A7` जैसी हेक्साडेसिमल संख्या के साथ एक JavaScript स्ट्रिंग प्राप्त करने की उम्मीद है, और यह उसी संरचना के साथ एक और स्ट्रिंग के साथ प्रतिक्रिया करता है। हालांकि, बाकी कोड के लिए `BigInt` का उपयोग करना आसान है, इसलिए हम एक हेक्साडेसिमल स्ट्रिंग में कनवर्ट करते हैं और फिर वापस।
+
+```javascript
+// एक जोड़ी का सममित हैश ताकि हमें इस बात की परवाह न हो कि क्रम उलटा है।
+const pairHash = (a, b) => hash(hash(a) ^ hash(b))
+```
+
+यह फ़ंक्शन सममित है (a [xor](https://en.wikipedia.org/wiki/Exclusive_or) b का हैश)। इसका मतलब है कि जब हम मर्कल प्रमाण की जाँच करते हैं तो हमें इस बात की चिंता करने की आवश्यकता नहीं है कि प्रमाण से मान को परिकलित मान से पहले रखना है या बाद में। मर्कल प्रमाण की जाँच ऑन-चेन की जाती है, इसलिए हमें वहाँ जितना कम करना पड़े, उतना अच्छा है।
+
+चेतावनी:
+क्रिप्टोग्राफी जितनी दिखती है उससे कहीं ज्यादा कठिन है।
+इस लेख के शुरुआती संस्करण में हैश फ़ंक्शन `hash(a^b)` था।
+यह एक **खराब** विचार था क्योंकि इसका मतलब था कि यदि आप `a` और `b` के वैध मान जानते हैं तो आप किसी भी वांछित `a'` मान को साबित करने के लिए `b' = a^b^a'` का उपयोग कर सकते हैं।
+इस फ़ंक्शन के साथ आपको `b'` की गणना करनी होगी ताकि `hash(a') ^ hash(b')` एक ज्ञात मान (रूट के रास्ते पर अगली शाखा) के बराबर हो, जो बहुत अधिक कठिन है।
+
+```javascript
+// यह दर्शाने वाला मान कि एक निश्चित शाखा खाली है, उसमें
+// कोई मान नहीं है
+const empty = 0n
+```
+
+जब मानों की संख्या दो की पूर्णांक घात नहीं होती है तो हमें खाली शाखाओं को संभालना पड़ता है। यह प्रोग्राम इसे करने का तरीका यह है कि यह एक प्लेस होल्डर के रूप में शून्य रखता है।
+
+
+
+```javascript
+// एक हैश ऐरे के ट्री में, क्रम में प्रत्येक जोड़ी का हैश लेकर एक स्तर ऊपर की
+// गणना करें
+const oneLevelUp = (inputArray) => {
+ var result = []
+ var inp = [...inputArray] // इनपुट पर लिखने से बचने के लिए // यदि आवश्यक हो तो एक खाली मान जोड़ें (हमें सभी पत्तियों को // जोड़ा बनाना होगा)
+
+ if (inp.length % 2 === 1) inp.push(empty)
+
+ for (var i = 0; i < inp.length; i += 2)
+ result.push(pairHash(inp[i], inp[i + 1]))
+
+ return result
+} // oneLevelUp
+```
+
+यह फ़ंक्शन वर्तमान परत पर मानों के जोड़े को हैश करके मर्कल ट्री में एक स्तर "चढ़ता" है। ध्यान दें कि यह सबसे कुशल कार्यान्वयन नहीं है, हम इनपुट की प्रतिलिपि बनाने से बच सकते थे और लूप में उपयुक्त होने पर बस `hashEmpty` जोड़ सकते थे, लेकिन यह कोड पठनीयता के लिए अनुकूलित है।
+
+```javascript
+const getMerkleRoot = (inputArray) => {
+ var result
+
+ result = [...inputArray] // पेड़ पर तब तक चढ़ें जब तक कि केवल एक मान न रह जाए, जो कि // रूट है। // // यदि किसी परत में विषम संख्या में प्रविष्टियाँ हैं तो // oneLevelUp में कोड एक खाली मान जोड़ता है, इसलिए यदि हमारे पास, उदाहरण के लिए, // 10 पत्तियाँ हैं तो दूसरी परत में 5 शाखाएँ, तीसरी में 3 // शाखाएँ, चौथी में 2 और रूट पाँचवाँ होगा
+
+ while (result.length > 1) result = oneLevelUp(result)
+
+ return result[0]
+}
+```
+
+रूट प्राप्त करने के लिए, तब तक चढ़ें जब तक केवल एक मान न रह जाए।
+
+#### मर्कल प्रमाण बनाना {#creating-a-merkle-proof}
+
+एक मर्कल प्रमाण वे मान हैं जिन्हें मर्कल रूट को वापस पाने के लिए साबित किए जा रहे मान के साथ एक साथ हैश किया जाता है। साबित किया जाने वाला मान अक्सर अन्य डेटा से उपलब्ध होता है, इसलिए मैं इसे कोड के हिस्से के रूप में प्रदान करने के बजाय अलग से प्रदान करना पसंद करता हूँ।
+
+```javascript
+// एक मर्कल प्रमाण में हैश करने के लिए प्रविष्टियों की
+// सूची का मान होता है। क्योंकि हम एक सममित हैश फ़ंक्शन का उपयोग करते हैं, इसलिए हमें
+// प्रमाण को सत्यापित करने के लिए आइटम के स्थान की आवश्यकता नहीं है, केवल इसे बनाने के लिए
+const getMerkleProof = (inputArray, n) => {
+ var result = [], currentLayer = [...inputArray], currentN = n
+
+ // जब तक हम शीर्ष पर नहीं पहुँच जाते
+ while (currentLayer.length > 1) {
+ // कोई विषम लंबाई वाली परतें नहीं
+ if (currentLayer.length % 2)
+ currentLayer.push(empty)
+
+ result.push(currentN % 2
+ // यदि currentN विषम है, तो प्रमाण में उसके पहले वाले मान को जोड़ें
+ ? currentLayer[currentN-1]
+ // यदि यह सम है, तो उसके बाद का मान जोड़ें
+ : currentLayer[currentN+1])
+
+```
+
+हम `(v[0],v[1])`, `(v[2],v[3])` आदि को हैश करते हैं। इसलिए सम मानों के लिए हमें अगला वाला चाहिए, विषम मानों के लिए पिछला वाला।
+
+```javascript
+ // अगली परत पर जाएँ
+ currentN = Math.floor(currentN/2)
+ currentLayer = oneLevelUp(currentLayer)
+ } // while currentLayer.length > 1
+
+ return result
+} // getMerkleProof
+```
+
+### ऑन-चेन कोड {#onchain-code}
+
+अंत में हमारे पास वह कोड है जो प्रमाण की जाँच करता है। ऑन-चेन कोड [Solidity](https://docs.soliditylang.org/en/v0.8.11/) में लिखा गया है। अनुकूलन यहाँ बहुत अधिक महत्वपूर्ण है क्योंकि गैस अपेक्षाकृत महंगी है।
+
+```solidity
+//SPDX-License-Identifier: Public Domain
+pragma solidity ^0.8.0;
+
+import "hardhat/console.sol";
+```
+
+मैंने इसे [Hardhat विकास परिवेश](https://hardhat.org/) का उपयोग करके लिखा है, जो हमें विकास के दौरान [Solidity से कंसोल आउटपुट](https://hardhat.org/tutorial/debugging-with-hardhat-network.html) प्राप्त करने की अनुमति देता है।
+
+```solidity
+
+contract MerkleProof {
+ uint merkleRoot;
+
+ function getRoot() public view returns (uint) {
+ return merkleRoot;
+ }
+
+ // अत्यंत असुरक्षित, प्रोडक्शन कोड में इस तक पहुँच
+ // फ़ंक्शन को सख्ती से सीमित किया जाना चाहिए, शायद किसी
+ // स्वामी के लिए
+ function setRoot(uint _merkleRoot) external {
+ merkleRoot = _merkleRoot;
+ } // setRoot
+```
+
+मर्कल रूट के लिए सेट और गेट फ़ंक्शन। उत्पादन प्रणाली में सभी को मर्कल रूट अपडेट करने देना एक _अत्यंत बुरा विचार_ है। मैं इसे यहाँ नमूना कोड के लिए सरलता के लिए करता हूँ। **इसे किसी ऐसे सिस्टम पर न करें जहाँ डेटा अखंडता वास्तव में मायने रखती है**।
+
+```solidity
+ function hash(uint _a) internal pure returns(uint) {
+ return uint(keccak256(abi.encode(_a)));
+ }
+
+ function pairHash(uint _a, uint _b) internal pure returns(uint) {
+ return hash(hash(_a) ^ hash(_b));
+ }
+```
+
+यह फ़ंक्शन एक जोड़ी हैश उत्पन्न करता है। यह `hash` और `pairHash` के लिए जावास्क्रिप्ट कोड का केवल सॉलिडिटी अनुवाद है।
+
+**नोट:** यह पठनीयता के लिए अनुकूलन का एक और मामला है। [फ़ंक्शन परिभाषा](https://www.tutorialspoint.com/solidity/solidity_cryptographic_functions.htm) के आधार पर, डेटा को [`bytes32`](https://docs.soliditylang.org/en/v0.5.3/types.html#fixed-size-byte-arrays) मान के रूप में संग्रहीत करना और रूपांतरणों से बचना संभव हो सकता है।
+
+```solidity
+ // एक मर्कल प्रमाण सत्यापित करें
+ function verifyProof(uint _value, uint[] calldata _proof)
+ public view returns (bool) {
+ uint temp = _value;
+ uint i;
+
+ for(i=0; i<_proof.length; i++) {
+ temp = pairHash(temp, _proof[i]);
+ }
+
+ return temp == merkleRoot;
+ }
+
+} // MarkleProof
+```
+
+गणितीय अंकन में मर्कल प्रमाण सत्यापन इस तरह दिखता है: `H(proof_n, H(proof_n-1, H(proof_n-2, ...` `H(proof_1, H(proof_0, value))...)))`। यह कोड इसे लागू करता है।
+
+## मर्कल प्रमाण और रोलअप का मेल नहीं होता {#merkle-proofs-and-rollups}
+
+मर्कल प्रमाण [रोलअप](/developers/docs/scaling/#rollups) के साथ अच्छी तरह से काम नहीं करते हैं। इसका कारण यह है कि रोलअप सभी ट्रांजेक्शन डेटा L1 पर लिखते हैं, लेकिन L2 पर प्रोसेस करते हैं। एक ट्रांजेक्शन के साथ मर्कल प्रमाण भेजने की लागत प्रति परत औसतन 638 गैस है (वर्तमान में कॉल डेटा में एक बाइट की लागत 16 गैस है यदि यह शून्य नहीं है, और 4 यदि यह शून्य है)। यदि हमारे पास 1024 शब्दों का डेटा है, तो एक मर्कल प्रमाण के लिए दस परतों की आवश्यकता होती है, या कुल 6380 गैस की।
+
+[Optimism](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m) को उदाहरण के तौर पर देखें, L1 गैस लिखने पर लगभग 100 gwei और L2 गैस पर 0.001 gwei की लागत आती है (यह सामान्य मूल्य है, यह संकुलन के साथ बढ़ सकता है)। तो एक L1 गैस की कीमत पर हम L2 प्रसंस्करण पर एक लाख गैस खर्च कर सकते हैं। यह मानते हुए कि हम स्टोरेज को ओवरराइट नहीं करते हैं, इसका मतलब है कि हम एक L1 गैस की कीमत के लिए L2 पर स्टोरेज में लगभग पांच शब्द लिख सकते हैं। एकल मर्कल प्रमाण के लिए हम पूरे 1024 शब्दों को स्टोरेज में लिख सकते हैं (यह मानते हुए कि उन्हें शुरू में ऑन-चेन परिकलित किया जा सकता है, बजाय इसके कि एक ट्रांजेक्शन में प्रदान किया जाए) और फिर भी अधिकांश गैस बची रहेगी।
+
+## निष्कर्ष {#conclusion}
+
+वास्तविक जीवन में आप शायद कभी भी अपने दम पर मर्कल ट्री लागू नहीं करेंगे। ऐसी जानी-मानी और ऑडिट की गई लाइब्रेरी हैं जिनका आप उपयोग कर सकते हैं और सामान्य तौर पर यह सबसे अच्छा है कि आप अपने दम पर क्रिप्टोग्राफिक प्रिमिटिव लागू न करें। लेकिन मुझे उम्मीद है कि अब आप मर्कल प्रमाणों को बेहतर ढंग से समझते हैं और यह तय कर सकते हैं कि उनका उपयोग कब करने लायक है।
+
+ध्यान दें कि जबकि मर्कल प्रमाण _अखंडता_ को संरक्षित करते हैं, वे _उपलब्धता_ को संरक्षित नहीं करते हैं। यह जानना कि कोई और आपकी संपत्ति नहीं ले सकता है, यह एक छोटी सी सांत्वना है यदि डेटा स्टोरेज पहुँच को अस्वीकार करने का फैसला करता है और आप उन तक पहुँचने के लिए मर्कल ट्री का निर्माण भी नहीं कर सकते हैं। इसलिए मर्कल ट्री का सबसे अच्छा उपयोग किसी प्रकार के विकेंद्रीकृत स्टोरेज, जैसे कि IPFS के साथ किया जाता है।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md b/public/content/translations/hi/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
new file mode 100644
index 00000000000..cb1626826ee
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/monitoring-geth-with-influxdb-and-grafana/index.md
@@ -0,0 +1,151 @@
+---
+title: "InfluxDB और Grafana के साथ Geth की निगरानी"
+description: "प्रदर्शन को ट्रैक करने और समस्याओं की पहचान करने के लिए InfluxDB और Grafana का उपयोग करके अपने Geth नोड के लिए निगरानी सेट करें।"
+author: "मारियो हवेल"
+tags: [ "क्लाइंट्स", "नोड्स" ]
+skill: intermediate
+lang: hi
+published: 2021-01-13
+---
+
+यह ट्यूटोरियल आपको अपने Geth नोड के लिए निगरानी सेट करने में मदद करेगा ताकि आप इसके प्रदर्शन को बेहतर ढंग से समझ सकें और संभावित समस्याओं की पहचान कर सकें।
+
+## पूर्वापेक्षाएं {#prerequisites}
+
+- आपको पहले से ही Geth का एक इंस्टेंस चलाना चाहिए।
+- अधिकांश चरण और उदाहरण लिनक्स एनवायरमेंट के लिए हैं, बेसिक टर्मिनल नॉलेज सहायक होगा।
+- Geth के मेट्रिक्स के सुइट का यह वीडियो अवलोकन देखें: [Péter Szilágyi द्वारा एक Ethereum इंफ्रास्ट्रक्चर की निगरानी](https://www.youtube.com/watch?v=cOBab8IJMYI)।
+
+## निगरानी स्टैक {#monitoring-stack}
+
+एक एथेरियम क्लाइंट बहुत सारा डेटा एकत्र करता है जिसे एक कालानुक्रमिक डेटाबेस के रूप में पढ़ा जा सकता है। निगरानी को आसान बनाने के लिए, आप इसे डेटा विज़ुअलाइज़ेशन सॉफ़्टवेयर में फीड कर सकते हैं। कई विकल्प उपलब्ध हैं:
+
+- [Prometheus](https://prometheus.io/) (पुल मॉडल)
+- [InfluxDB](https://www.influxdata.com/get-influxdb/) (पुश मॉडल)
+- [Telegraf](https://www.influxdata.com/get-influxdb/)
+- [Grafana](https://www.grafana.com/)
+- [Datadog](https://www.datadoghq.com/)
+- [Chronograf](https://www.influxdata.com/time-series-platform/chronograf/)
+
+[Geth Prometheus Exporter](https://github.com/hunterlong/gethexporter) भी है, जो InfluxDB और Grafana के साथ पहले से कॉन्फ़िगर किया गया एक विकल्प है।
+
+इस ट्यूटोरियल में, हम डेटाबेस बनाने के लिए InfluxDB में डेटा पुश करने के लिए आपके Geth क्लाइंट को और डेटा का ग्राफ़ विज़ुअलाइज़ेशन बनाने के लिए Grafana को सेट करेंगे। इसे मैन्युअल रूप से करने से आपको प्रक्रिया को बेहतर ढंग से समझने, इसे बदलने और विभिन्न एनवायरमेंट में तैनात करने में मदद मिलेगी।
+
+## InfluxDB सेट करना {#setting-up-influxdb}
+
+सबसे पहले, आइए InfluxDB डाउनलोड और इंस्टॉल करें। विभिन्न डाउनलोड विकल्प [Influxdata रिलीज़ पेज](https://portal.influxdata.com/downloads/) पर मिल सकते हैं। अपने एनवायरमेंट के अनुकूल एक चुनें।
+आप इसे [रिपॉजिटरी](https://repos.influxdata.com/) से भी इंस्टॉल कर सकते हैं। उदाहरण के लिए डेबियन आधारित वितरण में:
+
+```
+curl -tlsv1.3 --proto =https -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add
+source /etc/lsb-release
+echo "deb https://repos.influxdata.com/${DISTRIB_ID,,} ${DISTRIB_CODENAME} stable" | sudo tee /etc/apt/sources.list.d/influxdb.list
+sudo apt update
+sudo apt install influxdb -y
+sudo systemctl enable influxdb
+sudo systemctl start influxdb
+sudo apt install influxdb-client
+```
+
+InfluxDB को सफलतापूर्वक इंस्टॉल करने के बाद, सुनिश्चित करें कि यह बैकग्राउंड में चल रहा है। डिफ़ॉल्ट रूप से, यह `localhost:8086` पर उपलब्ध है।
+`influx` क्लाइंट का उपयोग करने से पहले, आपको एडमिन विशेषाधिकारों के साथ नया यूज़र बनाना होगा। यह यूज़र उच्च स्तरीय प्रबंधन, डेटाबेस और यूज़र्स बनाने के लिए काम करेगा।
+
+```
+curl -XPOST "http://localhost:8086/query" --data-urlencode "q=CREATE USER username WITH PASSWORD 'password' WITH ALL PRIVILEGES"
+```
+
+अब आप इस यूज़र के साथ [InfluxDB शेल](https://docs.influxdata.com/influxdb/v1.8/tools/shell/) में प्रवेश करने के लिए influx क्लाइंट का उपयोग कर सकते हैं।
+
+```
+influx -username 'username' -password 'password'
+```
+
+इसके शेल में InfluxDB के साथ सीधे संवाद करते हुए, आप geth मेट्रिक्स के लिए डेटाबेस और यूज़र बना सकते हैं।
+
+```
+create database geth
+create user geth with password choosepassword
+```
+
+बनाई गई प्रविष्टियों को इसके साथ सत्यापित करें:
+
+```
+show databases
+show users
+```
+
+InfluxDB शेल छोड़ दें।
+
+```
+exit
+```
+
+InfluxDB चल रहा है और Geth से मेट्रिक्स स्टोर करने के लिए कॉन्फ़िगर किया गया है।
+
+## Geth तैयार करना {#preparing-geth}
+
+डेटाबेस सेट करने के बाद, हमें Geth में मेट्रिक्स कलेक्शन को सक्षम करना होगा। `geth --help` में `METRICS AND STATS OPTIONS` पर ध्यान दें। वहां कई विकल्प मिल सकते हैं, इस मामले में हम चाहते हैं कि Geth डेटा को InfluxDB में पुश करे।
+बेसिक सेटअप उस एंडपॉइंट को निर्दिष्ट करता है जहां InfluxDB पहुंच योग्य है और डेटाबेस के लिए प्रमाणीकरण।
+
+```
+geth --metrics --metrics.influxdb --metrics.influxdb.endpoint "http://0.0.0.0:8086" --metrics.influxdb.username "geth" --metrics.influxdb.password "chosenpassword"
+```
+
+यह फ्लैग क्लाइंट को शुरू करने वाले कमांड में जोड़ा जा सकता है या कॉन्फ़िगरेशन फ़ाइल में सहेजा जा सकता है।
+
+आप यह सत्यापित कर सकते हैं कि Geth सफलतापूर्वक डेटा पुश कर रहा है, उदाहरण के लिए डेटाबेस में मेट्रिक्स को सूचीबद्ध करके। InfluxDB शेल में:
+
+```
+use geth
+show measurements
+```
+
+## Grafana सेट करना {#setting-up-grafana}
+
+अगला कदम Grafana इंस्टॉल करना है जो डेटा को ग्राफिक रूप से इंटरप्रेट करेगा। Grafana प्रलेखन में अपने एनवायरमेंट के लिए इंस्टॉलेशन प्रक्रिया का पालन करें। सुनिश्चित करें कि आप OSS संस्करण इंस्टॉल करें यदि आप अन्यथा नहीं चाहते हैं।
+रिपॉजिटरी का उपयोग करके डेबियन वितरण के लिए उदाहरण इंस्टॉलेशन चरण:
+
+```
+curl -tlsv1.3 --proto =https -sL https://packages.grafana.com/gpg.key | sudo apt-key add -
+echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
+sudo apt update
+sudo apt install grafana
+sudo systemctl enable grafana-server
+sudo systemctl start grafana-server
+```
+
+जब आपके पास Grafana चल रहा हो, तो यह `localhost:3000` पर उपलब्ध होना चाहिए।
+इस पाथ तक पहुंचने के लिए अपने पसंदीदा ब्राउज़र का उपयोग करें, फिर डिफ़ॉल्ट क्रेडेंशियल्स (यूज़र: `admin` और पासवर्ड: `admin`) के साथ लॉगिन करें। पूछे जाने पर, डिफ़ॉल्ट पासवर्ड बदलें और सेव करें।
+
+
+
+आपको Grafana होम पेज पर रीडायरेक्ट कर दिया जाएगा। सबसे पहले, अपना स्रोत डेटा सेट करें। बाईं ओर बार में कॉन्फ़िगरेशन आइकन पर क्लिक करें और "डेटा स्रोत" चुनें।
+
+
+
+अभी तक कोई डेटा स्रोत नहीं बनाया गया है, एक को परिभाषित करने के लिए "डेटा स्रोत जोड़ें" पर क्लिक करें।
+
+
+
+इस सेटअप के लिए, "InfluxDB" चुनें और आगे बढ़ें।
+
+
+
+यदि आप एक ही मशीन पर उपकरण चला रहे हैं तो डेटा स्रोत कॉन्फ़िगरेशन बहुत सीधा है। आपको डेटाबेस तक पहुंचने के लिए InfluxDB पता और विवरण सेट करना होगा। नीचे दी गई तस्वीर देखें।
+
+
+
+यदि सब कुछ पूरा हो गया है और InfluxDB पहुंच योग्य है, तो "सहेजें और परीक्षण करें" पर क्लिक करें और पुष्टि के पॉप अप होने की प्रतीक्षा करें।
+
+
+
+Grafana अब InfluxDB से डेटा पढ़ने के लिए सेट है। अब आपको एक डैशबोर्ड बनाना होगा जो इसे इंटरप्रेट और प्रदर्शित करेगा। डैशबोर्ड गुण JSON फ़ाइलों में एन्कोड किए गए हैं जिन्हें कोई भी बना सकता है और आसानी से आयात कर सकता है। बाईं ओर बार में, "बनाएँ और आयात करें" पर क्लिक करें।
+
+
+
+Geth निगरानी डैशबोर्ड के लिए, [इस डैशबोर्ड](https://grafana.com/grafana/dashboards/13877/) की आईडी कॉपी करें और इसे Grafana में "आयात पृष्ठ" में पेस्ट करें। डैशबोर्ड को सहेजने के बाद, यह इस तरह दिखना चाहिए:
+
+
+
+आप अपने डैशबोर्ड को संशोधित कर सकते हैं। प्रत्येक पैनल को संपादित, स्थानांतरित, हटाया या जोड़ा जा सकता है। आप अपने कॉन्फ़िगरेशन बदल सकते हैं। यह आप पर निर्भर है! डैशबोर्ड कैसे काम करते हैं, इसके बारे में अधिक जानने के लिए, [Grafana का प्रलेखन](https://grafana.com/docs/grafana/latest/dashboards/) देखें।
+आप [अलर्टिंग](https://grafana.com/docs/grafana/latest/alerting/) में भी रुचि ले सकते हैं। यह आपको मेट्रिक्स के कुछ मानों तक पहुंचने पर अलर्ट नोटिफिकेशन सेट करने देता है। विभिन्न संचार चैनल समर्थित हैं।
diff --git a/public/content/translations/hi/developers/tutorials/nft-minter/index.md b/public/content/translations/hi/developers/tutorials/nft-minter/index.md
new file mode 100644
index 00000000000..04f1aafc0b2
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/nft-minter/index.md
@@ -0,0 +1,874 @@
+---
+title: "NFT मिन्टर ट्यूटोरियल"
+description: "इस ट्यूटोरियल में, आप एक NFT मिन्टर बनाएँगे और MetaMask व Web3 टूल का उपयोग करके अपने स्मार्ट अनुबंध को React फ्रंटएंड से जोड़कर एक पूर्ण स्टैक डैप बनाना सीखेंगे।"
+author: "smudgil"
+tags:
+ [
+ "सोलिडीटी",
+ "NFT",
+ "एल्केमी",
+ "स्मार्ट अनुबंध",
+ "frontend",
+ "Pinata"
+ ]
+skill: intermediate
+lang: hi
+published: 2021-10-06
+---
+
+Web2 बैकग्राउंड से आने वाले डेवलपर्स के लिए सबसे बड़ी चुनौतियों में से एक यह पता लगाना है कि अपने स्मार्ट अनुबंध को फ्रंटएंड प्रोजेक्ट से कैसे जोड़ा जाए और उसके साथ कैसे इंटरैक्ट किया जाए।
+
+एक NFT मिन्टर बनाकर — एक सरल UI जहाँ आप अपनी डिजिटल संपत्ति, एक शीर्षक और एक विवरण के लिए एक लिंक इनपुट कर सकते हैं — आप सीखेंगे कि:
+
+- अपने फ्रंटएंड प्रोजेक्ट के माध्यम से MetaMask से कनेक्ट करें
+- अपने फ्रंटएंड से स्मार्ट अनुबंध विधियों को कॉल करें
+- MetaMask का उपयोग करके लेनदेन पर हस्ताक्षर करें
+
+इस ट्यूटोरियल में, हम अपने फ्रंटएंड फ्रेमवर्क के रूप में [React](https://react.dev/) का उपयोग करेंगे। क्योंकि यह ट्यूटोरियल मुख्य रूप से Web3 विकास पर केंद्रित है, हम React की बुनियादी बातों को समझने में ज्यादा समय नहीं बिताएँगे। इसके बजाय, हम अपने प्रोजेक्ट में कार्यक्षमता लाने पर ध्यान केंद्रित करेंगे।
+
+एक पूर्वापेक्षा के रूप में, आपको React की शुरुआती स्तर की समझ होनी चाहिए—पता होना चाहिए कि कंपोनेंट्स, प्रॉप्स, useState/useEffect, और बेसिक फंक्शन कॉलिंग कैसे काम करते हैं। यदि आपने पहले इनमें से किसी भी शब्द के बारे में नहीं सुना है, तो आप इस [React ट्यूटोरियल का परिचय](https://react.dev/learn/tutorial-tic-tac-toe) देख सकते हैं। अधिक विज़ुअल शिक्षार्थियों के लिए, हम नेट निंजा द्वारा इस उत्कृष्ट [पूर्ण आधुनिक React ट्यूटोरियल](https://www.youtube.com/playlist?list=PL4cUxeGkcC9gZD-Tvwfod2gaISzfRiP9d) वीडियो श्रृंखला की अत्यधिक अनुशंसा करते हैं।
+
+और अगर आपके पास पहले से नहीं है, तो आपको इस ट्यूटोरियल को पूरा करने और ब्लॉकचेन पर कुछ भी बनाने के लिए निश्चित रूप से एक Alchemy खाते की आवश्यकता होगी। [यहां](https://alchemy.com/) एक निःशुल्क खाते के लिए साइन अप करें।
+
+बिना किसी और देरी के, चलिए शुरू करते हैं!
+
+## NFTs बनाना 101 {#making-nfts-101}
+
+इससे पहले कि हम किसी भी कोड को देखना शुरू करें, यह समझना महत्वपूर्ण है कि NFT बनाना कैसे काम करता है। इसमें दो चरण शामिल हैं:
+
+### एथेरियम ब्लॉकचेन पर एक NFT स्मार्ट अनुबंध प्रकाशित करें {#publish-nft}
+
+दो NFT स्मार्ट अनुबंध मानकों के बीच सबसे बड़ा अंतर यह है कि ERC-1155 एक मल्टी-टोकन मानक है और इसमें बैच कार्यक्षमता शामिल है, जबकि ERC-721 एक एकल-टोकन मानक है और इसलिए एक समय में केवल एक टोकन स्थानांतरित करने का समर्थन करता है।
+
+### मिन्टिंग फ़ंक्शन को कॉल करें {#minting-function}
+
+आमतौर पर, इस मिन्टिंग फ़ंक्शन में आपको पैरामीटर के रूप में दो चर पास करने की आवश्यकता होती है, पहला `recipient`, जो उस पते को निर्दिष्ट करता है जिसे आपका ताज़ा बनाया गया NFT प्राप्त होगा, और दूसरा NFT का `tokenURI`, एक स्ट्रिंग जो NFT के मेटाडेटा का वर्णन करने वाले JSON दस्तावेज़ में हल होती है।
+
+एक NFT का मेटाडेटा वास्तव में वही है जो इसे जीवंत करता है, जिससे इसमें नाम, विवरण, छवि (या अलग डिजिटल संपत्ति), और अन्य विशेषताओं जैसे गुण होते हैं। यहाँ [tokenURI का एक उदाहरण](https://gateway.pinata.cloud/ipfs/QmSvBcb4tjdFpajGJhbFAWeK3JAxCdNQLQtr6ZdiSi42V2) है, जिसमें NFT का मेटाडेटा है।
+
+इस ट्यूटोरियल में, हम भाग 2 पर ध्यान केंद्रित करने जा रहे हैं, हमारे React UI का उपयोग करके मौजूदा NFT के स्मार्ट अनुबंध मिन्टिंग फ़ंक्शन को कॉल करना।
+
+इस ट्यूटोरियल में हम जिस ERC-721 NFT स्मार्ट अनुबंध को कॉल करेंगे, उसका [लिंक यहाँ है](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE)। यदि आप यह जानना चाहते हैं कि हमने इसे कैसे बनाया, तो हम आपको हमारे दूसरे ट्यूटोरियल, [\"एक NFT कैसे बनाएँ\"](https://www.alchemy.com/docs/how-to-create-an-nft) को देखने की अत्यधिक अनुशंसा करते हैं।
+
+बढ़िया, अब जब हम समझ गए हैं कि NFT बनाना कैसे काम करता है, तो चलिए अपनी स्टार्टर फ़ाइलों को क्लोन करते हैं!
+
+## स्टार्टर फ़ाइलों को क्लोन करें {#clone-the-starter-files}
+
+सबसे पहले, इस प्रोजेक्ट के लिए स्टार्टर फाइलें प्राप्त करने के लिए [nft-minter-tutorial GitHub रिपॉजिटरी](https://github.com/alchemyplatform/nft-minter-tutorial) पर जाएं। इस रिपॉजिटरी को अपने स्थानीय परिवेश में क्लोन करें।
+
+जब आप इस क्लोन की गई `nft-minter-tutorial` रिपॉजिटरी को खोलते हैं, तो आप देखेंगे कि इसमें दो फोल्डर हैं: `minter-starter-files` और `nft-minter`।
+
+- `minter-starter-files` में इस प्रोजेक्ट के लिए स्टार्टर फाइलें (अनिवार्य रूप से React UI) होती हैं। इस ट्यूटोरियल में, **हम इस डायरेक्टरी में काम करेंगे**, क्योंकि आप इसे अपने एथेरियम वॉलेट और एक NFT स्मार्ट अनुबंध से जोड़कर इस UI को जीवंत करना सीखेंगे।
+- `nft-minter` में पूरा पूरा किया गया ट्यूटोरियल है और यह आपके लिए **संदर्भ** के रूप में है **यदि आप फंस जाते हैं।**
+
+अगला, अपने कोड एडिटर में `minter-starter-files` की अपनी प्रतिलिपि खोलें, और फिर अपने `src` फ़ोल्डर में नेविगेट करें।
+
+हम जो भी कोड लिखेंगे वह `src` फोल्डर के अंतर्गत रहेगा। हम `Minter.js` घटक का संपादन करेंगे और अपने प्रोजेक्ट को Web3 कार्यक्षमता देने के लिए अतिरिक्त जावास्क्रिप्ट फाइलें लिखेंगे।
+
+## चरण 2: हमारी स्टार्टर फाइलों को देखें {#step-2-check-out-our-starter-files}
+
+कोडिंग शुरू करने से पहले, यह जांचना महत्वपूर्ण है कि स्टार्टर फ़ाइलों में हमारे लिए पहले से क्या प्रदान किया गया है।
+
+### अपना react प्रोजेक्ट चलाएँ {#get-your-react-project-running}
+
+आइए अपने ब्राउज़र में React प्रोजेक्ट चलाकर शुरू करें। React की खूबी यह है कि एक बार जब हमारा प्रोजेक्ट हमारे ब्राउज़र में चल रहा होता है, तो हमारे द्वारा सहेजे गए कोई भी परिवर्तन हमारे ब्राउज़र में लाइव अपडेट हो जाएँगे।
+
+प्रोजेक्ट को चलाने के लिए, `minter-starter-files` फ़ोल्डर की रूट डायरेक्टरी में नेविगेट करें, और प्रोजेक्ट की निर्भरताएँ स्थापित करने के लिए अपने टर्मिनल में `npm install` चलाएँ:
+
+```bash
+cd minter-starter-files
+npm install
+```
+
+एक बार वे स्थापित हो जाने के बाद, अपने टर्मिनल में `npm start` चलाएँ:
+
+```bash
+npm start
+```
+
+ऐसा करने से आपके ब्राउज़र में http://localhost:3000/ खुल जाना चाहिए, जहाँ आप हमारे प्रोजेक्ट के लिए फ्रंटएंड देखेंगे। इसमें 3 फ़ील्ड होने चाहिए: आपके NFT की संपत्ति के लिए एक लिंक इनपुट करने की जगह, आपके NFT का नाम दर्ज करें, और एक विवरण प्रदान करें।
+
+यदि आप \"वॉलेट कनेक्ट करें\" या \"NFT मिंट करें\" बटन पर क्लिक करने का प्रयास करते हैं, तो आप देखेंगे कि वे काम नहीं करते हैं—ऐसा इसलिए है क्योंकि हमें अभी भी उनकी कार्यक्षमता को प्रोग्राम करने की आवश्यकता है! :\)
+
+### Minter.js घटक {#minter-js}
+
+**ध्यान दें:** सुनिश्चित करें कि आप `minter-starter-files` फ़ोल्डर में हैं न कि `nft-minter` फ़ोल्डर में!
+
+चलिए हमारे संपादक में `src` फ़ोल्डर में वापस जाते हैं और `Minter.js` फ़ाइल खोलते हैं। यह बहुत महत्वपूर्ण है कि हम इस फ़ाइल में सब कुछ समझें, क्योंकि यह प्राथमिक React घटक है जिस पर हम काम करेंगे।
+
+इस फ़ाइल के शीर्ष पर, हमारे पास हमारे स्थिति चर हैं जिन्हें हम विशिष्ट घटनाओं के बाद अपडेट करेंगे।
+
+```javascript
+//स्थिति चर
+const [walletAddress, setWallet] = useState("")
+const [status, setStatus] = useState("")
+const [name, setName] = useState("")
+const [description, setDescription] = useState("")
+const [url, setURL] = useState("")
+```
+
+React स्थिति चर या स्थिति हुक के बारे में कभी नहीं सुना? [इन](https://legacy.reactjs.org/docs/hooks-state.html) दस्तावेज़ों को देखें।
+
+यहाँ प्रत्येक चर का प्रतिनिधित्व है:
+
+- `walletAddress` - एक स्ट्रिंग जो यूज़र के वॉलेट पते को संग्रहीत करती है
+- `status` - एक स्ट्रिंग जिसमें UI के नीचे प्रदर्शित करने के लिए एक संदेश होता है
+- `name` - एक स्ट्रिंग जो NFT के नाम को संग्रहीत करती है
+- `description` - एक स्ट्रिंग जो NFT के विवरण को संग्रहीत करती है
+- `url` - एक स्ट्रिंग जो NFT की डिजिटल संपत्ति का एक लिंक है
+
+स्थिति चर के बाद, आप तीन गैर-कार्यान्वित फ़ंक्शन देखेंगे: `useEffect`, `connectWalletPressed`, और `onMintPressed`। आप देखेंगे कि ये सभी फ़ंक्शन `async` हैं, ऐसा इसलिए है क्योंकि हम उनमें एसिंक्रोनस API कॉल करेंगे! उनके नाम उनकी कार्यात्मकताओं के साथ समानार्थक हैं:
+
+```javascript
+useEffect(async () => {
+ //TODO: लागू करें
+}, [])
+
+const connectWalletPressed = async () => {
+ //TODO: लागू करें
+}
+
+const onMintPressed = async () => {
+ //TODO: लागू करें
+}
+```
+
+- [`useEffect`](https://legacy.reactjs.org/docs/hooks-effect.html) - यह एक React हुक है जिसे आपका घटक रेंडर होने के बाद कॉल किया जाता है। क्योंकि इसमें एक खाली ऐरे `[]` प्रोप पास किया गया है (लाइन 3 देखें), इसे केवल घटक के _पहले_ रेंडर पर कॉल किया जाएगा। यहां हम अपने वॉलेट श्रोता और एक अन्य वॉलेट फ़ंक्शन को अपने UI को अपडेट करने के लिए कॉल करेंगे ताकि यह प्रतिबिंबित हो सके कि वॉलेट पहले से जुड़ा हुआ है या नहीं।
+- `connectWalletPressed` - इस फ़ंक्शन को यूज़र के MetaMask वॉलेट को हमारे डैप से जोड़ने के लिए कॉल किया जाएगा।
+- `onMintPressed` - यह फ़ंक्शन यूज़र के NFT को मिंट करने के लिए कॉल किया जाएगा।
+
+इस फ़ाइल के अंत के पास, हमारे पास हमारे घटक का UI है। यदि आप इस कोड को ध्यान से स्कैन करते हैं, तो आप देखेंगे कि जब उनके संबंधित टेक्स्ट फ़ील्ड में इनपुट बदलता है तो हम अपने `url`, `name`, और `description` स्थिति चर को अपडेट करते हैं।
+
+आप यह भी देखेंगे कि `connectWalletPressed` और `onMintPressed` को क्रमशः `mintButton` और `walletButton` ID वाले बटन पर क्लिक किए जाने पर कॉल किया जाता है।
+
+```javascript
+//हमारे घटक का UI
+return (
+
+
+
+
+ 🧙♂️ Alchemy NFT मिन्टर
+
+ बस अपनी संपत्ति का लिंक, नाम और विवरण जोड़ें, फिर \"मिंट\" दबाएँ।
+
+
+
+ {status}
+
+)
+```
+
+अंत में, चलिए देखते हैं कि यह मिन्टर घटक कहाँ जोड़ा गया है।
+
+यदि आप `App.js` फ़ाइल पर जाते हैं, जो React में मुख्य घटक है जो अन्य सभी घटकों के लिए एक कंटेनर के रूप में कार्य करता है, तो आप देखेंगे कि हमारा मिन्टर घटक लाइन 7 पर इंजेक्ट किया गया है।
+
+**इस ट्यूटोरियल में, हम केवल `Minter.js फ़ाइल` का संपादन करेंगे और हमारी `src` फ़ोल्डर में फ़ाइलें जोड़ेंगे।**
+
+अब जब हम समझ गए हैं कि हम किसके साथ काम कर रहे हैं, तो चलिए अपना एथेरियम वॉलेट सेट अप करें!
+
+## अपना एथेरियम वॉलेट सेट अप करें {#set-up-your-ethereum-wallet}
+
+यूज़र्स को आपके स्मार्ट अनुबंध के साथ इंटरैक्ट करने में सक्षम होने के लिए, उन्हें अपने एथेरियम वॉलेट को आपके डैप से कनेक्ट करने की आवश्यकता होगी।
+
+### MetaMask डाउनलोड करें {#download-metamask}
+
+इस ट्यूटोरियल के लिए, हम MetaMask का उपयोग करेंगे, जो ब्राउज़र में एक वर्चुअल वॉलेट है जिसका उपयोग आपके एथेरियम खाते के पते को प्रबंधित करने के लिए किया जाता है। यदि आप एथेरियम पर लेनदेन कैसे काम करते हैं, इसके बारे में और समझना चाहते हैं, तो [इस पृष्ठ](/developers/docs/transactions/) को देखें।
+
+आप [यहां](https://metamask.io/download) मुफ्त में MetaMask खाता डाउनलोड और बना सकते हैं। जब आप एक खाता बना रहे हों, या यदि आपके पास पहले से ही एक खाता है, तो ऊपरी दाएँ कोने में “Ropsten टेस्ट नेटवर्क” पर स्विच करना सुनिश्चित करें (ताकि हम वास्तविक धन के साथ काम न करें)।
+
+### एक फोसेट से ईथर जोड़ें {#add-ether-from-faucet}
+
+हमारे NFTs को मिंट करने के लिए (या एथेरियम ब्लॉकचेन पर किसी भी लेनदेन पर हस्ताक्षर करने के लिए), हमें कुछ नकली Eth की आवश्यकता होगी। Eth प्राप्त करने के लिए आप [Ropsten फोसेट](https://faucet.ropsten.be/) पर जा सकते हैं और अपना Ropsten खाता पता दर्ज कर सकते हैं, फिर “Send Ropsten Eth” पर क्लिक करें। आपको जल्द ही अपने MetaMask खाते में Eth दिखना चाहिए!
+
+### अपना बैलेंस जांचें {#check-your-balance}
+
+यह सुनिश्चित करने के लिए कि हमारा बैलेंस वहाँ है, चलिए [Alchemy के कंपोजर टूल](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D) का उपयोग करके एक [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) अनुरोध करें। यह हमारे वॉलेट में Eth की मात्रा लौटाएगा। जब आप अपना MetaMask खाता पता इनपुट करते हैं और "Send Request" पर क्लिक करते हैं, तो आपको इस तरह का एक जवाब देखना चाहिए:
+
+```text
+{\"jsonrpc\": \"2.0\", \"id\": 0, \"result\": \"0xde0b6b3a7640000\"}
+```
+
+**ध्यान दें:** यह परिणाम eth में नहीं, wei में है। Wei का उपयोग ईथर के सबसे छोटे मूल्यवर्ग के रूप में किया जाता है। wei से eth में रूपांतरण है: 1 eth = 10¹⁸ wei। तो अगर हम 0xde0b6b3a7640000 को दशमलव में बदलते हैं तो हमें 1\*10¹⁸ मिलता है जो 1 eth के बराबर है।
+
+उफ्फ! हमारा नकली पैसा सब वहाँ है!
+ {" "}
+ 🦊
+ आपको अपने ब्राउज़र में MetaMask, एक वर्चुअल एथेरियम वॉलेट, इंस्टॉल करना होगा।
+
+
+
+ ),
+ }
+ }
+}
+```
+
+चलिए देखते हैं कि यह कोड क्या करता है:
+
+सबसे पहले, हमारा फ़ंक्शन जांचता है कि आपके ब्राउज़र में `window.ethereum` सक्षम है या नहीं।
+
+`window.ethereum` MetaMask और अन्य वॉलेट प्रदाताओं द्वारा इंजेक्ट किया गया एक वैश्विक API है जो वेबसाइटों को यूज़र्स के एथेरियम खातों का अनुरोध करने की अनुमति देता है। यदि अनुमोदित हो, तो यह उन ब्लॉकचेन से डेटा पढ़ सकता है जिनसे यूज़र जुड़ा हुआ है, और यूज़र को संदेशों और लेनदेन पर हस्ताक्षर करने का सुझाव दे सकता है। अधिक जानकारी के लिए [MetaMask दस्तावेज़](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) देखें!
+
+यदि `window.ethereum` मौजूद _नहीं_ है, तो इसका मतलब है कि MetaMask इंस्टॉल नहीं है। इसके परिणामस्वरूप एक JSON ऑब्जेक्ट वापस कर दिया जाता है, जहाँ लौटाया गया `address` एक खाली स्ट्रिंग है, और `status` JSX ऑब्जेक्ट यह बताता है कि यूज़र को MetaMask इंस्टॉल करना होगा।
+
+**हमारे द्वारा लिखे गए अधिकांश फ़ंक्शन JSON ऑब्जेक्ट लौटा रहे होंगे जिनका उपयोग हम अपने स्थिति चर और UI को अपडेट करने के लिए कर सकते हैं।**
+
+अब यदि `window.ethereum` मौजूद _है_, तो चीजें दिलचस्प हो जाती हैं।
+
+एक try/catch लूप का उपयोग करके, हम [`window.ethereum.request({ method: \"eth_requestAccounts\" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts) को कॉल करके MetaMask से कनेक्ट करने का प्रयास करेंगे। इस फ़ंक्शन को कॉल करने से ब्राउज़र में MetaMask खुल जाएगा, जिससे यूज़र को अपने वॉलेट को आपके डैप से कनेक्ट करने के लिए प्रेरित किया जाएगा।
+
+- यदि यूज़र कनेक्ट करना चुनता है, तो `method: \"eth_requestAccounts\"` एक ऐरे लौटाएगा जिसमें यूज़र के सभी खाता पते शामिल होंगे जो डैप से जुड़े हैं। कुल मिलाकर, हमारा `connectWallet` फ़ंक्शन एक JSON ऑब्जेक्ट लौटाएगा जिसमें इस ऐरे में _पहला_ `पता` (पंक्ति 9 देखें) और एक `स्थिति` संदेश होगा जो यूज़र को स्मार्ट अनुबंध को एक संदेश लिखने के लिए प्रेरित करता है।
+- यदि यूज़र कनेक्शन को अस्वीकार कर देता है, तो JSON ऑब्जेक्ट में लौटाए गए `पते` के लिए एक खाली स्ट्रिंग और एक `स्थिति` संदेश होगा जो यह दर्शाता है कि यूज़र ने कनेक्शन को अस्वीकार कर दिया है।
+
+### अपने Minter.js UI घटक में connectWallet फ़ंक्शन जोड़ें {#add-connect-wallet}
+
+अब जब हमने यह `connectWallet` फ़ंक्शन लिख लिया है, तो चलिए इसे अपने `Minter.js.` घटक से कनेक्ट करते हैं।
+
+सबसे पहले, हमें अपने फ़ंक्शन को अपनी `Minter.js` फ़ाइल में `import { connectWallet } from "./utils/interact.js";` को `Minter.js` फ़ाइल के शीर्ष पर जोड़कर आयात करना होगा। आपकी `Minter.js` की पहली 11 पंक्तियाँ अब इस तरह दिखनी चाहिए:
+
+```javascript
+import { useEffect, useState } from "react";
+import { connectWallet } from "./utils/interact.js";
+
+const Minter = (props) => {
+
+ //स्थिति चर
+ const [walletAddress, setWallet] = useState("");
+ const [status, setStatus] = useState("");
+ const [name, setName] = useState("");
+ const [description, setDescription] = useState("");
+ const [url, setURL] = useState("");
+```
+
+फिर, हमारे `connectWalletPressed` फ़ंक्शन के अंदर, हम अपने आयातित `connectWallet` फ़ंक्शन को कॉल करेंगे, जैसे:
+
+```javascript
+const connectWalletPressed = async () => {
+ const walletResponse = await connectWallet()
+ setStatus(walletResponse.status)
+ setWallet(walletResponse.address)
+}
+```
+
+ध्यान दें कि हमारी अधिकांश कार्यक्षमता `interact.js` फ़ाइल से हमारे `Minter.js` घटक से कैसे अमूर्त है? यह इसलिए है ताकि हम M-V-C प्रतिमान का अनुपालन करें!
+
+`connectWalletPressed` में, हम बस अपने आयातित `connectWallet` फ़ंक्शन को एक await कॉल करते हैं, और इसकी प्रतिक्रिया का उपयोग करके, हम अपने `status` और `walletAddress` चर को उनके स्थिति हुक के माध्यम से अपडेट करते हैं।
+
+अब, चलिए दोनों फाइलों `Minter.js` और `interact.js` को सहेजते हैं और अब तक हमारे UI का परीक्षण करते हैं।
+
+localhost:3000 पर अपना ब्राउज़र खोलें, और पृष्ठ के ऊपरी दाएँ कोने में \"वॉलेट कनेक्ट करें\" बटन दबाएँ।
+
+यदि आपने MetaMask इंस्टॉल किया है, तो आपको अपने वॉलेट को अपने डैप से कनेक्ट करने के लिए प्रेरित किया जाना चाहिए। कनेक्ट करने के लिए निमंत्रण स्वीकार करें।
+
+आपको देखना चाहिए कि वॉलेट बटन अब यह दर्शाता है कि आपका पता जुड़ा हुआ है।
+
+अगला, पृष्ठ को रीफ्रेश करने का प्रयास करें... यह अजीब है। हमारा वॉलेट बटन हमें MetaMask से कनेक्ट करने के लिए कह रहा है, भले ही यह पहले से ही जुड़ा हुआ है...
+
+चिंता न करें! हम इसे आसानी से `getCurrentWalletConnected` नामक एक फ़ंक्शन लागू करके ठीक कर सकते हैं, जो यह जांचेगा कि क्या कोई पता पहले से ही हमारे डैप से जुड़ा हुआ है और तदनुसार हमारे UI को अपडेट करेगा!
+
+### getCurrentWalletConnected फ़ंक्शन {#get-current-wallet}
+
+अपनी `interact.js` फ़ाइल में, निम्नलिखित `getCurrentWalletConnected` फ़ंक्शन जोड़ें:
+
+```javascript
+export const getCurrentWalletConnected = async () => {
+ if (window.ethereum) {
+ try {
+ const addressArray = await window.ethereum.request({
+ method: "eth_accounts",
+ })
+ if (addressArray.length > 0) {
+ return {
+ address: addressArray[0],
+ status: "👆🏽 ऊपर टेक्स्ट-फील्ड में एक संदेश लिखें।",
+ }
+ } else {
+ return {
+ address: "",
+ status: "🦊 ऊपरी दाएँ बटन का उपयोग करके MetaMask से कनेक्ट करें।",
+ }
+ }
+ } catch (err) {
+ return {
+ address: "",
+ status: "😥 " + err.message,
+ }
+ }
+ } else {
+ return {
+ address: "",
+ status: (
+
+
+ {" "}
+ 🦊
+ आपको अपने ब्राउज़र में MetaMask, एक वर्चुअल एथेरियम वॉलेट, इंस्टॉल करना होगा।
+
+
+
+ ),
+ }
+ }
+}
+```
+
+यह कोड उस `connectWallet` फ़ंक्शन के _बहुत_ समान है जिसे हमने अभी-अभी लिखा है।
+
+मुख्य अंतर यह है कि `eth_requestAccounts` विधि को कॉल करने के बजाय, जो यूज़र को अपने वॉलेट को कनेक्ट करने के लिए MetaMask खोलता है, यहाँ हम `eth_accounts` विधि को कॉल करते हैं, जो बस एक ऐरे लौटाता है जिसमें वर्तमान में हमारे डैप से जुड़े MetaMask पते होते हैं।
+
+इस फ़ंक्शन को क्रिया में देखने के लिए, चलिए इसे अपने `Minter.js` घटक के `useEffect` फ़ंक्शन में कॉल करते हैं।
+
+जैसे हमने `connectWallet` के लिए किया था, हमें इस फ़ंक्शन को अपनी `interact.js` फ़ाइल से अपनी `Minter.js` फ़ाइल में आयात करना होगा:
+
+```javascript
+import { useEffect, useState } from "react"
+import {
+ connectWallet,
+ getCurrentWalletConnected, //यहां आयात करें
+} from "./utils/interact.js"
+```
+
+अब, हम इसे बस अपने `useEffect` फ़ंक्शन में कॉल करते हैं:
+
+```javascript
+useEffect(async () => {
+ const { address, status } = await getCurrentWalletConnected()
+ setWallet(address)
+ setStatus(status)
+}, [])
+```
+
+ध्यान दें, हम अपने `walletAddress` और `status` स्थिति चर को अपडेट करने के लिए `getCurrentWalletConnected` पर हमारी कॉल की प्रतिक्रिया का उपयोग करते हैं।
+
+एक बार जब आप यह कोड जोड़ लेते हैं, तो हमारी ब्राउज़र विंडो को रीफ्रेश करने का प्रयास करें। बटन को कहना चाहिए कि आप जुड़े हुए हैं, और अपने जुड़े हुए वॉलेट के पते का पूर्वावलोकन दिखाएं - भले ही आप रीफ्रेश करें!
+
+### addWalletListener लागू करें {#implement-add-wallet-listener}
+
+हमारे डैप वॉलेट सेटअप में अंतिम चरण वॉलेट श्रोता को लागू करना है ताकि हमारा UI तब अपडेट हो जब हमारे वॉलेट की स्थिति बदल जाए, जैसे कि जब यूज़र डिस्कनेक्ट हो जाता है या खाते बदलता है।
+
+अपनी `Minter.js` फ़ाइल में, एक फ़ंक्शन `addWalletListener` जोड़ें जो निम्न जैसा दिखता है:
+
+```javascript
+function addWalletListener() {
+ if (window.ethereum) {
+ window.ethereum.on("accountsChanged", (accounts) => {
+ if (accounts.length > 0) {
+ setWallet(accounts[0])
+ setStatus("👆🏽 ऊपर टेक्स्ट-फील्ड में एक संदेश लिखें।")
+ } else {
+ setWallet("")
+ setStatus("🦊 ऊपरी दाएँ बटन का उपयोग करके MetaMask से कनेक्ट करें।")
+ }
+ })
+ } else {
+ setStatus(
+
+ {" "}
+ 🦊
+ आपको अपने ब्राउज़र में MetaMask, एक वर्चुअल एथेरियम वॉलेट, इंस्टॉल करना होगा।
+
+
+ )
+ }
+}
+```
+
+आइए जल्दी से देखें कि यहाँ क्या हो रहा है:
+
+- सबसे पहले, हमारा फ़ंक्शन जांचता है कि क्या `window.ethereum` सक्षम है (यानी, MetaMask इंस्टॉल है)।
+ - यदि यह नहीं है, तो हम बस अपने `status` स्थिति चर को एक JSX स्ट्रिंग पर सेट करते हैं जो यूज़र को MetaMask इंस्टॉल करने के लिए प्रेरित करता है।
+ - यदि यह सक्षम है, तो हम श्रोता `window.ethereum.on("accountsChanged")` को लाइन 3 पर सेट करते हैं जो MetaMask वॉलेट में स्थिति परिवर्तनों को सुनता है, जिसमें जब यूज़र डैप में एक अतिरिक्त खाता जोड़ता है, खाते बदलता है, या एक खाता डिस्कनेक्ट करता है। यदि कम से कम एक खाता जुड़ा हुआ है, तो `walletAddress` स्थिति चर को श्रोता द्वारा लौटाए गए `accounts` ऐरे में पहले खाते के रूप में अपडेट किया जाता है। अन्यथा, `walletAddress` को एक खाली स्ट्रिंग के रूप में सेट किया जाता है।
+
+अंत में, हमें इसे अपने `useEffect` फ़ंक्शन में कॉल करना होगा:
+
+```javascript
+useEffect(async () => {
+ const { address, status } = await getCurrentWalletConnected()
+ setWallet(address)
+ setStatus(status)
+
+ addWalletListener()
+}, [])
+```
+
+और वोइला! हमने अपनी सभी वॉलेट कार्यक्षमता को प्रोग्राम करना पूरा कर लिया है! अब जब हमारा वॉलेट सेट हो गया है, तो चलिए पता लगाते हैं कि अपने NFT को कैसे मिंट करें!
+
+## NFT मेटाडेटा 101 {#nft-metadata-101}
+
+तो याद रखें NFT मेटाडेटा जिसके बारे में हमने इस ट्यूटोरियल के चरण 0 में बात की थी—यह एक NFT को जीवंत करता है, जिससे इसमें डिजिटल संपत्ति, नाम, विवरण और अन्य विशेषताओं जैसे गुण होते हैं।
+
+हमें इस मेटाडेटा को एक JSON ऑब्जेक्ट के रूप में कॉन्फ़िगर करने और इसे संग्रहीत करने की आवश्यकता होगी, ताकि हम इसे अपने स्मार्ट अनुबंध के `mintNFT` फ़ंक्शन को कॉल करते समय `tokenURI` पैरामीटर के रूप में पास कर सकें।
+
+\"संपत्ति का लिंक\", \"नाम\", \"विवरण\" फ़ील्ड में पाठ हमारे NFT के मेटाडेटा के विभिन्न गुणों का निर्माण करेगा। हम इस मेटाडेटा को JSON ऑब्जेक्ट के रूप में प्रारूपित करेंगे, लेकिन इस JSON ऑब्जेक्ट को हम कहाँ संग्रहीत कर सकते हैं, इसके लिए कुछ विकल्प हैं:
+
+- हम इसे एथेरियम ब्लॉकचेन पर संग्रहीत कर सकते हैं; हालाँकि, ऐसा करना बहुत महंगा होगा।
+- हम इसे एक केंद्रीकृत सर्वर, जैसे AWS या Firebase पर संग्रहीत कर सकते हैं। लेकिन यह हमारे विकेंद्रीकरण लोकाचार को हरा देगा।
+- हम IPFS का उपयोग कर सकते हैं, जो एक विकेन्द्रीकृत प्रोटोकॉल और पीयर-टू-पीयर नेटवर्क है जो एक वितरित फ़ाइल सिस्टम में डेटा को संग्रहीत और साझा करने के लिए है। चूंकि यह प्रोटोकॉल विकेन्द्रीकृत और मुफ्त है, यह हमारा सबसे अच्छा विकल्प है!
+
+IPFS पर हमारे मेटाडेटा को संग्रहीत करने के लिए, हम [Pinata](https://pinata.cloud/) का उपयोग करेंगे, जो एक सुविधाजनक IPFS API और टूलकिट है। अगले चरण में, हम ठीक से समझाएंगे कि यह कैसे करना है!
+
+## IPFS पर अपने मेटाडेटा को पिन करने के लिए Pinata का उपयोग करें {#use-pinata-to-pin-your-metadata-to-IPFS}
+
+यदि आपके पास [Pinata](https://pinata.cloud/) खाता नहीं है, तो [यहां](https://app.pinata.cloud/auth/signup) एक निःशुल्क खाते के लिए साइन अप करें और अपने ईमेल और खाते को सत्यापित करने के लिए चरणों को पूरा करें।
+
+### अपनी Pinata API कुंजी बनाएँ {#create-pinata-api-key}
+
+[https://pinata.cloud/keys](https://pinata.cloud/keys) पृष्ठ पर नेविगेट करें, फिर शीर्ष पर \"नई कुंजी\" बटन चुनें, व्यवस्थापक विजेट को सक्षम के रूप में सेट करें, और अपनी कुंजी का नाम दें।
+
+आपको तब आपकी API जानकारी के साथ एक पॉपअप दिखाया जाएगा। इसे कहीं सुरक्षित रखना सुनिश्चित करें।
+
+अब जब हमारी कुंजी सेट हो गई है, तो चलिए इसे हमारे प्रोजेक्ट में जोड़ते हैं ताकि हम इसका उपयोग कर सकें।
+
+### .env फ़ाइल बनाएँ {#create-a-env}
+
+हम अपनी पिनाटा कुंजी और रहस्य को एक पर्यावरण फ़ाइल में सुरक्षित रूप से संग्रहीत कर सकते हैं। चलिए आपके प्रोजेक्ट डायरेक्टरी में [dotenv पैकेज](https://www.npmjs.com/package/dotenv) इंस्टॉल करते हैं।
+
+अपने टर्मिनल में एक नया टैब खोलें (लोकल होस्ट चलाने वाले से अलग) और सुनिश्चित करें कि आप `minter-starter-files` फ़ोल्डर में हैं, फिर अपने टर्मिनल में निम्न कमांड चलाएँ:
+
+```text
+npm install dotenv --save
+```
+
+अगला, अपनी कमांड लाइन पर निम्न दर्ज करके अपनी `minter-starter-files` की रूट डायरेक्टरी में एक `.env` फ़ाइल बनाएँ:
+
+```javascript
+vim.env
+```
+
+यह आपकी `.env` फ़ाइल को vim (एक टेक्स्ट एडिटर) में खोल देगा। इसे सहेजने के लिए अपने कीबोर्ड पर \"esc\" + \":\" + \"q\" को उस क्रम में दबाएँ।
+
+अगला, VSCode में, अपनी `.env` फ़ाइल पर नेविगेट करें और अपनी पिनाटा API कुंजी और API रहस्य को इसमें जोड़ें, जैसे:
+
+```text
+REACT_APP_PINATA_KEY =
+REACT_APP_PINATA_SECRET =
+```
+
+फ़ाइल सहेजें, और फिर आप अपने JSON मेटाडेटा को IPFS पर अपलोड करने के लिए फ़ंक्शन लिखना शुरू करने के लिए तैयार हैं!
+
+### pinJSONToIPFS लागू करें {#pin-json-to-ipfs}
+
+सौभाग्य से, Pinata के पास [IPFS पर JSON डेटा अपलोड करने के लिए विशेष रूप से एक API](https://docs.pinata.cloud/api-reference/endpoint/ipfs/pin-json-to-ipfs#pin-json) है और axios के साथ एक सुविधाजनक JavaScript उदाहरण है जिसका हम कुछ मामूली संशोधनों के साथ उपयोग कर सकते हैं।
+
+अपनी `utils` फ़ोल्डर में, चलिए `pinata.js` नामक एक और फ़ाइल बनाते हैं और फिर .env फ़ाइल से अपने Pinata रहस्य और कुंजी को इस तरह आयात करते हैं:
+
+```javascript
+require("dotenv").config()
+const key = process.env.REACT_APP_PINATA_KEY
+const secret = process.env.REACT_APP_PINATA_SECRET
+```
+
+अगला, नीचे से अतिरिक्त कोड को अपनी `pinata.js` फ़ाइल में पेस्ट करें। चिंता न करें, हम सब कुछ का मतलब समझाएंगे!
+
+```javascript
+require("dotenv").config()
+const key = process.env.REACT_APP_PINATA_KEY
+const secret = process.env.REACT_APP_PINATA_SECRET
+
+const axios = require("axios")
+
+export const pinJSONToIPFS = async (JSONBody) => {
+ const url = `https://api.pinata.cloud/pinning/pinJSONToIPFS`
+ //axios पोस्ट अनुरोध को पिनाटा को करना ⬇️
+ return axios
+ .post(url, JSONBody, {
+ headers: {
+ pinata_api_key: key,
+ pinata_secret_api_key: secret,
+ },
+ })
+ .then(function (response) {
+ return {
+ success: true,
+ pinataUrl:
+ "https://gateway.pinata.cloud/ipfs/" + response.data.IpfsHash,
+ }
+ })
+ .catch(function (error) {
+ console.log(error)
+ return {
+ success: false,
+ message: error.message,
+ }
+ })
+}
+```
+
+तो यह कोड वास्तव में क्या करता है?
+
+सबसे पहले, यह [axios](https://www.npmjs.com/package/axios) को आयात करता है, जो ब्राउज़र और node.js के लिए एक वादा आधारित HTTP क्लाइंट है, जिसका उपयोग हम पिनाटा से अनुरोध करने के लिए करेंगे।
+
+फिर हमारे पास हमारा एसिंक्रोनस फ़ंक्शन `pinJSONToIPFS` है, जो अपने इनपुट के रूप में एक `JSONBody` और अपने हेडर में पिनाटा एपीआई कुंजी और रहस्य लेता है, यह सब उनके `pinJSONToIPFS` API को पोस्ट अनुरोध करने के लिए है।
+
+- यदि यह POST अनुरोध सफल होता है, तो हमारा फ़ंक्शन एक JSON ऑब्जेक्ट लौटाता है जिसमें `success` बूलियन सत्य होता है और `pinataUrl` जहाँ हमारा मेटाडेटा पिन किया गया था। हम इस `pinataUrl` को अपने स्मार्ट अनुबंध के मिंट फ़ंक्शन के लिए `tokenURI` इनपुट के रूप में उपयोग करेंगे।
+- यदि यह पोस्ट अनुरोध विफल हो जाता है, तो हमारा फ़ंक्शन एक JSON ऑब्जेक्ट लौटाता है जिसमें `success` बूलियन झूठा होता है और एक `message` स्ट्रिंग जो हमारी त्रुटि को बताती है।
+
+हमारे `connectWallet` फ़ंक्शन रिटर्न प्रकारों की तरह, हम JSON ऑब्जेक्ट लौटा रहे हैं ताकि हम अपने स्थिति चर और UI को अपडेट करने के लिए उनके मापदंडों का उपयोग कर सकें।
+
+## अपना स्मार्ट अनुबंध लोड करें {#load-your-smart-contract}
+
+अब जब हमारे पास हमारे NFT मेटाडेटा को IPFS पर `pinJSONToIPFS` फ़ंक्शन के माध्यम से अपलोड करने का एक तरीका है, तो हमें अपने स्मार्ट अनुबंध का एक उदाहरण लोड करने का एक तरीका चाहिए होगा ताकि हम इसके `mintNFT` फ़ंक्शन को कॉल कर सकें।
+
+जैसा कि हमने पहले उल्लेख किया है, इस ट्यूटोरियल में हम [इस मौजूदा NFT स्मार्ट अनुबंध](https://ropsten.etherscan.io/address/0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE) का उपयोग करेंगे; हालाँकि, यदि आप यह जानना चाहते हैं कि हमने इसे कैसे बनाया, या खुद एक बनाना चाहते हैं, तो हम आपको हमारे दूसरे ट्यूटोरियल, [\"एक NFT कैसे बनाएँ\"](https://www.alchemy.com/docs/how-to-create-an-nft) को देखने की अत्यधिक अनुशंसा करते हैं।
+
+### अनुबंध ABI {#contract-abi}
+
+यदि आपने हमारी फाइलों को ध्यान से देखा है, तो आपने देखा होगा कि हमारी `src` डायरेक्टरी में एक `contract-abi.json` फ़ाइल है। एक ABI यह निर्दिष्ट करने के लिए आवश्यक है कि कोई अनुबंध किस फ़ंक्शन को लागू करेगा और यह भी सुनिश्चित करेगा कि फ़ंक्शन आपके द्वारा अपेक्षित प्रारूप में डेटा लौटाएगा।
+
+हमें एथेरियम ब्लॉकचेन से कनेक्ट करने और हमारे स्मार्ट अनुबंध को लोड करने के लिए एक Alchemy API कुंजी और Alchemy Web3 API की भी आवश्यकता होगी।
+
+### अपनी Alchemy API कुंजी बनाएँ {#create-alchemy-api}
+
+यदि आपके पास पहले से Alchemy खाता नहीं है, तो [यहां निःशुल्क साइन अप करें।](https://alchemy.com/?a=eth-org-nft-minter)
+
+एक बार जब आप एक Alchemy खाता बना लेते हैं, तो आप एक ऐप बनाकर एक API कुंजी उत्पन्न कर सकते हैं। यह हमें Ropsten टेस्ट नेटवर्क पर अनुरोध करने की अनुमति देगा।
+
+अपने Alchemy डैशबोर्ड में “ऐप बनाएँ” पृष्ठ पर जाएँ, नव बार में “ऐप्स” पर होवर करके और “ऐप बनाएँ” पर क्लिक करके।
+
+अपने ऐप को नाम दें, हमने \"मेरा पहला NFT!\" चुना, एक संक्षिप्त विवरण प्रदान करें, अपने ऐप की बहीखाता पद्धति के लिए उपयोग किए जाने वाले पर्यावरण के लिए “स्टेजिंग” चुनें, और अपने नेटवर्क के लिए “Ropsten” चुनें।
+
+“Create app” पर क्लिक करें और बस हो गया! आपका ऐप नीचे दी गई तालिका में दिखाई देना चाहिए।
+
+बहुत बढ़िया, तो अब जब हमने अपना HTTP Alchemy API URL बना लिया है, तो इसे अपने क्लिपबोर्ड पर कॉपी करें...
+
+...और फिर चलिए इसे अपनी `.env` फ़ाइल में जोड़ते हैं। कुल मिलाकर, आपकी .env फ़ाइल इस तरह दिखनी चाहिए:
+
+```text
+REACT_APP_PINATA_KEY =
+REACT_APP_PINATA_SECRET =
+REACT_APP_ALCHEMY_KEY = https://eth-ropsten.alchemyapi.io/v2/
+```
+
+अब जब हमारे पास हमारा अनुबंध ABI और हमारी Alchemy API कुंजी है, तो हम [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) का उपयोग करके अपना स्मार्ट अनुबंध लोड करने के लिए तैयार हैं।
+
+### अपना Alchemy Web3 एंडपॉइंट और अनुबंध सेट अप करें {#setup-alchemy-endpoint}
+
+सबसे पहले, यदि आपके पास यह पहले से नहीं है, तो आपको टर्मिनल में होम डायरेक्टरी `nft-minter-tutorial` पर नेविगेट करके [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) इंस्टॉल करना होगा:
+
+```text
+cd ..
+npm install @alch/alchemy-web3
+```
+
+अगला, चलिए हमारी `interact.js` फ़ाइल पर वापस जाते हैं। फ़ाइल के शीर्ष पर, अपनी .env फ़ाइल से अपनी Alchemy कुंजी आयात करने और अपना Alchemy Web3 एंडपॉइंट सेट करने के लिए निम्न कोड जोड़ें:
+
+```javascript
+require("dotenv").config()
+const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(alchemyKey)
+```
+
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) [Web3.js](https://docs.web3js.org/) के चारों ओर एक रैपर है, जो उन्नत API विधियों और अन्य महत्वपूर्ण लाभ प्रदान करता है ताकि आपका जीवन एक web3 डेवलपर के रूप में आसान हो सके। इसे न्यूनतम कॉन्फ़िगरेशन की आवश्यकता के लिए डिज़ाइन किया गया है ताकि आप इसे अपने ऐप में तुरंत उपयोग करना शुरू कर सकें!
+
+अगला, चलिए हमारे अनुबंध ABI और अनुबंध पते को हमारी फ़ाइल में जोड़ते हैं।
+
+```javascript
+require("dotenv").config()
+const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY
+const { createAlchemyWeb3 } = require("@alch/alchemy-web3")
+const web3 = createAlchemyWeb3(alchemyKey)
+
+const contractABI = require("../contract-abi.json")
+const contractAddress = "0x4C4a07F737Bf57F6632B6CAB089B78f62385aCaE"
+```
+
+एक बार जब हमारे पास वे दोनों हो जाते हैं, तो हम अपना मिंट फ़ंक्शन कोडिंग शुरू करने के लिए तैयार हैं!
+
+## mintNFT फ़ंक्शन लागू करें {#implement-the-mintnft-function}
+
+अपनी `interact.js` फ़ाइल के अंदर, चलिए हमारे फ़ंक्शन, `mintNFT` को परिभाषित करते हैं, जो समान रूप से हमारे NFT को मिंट करेगा।
+
+क्योंकि हम कई एसिंक्रोनस कॉल करेंगे (पिनाटा को हमारे मेटाडेटा को IPFS पर पिन करने के लिए, Alchemy Web3 को हमारे स्मार्ट अनुबंध को लोड करने के लिए, और MetaMask को हमारे लेनदेन पर हस्ताक्षर करने के लिए), हमारा फ़ंक्शन भी एसिंक्रोनस होगा।
+
+हमारे फ़ंक्शन के तीन इनपुट हमारी डिजिटल संपत्ति का `url`, `नाम` और `विवरण` होंगे। `connectWallet` फ़ंक्शन के नीचे निम्न फ़ंक्शन हस्ताक्षर जोड़ें:
+
+```javascript
+export const mintNFT = async (url, name, description) => {}
+```
+
+### इनपुट त्रुटि हैंडलिंग {#input-error-handling}
+
+स्वाभाविक रूप से, फ़ंक्शन की शुरुआत में किसी प्रकार का इनपुट त्रुटि हैंडलिंग होना समझ में आता है, इसलिए यदि हमारे इनपुट पैरामीटर सही नहीं हैं तो हम इस फ़ंक्शन से बाहर निकल जाते हैं। हमारे फ़ंक्शन के अंदर, चलिए निम्न कोड जोड़ते हैं:
+
+```javascript
+export const mintNFT = async (url, name, description) => {
+ //त्रुटि हैंडलिंग
+ if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
+ return {
+ success: false,
+ status: "❗कृपया सुनिश्चित करें कि मिंटिंग से पहले सभी फ़ील्ड पूरे हो गए हैं।",
+ }
+ }
+}
+```
+
+अनिवार्य रूप से, यदि कोई भी इनपुट पैरामीटर एक खाली स्ट्रिंग है, तो हम एक JSON ऑब्जेक्ट लौटाते हैं जहाँ `success` बूलियन झूठा है, और `status` स्ट्रिंग यह बताती है कि हमारे UI में सभी फ़ील्ड पूरे होने चाहिए।
+
+### मेटाडेटा को IPFS पर अपलोड करें {#upload-metadata-to-ipfs}
+
+एक बार जब हम जान जाते हैं कि हमारा मेटाडेटा ठीक से स्वरूपित है, तो अगला कदम इसे एक JSON ऑब्जेक्ट में लपेटना और इसे IPFS पर `pinJSONToIPFS` के माध्यम से अपलोड करना है जिसे हमने लिखा था!
+
+ऐसा करने के लिए, हमें पहले `pinJSONToIPFS` फ़ंक्शन को अपनी `interact.js` फ़ाइल में आयात करना होगा। `interact.js` के बिल्कुल शीर्ष पर, चलिए जोड़ते हैं:
+
+```javascript
+import { pinJSONToIPFS } from "./pinata.js"
+```
+
+याद रखें कि `pinJSONToIPFS` एक JSON बॉडी लेता है। तो इससे पहले कि हम इसे कॉल करें, हमें अपने `url`, `नाम` और `विवरण` मापदंडों को एक JSON ऑब्जेक्ट में प्रारूपित करना होगा।
+
+चलिए हमारे कोड को `metadata` नामक एक JSON ऑब्जेक्ट बनाने के लिए अपडेट करते हैं और फिर इस `metadata` पैरामीटर के साथ `pinJSONToIPFS` को कॉल करते हैं:
+
+```javascript
+export const mintNFT = async (url, name, description) => {
+ //त्रुटि हैंडलिंग
+ if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
+ return {
+ success: false,
+ status: "❗कृपया सुनिश्चित करें कि मिंटिंग से पहले सभी फ़ील्ड पूरे हो गए हैं।",
+ }
+ }
+
+ //मेटाडेटा बनाएँ
+ const metadata = new Object()
+ metadata.name = name
+ metadata.image = url
+ metadata.description = description
+
+ //पिनाटा कॉल करें
+ const pinataResponse = await pinJSONToIPFS(metadata)
+ if (!pinataResponse.success) {
+ return {
+ success: false,
+ status: "😢 आपके tokenURI को अपलोड करते समय कुछ गलत हो गया।",
+ }
+ }
+ const tokenURI = pinataResponse.pinataUrl
+}
+```
+
+ध्यान दें, हम `pinataResponse` ऑब्जेक्ट में `pinJSONToIPFS(metadata)` पर हमारी कॉल की प्रतिक्रिया को संग्रहीत करते हैं। फिर, हम किसी भी त्रुटि के लिए इस ऑब्जेक्ट को पार्स करते हैं।
+
+यदि कोई त्रुटि है, तो हम एक JSON ऑब्जेक्ट लौटाते हैं जहाँ `success` बूलियन झूठा है और हमारी `status` स्ट्रिंग यह बताती है कि हमारी कॉल विफल हो गई है। अन्यथा, हम `pinataResponse` से `pinataURL` निकालते हैं और इसे हमारे `tokenURI` चर के रूप में संग्रहीत करते हैं।
+
+अब हमारे स्मार्ट अनुबंध को Alchemy Web3 API का उपयोग करके लोड करने का समय है जिसे हमने अपनी फ़ाइल के शीर्ष पर प्रारंभ किया था। `window.contract` ग्लोबल वैरिएबल पर अनुबंध को सेट करने के लिए `mintNFT` फ़ंक्शन के नीचे कोड की निम्न पंक्ति जोड़ें:
+
+```javascript
+window.contract = await new web3.eth.Contract(contractABI, contractAddress)
+```
+
+हमारे `mintNFT` फ़ंक्शन में जोड़ने वाली आखिरी चीज़ हमारा एथेरियम लेनदेन है:
+
+```javascript
+//अपना एथेरियम लेनदेन सेट करें
+const transactionParameters = {
+ to: contractAddress, // अनुबंध प्रकाशनों के दौरान को छोड़कर आवश्यक।
+ from: window.ethereum.selectedAddress, // यूज़र के सक्रिय पते से मेल खाना चाहिए।
+ data: window.contract.methods
+ .mintNFT(window.ethereum.selectedAddress, tokenURI)
+ .encodeABI(), //NFT स्मार्ट अनुबंध को कॉल करें
+}
+
+//MetaMask के माध्यम से लेनदेन पर हस्ताक्षर करें
+try {
+ const txHash = await window.ethereum.request({
+ method: "eth_sendTransaction",
+ params: [transactionParameters],
+ })
+ return {
+ success: true,
+ status:
+ "✅ Etherscan पर अपने लेनदेन की जाँच करें: https://ropsten.etherscan.io/tx/" +
+ txHash,
+ }
+} catch (error) {
+ return {
+ success: false,
+ status: "😥 कुछ गलत हो गया: " + error.message,
+ }
+}
+```
+
+यदि आप पहले से ही एथेरियम लेनदेन से परिचित हैं, तो आप देखेंगे कि संरचना आपके द्वारा देखे गए से काफी मिलती-जुलती है।
+
+- सबसे पहले, हम अपने लेनदेन पैरामीटर सेट करते हैं।
+ - `to` प्राप्तकर्ता का पता निर्दिष्ट करता है (हमारा स्मार्ट अनुबंध)
+ - `from` लेनदेन के हस्ताक्षरकर्ता को निर्दिष्ट करता है (यूज़र का MetaMask से जुड़ा पता: `window.ethereum.selectedAddress`)
+ - `data` में हमारे स्मार्ट अनुबंध `mintNFT` विधि को कॉल करना शामिल है, जो हमारे `tokenURI` और यूज़र के वॉलेट पते, `window.ethereum.selectedAddress` को इनपुट के रूप में प्राप्त करता है
+- फिर, हम एक await कॉल करते हैं, `window.ethereum.request,` जहाँ हम MetaMask से लेनदेन पर हस्ताक्षर करने के लिए कहते हैं। ध्यान दें, इस अनुरोध में, हम अपनी eth विधि (eth_SentTransaction) निर्दिष्ट कर रहे हैं और हमारे `transactionParameters` में पास कर रहे हैं। इस बिंदु पर, MetaMask ब्राउज़र में खुल जाएगा, और यूज़र को लेनदेन पर हस्ताक्षर करने या अस्वीकार करने के लिए प्रेरित करेगा।
+ - यदि लेनदेन सफल होता है, तो फ़ंक्शन एक JSON ऑब्जेक्ट लौटाएगा जहाँ बूलियन `success` को सत्य पर सेट किया गया है और `status` स्ट्रिंग यूज़र को उनके लेनदेन के बारे में अधिक जानकारी के लिए Etherscan की जाँच करने के लिए प्रेरित करती है।
+ - यदि लेनदेन विफल हो जाता है, तो फ़ंक्शन एक JSON ऑब्जेक्ट लौटाएगा जहाँ `success` बूलियन को झूठे पर सेट किया गया है, और `status` स्ट्रिंग त्रुटि संदेश बताती है।
+
+कुल मिलाकर, हमारा `mintNFT` फ़ंक्शन इस तरह दिखना चाहिए:
+
+```javascript
+export const mintNFT = async (url, name, description) => {
+ //त्रुटि हैंडलिंग
+ if (url.trim() == "" || name.trim() == "" || description.trim() == "") {
+ return {
+ success: false,
+ status: "❗कृपया सुनिश्चित करें कि मिंटिंग से पहले सभी फ़ील्ड पूरे हो गए हैं।",
+ }
+ }
+
+ //मेटाडेटा बनाएँ
+ const metadata = new Object()
+ metadata.name = name
+ metadata.image = url
+ metadata.description = description
+
+ //पिनाटा पिन अनुरोध
+ const pinataResponse = await pinJSONToIPFS(metadata)
+ if (!pinataResponse.success) {
+ return {
+ success: false,
+ status: "😢 आपके tokenURI को अपलोड करते समय कुछ गलत हो गया।",
+ }
+ }
+ const tokenURI = pinataResponse.pinataUrl
+
+ //स्मार्ट अनुबंध लोड करें
+ window.contract = await new web3.eth.Contract(contractABI, contractAddress) //loadContract();
+
+ //अपना एथेरियम लेनदेन सेट करें
+ const transactionParameters = {
+ to: contractAddress, // अनुबंध प्रकाशनों के दौरान को छोड़कर आवश्यक।
+ from: window.ethereum.selectedAddress, // यूज़र के सक्रिय पते से मेल खाना चाहिए।
+ data: window.contract.methods
+ .mintNFT(window.ethereum.selectedAddress, tokenURI)
+ .encodeABI(), //NFT स्मार्ट अनुबंध को कॉल करें
+ }
+
+ //MetaMask के माध्यम से लेनदेन पर हस्ताक्षर करें
+ try {
+ const txHash = await window.ethereum.request({
+ method: "eth_sendTransaction",
+ params: [transactionParameters],
+ })
+ return {
+ success: true,
+ status:
+ "✅ Etherscan पर अपने लेनदेन की जाँच करें: https://ropsten.etherscan.io/tx/" +
+ txHash,
+ }
+ } catch (error) {
+ return {
+ success: false,
+ status: "😥 कुछ गलत हो गया: " + error.message,
+ }
+ }
+}
+```
+
+यह एक विशाल कार्य है! अब, हमें बस अपने `mintNFT` फ़ंक्शन को हमारे `Minter.js` घटक से कनेक्ट करना है...
+
+## mintNFT को हमारे Minter.js फ्रंटएंड से कनेक्ट करें {#connect-our-frontend}
+
+अपनी `Minter.js` फ़ाइल खोलें और शीर्ष पर `import { connectWallet, getCurrentWalletConnected } from "./utils/interact.js";` लाइन को अपडेट करें:
+
+```javascript
+import {
+ connectWallet,
+ getCurrentWalletConnected,
+ mintNFT,
+} from "./utils/interact.js"
+```
+
+अंत में, अपने आयातित `mintNFT` फ़ंक्शन को await कॉल करने के लिए `onMintPressed` फ़ंक्शन को लागू करें और `status` स्थिति चर को यह दर्शाने के लिए अपडेट करें कि हमारा लेनदेन सफल हुआ या विफल:
+
+```javascript
+const onMintPressed = async () => {
+ const { status } = await mintNFT(url, name, description)
+ setStatus(status)
+}
+```
+
+## अपने NFT को एक लाइव वेबसाइट पर तैनात करें {#deploy-your-NFT}
+
+क्या आप यूज़र्स के साथ इंटरैक्ट करने के लिए अपने प्रोजेक्ट को लाइव करने के लिए तैयार हैं? अपने मिन्टर को लाइव वेबसाइट पर तैनात करने के लिए [इस ट्यूटोरियल](https://docs.alchemy.com/alchemy/tutorials/nft-minter/how-do-i-deploy-nfts-online) को देखें।
+
+एक आखिरी कदम...
+
+## ब्लॉकचेन की दुनिया में तहलका मचा दें {#take-the-blockchain-world-by-storm}
+
+बस मज़ाक कर रहा था, आप ट्यूटोरियल के अंत तक पहुँच गए हैं!
+
+संक्षेप में, एक NFT मिन्टर बनाकर, आपने सफलतापूर्वक सीखा कि:
+
+- अपने फ्रंटएंड प्रोजेक्ट के माध्यम से MetaMask से कनेक्ट करें
+- अपने फ्रंटएंड से स्मार्ट अनुबंध विधियों को कॉल करें
+- MetaMask का उपयोग करके लेनदेन पर हस्ताक्षर करें
+
+संभवतः, आप अपने वॉलेट में अपने डैप के माध्यम से बनाए गए NFTs को दिखाने में सक्षम होना चाहेंगे - इसलिए हमारे त्वरित ट्यूटोरियल [अपने वॉलेट में अपना NFT कैसे देखें](https://www.alchemy.com/docs/how-to-view-your-nft-in-your-mobile-wallet) को देखना सुनिश्चित करें!
+
+और, हमेशा की तरह, यदि आपके कोई प्रश्न हैं, तो हम [Alchemy Discord](https://discord.gg/gWuC7zB) में मदद के लिए यहाँ हैं। हम यह देखने के लिए इंतजार नहीं कर सकते कि आप इस ट्यूटोरियल से अवधारणाओं को अपनी भविष्य की परियोजनाओं पर कैसे लागू करते हैं!
diff --git a/public/content/translations/hi/developers/tutorials/optimism-std-bridge-annotated-code/index.md b/public/content/translations/hi/developers/tutorials/optimism-std-bridge-annotated-code/index.md
new file mode 100644
index 00000000000..b85066496ee
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/optimism-std-bridge-annotated-code/index.md
@@ -0,0 +1,1356 @@
+---
+title: "ऑप्टिमिज्म स्टैंडर्ड ब्रिज कॉन्ट्रैक्ट वॉकथ्रू"
+description: "ऑप्टिमिज्म के लिए स्टैंडर्ड ब्रिज कैसे काम करता है? यह इस तरह से क्यों काम करता है?"
+author: "ओरी पोमेरेन्ट्ज़"
+tags: [ "सोलिडीटी", "ब्रिज", "परत 2" ]
+skill: intermediate
+published: 2022-03-30
+lang: hi
+---
+
+[Optimism](https://www.optimism.io/) एक [ऑप्टिमिस्टिक रोलअप](/developers/docs/scaling/optimistic-rollups/) है।
+ऑप्टिमिस्टिक रोलअप, Ethereum मेननेट (जिसे लेयर 1 या L1 भी कहा जाता है) की तुलना में बहुत कम कीमत पर ट्रांज़ैक्शन को प्रोसेस कर सकते हैं क्योंकि ट्रांज़ैक्शन नेटवर्क पर हर नोड के बजाय केवल कुछ नोड्स द्वारा प्रोसेस किए जाते हैं।
+साथ ही, सभी डेटा L1 पर लिखे जाते हैं ताकि मेननेट की सभी अखंडता और उपलब्धता गारंटी के साथ सब कुछ साबित और पुनर्निर्मित किया जा सके।
+
+ऑप्टिमिज्म (या किसी अन्य L2) पर L1 परिसंपत्तियों का उपयोग करने के लिए, परिसंपत्तियों को [ब्रिज](/bridges/#prerequisites) करने की आवश्यकता होती है।
+इसे प्राप्त करने का एक तरीका यह है कि यूज़र L1 पर परिसंपत्तियों (ETH और [ERC-20 टोकन](/developers/docs/standards/tokens/erc-20/) सबसे आम हैं) को लॉक करें, और L2 पर उपयोग करने के लिए समकक्ष परिसंपत्तियां प्राप्त करें।
+अंततः, जिसके पास भी वे होते हैं, वह उन्हें L1 पर वापस ब्रिज करना चाह सकता है।
+ऐसा करने पर, संपत्ति L2 पर बर्न हो जाती है और फिर L1 पर यूज़र को वापस जारी कर दी जाती है।
+
+यह वह तरीका है जिससे [ऑप्टिमिज्म स्टैंडर्ड ब्रिज](https://docs.optimism.io/app-developers/bridging/standard-bridge) काम करता है।
+इस लेख में हम उस ब्रिज के सोर्स कोड पर जाते हैं यह देखने के लिए कि यह कैसे काम करता है और अच्छी तरह से लिखे गए Solidity कोड के उदाहरण के रूप में इसका अध्ययन करते हैं।
+
+## कंट्रोल फ्लो {#control-flows}
+
+ब्रिज में दो मुख्य फ्लो हैं:
+
+- जमा (L1 से L2 तक)
+- निकासी (L2 से L1 तक)
+
+### जमा फ्लो {#deposit-flow}
+
+#### लेयर 1 {#deposit-flow-layer-1}
+
+1. यदि ERC-20 जमा कर रहे हैं, तो जमाकर्ता ब्रिज को जमा की जा रही राशि खर्च करने के लिए भत्ता देता है
+2. जमाकर्ता L1 ब्रिज (`depositERC20`, `depositERC20To`, `depositETH`, या `depositETHTo`) को कॉल करता है
+3. L1 ब्रिज, ब्रिज की गई संपत्ति का कब्ज़ा ले लेता है
+ - ETH: संपत्ति को कॉल के हिस्से के रूप में जमाकर्ता द्वारा स्थानांतरित किया जाता है
+ - ERC-20: संपत्ति को ब्रिज द्वारा जमाकर्ता द्वारा प्रदान किए गए भत्ते का उपयोग करके स्वयं को स्थानांतरित किया जाता है
+4. L1 ब्रिज, L2 ब्रिज पर `finalizeDeposit` को कॉल करने के लिए क्रॉस-डोमेन संदेश तंत्र का उपयोग करता है
+
+#### लेयर 2 {#deposit-flow-layer-2}
+
+5. L2 ब्रिज `finalizeDeposit` के कॉल को सत्यापित करता है कि वह वैध है:
+ - क्रॉस डोमेन संदेश अनुबंध से आया है
+ - मूल रूप से L1 पर ब्रिज से था
+6. L2 ब्रिज यह जाँचता है कि L2 पर ERC-20 टोकन अनुबंध सही है या नहीं:
+ - L2 अनुबंध रिपोर्ट करता है कि उसका L1 समकक्ष वही है जहां से टोकन L1 पर आए थे
+ - L2 अनुबंध रिपोर्ट करता है कि यह सही इंटरफ़ेस का समर्थन करता है ([ERC-165 का उपयोग करके](https://eips.ethereum.org/EIPS/eip-165))।
+7. यदि L2 अनुबंध सही है, तो उपयुक्त पते पर उपयुक्त संख्या में टोकन बनाने के लिए इसे कॉल करें। यदि नहीं, तो यूज़र को L1 पर टोकन का दावा करने की अनुमति देने के लिए निकासी प्रक्रिया शुरू करें।
+
+### निकासी फ्लो {#withdrawal-flow}
+
+#### लेयर 2 {#withdrawal-flow-layer-2}
+
+1. निकासीकर्ता L2 ब्रिज (`withdraw` या `withdrawTo`) को कॉल करता है
+2. L2 ब्रिज `msg.sender` से संबंधित टोकन की उचित संख्या को बर्न करता है
+3. L2 ब्रिज, L1 ब्रिज पर `finalizeETHWithdrawal` या `finalizeERC20Withdrawal` को कॉल करने के लिए क्रॉस-डोमेन संदेश तंत्र का उपयोग करता है
+
+#### लेयर 1 {#withdrawal-flow-layer-1}
+
+4. L1 ब्रिज `finalizeETHWithdrawal` या `finalizeERC20Withdrawal` के कॉल को सत्यापित करता है कि वह वैध है:
+ - क्रॉस डोमेन संदेश तंत्र से आया है
+ - मूल रूप से L2 पर ब्रिज से था
+5. L1 ब्रिज उपयुक्त संपत्ति (ETH या ERC-20) को उपयुक्त पते पर स्थानांतरित करता है
+
+## लेयर 1 कोड {#layer-1-code}
+
+यह वह कोड है जो L1, Ethereum मेननेट पर चलता है।
+
+### IL1ERC20Bridge {#IL1ERC20Bridge}
+
+[यह इंटरफ़ेस यहाँ परिभाषित किया गया है](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1ERC20Bridge.sol)।
+इसमें ERC-20 टोकन को ब्रिज करने के लिए आवश्यक फ़ंक्शन और परिभाषाएँ शामिल हैं।
+
+```solidity
+// SPDX-License-Identifier: MIT
+```
+
+[ऑप्टिमिज्म का अधिकांश कोड MIT लाइसेंस के तहत जारी किया गया है](https://help.optimism.io/hc/en-us/articles/4411908707995-What-software-license-does-Optimism-use-)।
+
+```solidity
+pragma solidity >0.5.0 <0.9.0;
+```
+
+लिखने के समय Solidity का नवीनतम संस्करण 0.8.12 है।
+जब तक संस्करण 0.9.0 जारी नहीं हो जाता, हम नहीं जानते कि यह कोड इसके साथ संगत है या नहीं।
+
+```solidity
+/**
+ * @title IL1ERC20Bridge
+ */
+interface IL1ERC20Bridge {
+ /**********
+ * इवेंट्स *
+ **********/
+
+ event ERC20DepositInitiated(
+```
+
+ऑप्टिमिज्म ब्रिज शब्दावली में _deposit_ का अर्थ L1 से L2 में स्थानांतरण है, और _withdrawal_ का अर्थ L2 से L1 में स्थानांतरण है।
+
+```solidity
+ address indexed _l1Token,
+ address indexed _l2Token,
+```
+
+अधिकांश मामलों में L1 पर एक ERC-20 का पता L2 पर समकक्ष ERC-20 के पते के समान नहीं होता है।
+[आप टोकन पतों की सूची यहां देख सकते हैं](https://static.optimism.io/optimism.tokenlist.json)।
+`chainId` 1 वाला पता L1 (मेननेट) पर है और `chainId` 10 वाला पता L2 (ऑप्टिमिज्म) पर है।
+अन्य दो `chainId` मान कोवन टेस्ट नेटवर्क (42) और ऑप्टिमिस्टिक कोवन टेस्ट नेटवर्क (69) के लिए हैं।
+
+```solidity
+ address indexed _from,
+ address _to,
+ uint256 _amount,
+ bytes _data
+ );
+```
+
+स्थानांतरण में नोट्स जोड़ना संभव है, जिस स्थिति में वे उन्हें रिपोर्ट करने वाले इवेंट्स में जोड़े जाते हैं।
+
+```solidity
+ event ERC20WithdrawalFinalized(
+ address indexed _l1Token,
+ address indexed _l2Token,
+ address indexed _from,
+ address _to,
+ uint256 _amount,
+ bytes _data
+ );
+```
+
+एक ही ब्रिज अनुबंध दोनों दिशाओं में स्थानांतरण को संभालता है।
+L1 ब्रिज के मामले में, इसका मतलब जमा की शुरुआत और निकासी को अंतिम रूप देना है।
+
+```solidity
+
+ /********************
+ * सार्वजनिक फ़ंक्शन *
+ ********************/
+
+ /**
+ * @dev संबंधित L2 ब्रिज अनुबंध का पता प्राप्त करें।
+ * @return संबंधित L2 ब्रिज अनुबंध का पता।
+ */
+ function l2TokenBridge() external returns (address);
+```
+
+इस फ़ंक्शन की वास्तव में आवश्यकता नहीं है, क्योंकि L2 पर यह एक पूर्व-तैनात अनुबंध है, इसलिए यह हमेशा पते `0x4200000000000000000000000000000000000010` पर होता है।
+यह यहां L2 ब्रिज के साथ समरूपता के लिए है, क्योंकि L1 ब्रिज का पता जानना मामूली नहीं है।
+
+```solidity
+ /**
+ * @dev L2 पर कॉलर की शेष राशि में ERC20 की राशि जमा करें।
+ * @param _l1Token हम जिस L1 ERC20 को जमा कर रहे हैं उसका पता
+ * @param _l2Token L1 संबंधित L2 ERC20 का पता
+ * @param _amount जमा करने के लिए ERC20 की राशि
+ * @param _l2Gas L2 पर जमा को पूरा करने के लिए आवश्यक गैस सीमा।
+ * @param _data L2 को अग्रेषित करने के लिए वैकल्पिक डेटा। यह डेटा प्रदान किया गया है
+ * पूरी तरह से बाहरी अनुबंधों की सुविधा के रूप में। अधिकतम लागू करने के अलावा
+ * लंबाई, ये अनुबंध इसकी सामग्री के बारे में कोई गारंटी नहीं देते हैं।
+ */
+ function depositERC20(
+ address _l1Token,
+ address _l2Token,
+ uint256 _amount,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) external;
+```
+
+`_l2Gas` पैरामीटर L2 गैस की वह राशि है जिसे ट्रांज़ैक्शन खर्च करने की अनुमति है।
+[एक निश्चित (उच्च) सीमा तक, यह मुफ़्त है](https://community.optimism.io/docs/developers/bridge/messaging/#for-l1-%E2%87%92-l2-transactions-2), इसलिए जब तक ERC-20 अनुबंध मिन्टिंग के समय कुछ वास्तव में अजीब नहीं करता है, यह एक मुद्दा नहीं होना चाहिए।
+यह फ़ंक्शन सामान्य परिदृश्य का ध्यान रखता है, जहां एक यूज़र एक अलग ब्लॉकचेन पर एक ही पते पर संपत्ति को ब्रिज करता है।
+
+```solidity
+ /**
+ * @dev L2 पर प्राप्तकर्ता की शेष राशि में ERC20 की राशि जमा करें।
+ * @param _l1Token हम जिस L1 ERC20 को जमा कर रहे हैं उसका पता
+ * @param _l2Token L1 संबंधित L2 ERC20 का पता
+ * @param _to L2 पता जिसमें निकासी जमा करनी है।
+ * @param _amount जमा करने के लिए ERC20 की राशि।
+ * @param _l2Gas L2 पर जमा को पूरा करने के लिए आवश्यक गैस सीमा।
+ * @param _data L2 को अग्रेषित करने के लिए वैकल्पिक डेटा। यह डेटा प्रदान किया गया है
+ * पूरी तरह से बाहरी अनुबंधों की सुविधा के रूप में। अधिकतम लागू करने के अलावा
+ * लंबाई, ये अनुबंध इसकी सामग्री के बारे में कोई गारंटी नहीं देते हैं।
+ */
+ function depositERC20To(
+ address _l1Token,
+ address _l2Token,
+ address _to,
+ uint256 _amount,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) external;
+```
+
+यह फ़ंक्शन `depositERC20` के लगभग समान है, लेकिन यह आपको ERC-20 को एक अलग पते पर भेजने की सुविधा देता है।
+
+```solidity
+ /*************************
+ * क्रॉस-चेन फ़ंक्शन *
+ *************************/
+
+ /**
+ * @dev L2 से L1 में निकासी पूरी करें, और धन को प्राप्तकर्ता की
+ * L1 ERC20 टोकन की शेष राशि में जमा करें।
+ * यदि L2 से आरंभ की गई निकासी को अंतिम रूप नहीं दिया गया है तो यह कॉल विफल हो जाएगा।
+ *
+ * @param _l1Token L1 टोकन का पता जिसके लिए finalizeWithdrawal करना है।
+ * @param _l2Token L2 टोकन का पता जहां निकासी शुरू की गई थी।
+ * @param _from स्थानांतरण शुरू करने वाला L2 पता।
+ * @param _to L1 पता जिसमें निकासी जमा करनी है।
+ * @param _amount जमा करने के लिए ERC20 की राशि।
+ * @param _data L2 पर प्रेषक द्वारा प्रदान किया गया डेटा। यह डेटा प्रदान किया गया है
+ * पूरी तरह से बाहरी अनुबंधों की सुविधा के रूप में। अधिकतम लागू करने के अलावा
+ * लंबाई, ये अनुबंध इसकी सामग्री के बारे में कोई गारंटी नहीं देते हैं।
+ */
+ function finalizeERC20Withdrawal(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+ ) external;
+}
+```
+
+ऑप्टिमिज्म में निकासी (और L2 से L1 के अन्य संदेश) एक दो-चरणीय प्रक्रिया है:
+
+1. L2 पर एक प्रारंभिक ट्रांज़ैक्शन।
+2. L1 पर एक अंतिम या दावा करने वाला ट्रांज़ैक्शन।
+ यह ट्रांज़ैक्शन L2 ट्रांज़ैक्शन के लिए [फॉल्ट चैलेंज अवधि](https://community.optimism.io/docs/how-optimism-works/#fault-proofs) समाप्त होने के बाद होना चाहिए।
+
+### IL1StandardBridge {#il1standardbridge}
+
+[यह इंटरफ़ेस यहाँ परिभाषित किया गया है](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/IL1StandardBridge.sol)।
+इस फ़ाइल में ETH के लिए इवेंट और फ़ंक्शन परिभाषाएँ हैं।
+ये परिभाषाएँ ERC-20 के लिए ऊपर `IL1ERC20Bridge` में परिभाषित परिभाषाओं के बहुत समान हैं।
+
+ब्रिज इंटरफ़ेस को दो फ़ाइलों के बीच विभाजित किया गया है क्योंकि कुछ ERC-20 टोकन को कस्टम प्रोसेसिंग की आवश्यकता होती है और उन्हें स्टैंडर्ड ब्रिज द्वारा नियंत्रित नहीं किया जा सकता है।
+इस तरह से कस्टम ब्रिज जो ऐसे टोकन को संभालता है, `IL1ERC20Bridge` को लागू कर सकता है और उसे ETH को भी ब्रिज करने की आवश्यकता नहीं होती है।
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >0.5.0 <0.9.0;
+
+import "./IL1ERC20Bridge.sol";
+
+/**
+ * @title IL1StandardBridge
+ */
+interface IL1StandardBridge is IL1ERC20Bridge {
+ /**********
+ * इवेंट्स *
+ **********/
+ event ETHDepositInitiated(
+ address indexed _from,
+ address indexed _to,
+ uint256 _amount,
+ bytes _data
+ );
+```
+
+यह इवेंट ERC-20 संस्करण (`ERC20DepositInitiated`) के लगभग समान है, सिवाय L1 और L2 टोकन पतों के बिना।
+यही बात अन्य इवेंट्स और फ़ंक्शन के लिए भी सच है।
+
+```solidity
+ event ETHWithdrawalFinalized(
+ .
+ .
+ .
+ );
+
+ /********************
+ * सार्वजनिक फ़ंक्शन *
+ ********************/
+
+ /**
+ * @dev ETH की एक राशि को L2 पर कॉलर की शेष राशि में जमा करें।
+ .
+ .
+ .
+ */
+ function depositETH(uint32 _l2Gas, bytes calldata _data) external payable;
+
+ /**
+ * @dev L2 पर प्राप्तकर्ता की शेष राशि में ETH की राशि जमा करें।
+ .
+ .
+ .
+ */
+ function depositETHTo(
+ address _to,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) external payable;
+
+ /*************************
+ * क्रॉस-चेन फ़ंक्शन *
+ *************************/
+
+ /**
+ * @dev L2 से L1 में निकासी पूरी करें, और धन को प्राप्तकर्ता की
+ * L1 ETH टोकन की शेष राशि में जमा करें। चूंकि केवल xDomainMessenger ही इस फ़ंक्शन को कॉल कर सकता है, इसलिए इसे कभी भी
+ * निकासी को अंतिम रूप दिए जाने से पहले कॉल नहीं किया जाएगा।
+ .
+ .
+ .
+ */
+ function finalizeETHWithdrawal(
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+ ) external;
+}
+```
+
+### CrossDomainEnabled {#crossdomainenabled}
+
+[यह अनुबंध](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/CrossDomainEnabled.sol) दोनों ब्रिज ([L1](#the-l1-bridge-contract) और [L2](#the-l2-bridge-contract)) द्वारा दूसरी लेयर को संदेश भेजने के लिए इनहेरिट किया गया है।
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >0.5.0 <0.9.0;
+
+/* इंटरफ़ेस इम्पोर्ट */
+import { ICrossDomainMessenger } from "./ICrossDomainMessenger.sol";
+```
+
+[यह इंटरफ़ेस](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/bridge/ICrossDomainMessenger.sol) अनुबंध को बताता है कि क्रॉस डोमेन मैसेंजर का उपयोग करके दूसरी लेयर को संदेश कैसे भेजें।
+यह क्रॉस डोमेन मैसेंजर एक पूरी तरह से अलग सिस्टम है, और इसके अपने लेख का हकदार है, जिसे मैं भविष्य में लिखने की उम्मीद करता हूं।
+
+```solidity
+/**
+ * @title CrossDomainEnabled
+ * @dev क्रॉस-डोमेन संचार करने वाले अनुबंधों के लिए हेल्पर अनुबंध
+ *
+ * कंपाइलर का उपयोग किया गया: इनहेरिट करने वाले अनुबंध द्वारा परिभाषित
+ */
+contract CrossDomainEnabled {
+ /*************
+ * चर *
+ *************/
+
+ // मैसेंजर अनुबंध का उपयोग दूसरे डोमेन से संदेश भेजने और प्राप्त करने के लिए किया जाता है।
+ address public messenger;
+
+ /***************
+ * कंस्ट्रक्टर *
+ ***************/
+
+ /**
+ * @param _messenger वर्तमान लेयर पर CrossDomainMessenger का पता।
+ */
+ constructor(address _messenger) {
+ messenger = _messenger;
+ }
+```
+
+एक पैरामीटर जो अनुबंध को जानना आवश्यक है, वह है इस लेयर पर क्रॉस डोमेन मैसेंजर का पता।
+यह पैरामीटर एक बार, कंस्ट्रक्टर में सेट किया जाता है, और कभी नहीं बदलता है।
+
+```solidity
+
+ /**********************
+ * फ़ंक्शन संशोधक *
+ **********************/
+
+ /**
+ * यह सुनिश्चित करता है कि संशोधित फ़ंक्शन केवल एक विशिष्ट क्रॉस-डोमेन खाते द्वारा कॉल करने योग्य है।
+ * @param _sourceDomainAccount मूल डोमेन पर एकमात्र खाता जो इस फ़ंक्शन को कॉल करने के लिए
+ * प्रमाणित है।
+ */
+ modifier onlyFromCrossDomainAccount(address _sourceDomainAccount) {
+```
+
+क्रॉस डोमेन मैसेजिंग उस ब्लॉकचेन पर किसी भी अनुबंध द्वारा सुलभ है जहां यह चल रहा है (या तो Ethereum मेननेट या ऑप्टिमिज्म)।
+लेकिन हमें प्रत्येक तरफ ब्रिज की आवश्यकता है ताकि कुछ संदेशों पर _केवल_ भरोसा किया जा सके यदि वे दूसरी तरफ के ब्रिज से आते हैं।
+
+```solidity
+ require(
+ msg.sender == address(getCrossDomainMessenger()),
+ "OVM_XCHAIN: messenger contract unauthenticated"
+ );
+```
+
+केवल उपयुक्त क्रॉस डोमेन मैसेंजर (`messenger`, जैसा कि आप नीचे देखते हैं) से संदेशों पर भरोसा किया जा सकता है।
+
+```solidity
+
+ require(
+ getCrossDomainMessenger().xDomainMessageSender() == _sourceDomainAccount,
+ "OVM_XCHAIN: wrong sender of cross-domain message"
+ );
+```
+
+जिस तरह से क्रॉस डोमेन मैसेंजर उस पते को प्रदान करता है जिसने दूसरी लेयर के साथ एक संदेश भेजा है, वह [`.xDomainMessageSender()` फ़ंक्शन](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1CrossDomainMessenger.sol#L122-L128) है।
+जब तक इसे उस ट्रांज़ैक्शन में कॉल किया जाता है जिसे संदेश द्वारा शुरू किया गया था, यह इस जानकारी को प्रदान कर सकता है।
+
+हमें यह सुनिश्चित करने की आवश्यकता है कि हमें जो संदेश मिला है वह दूसरे ब्रिज से आया है।
+
+```solidity
+
+ _;
+ }
+
+ /**********************
+ * आंतरिक फ़ंक्शन *
+ **********************/
+
+ /**
+ * मैसेंजर प्राप्त करता है, आमतौर पर स्टोरेज से। यह फ़ंक्शन उस स्थिति में उजागर होता है जब किसी चाइल्ड अनुबंध को
+ * ओवरराइड करने की आवश्यकता होती है।
+ * @return क्रॉस-डोमेन मैसेंजर अनुबंध का पता जिसका उपयोग किया जाना चाहिए।
+ */
+ function getCrossDomainMessenger() internal virtual returns (ICrossDomainMessenger) {
+ return ICrossDomainMessenger(messenger);
+ }
+```
+
+यह फ़ंक्शन क्रॉस डोमेन मैसेंजर लौटाता है।
+हम `messenger` चर के बजाय एक फ़ंक्शन का उपयोग करते हैं ताकि इससे इनहेरिट करने वाले अनुबंध एक एल्गोरिथम का उपयोग कर सकें यह निर्दिष्ट करने के लिए कि किस क्रॉस डोमेन मैसेंजर का उपयोग करना है।
+
+```solidity
+
+ /**
+ * दूसरे डोमेन पर एक खाते में एक संदेश भेजता है
+ * @param _crossDomainTarget गंतव्य डोमेन पर इच्छित प्राप्तकर्ता
+ * @param _message लक्ष्य को भेजने के लिए डेटा (आमतौर पर `onlyFromCrossDomainAccount()` के साथ एक फ़ंक्शन के लिए calldata)
+ * @param _gasLimit लक्ष्य डोमेन पर संदेश की रसीद के लिए gasLimit।
+ */
+ function sendCrossDomainMessage(
+ address _crossDomainTarget,
+ uint32 _gasLimit,
+ bytes memory _message
+```
+
+अंत में, वह फ़ंक्शन जो दूसरी लेयर को एक संदेश भेजता है।
+
+```solidity
+ ) internal {
+ // slither-disable-next-line reentrancy-events, reentrancy-benign
+```
+
+[Slither](https://github.com/crytic/slither) एक स्टैटिक एनालाइज़र है जिसे ऑप्टिमिज्म हर अनुबंध पर चलाता है ताकि कमजोरियों और अन्य संभावित समस्याओं की तलाश की जा सके।
+इस मामले में, निम्नलिखित लाइन दो कमजोरियों को ट्रिगर करती है:
+
+1. [रीएंट्रेंसी इवेंट्स](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-3)
+2. [सौम्य रीएंट्रेंसी](https://github.com/crytic/slither/wiki/Detector-Documentation#reentrancy-vulnerabilities-2)
+
+```solidity
+ getCrossDomainMessenger().sendMessage(_crossDomainTarget, _message, _gasLimit);
+ }
+}
+```
+
+इस मामले में हम रीएंट्रेंसी के बारे में चिंतित नहीं हैं, हम जानते हैं कि `getCrossDomainMessenger()` एक भरोसेमंद पता लौटाता है, भले ही Slither के पास यह जानने का कोई तरीका न हो।
+
+### L1 ब्रिज अनुबंध {#the-l1-bridge-contract}
+
+[इस अनुबंध का सोर्स कोड यहाँ है](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L1/messaging/L1StandardBridge.sol)।
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+```
+
+इंटरफ़ेस अन्य अनुबंधों का हिस्सा हो सकते हैं, इसलिए उन्हें Solidity संस्करणों की एक विस्तृत श्रृंखला का समर्थन करना होता है।
+लेकिन ब्रिज खुद हमारा अनुबंध है, और हम इस बारे में सख्त हो सकते हैं कि यह किस Solidity संस्करण का उपयोग करता है।
+
+```solidity
+/* इंटरफ़ेस इम्पोर्ट */
+import { IL1StandardBridge } from "./IL1StandardBridge.sol";
+import { IL1ERC20Bridge } from "./IL1ERC20Bridge.sol";
+```
+
+[IL1ERC20Bridge](#IL1ERC20Bridge) और [IL1StandardBridge](#IL1StandardBridge) को ऊपर समझाया गया है।
+
+```solidity
+import { IL2ERC20Bridge } from "../../L2/messaging/IL2ERC20Bridge.sol";
+```
+
+[यह इंटरफ़ेस](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) हमें L2 पर स्टैंडर्ड ब्रिज को नियंत्रित करने के लिए संदेश बनाने की सुविधा देता है।
+
+```solidity
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+```
+
+[यह इंटरफ़ेस](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) हमें ERC-20 अनुबंधों को नियंत्रित करने की सुविधा देता है।
+[आप इसके बारे में और यहां पढ़ सकते हैं](/developers/tutorials/erc20-annotated-code/#the-interface)।
+
+```solidity
+/* लाइब्रेरी इम्पोर्ट */
+import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
+```
+
+[जैसा कि ऊपर बताया गया है](#crossdomainenabled), इस अनुबंध का उपयोग इंटरलेयर मैसेजिंग के लिए किया जाता है।
+
+```solidity
+import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
+```
+
+[`Lib_PredeployAddresses`](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/libraries/constants/Lib_PredeployAddresses.sol) में L2 अनुबंधों के लिए पते हैं जिनका पता हमेशा समान होता है। इसमें L2 पर स्टैंडर्ड ब्रिज शामिल है।
+
+```solidity
+import { Address } from "@openzeppelin/contracts/utils/Address.sol";
+```
+
+[OpenZeppelin की पता उपयोगिताएँ](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol)। इसका उपयोग अनुबंध पतों और बाह्य रूप से स्वामित्व वाले खातों (EOA) से संबंधित पतों के बीच अंतर करने के लिए किया जाता है।
+
+ध्यान दें कि यह एक आदर्श समाधान नहीं है, क्योंकि सीधे कॉल और एक अनुबंध के कंस्ट्रक्टर से किए गए कॉल के बीच अंतर करने का कोई तरीका नहीं है, लेकिन कम से कम यह हमें कुछ सामान्य यूज़र त्रुटियों को पहचानने और रोकने की सुविधा देता है।
+
+```solidity
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+```
+
+[ERC-20 मानक](https://eips.ethereum.org/EIPS/eip-20) एक अनुबंध के लिए विफलता की रिपोर्ट करने के दो तरीकों का समर्थन करता है:
+
+1. रिवर्ट करें
+2. `false` लौटाएं
+
+दोनों मामलों को संभालने से हमारा कोड और अधिक जटिल हो जाएगा, इसलिए इसके बजाय हम [OpenZeppelin के `SafeERC20`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol) का उपयोग करते हैं, जो यह सुनिश्चित करता है कि [सभी विफलताएं एक रिवर्ट में परिणत हों](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol#L96)।
+
+```solidity
+/**
+ * @title L1StandardBridge
+ * @dev L1 ETH और ERC20 ब्रिज एक अनुबंध है जो जमा किए गए L1 फंड और L2 पर उपयोग में आने वाले स्टैंडर्ड टोकन को संग्रहीत करता है।
+ * यह एक संबंधित L2 ब्रिज को सिंक्रनाइज़ करता है, इसे जमा के बारे में सूचित करता है
+ * और नई अंतिम रूप दी गई निकासी के लिए इसे सुनता है।
+ *
+ */
+contract L1StandardBridge is IL1StandardBridge, CrossDomainEnabled {
+ using SafeERC20 for IERC20;
+```
+
+यह लाइन है कि हम `IERC20` इंटरफ़ेस का उपयोग करते समय हर बार `SafeERC20` रैपर का उपयोग करने के लिए कैसे निर्दिष्ट करते हैं।
+
+```solidity
+
+ /********************************
+ * बाहरी अनुबंध संदर्भ *
+ ********************************/
+
+ address public l2TokenBridge;
+```
+
+[L2StandardBridge](#the-l2-bridge-contract) का पता।
+
+```solidity
+
+ // जमा किए गए L1 टोकन की शेष राशि के लिए L1 टोकन को L2 टोकन से मैप करता है
+ mapping(address => mapping(address => uint256)) public deposits;
+```
+
+इस तरह की एक डबल [मैपिंग](https://www.tutorialspoint.com/solidity/solidity_mappings.htm) [दो-आयामी स्पार्स ऐरे](https://en.wikipedia.org/wiki/Sparse_matrix) को परिभाषित करने का तरीका है।
+इस डेटा संरचना में मान `deposit[L1 token addr][L2 token addr]` के रूप में पहचाने जाते हैं।
+डिफ़ॉल्ट मान शून्य है।
+केवल वे सेल जो एक अलग मान पर सेट हैं, स्टोरेज में लिखे जाते हैं।
+
+```solidity
+
+ /***************
+ * कंस्ट्रक्टर *
+ ***************/
+
+ // यह अनुबंध एक प्रॉक्सी के पीछे रहता है, इसलिए कंस्ट्रक्टर पैरामीटर का उपयोग नहीं किया जाएगा।
+ constructor() CrossDomainEnabled(address(0)) {}
+```
+
+स्टोरेज में सभी चर को कॉपी किए बिना इस अनुबंध को अपग्रेड करने में सक्षम होना चाहते हैं।
+ऐसा करने के लिए हम एक [`Proxy`](https://docs.openzeppelin.com/contracts/3.x/api/proxy) का उपयोग करते हैं, एक अनुबंध जो एक अलग अनुबंध में कॉल स्थानांतरित करने के लिए [`delegatecall`](https://solidity-by-example.org/delegatecall/) का उपयोग करता है जिसका पता प्रॉक्सी अनुबंध द्वारा संग्रहीत किया जाता है (जब आप अपग्रेड करते हैं तो आप प्रॉक्सी को उस पते को बदलने के लिए कहते हैं)।
+जब आप `delegatecall` का उपयोग करते हैं तो स्टोरेज _कॉलिंग_ अनुबंध का स्टोरेज बना रहता है, इसलिए सभी अनुबंध स्थिति चर के मान अप्रभावित रहते हैं।
+
+इस पैटर्न का एक प्रभाव यह है कि `delegatecall` के _कॉल किए गए_ अनुबंध का स्टोरेज उपयोग नहीं किया जाता है और इसलिए इसे पास किए गए कंस्ट्रक्टर मानों का कोई मतलब नहीं है।
+यही कारण है कि हम `CrossDomainEnabled` कंस्ट्रक्टर को एक निरर्थक मान प्रदान कर सकते हैं।
+यह भी कारण है कि नीचे आरंभीकरण कंस्ट्रक्टर से अलग है।
+
+```solidity
+ /******************
+ * आरंभीकरण *
+ ******************/
+
+ /**
+ * @param _l1messenger L1 Messenger पता जिसका उपयोग क्रॉस-चेन संचार के लिए किया जा रहा है।
+ * @param _l2TokenBridge L2 स्टैंडर्ड ब्रिज पता।
+ */
+ // slither-disable-next-line external-function
+```
+
+यह [Slither परीक्षण](https://github.com/crytic/slither/wiki/Detector-Documentation#public-function-that-could-be-declared-external) उन फ़ंक्शन की पहचान करता है जिन्हें अनुबंध कोड से नहीं बुलाया जाता है और इसलिए उन्हें `public` के बजाय `external` घोषित किया जा सकता है।
+`external` फ़ंक्शन की गैस लागत कम हो सकती है, क्योंकि उन्हें calldata में पैरामीटर के साथ प्रदान किया जा सकता है।
+`public` घोषित फ़ंक्शन अनुबंध के भीतर से सुलभ होने चाहिए।
+अनुबंध अपने स्वयं के calldata को संशोधित नहीं कर सकते हैं, इसलिए पैरामीटर मेमोरी में होने चाहिए।
+जब ऐसे फ़ंक्शन को बाह्य रूप से कॉल किया जाता है, तो calldata को मेमोरी में कॉपी करना आवश्यक होता है, जिसमें गैस लगती है।
+इस मामले में फ़ंक्शन को केवल एक बार कॉल किया जाता है, इसलिए अक्षमता हमारे लिए कोई मायने नहीं रखती है।
+
+```solidity
+ function initialize(address _l1messenger, address _l2TokenBridge) public {
+ require(messenger == address(0), "Contract has already been initialized.");
+```
+
+`initialize` फ़ंक्शन को केवल एक बार कॉल किया जाना चाहिए।
+यदि L1 क्रॉस डोमेन मैसेंजर या L2 टोकन ब्रिज का पता बदलता है, तो हम एक नया प्रॉक्सी और एक नया ब्रिज बनाते हैं जो इसे कॉल करता है।
+यह तब तक होने की संभावना नहीं है जब तक कि पूरे सिस्टम को अपग्रेड नहीं किया जाता है, जो एक बहुत ही दुर्लभ घटना है।
+
+ध्यान दें कि इस फ़ंक्शन में कोई तंत्र नहीं है जो यह प्रतिबंधित करता है कि _कौन_ इसे कॉल कर सकता है।
+इसका मतलब है कि सिद्धांत रूप में एक हमलावर तब तक इंतजार कर सकता है जब तक हम प्रॉक्सी और ब्रिज के पहले संस्करण को तैनात नहीं करते और फिर वैध यूज़र के करने से पहले `initialize` फ़ंक्शन तक पहुंचने के लिए [फ्रंट-रन](https://solidity-by-example.org/hacks/front-running/) कर सकता है। लेकिन इसे रोकने के दो तरीके हैं:
+
+1. यदि अनुबंध सीधे एक EOA द्वारा नहीं बल्कि [एक ट्रांज़ैक्शन में जिसमें एक और अनुबंध उन्हें बनाता है](https://medium.com/upstate-interactive/creating-a-contract-with-a-smart-contract-bdb67c5c8595) तैनात किए जाते हैं, तो पूरी प्रक्रिया परमाणु हो सकती है, और किसी भी अन्य ट्रांज़ैक्शन के निष्पादित होने से पहले समाप्त हो सकती है।
+2. यदि `initialize` के लिए वैध कॉल विफल हो जाती है, तो नए बनाए गए प्रॉक्सी और ब्रिज को अनदेखा करना और नए बनाना हमेशा संभव होता है।
+
+```solidity
+ messenger = _l1messenger;
+ l2TokenBridge = _l2TokenBridge;
+ }
+```
+
+ये दो पैरामीटर हैं जिन्हें ब्रिज को जानना आवश्यक है।
+
+```solidity
+
+ /**************
+ * जमा करना *
+ **************/
+
+ /** @dev प्रेषक को EOA होने की आवश्यकता वाला संशोधक। इस जाँच को एक दुर्भावनापूर्ण
+ * अनुबंध द्वारा initcode के माध्यम से बायपास किया जा सकता है, लेकिन यह उस यूज़र त्रुटि का ध्यान रखता है जिससे हम बचना चाहते हैं।
+ */
+ modifier onlyEOA() {
+ // अनुबंधों से जमा को रोकने के लिए उपयोग किया जाता है (गलती से खोए हुए टोकन से बचें)
+ require(!Address.isContract(msg.sender), "Account not EOA");
+ _;
+ }
+```
+
+यही कारण है कि हमें OpenZeppelin की `Address` उपयोगिताओं की आवश्यकता थी।
+
+```solidity
+ /**
+ * @dev इस फ़ंक्शन को बिना किसी डेटा के कॉल किया जा सकता है
+ * L2 पर कॉलर की शेष राशि में ETH की राशि जमा करने के लिए।
+ * चूंकि प्राप्त फ़ंक्शन डेटा नहीं लेता है, एक रूढ़िवादी
+ * डिफ़ॉल्ट राशि L2 को अग्रेषित की जाती है।
+ */
+ receive() external payable onlyEOA {
+ _initiateETHDeposit(msg.sender, msg.sender, 200_000, bytes(""));
+ }
+```
+
+यह फ़ंक्शन परीक्षण उद्देश्यों के लिए मौजूद है।
+ध्यान दें कि यह इंटरफ़ेस परिभाषाओं में दिखाई नहीं देता है - यह सामान्य उपयोग के लिए नहीं है।
+
+```solidity
+ /**
+ * @inheritdoc IL1StandardBridge
+ */
+ function depositETH(uint32 _l2Gas, bytes calldata _data) external payable onlyEOA {
+ _initiateETHDeposit(msg.sender, msg.sender, _l2Gas, _data);
+ }
+
+ /**
+ * @inheritdoc IL1StandardBridge
+ */
+ function depositETHTo(
+ address _to,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) external payable {
+ _initiateETHDeposit(msg.sender, _to, _l2Gas, _data);
+ }
+```
+
+ये दो फ़ंक्शन `_initiateETHDeposit` के आसपास रैपर हैं, वह फ़ंक्शन जो वास्तविक ETH जमा को संभालता है।
+
+```solidity
+ /**
+ * @dev ETH को संग्रहीत करके और L2 ETH गेटवे को
+ * जमा के बारे में सूचित करके जमा के लिए तर्क करता है।
+ * @param _from L1 पर जमा को खींचने के लिए खाता।
+ * @param _to L2 पर जमा देने के लिए खाता।
+ * @param _l2Gas L2 पर जमा को पूरा करने के लिए आवश्यक गैस सीमा।
+ * @param _data L2 को अग्रेषित करने के लिए वैकल्पिक डेटा। यह डेटा प्रदान किया गया है
+ * पूरी तरह से बाहरी अनुबंधों की सुविधा के रूप में। अधिकतम लागू करने के अलावा
+ * लंबाई, ये अनुबंध इसकी सामग्री के बारे में कोई गारंटी नहीं देते हैं।
+ */
+ function _initiateETHDeposit(
+ address _from,
+ address _to,
+ uint32 _l2Gas,
+ bytes memory _data
+ ) internal {
+ // finalizeDeposit कॉल के लिए calldata का निर्माण करें
+ bytes memory message = abi.encodeWithSelector(
+```
+
+जिस तरह से क्रॉस डोमेन संदेश काम करते हैं वह यह है कि गंतव्य अनुबंध को उसके calldata के रूप में संदेश के साथ कॉल किया जाता है।
+Solidity अनुबंध हमेशा अपने calldata की व्याख्या
+[ABI विनिर्देशों](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html) के अनुसार करते हैं।
+Solidity फ़ंक्शन [`abi.encodeWithSelector`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#abi-encoding-and-decoding-functions) उस calldata को बनाता है।
+
+```solidity
+ IL2ERC20Bridge.finalizeDeposit.selector,
+ address(0),
+ Lib_PredeployAddresses.OVM_ETH,
+ _from,
+ _to,
+ msg.value,
+ _data
+ );
+```
+
+यहां संदेश इन मापदंडों के साथ [`finalizeDeposit` फ़ंक्शन](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol#L141-L148) को कॉल करना है:
+
+| पैरामीटर | मूल्य | अर्थ |
+| ------------------------------- | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| \_l1Token | address(0) | L1 पर ETH (जो एक ERC-20 टोकन नहीं है) के लिए खड़े होने के लिए विशेष मान |
+| \_l2Token | Lib_PredeployAddresses.OVM_ETH | L2 अनुबंध जो ऑप्टिमिज्म पर ETH का प्रबंधन करता है, `0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000` (यह अनुबंध केवल आंतरिक ऑप्टिमिज्म उपयोग के लिए है) |
+| \_from | \_from | L1 पर वह पता जो ETH भेजता है |
+| \_to | \_to | L2 पर वह पता जो ETH प्राप्त करता है |
+| राशि | msg.value | भेजे गए wei की राशि (जो पहले ही ब्रिज को भेजी जा चुकी है) |
+| \_data | \_data | जमा में संलग्न करने के लिए अतिरिक्त डेटा |
+
+```solidity
+ // L2 में calldata भेजें
+ // slither-disable-next-line reentrancy-events
+ sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
+```
+
+क्रॉस डोमेन मैसेंजर के माध्यम से संदेश भेजें।
+
+```solidity
+ // slither-disable-next-line reentrancy-events
+ emit ETHDepositInitiated(_from, _to, msg.value, _data);
+ }
+```
+
+इस स्थानांतरण के बारे में सुनने वाले किसी भी विकेंद्रीकृत अनुप्रयोग को सूचित करने के लिए एक इवेंट उत्सर्जित करें।
+
+```solidity
+ /**
+ * @inheritdoc IL1ERC20Bridge
+ */
+ function depositERC20(
+ .
+ .
+ .
+ ) external virtual onlyEOA {
+ _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, msg.sender, _amount, _l2Gas, _data);
+ }
+
+ /**
+ * @inheritdoc IL1ERC20Bridge
+ */
+ function depositERC20To(
+ .
+ .
+ .
+ ) external virtual {
+ _initiateERC20Deposit(_l1Token, _l2Token, msg.sender, _to, _amount, _l2Gas, _data);
+ }
+```
+
+ये दो फ़ंक्शन `_initiateERC20Deposit` के आसपास रैपर हैं, वह फ़ंक्शन जो वास्तविक ERC-20 जमा को संभालता है।
+
+```solidity
+ /**
+ * @dev L2 जमा किए गए टोकन को सूचित करके जमा के लिए तर्क करता है
+ * अनुबंध को जमा के बारे में और L1 फंड को लॉक करने के लिए एक हैंडलर को कॉल करता है। (जैसे, transferFrom)
+ *
+ * @param _l1Token हम जिस L1 ERC20 को जमा कर रहे हैं उसका पता
+ * @param _l2Token L1 संबंधित L2 ERC20 का पता
+ * @param _from L1 पर जमा को खींचने के लिए खाता
+ * @param _to L2 पर जमा देने के लिए खाता
+ * @param _amount जमा करने के लिए ERC20 की राशि।
+ * @param _l2Gas L2 पर जमा को पूरा करने के लिए आवश्यक गैस सीमा।
+ * @param _data L2 को अग्रेषित करने के लिए वैकल्पिक डेटा। यह डेटा प्रदान किया गया है
+ * पूरी तरह से बाहरी अनुबंधों की सुविधा के रूप में। अधिकतम लागू करने के अलावा
+ * लंबाई, ये अनुबंध इसकी सामग्री के बारे में कोई गारंटी नहीं देते हैं।
+ */
+ function _initiateERC20Deposit(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ uint32 _l2Gas,
+ bytes calldata _data
+ ) internal {
+```
+
+यह फ़ंक्शन ऊपर दिए गए `_initiateETHDeposit` के समान है, जिसमें कुछ महत्वपूर्ण अंतर हैं।
+पहला अंतर यह है कि यह फ़ंक्शन टोकन पते और स्थानांतरित करने के लिए राशि को पैरामीटर के रूप में प्राप्त करता है।
+ETH के मामले में ब्रिज पर कॉल में पहले से ही ब्रिज खाते में संपत्ति का स्थानांतरण शामिल है (`msg.value`)।
+
+```solidity
+ // जब L1 पर एक जमा शुरू किया जाता है, तो L1 ब्रिज भविष्य के लिए फंड को खुद को स्थानांतरित करता है
+ // निकासी। safeTransferFrom यह भी जांचता है कि अनुबंध में कोड है या नहीं, इसलिए यह विफल हो जाएगा यदि
+ // _from एक EOA या address(0) है।
+ // slither-disable-next-line reentrancy-events, reentrancy-benign
+ IERC20(_l1Token).safeTransferFrom(_from, address(this), _amount);
+```
+
+ERC-20 टोकन स्थानांतरण ETH से एक अलग प्रक्रिया का पालन करते हैं:
+
+1. यूज़र (`_from`) उपयुक्त टोकन स्थानांतरित करने के लिए ब्रिज को एक भत्ता देता है।
+2. यूज़र टोकन अनुबंध के पते, राशि आदि के साथ ब्रिज को कॉल करता है।
+3. ब्रिज जमा प्रक्रिया के हिस्से के रूप में टोकन (स्वयं को) स्थानांतरित करता है।
+
+पहला चरण अंतिम दो से एक अलग ट्रांज़ैक्शन में हो सकता है।
+हालांकि, फ्रंट-रनिंग कोई समस्या नहीं है क्योंकि `_initiateERC20Deposit` (`depositERC20` और `depositERC20To`) को कॉल करने वाले दो फ़ंक्शन केवल `msg.sender` को `_from` पैरामीटर के रूप में इस फ़ंक्शन को कॉल करते हैं।
+
+```solidity
+ // _l2Token.finalizeDeposit(_to, _amount) के लिए calldata का निर्माण करें
+ bytes memory message = abi.encodeWithSelector(
+ IL2ERC20Bridge.finalizeDeposit.selector,
+ _l1Token,
+ _l2Token,
+ _from,
+ _to,
+ _amount,
+ _data
+ );
+
+ // L2 में calldata भेजें
+ // slither-disable-next-line reentrancy-events, reentrancy-benign
+ sendCrossDomainMessage(l2TokenBridge, _l2Gas, message);
+
+ // slither-disable-next-line reentrancy-benign
+ deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] + _amount;
+```
+
+`deposits` डेटा संरचना में जमा किए गए टोकन की राशि जोड़ें।
+L2 पर कई पते हो सकते हैं जो एक ही L1 ERC-20 टोकन के अनुरूप हों, इसलिए जमा का ट्रैक रखने के लिए ब्रिज के L1 ERC-20 टोकन की शेष राशि का उपयोग करना पर्याप्त नहीं है।
+
+```solidity
+
+ // slither-disable-next-line reentrancy-events
+ emit ERC20DepositInitiated(_l1Token, _l2Token, _from, _to, _amount, _data);
+ }
+
+ /*************************
+ * क्रॉस-चेन फ़ंक्शन *
+ *************************/
+
+ /**
+ * @inheritdoc IL1StandardBridge
+ */
+ function finalizeETHWithdrawal(
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+```
+
+L2 ब्रिज L2 क्रॉस डोमेन मैसेंजर को एक संदेश भेजता है जो L1 क्रॉस डोमेन मैसेंजर को इस फ़ंक्शन को कॉल करने का कारण बनता है (एक बार जब [संदेश को अंतिम रूप देने वाला ट्रांज़ैक्शन](https://community.optimism.io/docs/developers/bridge/messaging/#fees-for-l2-%E2%87%92-l1-transactions) L1 पर सबमिट किया जाता है, निश्चित रूप से)।
+
+```solidity
+ ) external onlyFromCrossDomainAccount(l2TokenBridge) {
+```
+
+सुनिश्चित करें कि यह एक _वैध_ संदेश है, जो क्रॉस डोमेन मैसेंजर से आ रहा है और L2 टोकन ब्रिज से उत्पन्न हो रहा है।
+इस फ़ंक्शन का उपयोग ब्रिज से ETH निकालने के लिए किया जाता है, इसलिए हमें यह सुनिश्चित करना होगा कि इसे केवल अधिकृत कॉलर द्वारा ही कॉल किया जाए।
+
+```solidity
+ // slither-disable-next-line reentrancy-events
+ (bool success, ) = _to.call{ value: _amount }(new bytes(0));
+```
+
+ETH स्थानांतरित करने का तरीका `msg.value` में wei की राशि के साथ प्राप्तकर्ता को कॉल करना है।
+
+```solidity
+ require(success, "TransferHelper::safeTransferETH: ETH transfer failed");
+
+ // slither-disable-next-line reentrancy-events
+ emit ETHWithdrawalFinalized(_from, _to, _amount, _data);
+```
+
+निकासी के बारे में एक इवेंट उत्सर्जित करें।
+
+```solidity
+ }
+
+ /**
+ * @inheritdoc IL1ERC20Bridge
+ */
+ function finalizeERC20Withdrawal(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+ ) external onlyFromCrossDomainAccount(l2TokenBridge) {
+```
+
+यह फ़ंक्शन ऊपर `finalizeETHWithdrawal` के समान है, जिसमें ERC-20 टोकन के लिए आवश्यक परिवर्तन हैं।
+
+```solidity
+ deposits[_l1Token][_l2Token] = deposits[_l1Token][_l2Token] - _amount;
+```
+
+`deposits` डेटा संरचना को अपडेट करें।
+
+```solidity
+
+ // जब L1 पर एक निकासी को अंतिम रूप दिया जाता है, तो L1 ब्रिज फंड को निकासीकर्ता को स्थानांतरित करता है
+ // slither-disable-next-line reentrancy-events
+ IERC20(_l1Token).safeTransfer(_to, _amount);
+
+ // slither-disable-next-line reentrancy-events
+ emit ERC20WithdrawalFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
+ }
+
+
+ /*****************************
+ * अस्थायी - ETH माइग्रेट करना *
+ *****************************/
+
+ /**
+ * @dev खाते में ETH शेष राशि जोड़ता है। इसका उद्देश्य ETH को
+ * एक पुराने गेटवे से एक नए गेटवे पर माइग्रेट करने की अनुमति देना है।
+ * नोट: यह केवल एक अपग्रेड के लिए छोड़ा गया है ताकि हम पुराने अनुबंध से माइग्रेट किए गए ETH को प्राप्त करने में सक्षम हो सकें
+ *
+ */
+ function donateETH() external payable {}
+}
+```
+
+ब्रिज का एक पहले का कार्यान्वयन था।
+जब हम कार्यान्वयन से इस पर चले गए, तो हमें सभी संपत्तियों को स्थानांतरित करना पड़ा।
+ERC-20 टोकन को बस स्थानांतरित किया जा सकता है।
+हालांकि, एक अनुबंध में ETH स्थानांतरित करने के लिए आपको उस अनुबंध की मंजूरी की आवश्यकता होती है, जो `donateETH` हमें प्रदान करता है।
+
+## L2 पर ERC-20 टोकन {#erc-20-tokens-on-l2}
+
+एक ERC-20 टोकन को स्टैंडर्ड ब्रिज में फिट होने के लिए, इसे स्टैंडर्ड ब्रिज, और _केवल_ स्टैंडर्ड ब्रिज को टोकन मिंट करने की अनुमति देने की आवश्यकता है।
+यह आवश्यक है क्योंकि ब्रिज को यह सुनिश्चित करने की आवश्यकता है कि ऑप्टिमिज्म पर परिचालित टोकन की संख्या L1 ब्रिज अनुबंध के अंदर बंद टोकन की संख्या के बराबर हो।
+यदि L2 पर बहुत अधिक टोकन हैं तो कुछ यूज़र अपनी संपत्ति को L1 पर वापस ब्रिज नहीं कर पाएंगे।
+एक विश्वसनीय ब्रिज के बजाय, हम अनिवार्य रूप से [फ्रैक्शनल रिजर्व बैंकिंग](https://www.investopedia.com/terms/f/fractionalreservebanking.asp) को फिर से बनाएंगे।
+यदि L1 पर बहुत अधिक टोकन हैं, तो उनमें से कुछ टोकन ब्रिज अनुबंध के अंदर हमेशा के लिए बंद रहेंगे क्योंकि L2 टोकन को बर्न किए बिना उन्हें जारी करने का कोई तरीका नहीं है।
+
+### IL2StandardERC20 {#il2standarderc20}
+
+L2 पर प्रत्येक ERC-20 टोकन जो स्टैंडर्ड ब्रिज का उपयोग करता है, उसे [यह इंटरफ़ेस](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/IL2StandardERC20.sol) प्रदान करने की आवश्यकता है, जिसमें स्टैंडर्ड ब्रिज को आवश्यक फ़ंक्शन और इवेंट्स हैं।
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+```
+
+[स्टैंडर्ड ERC-20 इंटरफ़ेस](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol) में `mint` और `burn` फ़ंक्शन शामिल नहीं हैं।
+वे विधियाँ [ERC-20 मानक](https://eips.ethereum.org/EIPS/eip-20) द्वारा आवश्यक नहीं हैं, जो टोकन बनाने और नष्ट करने के तंत्र को अनिर्दिष्ट छोड़ देता है।
+
+```solidity
+import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+```
+
+[ERC-165 इंटरफ़ेस](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol) का उपयोग यह निर्दिष्ट करने के लिए किया जाता है कि एक अनुबंध कौन से फ़ंक्शन प्रदान करता है।
+[आप मानक को यहां पढ़ सकते हैं](https://eips.ethereum.org/EIPS/eip-165)।
+
+```solidity
+interface IL2StandardERC20 is IERC20, IERC165 {
+ function l1Token() external returns (address);
+```
+
+यह फ़ंक्शन L1 टोकन का पता प्रदान करता है जिसे इस अनुबंध से ब्रिज किया गया है।
+ध्यान दें कि हमारे पास विपरीत दिशा में कोई समान फ़ंक्शन नहीं है।
+हमें किसी भी L1 टोकन को ब्रिज करने में सक्षम होना चाहिए, भले ही इसे लागू करते समय L2 समर्थन की योजना बनाई गई हो या नहीं।
+
+```solidity
+
+ function mint(address _to, uint256 _amount) external;
+
+ function burn(address _from, uint256 _amount) external;
+
+ event Mint(address indexed _account, uint256 _amount);
+ event Burn(address indexed _account, uint256 _amount);
+}
+```
+
+टोकन को मिंट (बनाने) और बर्न (नष्ट) करने के लिए फ़ंक्शन और इवेंट्स।
+ब्रिज को एकमात्र इकाई होनी चाहिए जो यह सुनिश्चित करने के लिए इन कार्यों को चला सके कि टोकन की संख्या सही है (L1 पर लॉक किए गए टोकन की संख्या के बराबर)।
+
+### L2StandardERC20 {#L2StandardERC20}
+
+[यह `IL2StandardERC20` इंटरफ़ेस का हमारा कार्यान्वयन है](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/standards/L2StandardERC20.sol)।
+जब तक आपको किसी प्रकार के कस्टम तर्क की आवश्यकता न हो, आपको इसका उपयोग करना चाहिए।
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+```
+
+[OpenZeppelin ERC-20 अनुबंध](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)।
+ऑप्टिमिज्म पहिया को फिर से आविष्कार करने में विश्वास नहीं करता है, खासकर जब पहिया अच्छी तरह से ऑडिट किया गया हो और संपत्ति रखने के लिए पर्याप्त भरोसेमंद होना चाहिए।
+
+```solidity
+import "./IL2StandardERC20.sol";
+
+contract L2StandardERC20 is IL2StandardERC20, ERC20 {
+ address public l1Token;
+ address public l2Bridge;
+```
+
+ये दो अतिरिक्त कॉन्फ़िगरेशन पैरामीटर हैं जिनकी हमें आवश्यकता है और ERC-20 को सामान्य रूप से नहीं होती है।
+
+```solidity
+
+ /**
+ * @param _l2Bridge L2 स्टैंडर्ड ब्रिज का पता।
+ * @param _l1Token संबंधित L1 टोकन का पता।
+ * @param _name ERC20 नाम।
+ * @param _symbol ERC20 प्रतीक।
+ */
+ constructor(
+ address _l2Bridge,
+ address _l1Token,
+ string memory _name,
+ string memory _symbol
+ ) ERC20(_name, _symbol) {
+ l1Token = _l1Token;
+ l2Bridge = _l2Bridge;
+ }
+```
+
+पहले उस अनुबंध के लिए कंस्ट्रक्टर को कॉल करें जिससे हम इनहेरिट करते हैं (`ERC20(_name, _symbol)`) और फिर अपने स्वयं के चर सेट करें।
+
+```solidity
+
+ modifier onlyL2Bridge() {
+ require(msg.sender == l2Bridge, "Only L2 Bridge can mint and burn");
+ _;
+ }
+
+
+ // slither-disable-next-line external-function
+ function supportsInterface(bytes4 _interfaceId) public pure returns (bool) {
+ bytes4 firstSupportedInterface = bytes4(keccak256("supportsInterface(bytes4)")); // ERC165
+ bytes4 secondSupportedInterface = IL2StandardERC20.l1Token.selector ^
+ IL2StandardERC20.mint.selector ^
+ IL2StandardERC20.burn.selector;
+ return _interfaceId == firstSupportedInterface || _interfaceId == secondSupportedInterface;
+ }
+```
+
+यह वह तरीका है जिससे [ERC-165](https://eips.ethereum.org/EIPS/eip-165) काम करता है।
+प्रत्येक इंटरफ़ेस समर्थित फ़ंक्शन की एक संख्या है, और इसे उन फ़ंक्शन के [ABI फ़ंक्शन चयनकर्ताओं](https://docs.soliditylang.org/en/v0.8.12/abi-spec.html#function-selector) के [एक्सक्लूसिव या](https://en.wikipedia.org/wiki/Exclusive_or) के रूप में पहचाना जाता है।
+
+L2 ब्रिज ERC-165 का उपयोग एक सैनिटी चेक के रूप में करता है ताकि यह सुनिश्चित हो सके कि वह ERC-20 अनुबंध जिसमें वह संपत्ति भेजता है, एक `IL2StandardERC20` है।
+
+**नोट:** दुष्ट अनुबंध को `supportsInterface` के लिए झूठे उत्तर प्रदान करने से रोकने के लिए कुछ भी नहीं है, इसलिए यह एक सैनिटी चेक तंत्र है, _न_ कि एक सुरक्षा तंत्र।
+
+```solidity
+ // slither-disable-next-line external-function
+ function mint(address _to, uint256 _amount) public virtual onlyL2Bridge {
+ _mint(_to, _amount);
+
+ emit Mint(_to, _amount);
+ }
+
+ // slither-disable-next-line external-function
+ function burn(address _from, uint256 _amount) public virtual onlyL2Bridge {
+ _burn(_from, _amount);
+
+ emit Burn(_from, _amount);
+ }
+}
+```
+
+केवल L2 ब्रिज को संपत्ति मिंट और बर्न करने की अनुमति है।
+
+`_mint` और `_burn` वास्तव में [OpenZeppelin ERC-20 अनुबंध](/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn) में परिभाषित हैं।
+वह अनुबंध बस उन्हें बाह्य रूप से उजागर नहीं करता है, क्योंकि टोकन को मिंट और बर्न करने की शर्तें उतनी ही विविध हैं जितनी ERC-20 का उपयोग करने के तरीके।
+
+## L2 ब्रिज कोड {#l2-bridge-code}
+
+यह कोड है जो ऑप्टिमिज्म पर ब्रिज चलाता है।
+[इस अनुबंध का स्रोत यहाँ है](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/L2StandardBridge.sol)।
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+/* इंटरफ़ेस इम्पोर्ट */
+import { IL1StandardBridge } from "../../L1/messaging/IL1StandardBridge.sol";
+import { IL1ERC20Bridge } from "../../L1/messaging/IL1ERC20Bridge.sol";
+import { IL2ERC20Bridge } from "./IL2ERC20Bridge.sol";
+```
+
+[IL2ERC20Bridge](https://github.com/ethereum-optimism/optimism/blob/develop/packages/contracts/contracts/L2/messaging/IL2ERC20Bridge.sol) इंटरफ़ेस हमारे द्वारा ऊपर देखे गए [L1 समकक्ष](#IL1ERC20Bridge) के बहुत समान है।
+दो महत्वपूर्ण अंतर हैं:
+
+1. L1 पर आप जमा शुरू करते हैं और निकासी को अंतिम रूप देते हैं।
+ यहां आप निकासी शुरू करते हैं और जमा को अंतिम रूप देते हैं।
+2. L1 पर ETH और ERC-20 टोकन के बीच अंतर करना आवश्यक है।
+ L2 पर हम दोनों के लिए समान फ़ंक्शन का उपयोग कर सकते हैं क्योंकि आंतरिक रूप से ऑप्टिमिज्म पर ETH शेष राशि को पते [0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000](https://explorer.optimism.io/address/0xDeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000) के साथ एक ERC-20 टोकन के रूप में संभाला जाता है।
+
+```solidity
+/* लाइब्रेरी इम्पोर्ट */
+import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
+import { CrossDomainEnabled } from "../../libraries/bridge/CrossDomainEnabled.sol";
+import { Lib_PredeployAddresses } from "../../libraries/constants/Lib_PredeployAddresses.sol";
+
+/* अनुबंध इम्पोर्ट */
+import { IL2StandardERC20 } from "../../standards/IL2StandardERC20.sol";
+
+/**
+ * @title L2StandardBridge
+ * @dev L2 स्टैंडर्ड ब्रिज एक अनुबंध है जो L1 स्टैंडर्ड ब्रिज के साथ मिलकर काम करता है
+ * L1 और L2 के बीच ETH और ERC20 संक्रमण को सक्षम करने के लिए।
+ * यह अनुबंध नए टोकन के लिए एक मिंटर के रूप में कार्य करता है जब यह L1 स्टैंडर्ड में जमा के बारे में सुनता है
+ * ब्रिज।
+ * यह अनुबंध निकासी के लिए इच्छित टोकन के बर्नर के रूप में भी कार्य करता है, L1 को सूचित करता है
+ * L1 फंड जारी करने के लिए ब्रिज।
+ */
+contract L2StandardBridge is IL2ERC20Bridge, CrossDomainEnabled {
+ /********************************
+ * बाहरी अनुबंध संदर्भ *
+ ********************************/
+
+ address public l1TokenBridge;
+```
+
+L1 ब्रिज के पते का ट्रैक रखें।
+ध्यान दें कि L1 समकक्ष के विपरीत, यहाँ हमें इस चर की _आवश्यकता_ है।
+L1 ब्रिज का पता पहले से ज्ञात नहीं है।
+
+```solidity
+
+ /***************
+ * कंस्ट्रक्टर *
+ ***************/
+
+ /**
+ * @param _l2CrossDomainMessenger इस अनुबंध द्वारा उपयोग किया जाने वाला क्रॉस-डोमेन मैसेंजर।
+ * @param _l1TokenBridge मुख्य चेन पर तैनात L1 ब्रिज का पता।
+ */
+ constructor(address _l2CrossDomainMessenger, address _l1TokenBridge)
+ CrossDomainEnabled(_l2CrossDomainMessenger)
+ {
+ l1TokenBridge = _l1TokenBridge;
+ }
+
+ /***************
+ * निकासी *
+ ***************/
+
+ /**
+ * @inheritdoc IL2ERC20Bridge
+ */
+ function withdraw(
+ address _l2Token,
+ uint256 _amount,
+ uint32 _l1Gas,
+ bytes calldata _data
+ ) external virtual {
+ _initiateWithdrawal(_l2Token, msg.sender, msg.sender, _amount, _l1Gas, _data);
+ }
+
+ /**
+ * @inheritdoc IL2ERC20Bridge
+ */
+ function withdrawTo(
+ address _l2Token,
+ address _to,
+ uint256 _amount,
+ uint32 _l1Gas,
+ bytes calldata _data
+ ) external virtual {
+ _initiateWithdrawal(_l2Token, msg.sender, _to, _amount, _l1Gas, _data);
+ }
+```
+
+ये दो फ़ंक्शन निकासी शुरू करते हैं।
+ध्यान दें कि L1 टोकन पता निर्दिष्ट करने की कोई आवश्यकता नहीं है।
+L2 टोकन से यह अपेक्षा की जाती है कि वे हमें L1 समकक्ष का पता बताएं।
+
+```solidity
+
+ /**
+ * @dev टोकन को बर्न करके और सूचित करके निकासी के लिए तर्क करता है
+ * निकासी के L1 टोकन गेटवे।
+ * @param _l2Token L2 टोकन का पता जहां निकासी शुरू की गई है।
+ * @param _from L2 पर निकासी को खींचने के लिए खाता।
+ * @param _to L1 पर निकासी देने के लिए खाता।
+ * @param _amount निकालने के लिए टोकन की राशि।
+ * @param _l1Gas अप्रयुक्त, लेकिन संभावित फॉरवर्ड संगतता विचारों के लिए शामिल है।
+ * @param _data L1 को अग्रेषित करने के लिए वैकल्पिक डेटा। यह डेटा प्रदान किया गया है
+ * पूरी तरह से बाहरी अनुबंधों की सुविधा के रूप में। अधिकतम लागू करने के अलावा
+ * लंबाई, ये अनुबंध इसकी सामग्री के बारे में कोई गारंटी नहीं देते हैं।
+ */
+ function _initiateWithdrawal(
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ uint32 _l1Gas,
+ bytes calldata _data
+ ) internal {
+ // जब एक निकासी शुरू की जाती है, तो हम बाद के L2 को रोकने के लिए निकासीकर्ता के फंड को बर्न करते हैं
+ // उपयोग
+ // slither-disable-next-line reentrancy-events
+ IL2StandardERC20(_l2Token).burn(msg.sender, _amount);
+```
+
+ध्यान दें कि हम `_from` पैरामीटर पर निर्भर नहीं हैं, बल्कि `msg.sender` पर निर्भर हैं, जिसे नकली बनाना बहुत कठिन है (जहां तक मुझे पता है, असंभव है)।
+
+```solidity
+
+ // l1TokenBridge.finalizeERC20Withdrawal(_to, _amount) के लिए calldata का निर्माण करें
+ // slither-disable-next-line reentrancy-events
+ address l1Token = IL2StandardERC20(_l2Token).l1Token();
+ bytes memory message;
+
+ if (_l2Token == Lib_PredeployAddresses.OVM_ETH) {
+```
+
+L1 पर ETH और ERC-20 के बीच अंतर करना आवश्यक है।
+
+```solidity
+ message = abi.encodeWithSelector(
+ IL1StandardBridge.finalizeETHWithdrawal.selector,
+ _from,
+ _to,
+ _amount,
+ _data
+ );
+ } else {
+ message = abi.encodeWithSelector(
+ IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
+ l1Token,
+ _l2Token,
+ _from,
+ _to,
+ _amount,
+ _data
+ );
+ }
+
+ // L1 ब्रिज तक संदेश भेजें
+ // slither-disable-next-line reentrancy-events
+ sendCrossDomainMessage(l1TokenBridge, _l1Gas, message);
+
+ // slither-disable-next-line reentrancy-events
+ emit WithdrawalInitiated(l1Token, _l2Token, msg.sender, _to, _amount, _data);
+ }
+
+ /************************************
+ * क्रॉस-चेन फ़ंक्शन: जमा करना *
+ ************************************/
+
+ /**
+ * @inheritdoc IL2ERC20Bridge
+ */
+ function finalizeDeposit(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+```
+
+यह फ़ंक्शन `L1StandardBridge` द्वारा कॉल किया जाता है।
+
+```solidity
+ ) external virtual onlyFromCrossDomainAccount(l1TokenBridge) {
+```
+
+सुनिश्चित करें कि संदेश का स्रोत वैध है।
+यह महत्वपूर्ण है क्योंकि यह फ़ंक्शन `_mint` को कॉल करता है और उन टोकन को देने के लिए उपयोग किया जा सकता है जो L1 पर ब्रिज के स्वामित्व वाले टोकन द्वारा कवर नहीं किए गए हैं।
+
+```solidity
+ // जांचें कि लक्ष्य टोकन अनुपालन कर रहा है और
+ // सत्यापित करें कि L1 पर जमा किया गया टोकन यहां L2 जमा किए गए टोकन प्रतिनिधित्व से मेल खाता है
+ if (
+ // slither-disable-next-line reentrancy-events
+ ERC165Checker.supportsInterface(_l2Token, 0x1d1d8b63) &&
+ _l1Token == IL2StandardERC20(_l2Token).l1Token()
+```
+
+सैनिटी चेक:
+
+1. सही इंटरफ़ेस समर्थित है
+2. L2 ERC-20 अनुबंध का L1 पता टोकन के L1 स्रोत से मेल खाता है
+
+```solidity
+ ) {
+ // जब एक जमा को अंतिम रूप दिया जाता है, तो हम L2 पर खाते में समान राशि
+ // टोकन जमा करते हैं।
+ // slither-disable-next-line reentrancy-events
+ IL2StandardERC20(_l2Token).mint(_to, _amount);
+ // slither-disable-next-line reentrancy-events
+ emit DepositFinalized(_l1Token, _l2Token, _from, _to, _amount, _data);
+```
+
+यदि सैनिटी चेक पास हो जाते हैं, तो जमा को अंतिम रूप दें:
+
+1. टोकन मिंट करें
+2. उपयुक्त इवेंट उत्सर्जित करें
+
+```solidity
+ } else {
+ // या तो L2 टोकन जिसमें जमा किया जा रहा है, उसके L1 टोकन के सही पते के बारे में असहमत है,
+ // या सही इंटरफ़ेस का समर्थन नहीं करता है।
+ // यह केवल तभी होना चाहिए जब कोई दुर्भावनापूर्ण L2 टोकन हो, या यदि किसी यूज़र ने किसी तरह
+ // जमा करने के लिए गलत L2 टोकन पता निर्दिष्ट किया हो।
+ // किसी भी मामले में, हम यहां प्रक्रिया को रोकते हैं और एक निकासी
+ // संदेश का निर्माण करते हैं ताकि यूज़र कुछ मामलों में अपना धन निकाल सकें।
+ // दुर्भावनापूर्ण टोकन अनुबंधों को पूरी तरह से रोकने का कोई तरीका नहीं है, लेकिन यह यूज़र त्रुटि को सीमित करता है
+ // और दुर्भावनापूर्ण अनुबंध व्यवहार के कुछ रूपों को कम करता है।
+```
+
+यदि किसी यूज़र ने गलत L2 टोकन पते का उपयोग करके एक पता लगाने योग्य त्रुटि की है, तो हम जमा को रद्द करना चाहते हैं और L1 पर टोकन वापस करना चाहते हैं।
+L2 से ऐसा करने का एकमात्र तरीका एक संदेश भेजना है जिसे फॉल्ट चैलेंज अवधि का इंतजार करना होगा, लेकिन यह यूज़र के लिए स्थायी रूप से टोकन खोने से कहीं बेहतर है।
+
+```solidity
+ bytes memory message = abi.encodeWithSelector(
+ IL1ERC20Bridge.finalizeERC20Withdrawal.selector,
+ _l1Token,
+ _l2Token,
+ _to, // जमा को प्रेषक को वापस उछालने के लिए यहां _to और _from को स्विच किया गया है
+ _from,
+ _amount,
+ _data
+ );
+
+ // L1 ब्रिज तक संदेश भेजें
+ // slither-disable-next-line reentrancy-events
+ sendCrossDomainMessage(l1TokenBridge, 0, message);
+ // slither-disable-next-line reentrancy-events
+ emit DepositFailed(_l1Token, _l2Token, _from, _to, _amount, _data);
+ }
+ }
+}
+```
+
+## निष्कर्ष {#conclusion}
+
+स्टैंडर्ड ब्रिज संपत्ति हस्तांतरण के लिए सबसे लचीला तंत्र है।
+हालांकि, क्योंकि यह बहुत सामान्य है, यह हमेशा उपयोग करने के लिए सबसे आसान तंत्र नहीं है।
+विशेष रूप से निकासी के लिए, अधिकांश यूज़र [तृतीय पक्ष ब्रिज](https://optimism.io/apps#bridge) का उपयोग करना पसंद करते हैं जो चुनौती अवधि की प्रतीक्षा नहीं करते हैं और निकासी को अंतिम रूप देने के लिए मर्केल प्रूफ की आवश्यकता नहीं होती है।
+
+ये ब्रिज आमतौर पर L1 पर संपत्ति रखकर काम करते हैं, जिसे वे तुरंत एक छोटे से शुल्क (अक्सर एक स्टैंडर्ड ब्रिज निकासी के लिए गैस की लागत से कम) के लिए प्रदान करते हैं।
+जब ब्रिज (या इसे चलाने वाले लोग) L1 संपत्ति पर कमी का अनुमान लगाते हैं, तो यह L2 से पर्याप्त संपत्ति स्थानांतरित करता है। चूंकि ये बहुत बड़ी निकासी हैं, निकासी लागत एक बड़ी राशि पर परिशोधित होती है और यह बहुत छोटा प्रतिशत है।
+
+उम्मीद है कि इस लेख ने आपको लेयर 2 कैसे काम करता है, और स्पष्ट और सुरक्षित Solidity कोड कैसे लिखना है, के बारे में अधिक समझने में मदद की होगी।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/reverse-engineering-a-contract/index.md b/public/content/translations/hi/developers/tutorials/reverse-engineering-a-contract/index.md
new file mode 100644
index 00000000000..7bd8ebdd728
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/reverse-engineering-a-contract/index.md
@@ -0,0 +1,744 @@
+---
+title: "एक कॉन्ट्रैक्ट की रिवर्स इंजीनियरिंग"
+description: "जब आपके पास सोर्स कोड न हो तो किसी कॉन्ट्रैक्ट को कैसे समझें"
+author: "ओरी पोमेरेन्ट्ज़"
+lang: hi
+tags: [ "evm", "ऑपकोड" ]
+skill: advanced
+published: 2021-12-30
+---
+
+## परिचय {#introduction}
+
+_ब्लॉकचेन पर कोई रहस्य नहीं हैं_, जो कुछ भी होता है वह सुसंगत, सत्यापन योग्य और सार्वजनिक रूप से उपलब्ध होता है। आदर्श रूप से, [कॉन्ट्रैक्ट्स का सोर्स कोड Etherscan पर प्रकाशित और सत्यापित होना चाहिए](https://etherscan.io/address/0xb8901acb165ed027e32754e0ffe830802919727f#code)। हालांकि, [हमेशा ऐसा नहीं होता है](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#code)। इस लेख में आप बिना सोर्स कोड वाले कॉन्ट्रैक्ट को देखकर कॉन्ट्रैक्ट की रिवर्स इंजीनियरिंग करना सीखेंगे, [`0x2510c039cc3b061d79e564b38836da87e31b342f`](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f)।
+
+रिवर्स कंपाइलर होते हैं, लेकिन वे हमेशा [उपयोगी परिणाम](https://etherscan.io/bytecode-decompiler?a=0x2510c039cc3b061d79e564b38836da87e31b342f) नहीं देते हैं। इस लेख में आप [ऑपकोड](https://github.com/wolflo/evm-opcodes) से किसी कॉन्ट्रैक्ट को मैन्युअल रूप से रिवर्स इंजीनियर करना और समझना सीखेंगे, साथ ही डीकंपाइलर के परिणामों की व्याख्या कैसे करें यह भी सीखेंगे।
+
+इस लेख को समझने के लिए आपको पहले से ही EVM की मूल बातें पता होनी चाहिए, और EVM असेंबलर से कम से कम कुछ हद तक परिचित होना चाहिए। [आप इन विषयों के बारे में यहाँ पढ़ सकते हैं](https://medium.com/mycrypto/the-ethereum-virtual-machine-how-does-it-work-9abac2b7c9e)।
+
+## निष्पादन योग्य कोड तैयार करें {#prepare-the-executable-code}
+
+आप कॉन्ट्रैक्ट के लिए Etherscan पर जाकर, **कॉन्ट्रैक्ट** टैब पर क्लिक करके और फिर **ऑपकोड व्यू पर स्विच करें** पर क्लिक करके ऑपकोड प्राप्त कर सकते हैं। आपको एक ऐसा व्यू मिलता है जिसमें प्रति लाइन एक ऑपकोड होता है।
+
+
+
+हालांकि, जंप को समझने के लिए, आपको यह जानना होगा कि प्रत्येक ऑपकोड कोड में कहाँ स्थित है। ऐसा करने के लिए, एक तरीका यह है कि एक Google स्प्रेडशीट खोलें और ऑपकोड को कॉलम C में पेस्ट करें। [आप इस पहले से तैयार स्प्रेडशीट की एक कॉपी बनाकर निम्नलिखित चरणों को छोड़ सकते हैं](https://docs.google.com/spreadsheets/d/1tKmTJiNjUwHbW64wCKOSJxHjmh0bAUapt6btUYE7kDA/edit?usp=sharing)।
+
+अगला कदम सही कोड लोकेशन प्राप्त करना है ताकि हम जंप को समझ सकें। हम ऑपकोड साइज को कॉलम B में, और लोकेशन (हेक्साडेसिमल में) को कॉलम A में रखेंगे। सेल `B1` में इस फ़ंक्शन को टाइप करें और फिर इसे कोड के अंत तक, कॉलम B के बाकी हिस्सों के लिए कॉपी और पेस्ट करें। ऐसा करने के बाद आप कॉलम B को छिपा सकते हैं।
+
+```
+=1+IF(REGEXMATCH(C1,"PUSH"),REGEXEXTRACT(C1,"PUSH(\d+)"),0)
+```
+
+सबसे पहले यह फ़ंक्शन ऑपकोड के लिए एक बाइट जोड़ता है, और फिर `PUSH` की तलाश करता है। पुश ऑपकोड विशेष होते हैं क्योंकि उन्हें पुश किए जा रहे मान के लिए अतिरिक्त बाइट्स की आवश्यकता होती है। यदि ऑपकोड एक `PUSH` है, तो हम बाइट्स की संख्या निकालते हैं और उसे जोड़ते हैं।
+
+`A1` में पहला ऑफ़सेट, शून्य डालें। फिर, `A2` में, इस फ़ंक्शन को डालें और फिर से इसे कॉलम A के बाकी हिस्सों के लिए कॉपी और पेस्ट करें:
+
+```
+=dec2hex(hex2dec(A1)+B1)
+```
+
+हमें इस फ़ंक्शन की आवश्यकता है ताकि हमें हेक्साडेसिमल मान मिल सके क्योंकि जंप (`JUMP` और `JUMPI`) से पहले पुश किए गए मान हमें हेक्साडेसिमल में दिए जाते हैं।
+
+## एंट्री प्वाइंट (0x00) {#the-entry-point-0x00}
+
+कॉन्ट्रैक्ट हमेशा पहले बाइट से निष्पादित होते हैं। यह कोड का प्रारंभिक भाग है:
+
+| ऑफ़सेट | ऑपकोड | स्टैक (ऑपकोड के बाद) |
+| -----: | ------------ | ---------------------------------------------- |
+| 0 | PUSH1 0x80 | 0x80 |
+| 2 | PUSH1 0x40 | 0x40, 0x80 |
+| 4 | MSTORE | खाली |
+| 5 | PUSH1 0x04 | 0x04 |
+| 7 | CALLDATASIZE | CALLDATASIZE 0x04 |
+| 8 | LT | CALLDATASIZE\<4 |
+| 9 | PUSH2 0x005e | 0x5E CALLDATASIZE\<4 |
+| C | JUMPI | खाली |
+
+यह कोड दो चीजें करता है:
+
+1. मेमोरी लोकेशन 0x40-0x5F में 0x80 को 32 बाइट मान के रूप में लिखें (0x80 को 0x5F में संग्रहीत किया जाता है, और 0x40-0x5E सभी शून्य हैं)।
+2. कॉलडेटा का आकार पढ़ें। आमतौर पर एक Ethereum कॉन्ट्रैक्ट के लिए कॉल डेटा [ABI (एप्लिकेशन बाइनरी इंटरफ़ेस)](https://docs.soliditylang.org/en/v0.8.10/abi-spec.html) का पालन करता है, जिसके लिए फ़ंक्शन चयनकर्ता के लिए कम से कम चार बाइट्स की आवश्यकता होती है। यदि कॉल डेटा का आकार चार से कम है, तो 0x5E पर जंप करें।
+
+
+
+### 0x5E पर हैंडलर (गैर-ABI कॉल डेटा के लिए) {#the-handler-at-0x5e-for-non-abi-call-data}
+
+| ऑफ़सेट | ऑपकोड |
+| -----: | ------------ |
+| 5E | JUMPDEST |
+| 5F | CALLDATASIZE |
+| 60 | PUSH2 0x007c |
+| 63 | JUMPI |
+
+यह स्निपेट `JUMPDEST` से शुरू होता है। EVM (एथेरियम वर्चुअल मशीन) प्रोग्राम एक अपवाद फेंकते हैं यदि आप एक ऐसे ऑपकोड पर जंप करते हैं जो `JUMPDEST` नहीं है। फिर यह CALLDATASIZE को देखता है, और यदि यह "true" है (यानी, शून्य नहीं) तो 0x7C पर जंप करता है। हम नीचे उस पर आएंगे।
+
+| ऑफ़सेट | ऑपकोड | स्टैक (ऑपकोड के बाद) |
+| -----: | ---------- | -------------------------------------------------------------------------------------- |
+| 64 | CALLVALUE | कॉल द्वारा प्रदान किया गया [Wei](/glossary/#wei)। Solidity में `msg.value` कहा जाता है |
+| 65 | PUSH1 0x06 | 6 CALLVALUE |
+| 67 | PUSH1 0x00 | 0 6 CALLVALUE |
+| 69 | DUP3 | CALLVALUE 0 6 CALLVALUE |
+| 6A | DUP3 | 6 CALLVALUE 0 6 CALLVALUE |
+| 6B | SLOAD | भंडारण[6] CALLVALUE 0 6 CALLVALUE |
+
+तो जब कोई कॉल डेटा नहीं होता है तो हम Storage[6] का मान पढ़ते हैं। हमें अभी तक यह नहीं पता कि यह मान क्या है, लेकिन हम उन लेन-देन की तलाश कर सकते हैं जो कॉन्ट्रैक्ट को बिना किसी कॉल डेटा के प्राप्त हुए हैं। वे लेनदेन जो बिना किसी कॉल डेटा (और इसलिए कोई विधि नहीं) के केवल ETH ट्रांसफर करते हैं, Etherscan में `Transfer` विधि होती है। वास्तव में, [कॉन्ट्रैक्ट को प्राप्त पहला लेनदेन](https://etherscan.io/tx/0xeec75287a583c36bcc7ca87685ab41603494516a0f5986d18de96c8e630762e7) एक ट्रांसफर है।
+
+यदि हम उस लेनदेन में देखते हैं और **अधिक देखने के लिए क्लिक करें** पर क्लिक करते हैं, तो हम देखते हैं कि कॉल डेटा, जिसे इनपुट डेटा कहा जाता है, वास्तव में खाली (`0x`) है। यह भी ध्यान दें कि मान 1.559 ETH है, जो बाद में प्रासंगिक होगा।
+
+
+
+इसके बाद, **स्टेट** टैब पर क्लिक करें और उस कॉन्ट्रैक्ट का विस्तार करें जिसकी हम रिवर्स इंजीनियरिंग कर रहे हैं (0x2510...)। आप देख सकते हैं कि लेनदेन के दौरान `Storage[6]` बदल गया, और यदि आप Hex को **नंबर** में बदलते हैं, तो आप देखते हैं कि यह 1,559,000,000,000,000,000 हो गया, wei में स्थानांतरित मान (मैंने स्पष्टता के लिए कॉमा जोड़ा है), जो अगले कॉन्ट्रैक्ट मान के अनुरूप है।
+
+![भंडारण[6] में परिवर्तन](storage6.png)
+
+यदि हम [उसी अवधि के अन्य `ट्रांसफर` लेन-देन](https://etherscan.io/tx/0xf708d306de39c422472f43cb975d97b66fd5d6a6863db627067167cbf93d84d1#statechange) के कारण हुए स्टेट परिवर्तनों को देखते हैं, तो हम देखते हैं कि `Storage[6]` ने कुछ समय के लिए कॉन्ट्रैक्ट के मान को ट्रैक किया। अभी के लिए हम इसे `Value*` कहेंगे। तारांकन चिह्न (`*`) हमें याद दिलाता है कि हम अभी तक _नहीं जानते_ कि यह चर क्या करता है, लेकिन यह केवल कॉन्ट्रैक्ट मान को ट्रैक करने के लिए नहीं हो सकता है क्योंकि भंडारण का उपयोग करने की कोई आवश्यकता नहीं है, जो बहुत महंगा है, जब आप `ADDRESS BALANCE` का उपयोग करके अपने खातों का बैलेंस प्राप्त कर सकते हैं। पहला ऑपकोड कॉन्ट्रैक्ट का अपना पता पुश करता है। दूसरा वाला स्टैक के शीर्ष पर पते को पढ़ता है और उसे उस पते की शेष राशि से बदल देता है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ------------------------------------------- |
+| 6C | PUSH2 0x0075 | 0x75 Value\* CALLVALUE 0 6 CALLVALUE |
+| 6F | SWAP2 | CALLVALUE Value\* 0x75 0 6 CALLVALUE |
+| 70 | SWAP1 | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 71 | PUSH2 0x01a7 | 0x01A7 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 74 | JUMP | |
+
+हम जंप डेस्टिनेशन पर इस कोड को ट्रेस करना जारी रखेंगे।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ---------- | ----------------------------------------------------------- |
+| 1A7 | JUMPDEST | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1A8 | PUSH1 0x00 | 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AA | DUP3 | CALLVALUE 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AB | NOT | 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+
+`NOT` बिटवाइज़ है, इसलिए यह कॉल वैल्यू में हर बिट के मान को उलट देता है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ------------------------------------------------------------------------------------------------------ |
+| 1AC | DUP3 | Value\* 2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AD | GT | Value\*>2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AE | ISZERO | Value\*\<=2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1AF | PUSH2 0x01df | 0x01DF Value\*\<=2^256-CALLVALUE-1 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1B2 | JUMPI | |
+
+हम जंप करते हैं यदि `Value*` 2^256-CALLVALUE-1 से छोटा या उसके बराबर है। यह ओवरफ़्लो को रोकने के लिए लॉजिक जैसा दिखता है। और वास्तव में, हम देखते हैं कि कुछ निरर्थक ऑपरेशनों के बाद (उदाहरण के लिए, मेमोरी में लिखना हटा दिया जाने वाला है) ऑफ़सेट 0x01DE पर कॉन्ट्रैक्ट ओवरफ़्लो का पता चलने पर रिवर्ट हो जाता है, जो सामान्य व्यवहार है।
+
+ध्यान दें कि ऐसा ओवरफ़्लो अत्यंत असंभावित है, क्योंकि इसके लिए कॉल वैल्यू प्लस `Value*` को 2^256 wei, लगभग 10^59 ETH के बराबर होना होगा। [कुल ETH आपूर्ति, लिखते समय, दो सौ मिलियन से कम है](https://etherscan.io/stat/supply)।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | -------- | ----------------------------------------- |
+| 1DF | JUMPDEST | 0x00 Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E0 | POP | Value\* CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E1 | ADD | Value\*+CALLVALUE 0x75 0 6 CALLVALUE |
+| 1E2 | SWAP1 | 0x75 Value\*+CALLVALUE 0 6 CALLVALUE |
+| 1E3 | JUMP | |
+
+यदि हम यहाँ पहुँचते हैं, तो `Value* + CALLVALUE` प्राप्त करें और ऑफ़सेट 0x75 पर जंप करें।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | -------- | ------------------------------- |
+| 75 | JUMPDEST | Value\*+CALLVALUE 0 6 CALLVALUE |
+| 76 | SWAP1 | 0 Value\*+CALLVALUE 6 CALLVALUE |
+| 77 | SWAP2 | 6 Value\*+CALLVALUE 0 CALLVALUE |
+| 78 | SSTORE | 0 CALLVALUE |
+
+यदि हम यहाँ पहुँचते हैं (जिसके लिए कॉल डेटा खाली होना आवश्यक है) तो हम `Value*` में कॉल वैल्यू जोड़ते हैं। यह उसके अनुरूप है जो हम कहते हैं कि `ट्रांसफर` लेनदेन करते हैं।
+
+| ऑफ़सेट | ऑपकोड |
+| -----: | ----- |
+| 79 | POP |
+| 7A | POP |
+| 7B | STOP |
+
+अंत में, स्टैक को साफ़ करें (जो आवश्यक नहीं है) और लेनदेन के सफल अंत का संकेत दें।
+
+संक्षेप में, यहाँ प्रारंभिक कोड के लिए एक फ़्लोचार्ट है।
+
+
+
+## 0x7C पर हैंडलर {#the-handler-at-0x7c}
+
+मैंने जानबूझकर शीर्षक में यह नहीं डाला कि यह हैंडलर क्या करता है। इसका उद्देश्य आपको यह सिखाना नहीं है कि यह विशिष्ट कॉन्ट्रैक्ट कैसे काम करता है, बल्कि यह सिखाना है कि कॉन्ट्रैक्ट की रिवर्स इंजीनियरिंग कैसे की जाती है। आप उसी तरह सीखेंगे कि यह क्या करता है जैसे मैंने किया, कोड का पालन करके।
+
+हम यहाँ कई जगहों से आते हैं:
+
+- यदि 1, 2, या 3 बाइट्स का कॉल डेटा है (ऑफ़सेट 0x63 से)
+- यदि विधि हस्ताक्षर अज्ञात है (ऑफ़सेट 0x42 और 0x5D से)
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ----------------------------------------------------------------------- |
+| 7C | JUMPDEST | |
+| 7D | PUSH1 0x00 | 0x00 |
+| 7F | PUSH2 0x009d | 0x9D 0x00 |
+| 82 | PUSH1 0x03 | 0x03 0x9D 0x00 |
+| 84 | SLOAD | भंडारण[3] 0x9D 0x00 |
+
+यह एक और भंडारण सेल है, जिसे मैं किसी भी लेनदेन में नहीं खोज सका, इसलिए यह जानना कठिन है कि इसका क्या मतलब है। नीचे दिया गया कोड इसे और स्पष्ट कर देगा।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 85 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xff....ff भंडारण[3] 0x9D 0x00 |
+| 9A | AND | भंडारण[3]-के-रूप-में-पता 0x9D 0x00 |
+
+ये ऑपकोड हमारे द्वारा Storage[3] से पढ़े गए मान को 160 बिट्स तक छोटा कर देते हैं, जो एक Ethereum पते की लंबाई है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ----- | -------------------------------------------------------------------------------------- |
+| 9B | SWAP1 | 0x9D भंडारण[3]-के-रूप-में-पता 0x00 |
+| 9C | JUMP | भंडारण[3]-के-रूप-में-पता 0x00 |
+
+यह जंप अनावश्यक है, क्योंकि हम अगले ऑपकोड पर जा रहे हैं। यह कोड उतना गैस-कुशल नहीं है जितना हो सकता था।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| 9D | JUMPDEST | भंडारण[3]-के-रूप-में-पता 0x00 |
+| 9E | SWAP1 | 0x00 भंडारण[3]-के-रूप-में-पता |
+| 9F | POP | भंडारण[3]-के-रूप-में-पता |
+| A0 | PUSH1 0x40 | 0x40 भंडारण[3]-के-रूप-में-पता |
+| A2 | MLOAD | Mem[0x40] भंडारण[3]-के-रूप-में-पता |
+
+कोड की शुरुआत में ही हमने Mem[0x40] को 0x80 पर सेट किया है। यदि हम बाद में 0x40 की तलाश करते हैं, तो हम देखते हैं कि हम इसे नहीं बदलते हैं - इसलिए हम मान सकते हैं कि यह 0x80 है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | -------------------------------------------------------------------------------------------------------- |
+| A3 | CALLDATASIZE | CALLDATASIZE 0x80 भंडारण[3]-के-रूप-में-पता |
+| A4 | PUSH1 0x00 | 0x00 CALLDATASIZE 0x80 भंडारण[3]-के-रूप-में-पता |
+| A6 | DUP3 | 0x80 0x00 CALLDATASIZE 0x80 भंडारण[3]-के-रूप-में-पता |
+| A7 | CALLDATACOPY | 0x80 भंडारण[3]-के-रूप-में-पता |
+
+सभी कॉल डेटा को मेमोरी में कॉपी करें, 0x80 से शुरू करते हुए।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| A8 | PUSH1 0x00 | 0x00 0x80 भंडारण[3]-के-रूप-में-पता |
+| AA | DUP1 | 0x00 0x00 0x80 भंडारण[3]-के-रूप-में-पता |
+| AB | CALLDATASIZE | CALLDATASIZE 0x00 0x00 0x80 भंडारण[3]-के-रूप-में-पता |
+| AC | DUP4 | 0x80 CALLDATASIZE 0x00 0x00 0x80 भंडारण[3]-के-रूप-में-पता |
+| AD | DUP6 | भंडारण[3]-के-रूप-में-पता 0x80 CALLDATASIZE 0x00 0x00 0x80 भंडारण[3]-के-रूप-में-पता |
+| AE | GAS | GAS भंडारण[3]-के-रूप-में-पता 0x80 CALLDATASIZE 0x00 0x00 0x80 भंडारण[3]-के-रूप-में-पता |
+| AF | DELEGATE_CALL | |
+
+अब चीजें बहुत स्पष्ट हैं। यह कॉन्ट्रैक्ट [प्रॉक्सी](https://blog.openzeppelin.com/proxy-patterns/) के रूप में कार्य कर सकता है, जो वास्तविक कार्य करने के लिए Storage[3] में पते को कॉल करता है। `DELEGATE_CALL` एक अलग कॉन्ट्रैक्ट को कॉल करता है, लेकिन उसी भंडारण में रहता है। इसका मतलब है कि प्रत्यायोजित कॉन्ट्रैक्ट, जिसके लिए हम एक प्रॉक्सी हैं, उसी भंडारण स्थान तक पहुँचता है। कॉल के लिए पैरामीटर हैं:
+
+- _गैस_: बची हुई सभी गैस
+- _कॉल किया गया पता_: भंडारण[3]-के-रूप-में-पता
+- _कॉल डेटा_: 0x80 से शुरू होने वाले CALLDATASIZE बाइट्स, जहाँ हमने मूल कॉल डेटा रखा था
+- _रिटर्न डेटा_: कोई नहीं (0x00 - 0x00) हम रिटर्न डेटा अन्य तरीकों से प्राप्त करेंगे (नीचे देखें)
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| B0 | RETURNDATASIZE | RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| B1 | DUP1 | RETURNDATASIZE RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| B2 | PUSH1 0x00 | 0x00 RETURNDATASIZE RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| B4 | DUP5 | 0x80 0x00 RETURNDATASIZE RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| B5 | RETURNDATACOPY | RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+
+यहां हम सभी रिटर्न डेटा को मेमोरी बफर में कॉपी करते हैं जो 0x80 से शुरू होता है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| B6 | DUP2 | (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| B7 | DUP1 | (((कॉल सफलता/विफलता))) (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| B8 | ISZERO | (((क्या कॉल विफल हुआ))) (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| B9 | PUSH2 0x00c0 | 0xC0 (((क्या कॉल विफल हुआ))) (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| BC | JUMPI | (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| BD | DUP2 | RETURNDATASIZE (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| BE | DUP5 | 0x80 RETURNDATASIZE (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| BF | RETURN | |
+
+तो कॉल के बाद हम रिटर्न डेटा को बफर 0x80 - 0x80+RETURNDATASIZE पर कॉपी करते हैं, और यदि कॉल सफल होता है तो हम ठीक उसी बफर के साथ `RETURN` करते हैं।
+
+### DELEGATECALL विफल {#delegatecall-failed}
+
+अगर हम यहां, 0xC0 पर पहुंचते हैं, तो इसका मतलब है कि हमने जिस कॉन्ट्रैक्ट को कॉल किया था वह रिवर्ट हो गया। चूंकि हम केवल उस कॉन्ट्रैक्ट के लिए एक प्रॉक्सी हैं, हम उसी डेटा को वापस करना चाहते हैं और रिवर्ट भी करना चाहते हैं।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| C0 | JUMPDEST | (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| C1 | DUP2 | RETURNDATASIZE (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| C2 | DUP5 | 0x80 RETURNDATASIZE (((कॉल सफलता/विफलता))) RETURNDATASIZE (((कॉल सफलता/विफलता))) 0x80 भंडारण[3]-के-रूप-में-पता |
+| C3 | REVERT | |
+
+तो हम उसी बफर के साथ `REVERT` करते हैं जिसका उपयोग हमने पहले `RETURN` के लिए किया था: 0x80 - 0x80+RETURNDATASIZE
+
+
+
+## ABI कॉल {#abi-calls}
+
+यदि कॉल डेटा का आकार चार बाइट या अधिक है तो यह एक वैध ABI कॉल हो सकता है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ---------------------------------------------------------------------------------------------------------------------- |
+| D | PUSH1 0x00 | 0x00 |
+| F | CALLDATALOAD | (((कॉल डेटा का पहला शब्द (256 बिट)))) |
+| 10 | PUSH1 0xe0 | 0xE0 (((कॉल डेटा का पहला शब्द (256 बिट)))) |
+| 12 | SHR | (((कॉल डेटा के पहले 32 बिट (4 बाइट्स)))) |
+
+Etherscan हमें बताता है कि `1C` एक अज्ञात ऑपकोड है, क्योंकि [इसे Etherscan द्वारा इस सुविधा को लिखने के बाद जोड़ा गया था](https://eips.ethereum.org/EIPS/eip-145) और उन्होंने इसे अपडेट नहीं किया है। एक [अद्यतित ऑपकोड तालिका](https://github.com/wolflo/evm-opcodes) हमें दिखाती है कि यह राइट शिफ्ट है
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 13 | DUP1 | (((कॉल डेटा के पहले 32 बिट (4 बाइट्स)))) (((कॉल डेटा के पहले 32 बिट (4 बाइट्स)))) |
+| 14 | PUSH4 0x3cd8045e | 0x3CD8045E (((कॉल डेटा के पहले 32 बिट (4 बाइट्स)))) (((कॉल डेटा के पहले 32 बिट (4 बाइट्स)))) |
+| 19 | GT | 0x3CD8045E>कॉल-डेटा-के-पहले-32-बिट्स (((कॉल डेटा के पहले 32 बिट (4 बाइट्स)))) |
+| 1A | PUSH2 0x0043 | 0x43 0x3CD8045E>कॉल-डेटा-के-पहले-32-बिट्स (((कॉल डेटा के पहले 32 बिट (4 बाइट्स)))) |
+| 1D | JUMPI | (((कॉल डेटा के पहले 32 बिट (4 बाइट्स)))) |
+
+इस तरह से विधि हस्ताक्षर मिलान परीक्षणों को दो भागों में विभाजित करने से औसतन आधे परीक्षण बच जाते हैं। इसके तुरंत बाद का कोड और 0x43 में कोड एक ही पैटर्न का पालन करता है: कॉल डेटा के पहले 32 बिट्स को `DUP1` करें, `PUSH4 (((विधि हस्ताक्षर))`, समानता की जांच के लिए `EQ` चलाएं, और फिर यदि विधि हस्ताक्षर मेल खाता है तो `JUMPI` करें। यहाँ विधि हस्ताक्षर, उनके पते, और यदि ज्ञात हो तो [संबंधित विधि परिभाषा](https://www.4byte.directory/) दी गई है:
+
+| विधि | विधि हस्ताक्षर | जंप करने के लिए ऑफ़सेट |
+| --------------------------------------------------------------------------------------------------------- | -------------- | ---------------------- |
+| [splitter()](https://www.4byte.directory/signatures/?bytes4_signature=0x3cd8045e) | 0x3cd8045e | 0x0103 |
+| ??? | 0x81e580d3 | 0x0138 |
+| [currentWindow()](https://www.4byte.directory/signatures/?bytes4_signature=0xba0bafb4) | 0xba0bafb4 | 0x0158 |
+| ??? | 0x1f135823 | 0x00C4 |
+| [merkleRoot()](https://www.4byte.directory/signatures/?bytes4_signature=0x2eb4a7ab) | 0x2eb4a7ab | 0x00ED |
+
+यदि कोई मिलान नहीं मिलता है, तो कोड [0x7C पर प्रॉक्सी हैंडलर पर](#the-handler-at-0x7c) जंप करता है, इस उम्मीद में कि जिस कॉन्ट्रैक्ट के लिए हम प्रॉक्सी हैं, उसमें एक मिलान है।
+
+
+
+## splitter() {#splitter}
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ----------------------------- |
+| 103 | JUMPDEST | |
+| 104 | CALLVALUE | CALLVALUE |
+| 105 | DUP1 | CALLVALUE CALLVALUE |
+| 106 | ISZERO | CALLVALUE==0 CALLVALUE |
+| 107 | PUSH2 0x010f | 0x010F CALLVALUE==0 CALLVALUE |
+| 10A | JUMPI | CALLVALUE |
+| 10B | PUSH1 0x00 | 0x00 CALLVALUE |
+| 10D | DUP1 | 0x00 0x00 CALLVALUE |
+| 10E | REVERT | |
+
+यह फ़ंक्शन सबसे पहले यह जाँचता है कि कॉल ने कोई ETH नहीं भेजा है। यह फ़ंक्शन [`payable`](https://solidity-by-example.org/payable/) नहीं है। यदि किसी ने हमें ETH भेजा है तो यह एक गलती होनी चाहिए और हम उस ETH को वापस पाने से बचने के लिए `REVERT` करना चाहते हैं।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 10F | JUMPDEST | |
+| 110 | POP | |
+| 111 | PUSH1 0x03 | 0x03 |
+| 113 | SLOAD | (((भंडारण[3] उर्फ कॉन्ट्रैक्ट जिसके लिए हम एक प्रॉक्सी हैं))) |
+| 114 | PUSH1 0x40 | 0x40 (((भंडारण[3] उर्फ कॉन्ट्रैक्ट जिसके लिए हम एक प्रॉक्सी हैं))) |
+| 116 | MLOAD | 0x80 (((भंडारण[3] उर्फ कॉन्ट्रैक्ट जिसके लिए हम एक प्रॉक्सी हैं))) |
+| 117 | PUSH20 0xffffffffffffffffffffffffffffffffffffffff | 0xFF...FF 0x80 (((भंडारण[3] उर्फ कॉन्ट्रैक्ट जिसके लिए हम एक प्रॉक्सी हैं))) |
+| 12C | SWAP1 | 0x80 0xFF...FF (((भंडारण[3] उर्फ कॉन्ट्रैक्ट जिसके लिए हम एक प्रॉक्सी हैं))) |
+| 12D | SWAP2 | (((भंडारण[3] उर्फ कॉन्ट्रैक्ट जिसके लिए हम एक प्रॉक्सी हैं))) 0xFF...FF 0x80 |
+| 12E | AND | ProxyAddr 0x80 |
+| 12F | DUP2 | 0x80 ProxyAddr 0x80 |
+| 130 | MSTORE | 0x80 |
+
+और 0x80 में अब प्रॉक्सी पता है
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | --------- |
+| 131 | PUSH1 0x20 | 0x20 0x80 |
+| 133 | ADD | 0xA0 |
+| 134 | PUSH2 0x00e4 | 0xE4 0xA0 |
+| 137 | JUMP | 0xA0 |
+
+### E4 कोड {#the-e4-code}
+
+यह पहली बार है जब हम इन पंक्तियों को देखते हैं, लेकिन वे अन्य विधियों के साथ साझा की जाती हैं (नीचे देखें)। तो हम स्टैक में मान को X कहेंगे, और बस याद रखेंगे कि `splitter()` में इस X का मान 0xA0 है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ---------- | ----------- |
+| E4 | JUMPDEST | X |
+| E5 | PUSH1 0x40 | 0x40 X |
+| E7 | MLOAD | 0x80 X |
+| E8 | DUP1 | 0x80 0x80 X |
+| E9 | SWAP2 | X 0x80 0x80 |
+| EA | SUB | X-0x80 0x80 |
+| EB | SWAP1 | 0x80 X-0x80 |
+| EC | RETURN | |
+
+तो यह कोड स्टैक में एक मेमोरी पॉइंटर (X) प्राप्त करता है, और कॉन्ट्रैक्ट को 0x80 - X के बफर के साथ `RETURN` करने का कारण बनता है।
+
+`splitter()` के मामले में, यह उस पते को लौटाता है जिसके लिए हम एक प्रॉक्सी हैं। `RETURN` बफर को 0x80-0x9F में लौटाता है, जहां हमने यह डेटा लिखा था (ऊपर ऑफ़सेट 0x130)।
+
+## currentWindow() {#currentwindow}
+
+ऑफसेट 0x158-0x163 में कोड `splitter()` में 0x103-0x10E में हमने जो देखा था, उसके समान है (`JUMPI` गंतव्य के अलावा), इसलिए हम जानते हैं कि `currentWindow()` भी `payable` नहीं है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ----------------------------------------------------------------------- |
+| 164 | JUMPDEST | |
+| 165 | POP | |
+| 166 | PUSH2 0x00da | 0xDA |
+| 169 | PUSH1 0x01 | 0x01 0xDA |
+| 16B | SLOAD | भंडारण[1] 0xDA |
+| 16C | DUP2 | 0xDA भंडारण[1] 0xDA |
+| 16D | JUMP | भंडारण[1] 0xDA |
+
+### DA कोड {#the-da-code}
+
+यह कोड अन्य विधियों के साथ भी साझा किया जाता है। तो हम स्टैक में मान को Y कहेंगे, और बस याद रखेंगे कि `currentWindow()` में इस Y का मान Storage[1] है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ---------- | ---------------- |
+| DA | JUMPDEST | Y 0xDA |
+| DB | PUSH1 0x40 | 0x40 Y 0xDA |
+| DD | MLOAD | 0x80 Y 0xDA |
+| DE | SWAP1 | Y 0x80 0xDA |
+| DF | DUP2 | 0x80 Y 0x80 0xDA |
+| E0 | MSTORE | 0x80 0xDA |
+
+Y को 0x80-0x9F में लिखें।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ---------- | -------------- |
+| E1 | PUSH1 0x20 | 0x20 0x80 0xDA |
+| E3 | ADD | 0xA0 0xDA |
+
+और बाकी सब कुछ पहले ही [ऊपर](#the-e4-code) समझाया जा चुका है। तो 0xDA पर जंप स्टैक टॉप (Y) को 0x80-0x9F पर लिखते हैं, और उस मान को कॉलर को लौटाते हैं। `currentWindow()` के मामले में, यह Storage[1] लौटाता है।
+
+## merkleRoot() {#merkleroot}
+
+ऑफसेट 0xED-0xF8 में कोड `splitter()` में 0x103-0x10E में हमने जो देखा था, उसके समान है (`JUMPI` गंतव्य के अलावा), इसलिए हम जानते हैं कि `merkleRoot()` भी `payable` नहीं है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ----------------------------------------------------------------------- |
+| F9 | JUMPDEST | |
+| FA | POP | |
+| FB | PUSH2 0x00da | 0xDA |
+| FE | PUSH1 0x00 | 0x00 0xDA |
+| 100 | SLOAD | भंडारण[0] 0xDA |
+| 101 | DUP2 | 0xDA भंडारण[0] 0xDA |
+| 102 | JUMP | भंडारण[0] 0xDA |
+
+जंप के बाद क्या होता है [यह हम पहले ही पता लगा चुके हैं](#the-da-code)। तो `merkleRoot()` Storage[0] लौटाता है।
+
+## 0x81e580d3 {#0x81e580d3}
+
+ऑफसेट 0x138-0x143 में कोड `splitter()` में 0x103-0x10E में हमने जो देखा था, उसके समान है (`JUMPI` गंतव्य के अलावा), इसलिए हम जानते हैं कि यह फ़ंक्शन भी `payable` नहीं है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ------------------------------------------------------------------------------- |
+| 144 | JUMPDEST | |
+| 145 | POP | |
+| 146 | PUSH2 0x00da | 0xDA |
+| 149 | PUSH2 0x0153 | 0x0153 0xDA |
+| 14C | CALLDATASIZE | CALLDATASIZE 0x0153 0xDA |
+| 14D | PUSH1 0x04 | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 14F | PUSH2 0x018f | 0x018F 0x04 CALLDATASIZE 0x0153 0xDA |
+| 152 | JUMP | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 18F | JUMPDEST | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 190 | PUSH1 0x00 | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 192 | PUSH1 0x20 | 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 194 | DUP3 | 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 195 | DUP5 | CALLDATASIZE 0x04 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 196 | SUB | CALLDATASIZE-4 0x20 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 197 | SLT | CALLDATASIZE-4\<32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 198 | ISZERO | CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 199 | PUSH2 0x01a0 | 0x01A0 CALLDATASIZE-4>=32 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19C | JUMPI | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+
+ऐसा लगता है कि इस फ़ंक्शन को कम से कम 32 बाइट्स (एक शब्द) का कॉल डेटा लेता है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------ | -------------------------------------------- |
+| 19D | DUP1 | 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19E | DUP2 | 0x00 0x00 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 19F | REVERT | |
+
+यदि इसे कॉल डेटा नहीं मिलता है तो लेनदेन बिना किसी रिटर्न डेटा के रिवर्ट हो जाता है।
+
+आइए देखें कि क्या होता है यदि फ़ंक्शन को वह कॉल डेटा _मिलता_ है जिसकी उसे आवश्यकता है।
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | ----------------------------------------------------------- |
+| 1A0 | JUMPDEST | 0x00 0x04 CALLDATASIZE 0x0153 0xDA |
+| 1A1 | POP | 0x04 CALLDATASIZE 0x0153 0xDA |
+| 1A2 | CALLDATALOAD | calldataload(4) CALLDATASIZE 0x0153 0xDA |
+
+`calldataload(4)` कॉल डेटा का पहला शब्द है _के बाद_ विधि हस्ताक्षर
+
+| ऑफ़सेट | ऑपकोड | स्टैक |
+| -----: | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 1A3 | SWAP2 | 0x0153 CALLDATASIZE calldataload(4) 0xDA |
+| 1A4 | SWAP1 | CALLDATASIZE 0x0153 calldataload(4) 0xDA |
+| 1A5 | POP | 0x0153 calldataload(4) 0xDA |
+| 1A6 | JUMP | calldataload(4) 0xDA |
+| 153 | JUMPDEST | calldataload(4) 0xDA |
+| 154 | PUSH2 0x016e | 0x016E calldataload(4) 0xDA |
+| 157 | JUMP | calldataload(4) 0xDA |
+| 16E | JUMPDEST | calldataload(4) 0xDA |
+| 16F | PUSH1 0x04 | 0x04 calldataload(4) 0xDA |
+| 171 | DUP2 | calldataload(4) 0x04 calldataload(4) 0xDA |
+| 172 | DUP2 | 0x04 calldataload(4) 0x04 calldataload(4) 0xDA |
+| 173 | SLOAD | भंडारण[4] calldataload(4) 0x04 calldataload(4) 0xDA |
+| 174 | DUP2 | calldataload(4) भंडारण[4] calldataload(4) 0x04 calldataload(4) 0xDA |
+| 175 | LT | calldataload(4)\)` है, और दूसरी `isClaimed()` है, इसलिए यह एक एयरड्रॉप कॉन्ट्रैक्ट जैसा लगता है। बाकी ऑपकोड-दर-ऑपकोड जाने के बजाय, हम [डीकंपाइलर को आजमा सकते हैं](https://etherscan.io/bytecode-decompiler?a=0x2f81e57ff4f4d83b40a9f719fd892d8e806e0761), जो इस कॉन्ट्रैक्ट से तीन कार्यों के लिए प्रयोग करने योग्य परिणाम देता है। दूसरों की रिवर्स इंजीनियरिंग पाठक के लिए एक अभ्यास के रूप में छोड़ दी गई है।
+
+### scaleAmountByPercentage {#scaleamountbypercentage}
+
+यह वह है जो डीकंपाइलर हमें इस फ़ंक्शन के लिए देता है:
+
+```python
+def unknown8ffb5c97(uint256 _param1, uint256 _param2) payable:
+ require calldata.size - 4 >=′ 64
+ if _param1 and _param2 > -1 / _param1:
+ revert with 0, 17
+ return (_param1 * _param2 / 100 * 10^6)
+```
+
+पहला `require` यह परीक्षण करता है कि कॉल डेटा में, फ़ंक्शन हस्ताक्षर के चार बाइट्स के अलावा, कम से कम 64 बाइट्स हैं, जो दो मापदंडों के लिए पर्याप्त हैं। यदि नहीं तो स्पष्ट रूप से कुछ गड़बड़ है।
+
+`if` स्टेटमेंट यह जांचता प्रतीत होता है कि `_param1` शून्य नहीं है, और यह कि `_param1 * _param2` ऋणात्मक नहीं है। यह शायद रैप अराउंड के मामलों को रोकने के लिए है।
+
+अंत में, फ़ंक्शन एक स्केल्ड मान लौटाता है।
+
+### दावा {#claim}
+
+डीकंपाइलर द्वारा बनाया गया कोड जटिल है, और इसका सब कुछ हमारे लिए प्रासंगिक नहीं है। मैं उपयोगी जानकारी प्रदान करने वाली पंक्तियों पर ध्यान केंद्रित करने के लिए इसमें से कुछ को छोड़ने जा रहा हूं
+
+```python
+def unknown2e7ba6ef(uint256 _param1, uint256 _param2, uint256 _param3, array _param4) payable:
+ ...
+ require _param2 == addr(_param2)
+ ...
+ if currentWindow <= _param1:
+ revert with 0, 'cannot claim for a future window'
+```
+
+हम यहां दो महत्वपूर्ण बातें देखते हैं:
+
+- `_param2`, जबकि इसे `uint256` के रूप में घोषित किया गया है, वास्तव में एक पता है
+- `_param1` दावा की जा रही विंडो है, जिसे `currentWindow` या उससे पहले होना चाहिए।
+
+```python
+ ...
+ if stor5[_claimWindow][addr(_claimFor)]:
+ revert with 0, 'Account already claimed the given window'
+```
+
+तो अब हम जानते हैं कि Storage[5] विंडो और पतों की एक सरणी है, और क्या पते ने उस विंडो के लिए इनाम का दावा किया है।
+
+```python
+ ...
+ idx = 0
+ s = 0
+ while idx < _param4.length:
+ ...
+ if s + sha3(mem[(32 * _param4.length) + 328 len mem[(32 * _param4.length) + 296]]) > mem[(32 * idx) + 296]:
+ mem[mem[64] + 32] = mem[(32 * idx) + 296]
+ ...
+ s = sha3(mem[_62 + 32 len mem[_62]])
+ continue
+ ...
+ s = sha3(mem[_66 + 32 len mem[_66]])
+ continue
+ if unknown2eb4a7ab != s:
+ revert with 0, 'Invalid proof'
+```
+
+हम जानते हैं कि `unknown2eb4a7ab` वास्तव में फ़ंक्शन `merkleRoot()` है, इसलिए यह कोड ऐसा लगता है जैसे यह एक [मर्कल प्रूफ](https://medium.com/crypto-0-nite/merkle-proofs-explained-6dd429623dc5) की पुष्टि कर रहा है। इसका मतलब है कि `_param4` एक मर्कल प्रूफ है।
+
+```python
+ call addr(_param2) with:
+ value unknown81e580d3[_param1] * _param3 / 100 * 10^6 wei
+ gas 30000 wei
+```
+
+यह है कि कैसे एक कॉन्ट्रैक्ट अपने ETH को दूसरे पते (कॉन्ट्रैक्ट या बाहरी रूप से स्वामित्व वाले) में स्थानांतरित करता है। यह इसे एक मान के साथ कॉल करता है जो स्थानांतरित की जाने वाली राशि है। तो ऐसा लगता है कि यह ETH का एक एयरड्रॉप है।
+
+```python
+ if not return_data.size:
+ if not ext_call.success:
+ require ext_code.size(stor2)
+ call stor2.deposit() with:
+ value unknown81e580d3[_param1] * _param3 / 100 * 10^6 wei
+```
+
+नीचे की दो पंक्तियाँ हमें बताती हैं कि Storage[2] भी एक कॉन्ट्रैक्ट है जिसे हम कॉल करते हैं। यदि हम [कंस्ट्रक्टर लेनदेन को देखते हैं](https://etherscan.io/tx/0xa1ea0549fb349eb7d3aff90e1d6ce7469fdfdcd59a2fd9b8d1f5e420c0d05b58#statechange) तो हम देखते हैं कि यह कॉन्ट्रैक्ट [0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2) है, एक रैप्ड ईथर कॉन्ट्रैक्ट [जिसका सोर्स कोड Etherscan पर अपलोड किया गया है](https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code)।
+
+तो ऐसा लगता है कि कॉन्ट्रैक्ट `_param2` को ETH भेजने का प्रयास करता है। अगर यह कर सकता है, तो बढ़िया। यदि नहीं, तो यह [WETH](https://weth.tkn.eth.limo/) भेजने का प्रयास करता है। यदि `_param2` एक बाहरी स्वामित्व वाला खाता (EOA) है तो यह हमेशा ETH प्राप्त कर सकता है, लेकिन कॉन्ट्रैक्ट ETH प्राप्त करने से इनकार कर सकते हैं। हालांकि, WETH ERC-20 है और कॉन्ट्रैक्ट इसे स्वीकार करने से इनकार नहीं कर सकते हैं।
+
+```python
+ ...
+ log 0xdbd5389f: addr(_param2), unknown81e580d3[_param1] * _param3 / 100 * 10^6, bool(ext_call.success)
+```
+
+फ़ंक्शन के अंत में हम देखते हैं कि एक लॉग प्रविष्टि उत्पन्न हो रही है। [उत्पन्न लॉग प्रविष्टियों को देखें](https://etherscan.io/address/0x2510c039cc3b061d79e564b38836da87e31b342f#events) और उस विषय पर फ़िल्टर करें जो `0xdbd5...` से शुरू होता है। यदि हम [ऐसी प्रविष्टि उत्पन्न करने वाले लेनदेन में से किसी एक पर क्लिक करते हैं](https://etherscan.io/tx/0xe7d3b7e00f645af17dfbbd010478ef4af235896c65b6548def1fe95b3b7d2274) तो हम देखते हैं कि वास्तव में यह एक दावे की तरह लगता है - खाते ने उस कॉन्ट्रैक्ट को एक संदेश भेजा जिसकी हम रिवर्स इंजीनियरिंग कर रहे हैं, और बदले में ETH मिला।
+
+
+
+### 1e7df9d3 {#1e7df9d3}
+
+यह फ़ंक्शन ऊपर दिए गए [`claim`](#claim) के बहुत समान है। यह एक मर्कल प्रूफ की भी जांच करता है, पहले को ETH स्थानांतरित करने का प्रयास करता है, और उसी प्रकार की लॉग प्रविष्टि उत्पन्न करता है।
+
+```python
+def unknown1e7df9d3(uint256 _param1, uint256 _param2, array _param3) payable:
+ ...
+ idx = 0
+ s = 0
+ while idx < _param3.length:
+ if idx >= mem[96]:
+ revert with 0, 50
+ _55 = mem[(32 * idx) + 128]
+ if s + sha3(mem[(32 * _param3.length) + 160 len mem[(32 * _param3.length) + 128]]) > mem[(32 * idx) + 128]:
+ ...
+ s = sha3(mem[_58 + 32 len mem[_58]])
+ continue
+ mem[mem[64] + 32] = s + sha3(mem[(32 * _param3.length) + 160 len mem[(32 * _param3.length) + 128]])
+ ...
+ if unknown2eb4a7ab != s:
+ revert with 0, 'Invalid proof'
+ ...
+ call addr(_param1) with:
+ value s wei
+ gas 30000 wei
+ if not return_data.size:
+ if not ext_call.success:
+ require ext_code.size(stor2)
+ call stor2.deposit() with:
+ value s wei
+ gas gas_remaining wei
+ ...
+ log 0xdbd5389f: addr(_param1), s, bool(ext_call.success)
+```
+
+मुख्य अंतर यह है कि पहला पैरामीटर, निकालने के लिए विंडो, वहां नहीं है। इसके बजाय, दावा की जा सकने वाली सभी विंडो पर एक लूप है।
+
+```python
+ idx = 0
+ s = 0
+ while idx < currentWindow:
+ ...
+ if stor5[mem[0]]:
+ if idx == -1:
+ revert with 0, 17
+ idx = idx + 1
+ s = s
+ continue
+ ...
+ stor5[idx][addr(_param1)] = 1
+ if idx >= unknown81e580d3.length:
+ revert with 0, 50
+ mem[0] = 4
+ if unknown81e580d3[idx] and _param2 > -1 / unknown81e580d3[idx]:
+ revert with 0, 17
+ if s > !(unknown81e580d3[idx] * _param2 / 100 * 10^6):
+ revert with 0, 17
+ if idx == -1:
+ revert with 0, 17
+ idx = idx + 1
+ s = s + (unknown81e580d3[idx] * _param2 / 100 * 10^6)
+ continue
+```
+
+तो यह एक `claim` संस्करण जैसा लगता है जो सभी विंडो का दावा करता है।
+
+## निष्कर्ष {#conclusion}
+
+अब तक आपको पता होना चाहिए कि उन कॉन्ट्रैक्ट्स को कैसे समझा जाए जिनका सोर्स कोड उपलब्ध नहीं है, या तो ऑपकोड का उपयोग करके या (जब यह काम करता है) डीकंपाइलर का उपयोग करके। जैसा कि इस लेख की लंबाई से स्पष्ट है, किसी कॉन्ट्रैक्ट की रिवर्स इंजीनियरिंग करना कोई मामूली बात नहीं है, लेकिन एक ऐसी प्रणाली में जहाँ सुरक्षा आवश्यक है, यह एक महत्वपूर्ण कौशल है कि यह सत्यापित किया जा सके कि कॉन्ट्रैक्ट वादे के अनुसार काम करते हैं।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/run-node-raspberry-pi/index.md b/public/content/translations/hi/developers/tutorials/run-node-raspberry-pi/index.md
new file mode 100644
index 00000000000..9f3efefabd5
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/run-node-raspberry-pi/index.md
@@ -0,0 +1,184 @@
+---
+title: "रास्पबेरी पाई 4 पर एक एथेरियम नोड चलाएं"
+description: "अपने रास्पबेरी पाई 4 को फ्लैश करें, एक ईथरनेट केबल प्लग इन करें, SSD डिस्क कनेक्ट करें और रास्पबेरी पाई 4 को एक पूर्ण एथेरियम नोड + सत्यापनकर्ता में बदलने के लिए डिवाइस को पावर दें"
+author: "EthereumOnArm"
+tags: [ "क्लाइंट्स", "निष्पादन परत", "सहमति परत", "नोड्स" ]
+lang: hi
+skill: intermediate
+published: 2022-06-10
+source: "ARM पर एथेरियम"
+sourceUrl: https://ethereum-on-arm-documentation.readthedocs.io/en/latest/
+---
+
+**ARM पर एथेरियम एक कस्टम लिनक्स इमेज है जो रास्पबेरी पाई को एक एथेरियम नोड में बदल सकता है।**
+
+रास्पबेरी पाई को एथेरियम नोड में बदलने के लिए ARM पर एथेरियम का उपयोग करने के लिए, निम्नलिखित हार्डवेयर की अनुशंसा की जाती है:
+
+- Raspberry 4 (मॉडल B 8GB), Odroid M1 या Rock 5B (8GB/16GB RAM) बोर्ड
+- माइक्रोएसडी कार्ड (न्यूनतम 16 GB क्लास 10)
+- न्यूनतम 2 टीबी एसएसडी यूएसबी 3.0 डिस्क या यूएसबी से SATA केस वाला एसएसडी।
+- बिजली की आपूर्ति
+- ईथरनेट केबल
+- पोर्ट फॉरवर्डिंग (अधिक जानकारी के लिए क्लाइंट देखें)
+- हीटसिंक और पंखे के साथ एक केस
+- यूएसबी कीबोर्ड, मॉनिटर और एचडीएमआई केबल (माइक्रो-एचडीएमआई) (वैकल्पिक)
+
+## ARM पर एथेरियम क्यों चलाएं? {#why-run-ethereum-on-arm}
+
+ARM बोर्ड बहुत सस्ते, लचीले, छोटे कंप्यूटर हैं। वे एथेरियम नोड चलाने के लिए अच्छे विकल्प हैं क्योंकि उन्हें सस्ते में खरीदा जा सकता है, कॉन्फ़िगर किया गया है ताकि उनके सभी संसाधन सिर्फ नोड पर केंद्रित हों, जो उन्हें कुशल बनाता है, वे कम मात्रा में बिजली की खपत करते हैं और शारीरिक रूप से छोटे होते हैं ताकि वे किसी भी घर में बिना बाधा के फिट हो सकें। नोड्स को स्पिन करना भी बहुत आसान है क्योंकि रास्पबेरी पाई के माइक्रोएसडी को पहले से बनी इमेज के साथ आसानी से फ्लैश किया जा सकता है, जिसमें कोई डाउनलोडिंग या बिल्डिंग सॉफ़्टवेयर की आवश्यकता नहीं है।
+
+## यह कैसे काम करता है? {#how-does-it-work}
+
+रास्पबेरी पाई का मेमोरी कार्ड पहले से बनी इमेज के साथ फ्लैश किया गया है। इस इमेज में एथेरियम नोड चलाने के लिए आवश्यक सब कुछ है। एक फ्लैश किए गए कार्ड के साथ, उपयोगकर्ता को केवल रास्पबेरी पाई को पावर-ऑन करना होता है। नोड को चलाने के लिए आवश्यक सभी प्रक्रियाएं स्वचालित रूप से शुरू हो जाती हैं। यह काम करता है क्योंकि मेमोरी कार्ड में लिनक्स-आधारित ऑपरेटिंग सिस्टम (OS) होता है जिसके शीर्ष पर सिस्टम-स्तरीय प्रक्रियाएं स्वचालित रूप से चलती हैं जो यूनिट को एथेरियम नोड में बदल देती हैं।
+
+एथेरियम को लोकप्रिय रास्पबेरी पाई लिनक्स ओएस "रास्पबियन" का उपयोग करके नहीं चलाया जा सकता है क्योंकि रास्पबियन अभी भी 32-बिट आर्किटेक्चर का उपयोग करता है जिससे एथेरियम उपयोगकर्ताओं को मेमोरी समस्याओं का सामना करना पड़ता है और सहमति क्लाइंट 32-बिट बायनेरिज़ का समर्थन नहीं करते हैं। इस पर काबू पाने के लिए, ARM टीम पर एथेरियम "Armbian" नामक एक देशी 64-बिट OS में माइग्रेट हो गया।
+
+**इमेज सभी आवश्यक कदमों का ध्यान रखती हैं**, पर्यावरण स्थापित करने और SSD डिस्क को स्वरूपित करने से लेकर एथेरियम सॉफ़्टवेयर को स्थापित करने और चलाने के साथ-साथ ब्लॉकचेन सिंक्रनाइज़ेशन शुरू करने तक।
+
+## निष्पादन और सहमति क्लाइंट पर ध्यान दें {#note-on-execution-and-consensus-clients}
+
+ARM इमेज पर एथेरियम में सेवाओं के रूप में पहले से निर्मित निष्पादन और सहमति क्लाइंट शामिल हैं। एक एथेरियम नोड को सिंक और चलने के लिए दोनों क्लाइंट की आवश्यकता होती है। आपको केवल इमेज डाउनलोड और फ्लैश करना है और फिर सेवाओं को शुरू करना है। इमेज निम्नलिखित निष्पादन क्लाइंट के साथ प्रीलोडेड है:
+
+- गेथ
+- नेदरमाइंड
+- बेसु
+
+और निम्नलिखित सहमति क्लाइंट:
+
+- लाइटहाउस
+- निम्बस
+- प्रिज़्म
+- टेकू
+
+आपको चलाने के लिए प्रत्येक में से एक चुनना चाहिए - सभी निष्पादन क्लाइंट सभी सहमति क्लाइंट के साथ संगत हैं। यदि आप स्पष्ट रूप से एक क्लाइंट का चयन नहीं करते हैं, तो नोड अपने डिफ़ॉल्ट - Geth और Lighthouse - पर वापस आ जाएगा और बोर्ड के चालू होने पर उन्हें स्वचालित रूप से चलाएगा। आपको अपने राउटर पर पोर्ट 30303 खोलना होगा ताकि Geth सहकर्मी को ढूंढ सके और उनसे जुड़ सके।
+
+## इमेज डाउनलोड करना {#downloading-the-image}
+
+रास्पबेरी पाई 4 एथेरियम इमेज एक "प्लग एंड प्ले" इमेज है जो स्वचालित रूप से निष्पादन और सहमति क्लाइंट दोनों को इंस्टॉल और सेट करती है, उन्हें एक दूसरे से बात करने और एथेरियम नेटवर्क से कनेक्ट करने के लिए कॉन्फ़िगर करती है। उपयोगकर्ता को केवल एक साधारण कमांड का उपयोग करके अपनी प्रक्रियाओं को शुरू करना है।
+
+[ARM पर एथेरियम](https://ethereumonarm-my.sharepoint.com/:u:/p/dlosada/Ec_VmUvr80VFjf3RYSU-NzkBmj2JOteDECj8Bibde929Gw?download=1) से रास्पबेरी पाई इमेज डाउनलोड करें और SHA256 हैश सत्यापित करें:
+
+```sh
+# डाउनलोड की गई इमेज वाले डायरेक्टरी से
+shasum -a 256 ethonarm_22.04.00.img.zip
+# हैश आउटपुट होना चाहिए: fb497e8f8a7388b62d6e1efbc406b9558bee7ef46ec7e53083630029c117444f
+```
+
+ध्यान दें कि Rock 5B और Odroid M1 बोर्ड के लिए इमेज Ethereum-on-Arm [डाउनलोड पेज](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/quick-guide/download-and-install.html) पर उपलब्ध हैं।
+
+## माइक्रोएसडी फ्लैश करना {#flashing-the-microsd}
+
+रास्पबेरी पाई के लिए उपयोग किए जाने वाले माइक्रोएसडी कार्ड को पहले डेस्कटॉप या लैपटॉप में डाला जाना चाहिए ताकि इसे फ्लैश किया जा सके। फिर, निम्नलिखित टर्मिनल कमांड डाउनलोड की गई इमेज को एसडी कार्ड पर फ्लैश करेंगे:
+
+```shell
+# माइक्रोएसडी कार्ड का नाम जांचें
+sudo fdisk -l
+
+>> sdxxx
+```
+
+नाम को सही करना वास्तव में महत्वपूर्ण है क्योंकि अगले कमांड में `dd` शामिल है जो इमेज को उस पर डालने से पहले कार्ड की मौजूदा सामग्री को पूरी तरह से मिटा देता है। जारी रखने के लिए, जिप की गई इमेज वाली डायरेक्टरी पर नेविगेट करें:
+
+```shell
+# इमेज को अनज़िप और फ़्लैश करें
+unzip ethonarm_22.04.00.img.zip
+sudo dd bs=1M if=ethonarm_22.04.00.img of=/dev/ conv=fdatasync status=progress
+```
+
+कार्ड अब फ्लैश हो गया है, इसलिए इसे रास्पबेरी पाई में डाला जा सकता है।
+
+## नोड शुरू करें {#start-the-node}
+
+रास्पबेरी पाई में एसडी कार्ड डालने के साथ, ईथरनेट केबल और एसएसडी कनेक्ट करें फिर बिजली चालू करें। OS बूट हो जाएगा और स्वचालित रूप से पूर्व-कॉन्फ़िगर किए गए कार्यों को करना शुरू कर देगा जो रास्पबेरी पाई को एक एथेरियम नोड में बदल देते हैं, जिसमें क्लाइंट सॉफ़्टवेयर को स्थापित करना और बनाना शामिल है। इसमें शायद 10-15 मिनट लगेंगे।
+
+एक बार सब कुछ इंस्टॉल और कॉन्फ़िगर हो जाने के बाद, एक ssh कनेक्शन के माध्यम से डिवाइस में लॉग इन करें या यदि बोर्ड से मॉनिटर और कीबोर्ड जुड़ा हुआ है तो सीधे टर्मिनल का उपयोग करें। `ethereum` खाते का उपयोग लॉग इन करने के लिए करें, क्योंकि इसमें नोड शुरू करने के लिए आवश्यक अनुमतियां हैं।
+
+```shell
+यूज़र: ethereum
+पासवर्ड: ethereum
+```
+
+डिफ़ॉल्ट निष्पादन क्लाइंट, Geth, स्वचालित रूप से शुरू हो जाएगा। आप निम्न टर्मिनल कमांड का उपयोग करके लॉग की जांच करके इसकी पुष्टि कर सकते हैं:
+
+```sh
+sudo journalctl -u geth -f
+```
+
+सहमति क्लाइंट को स्पष्ट रूप से शुरू करने की आवश्यकता है। ऐसा करने के लिए, पहले अपने राउटर पर पोर्ट 9000 खोलें ताकि Lighthouse सहकर्मी को ढूंढ सके और उनसे जुड़ सके। फिर lighthouse सेवा को सक्षम और शुरू करें:
+
+```sh
+sudo systemctl enable lighthouse-beacon
+sudo systemctl start lighthouse-beacon
+```
+
+लॉग का उपयोग करके क्लाइंट की जांच करें:
+
+```sh
+sudo journalctl -u lighthouse-beacon
+```
+
+ध्यान दें कि सहमति क्लाइंट कुछ ही मिनटों में सिंक हो जाएगा क्योंकि यह चेकपॉइंट सिंक का उपयोग करता है। निष्पादन क्लाइंट को अधिक समय लगेगा - संभावित रूप से कई घंटे, और यह तब तक शुरू नहीं होगा जब तक कि सहमति क्लाइंट पहले से ही सिंकिंग समाप्त नहीं कर लेता (ऐसा इसलिए है क्योंकि निष्पादन क्लाइंट को सिंक करने के लिए एक लक्ष्य की आवश्यकता होती है, जो सिंक किया गया सहमति क्लाइंट प्रदान करता है)।
+
+Geth और Lighthouse सेवाओं के चलने और सिंक होने के साथ, आपका रास्पबेरी पाई अब एक एथेरियम नोड है! Geth के जावास्क्रिप्ट कंसोल का उपयोग करके एथेरियम नेटवर्क के साथ बातचीत करना सबसे आम है, जिसे पोर्ट 8545 पर Geth क्लाइंट से जोड़ा जा सकता है। Curl जैसे अनुरोध उपकरण का उपयोग करके JSON ऑब्जेक्ट के रूप में स्वरूपित कमांड सबमिट करना भी संभव है। [Geth प्रलेखन](https://geth.ethereum.org/) में और देखें।
+
+Geth को Grafana डैशबोर्ड पर मेट्रिक्स रिपोर्ट करने के लिए पूर्व-कॉन्फ़िगर किया गया है जिसे ब्राउज़र में देखा जा सकता है। अधिक उन्नत उपयोगकर्ता `ipaddress:3000` पर नेविगेट करके, `user: admin` और `passwd: ethereum` पास करके अपने नोड के स्वास्थ्य की निगरानी के लिए इस सुविधा का उपयोग करना चाह सकते हैं।
+
+## सत्यापनकर्ता {#validators}
+
+एक सत्यापनकर्ता को वैकल्पिक रूप से सहमति क्लाइंट में भी जोड़ा जा सकता है। सत्यापनकर्ता सॉफ्टवेयर आपके नोड को सहमति में सक्रिय रूप से भाग लेने की अनुमति देता है और नेटवर्क को क्रिप्टोकॉनॉमिक सुरक्षा प्रदान करता है। आपको इस काम के लिए ETH में पुरस्कृत किया जाता है। एक सत्यापनकर्ता को चलाने के लिए, आपके पास पहले 32 ETH होना चाहिए, जिसे जमा अनुबंध में जमा किया जाना चाहिए। जमा [लॉन्चपैड](https://launchpad.ethereum.org/) पर चरण-दर-चरण मार्गदर्शिका का पालन करके किया जा सकता है। इसे डेस्कटॉप/लैपटॉप पर करें, लेकिन कुंजियां उत्पन्न न करें — यह सीधे रास्पबेरी पाई पर किया जा सकता है।
+
+रास्पबेरी पाई पर एक टर्मिनल खोलें और जमा कुंजियों को उत्पन्न करने के लिए निम्न कमांड चलाएं:
+
+```
+sudo apt-get update
+sudo apt-get install staking-deposit-cli
+cd && deposit new-mnemonic --num_validators 1
+```
+
+(या एक एयरगैप्ड मशीन पर चलाने के लिए [staking-deposit-cli](https://github.com/ethereum/staking-deposit-cli) डाउनलोड करें, और `deposit new-mnemnonic` कमांड चलाएं)
+
+स्मृति सहायक वाक्यांश को सुरक्षित रखें! उपरोक्त कमांड ने नोड के कीस्टोर में दो फाइलें उत्पन्न कीं: सत्यापनकर्ता कुंजियाँ और एक जमा डेटा फ़ाइल। जमा डेटा को लॉन्चपैड में अपलोड करने की आवश्यकता है, इसलिए इसे रास्पबेरी पाई से डेस्कटॉप/लैपटॉप पर कॉपी किया जाना चाहिए। यह एक ssh कनेक्शन या किसी अन्य कॉपी/पेस्ट विधि का उपयोग करके किया जा सकता है।
+
+एक बार जब लॉन्चपैड चलाने वाले कंप्यूटर पर जमा डेटा फ़ाइल उपलब्ध हो जाती है, तो इसे लॉन्चपैड स्क्रीन पर `+` पर खींचा और छोड़ा जा सकता है। जमा अनुबंध में एक लेनदेन भेजने के लिए स्क्रीन पर दिए गए निर्देशों का पालन करें।
+
+रास्पबेरी पाई पर वापस, एक सत्यापनकर्ता शुरू किया जा सकता है। इसके लिए सत्यापनकर्ता कुंजियों को आयात करने, पुरस्कार एकत्र करने के लिए पता सेट करने और फिर पूर्व-कॉन्फ़िगर सत्यापनकर्ता प्रक्रिया शुरू करने की आवश्यकता है। नीचे दिया गया उदाहरण Lighthouse के लिए है—अन्य सहमति क्लाइंट के लिए निर्देश [ARM पर एथेरियम दस्तावेज़ों](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/) पर उपलब्ध हैं:
+
+```shell
+# सत्यापनकर्ता कुंजियों को आयात करें
+lighthouse account validator import --directory=/home/ethereum/validator_keys
+
+# पुरस्कार पता सेट करें
+sudo sed -i 's/' /etc/ethereum/lighthouse-validator.conf
+
+# सत्यापनकर्ता शुरू करें
+sudo systemctl start lighthouse-validator
+```
+
+बधाई हो, अब आपके पास रास्पबेरी पाई पर एक पूर्ण एथेरियम नोड और सत्यापनकर्ता चल रहा है!
+
+## अधिक जानकारी {#more-details}
+
+इस पृष्ठ ने रास्पबेरी पाई का उपयोग करके Geth-Lighthouse नोड और सत्यापनकर्ता को सेट करने का एक सिंहावलोकन दिया। अधिक विस्तृत निर्देश [Ethereum-on-Arm वेबसाइट](https://ethereum-on-arm-documentation.readthedocs.io/en/latest/index.html) पर उपलब्ध हैं।
+
+## प्रतिक्रिया की सराहना की जाती है {#feedback-appreciated}
+
+हम जानते हैं कि रास्पबेरी पाई का एक विशाल उपयोगकर्ता आधार है जो एथेरियम नेटवर्क के स्वास्थ्य पर बहुत सकारात्मक प्रभाव डाल सकता है।
+कृपया इस ट्यूटोरियल के विवरण में जाएं, टेस्टनेट पर चलाने का प्रयास करें, ARM GitHub पर एथेरियम देखें, प्रतिक्रिया दें, मुद्दे उठाएं और पुल अनुरोध करें और प्रौद्योगिकी और प्रलेखन को आगे बढ़ाने में मदद करें!
+
+## संदर्भ {#references}
+
+1. https://ubuntu.com/download/raspberry-pi
+2. https://wikipedia.org/wiki/Port_forwarding
+3. https://prometheus.io
+4. https://grafana.com
+5. https://forum.armbian.com/topic/5565-zram-vs-swap/
+6. https://geth.ethereum.org
+7. https://nethermind.io
+8. https://www.hyperledger.org/projects/besu
+9. https://github.com/prysmaticlabs/prysm
+10. https://lighthouse.sigmaprime.io
+11. https://ethersphere.github.io/swarm-home
+12. https://raiden.network
+13. https://ipfs.io
+14. https://status.im
+15. https://vipnode.org
diff --git a/public/content/translations/hi/developers/tutorials/scam-token-tricks/index.md b/public/content/translations/hi/developers/tutorials/scam-token-tricks/index.md
new file mode 100644
index 00000000000..d09505ed731
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/scam-token-tricks/index.md
@@ -0,0 +1,470 @@
+---
+title: "स्कैम टोकन द्वारा उपयोग की जाने वाली कुछ तरकीबें और उन्हें कैसे पहचानें"
+description: "इस ट्यूटोरियल में हम एक स्कैम टोकन का विश्लेषण करते हैं ताकि यह देख सकें कि घोटालेबाज कौन सी चालें खेलते हैं, वे उन्हें कैसे लागू करते हैं, और हम उन्हें कैसे पहचान सकते हैं।"
+author: "ओरी पोमेरेन्ट्ज़"
+tags:
+ [
+ "स्कैम",
+ "सोलिडीटी",
+ "erc-20",
+ "javascript",
+ "typescript"
+ ]
+skill: intermediate
+published: 2023-09-15
+lang: hi
+---
+
+इस ट्यूटोरियल में हम [एक स्कैम टोकन](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code) का विश्लेषण करते हैं ताकि यह देख सकें कि घोटालेबाज कौन सी चालें खेलते हैं और वे उन्हें कैसे लागू करते हैं। ट्यूटोरियल के अंत तक आपको ERC-20 टोकन अनुबंधों, उनकी क्षमताओं और संदेह क्यों आवश्यक है, के बारे में अधिक व्यापक दृष्टिकोण प्राप्त होगा। फिर हम उस स्कैम टोकन द्वारा उत्सर्जित इवेंट्स को देखते हैं और देखते हैं कि हम स्वचालित रूप से यह कैसे पहचान सकते हैं कि यह वैध नहीं है।
+
+## स्कैम टोकन - वे क्या हैं, लोग उन्हें क्यों बनाते हैं, और उनसे कैसे बचें {#scam-tokens}
+
+एथेरियम के लिए सबसे आम उपयोगों में से एक समूह के लिए एक व्यापार योग्य टोकन बनाना है, एक अर्थ में उनकी अपनी मुद्रा। हालांकि, जहां कही पर भी ऐसे इस्तेमाल के मामले होते है जो मूल्य रखते है, वहा पर अपराधी भी होते है जो अपने लिए उस मूल्य को चुराने की कोशिश करते है।
+
+आप उपयोगकर्ता के दृष्टिकोण से इस विषय के बारे में [ethereum.org पर कहीं और](/guides/how-to-id-scam-tokens/) अधिक पढ़ सकते हैं। यह ट्यूटोरियल एक स्कैम टोकन का विश्लेषण करने पर केंद्रित है ताकि यह देखा जा सके कि यह कैसे किया जाता है और इसका पता कैसे लगाया जा सकता है।
+
+### मुझे कैसे पता चलेगा कि wARB एक स्कैम है? {#warb-scam}
+
+जिस टोकन का हम विश्लेषण कर रहे हैं वह [wARB](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code) है, जो वैध [ARB टोकन](https://etherscan.io/token/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1) के बराबर होने का दिखावा करता है।
+
+यह जानने का सबसे आसान तरीका है कि कौन सा टोकन वैध है, मूल संगठन [Arbitrum](https://arbitrum.foundation/) को देखना। वैध पते [उनके प्रलेखन](https://docs.arbitrum.foundation/deployment-addresses#token) में निर्दिष्ट हैं।
+
+### सोर्स कोड क्यों उपलब्ध है? {#why-source}
+
+आम तौर पर हम उम्मीद करेंगे कि दूसरों को स्कैम करने की कोशिश करने वाले लोग गुप्त रहें, और वास्तव में कई स्कैम टोकन का कोड उपलब्ध नहीं होता है (उदाहरण के लिए, [यह](https://optimistic.etherscan.io/token/0x15992f382d8c46d667b10dc8456dc36651af1452#code) और [यह](https://optimistic.etherscan.io/token/0x026b623eb4aada7de37ef25256854f9235207178#code))।
+
+हालांकि, वैध टोकन आमतौर पर अपना सोर्स कोड प्रकाशित करते हैं, इसलिए वैध दिखने के लिए स्कैम टोकन के लेखक भी कभी-कभी ऐसा ही करते हैं। [wARB](https://etherscan.io/token/0xb047c8032b99841713b8e3872f06cf32beb27b82#code) उन टोकनों में से एक है जिनका सोर्स कोड उपलब्ध है, जिससे इसे समझना आसान हो जाता है।
+
+जबकि अनुबंध डिप्लॉयर्स यह चुन सकते हैं कि सोर्स कोड प्रकाशित करना है या नहीं, वे _गलत_ सोर्स कोड प्रकाशित नहीं कर सकते। ब्लॉक एक्सप्लोरर प्रदान किए गए सोर्स कोड को स्वतंत्र रूप से संकलित करता है, और यदि उसे बिल्कुल वही बाइटकोड नहीं मिलता है, तो वह उस सोर्स कोड को अस्वीकार कर देता है। [आप इस बारे में Etherscan साइट पर और अधिक पढ़ सकते हैं](https://etherscan.io/verifyContract)।
+
+## वैध ERC-20 टोकन के साथ तुलना {#compare-legit-erc20}
+
+हम इस टोकन की तुलना वैध ERC-20 टोकन से करने जा रहे हैं। यदि आप इस बात से परिचित नहीं हैं कि वैध ERC-20 टोकन आमतौर पर कैसे लिखे जाते हैं, तो [यह ट्यूटोरियल देखें](/developers/tutorials/erc20-annotated-code/)।
+
+### विशेषाधिकार प्राप्त पतों के लिए स्थिरांक {#constants-for-privileged-addresses}
+
+अनुबंधों को कभी-कभी विशेषाधिकार प्राप्त पतों की आवश्यकता होती है। दीर्घकालिक उपयोग के लिए डिज़ाइन किए गए अनुबंध कुछ विशेषाधिकार प्राप्त पतों को उन पतों को बदलने की अनुमति देते हैं, उदाहरण के लिए एक नए मल्टीसिग अनुबंध के उपयोग को सक्षम करने के लिए। ऐसा करने के कई तरीके हैं।
+
+[`HOP` टोकन अनुबंध](https://etherscan.io/address/0xc5102fe9359fd9a28f877a67e36b0f050d81a3cc#code) [`Ownable`](https://docs.openzeppelin.com/contracts/2.x/access-control#ownership-and-ownable) पैटर्न का उपयोग करता है। विशेषाधिकार प्राप्त पता स्टोरेज में `_owner` नामक फ़ील्ड में रखा जाता है (तीसरी फ़ाइल, `Ownable.sol` देखें)।
+
+```solidity
+abstract contract Ownable is Context {
+ address private _owner;
+ .
+ .
+ .
+}
+```
+
+[`ARB` टोकन अनुबंध](https://etherscan.io/address/0xad0c361ef902a7d9851ca7dcc85535da2d3c6fc7#code) में सीधे तौर पर कोई विशेषाधिकार प्राप्त पता नहीं है। हालाँकि, इसे एक की आवश्यकता नहीं है। यह [पते `0xb50721bcf8d664c30412cfbc6cf7a15145234ad1`](https://etherscan.io/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1#code) पर एक [`proxy`](https://docs.openzeppelin.com/contracts/5.x/api/proxy) के पीछे बैठता है। उस अनुबंध में एक विशेषाधिकार प्राप्त पता है (चौथी फ़ाइल, `ERC1967Upgrade.sol` देखें) जिसका उपयोग अपग्रेड के लिए किया जा सकता है।
+
+```solidity
+ /**
+ * @dev EIP1967 एडमिन स्लॉट में एक नया पता संग्रहीत करता है।
+ */
+ function _setAdmin(address newAdmin) private {
+ require(newAdmin != address(0), "ERC1967: new admin is the zero address");
+ StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
+ }
+```
+
+इसके विपरीत, `wARB` अनुबंध में एक हार्ड कोडेड `contract_owner` है।
+
+```solidity
+contract WrappedArbitrum is Context, IERC20 {
+ .
+ .
+ .
+ address deployer = 0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1;
+ address public contract_owner = 0xb40dE7b1beE84Ff2dc22B70a049A07A13a411A33;
+ .
+ .
+ .
+}
+```
+
+[यह अनुबंध स्वामी](https://etherscan.io/address/0xb40dE7b1beE84Ff2dc22B70a049A07A13a411A33) एक अनुबंध नहीं है जिसे अलग-अलग समय पर अलग-अलग खातों द्वारा नियंत्रित किया जा सकता है, बल्कि एक [बाह्य रूप से स्वामित्व वाला खाता](/developers/docs/accounts/#externally-owned-accounts-and-key-pairs) है। इसका मतलब है कि यह शायद किसी व्यक्ति द्वारा अल्पकालिक उपयोग के लिए डिज़ाइन किया गया है, न कि एक ERC-20 को नियंत्रित करने के लिए एक दीर्घकालिक समाधान के रूप में जो मूल्यवान बना रहेगा।
+
+और वास्तव में, अगर हम Etherscan में देखें तो हम देखते हैं कि घोटालेबाज ने 19 मई, 2023 के दौरान इस अनुबंध का केवल 12 घंटे के लिए उपयोग किया ([पहला लेनदेन](https://etherscan.io/tx/0xf49136198c3f925fcb401870a669d43cecb537bde36eb8b41df77f06d5f6fbc2) से [अंतिम लेनदेन](https://etherscan.io/tx/0xdfd6e717157354e64bbd5d6adf16761e5a5b3f914b1948d3545d39633244d47b))।
+
+### नकली `_transfer` फ़ंक्शन {#the-fake-transfer-function}
+
+[एक आंतरिक `_transfer` फ़ंक्शन](/developers/tutorials/erc20-annotated-code/#the-_transfer-function-_transfer) का उपयोग करके वास्तविक हस्तांतरण होना मानक है।
+
+`wARB` में यह फ़ंक्शन लगभग वैध लगता है:
+
+```solidity
+ function _transfer(address sender, address recipient, uint256 amount) internal virtual{
+ require(sender != address(0), "ERC20: transfer from the zero address");
+ require(recipient != address(0), "ERC20: transfer to the zero address");
+
+ _beforeTokenTransfer(sender, recipient, amount);
+
+ _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+ _balances[recipient] = _balances[recipient].add(amount);
+ if (sender == contract_owner){
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+ }
+```
+
+संदिग्ध हिस्सा है:
+
+```solidity
+ if (sender == contract_owner){
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+```
+
+यदि अनुबंध का स्वामी टोकन भेजता है, तो `Transfer` इवेंट क्यों दिखाता है कि वे `deployer` से आए हैं?
+
+हालाँकि, एक और महत्वपूर्ण मुद्दा है। इस `_transfer` फ़ंक्शन को कौन कॉल करता है? इसे बाहर से कॉल नहीं किया जा सकता, इसे `internal` के रूप में चिह्नित किया गया है। और हमारे पास जो कोड है, उसमें `_transfer` के लिए कोई कॉल शामिल नहीं है। स्पष्ट रूप से, यह यहां एक छलावे के रूप में है।
+
+```solidity
+ function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
+ _f_(_msgSender(), recipient, amount);
+ return true;
+ }
+
+ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
+ _f_(sender, recipient, amount);
+ _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
+ return true;
+ }
+```
+
+जब हम टोकन स्थानांतरित करने के लिए कॉल किए गए फ़ंक्शन, `transfer` और `transferFrom` को देखते हैं, तो हम देखते हैं कि वे पूरी तरह से एक अलग फ़ंक्शन, `_f_` को कॉल करते हैं।
+
+### असली `_f_` फ़ंक्शन {#the-real-f-function}
+
+```solidity
+ function _f_(address sender, address recipient, uint256 amount) internal _mod_(sender,recipient,amount) virtual {
+ require(sender != address(0), "ERC20: transfer from the zero address");
+ require(recipient != address(0), "ERC20: transfer to the zero address");
+
+ _beforeTokenTransfer(sender, recipient, amount);
+
+ _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
+ _balances[recipient] = _balances[recipient].add(amount);
+ if (sender == contract_owner){
+
+ sender = deployer;
+ }
+ emit Transfer(sender, recipient, amount);
+ }
+```
+
+इस फ़ंक्शन में दो संभावित खतरे के संकेत हैं।
+
+- [फ़ंक्शन मॉडिफ़ायर](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) `_mod_` का उपयोग। हालांकि, जब हम सोर्स कोड में देखते हैं तो हम पाते हैं कि `_mod_` वास्तव में हानिरहित है।
+
+ ```solidity
+ modifier _mod_(address sender, address recipient, uint256 amount){
+ _;
+ }
+ ```
+
+- वही समस्या जो हमने `_transfer` में देखी थी, जो यह है कि जब `contract_owner` टोकन भेजता है तो वे `deployer` से आते हुए दिखाई देते हैं।
+
+### नकली इवेंट्स फ़ंक्शन `dropNewTokens` {#the-fake-events-function-dropNewTokens}
+
+अब हम कुछ ऐसा देखते हैं जो एक वास्तविक स्कैम जैसा लगता है। मैंने पठनीयता के लिए फ़ंक्शन को थोड़ा संपादित किया है, लेकिन यह कार्यात्मक रूप से समकक्ष है।
+
+```solidity
+function dropNewTokens(address uPool,
+ address[] memory eReceiver,
+ uint256[] memory eAmounts) public auth()
+```
+
+इस फ़ंक्शन में `auth()` मॉडिफ़ायर है, जिसका अर्थ है कि इसे केवल अनुबंध स्वामी द्वारा ही कॉल किया जा सकता है।
+
+```solidity
+modifier auth() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+}
+```
+
+यह प्रतिबंध पूरी तरह से समझ में आता है, क्योंकि हम नहीं चाहेंगे कि यादृच्छिक खाते टोकन वितरित करें। हालांकि, फ़ंक्शन का शेष भाग संदिग्ध है।
+
+```solidity
+{
+ for (uint256 i = 0; i < eReceiver.length; i++) {
+ emit Transfer(uPool, eReceiver[i], eAmounts[i]);
+ }
+}
+```
+
+एक पूल खाते से रिसीवरों की एक सरणी को राशियों की एक सरणी में स्थानांतरित करने का एक फ़ंक्शन पूरी तरह से समझ में आता है। ऐसे कई उपयोग के मामले हैं जिनमें आप टोकन को एक ही स्रोत से कई गंतव्यों में वितरित करना चाहेंगे, जैसे कि पेरोल, एयरड्रॉप, आदि। कई लेनदेन जारी करने के बजाय, या एक ही लेनदेन के हिस्से के रूप में एक अलग अनुबंध से ERC-20 को कई बार कॉल करने के बजाय, इसे एक ही लेनदेन में करना (गैस में) सस्ता है।
+
+हालांकि, `dropNewTokens` ऐसा नहीं करता है। यह [`Transfer` इवेंट](https://eips.ethereum.org/EIPS/eip-20#transfer-1) उत्सर्जित करता है, लेकिन वास्तव में किसी भी टोकन को स्थानांतरित नहीं करता है। ऑफ़-चेन एप्लिकेशन को एक ऐसे हस्तांतरण के बारे में बताकर भ्रमित करने का कोई वैध कारण नहीं है जो वास्तव में हुआ ही नहीं।
+
+### जलाने वाला `Approve` फ़ंक्शन {#the-burning-approve-function}
+
+ERC-20 अनुबंधों में भत्तों के लिए [एक `approve` फ़ंक्शन](/developers/tutorials/erc20-annotated-code/#approve) होना चाहिए, और वास्तव में हमारे स्कैम टोकन में ऐसा फ़ंक्शन है, और यह सही भी है। हालांकि, क्योंकि Solidity C से उतरा है, यह केस महत्वपूर्ण है। "Approve" और "approve" अलग-अलग स्ट्रिंग्स हैं।
+
+इसके अलावा, कार्यक्षमता `approve` से संबंधित नहीं है।
+
+```solidity
+ function Approve(
+ address[] memory holders)
+```
+
+इस फ़ंक्शन को टोकन के धारकों के लिए पतों की एक सरणी के साथ कॉल किया जाता है।
+
+```solidity
+ public approver() {
+```
+
+`approver()` मॉडिफ़ायर यह सुनिश्चित करता है कि केवल `contract_owner` को ही इस फ़ंक्शन को कॉल करने की अनुमति है (नीचे देखें)।
+
+```solidity
+ for (uint256 i = 0; i < holders.length; i++) {
+ uint256 amount = _balances[holders[i]];
+ _beforeTokenTransfer(holders[i], 0x0000000000000000000000000000000000000001, amount);
+ _balances[holders[i]] = _balances[holders[i]].sub(amount,
+ "ERC20: burn amount exceeds balance");
+ _balances[0x0000000000000000000000000000000000000001] =
+ _balances[0x0000000000000000000000000000000000000001].add(amount);
+ }
+ }
+
+```
+
+प्रत्येक धारक पते के लिए फ़ंक्शन धारक की पूरी शेष राशि को पते `0x00...01` पर ले जाता है, प्रभावी रूप से इसे जला देता है (मानक में वास्तविक `burn` कुल आपूर्ति को भी बदलता है, और टोकन को `0x00...00` पर स्थानांतरित करता है)। इसका मतलब है कि `contract_owner` किसी भी उपयोगकर्ता की संपत्ति को हटा सकता है। यह एक ऐसी विशेषता नहीं लगती है जो आप एक शासन टोकन में चाहेंगे।
+
+### कोड गुणवत्ता के मुद्दे {#code-quality-issues}
+
+ये कोड गुणवत्ता के मुद्दे यह _साबित_ नहीं करते हैं कि यह कोड एक स्कैम है, लेकिन वे इसे संदिग्ध बनाते हैं। Arbitrum जैसी संगठित कंपनियाँ आमतौर पर इतना खराब कोड जारी नहीं करती हैं।
+
+#### `mount` फ़ंक्शन {#the-mount-function}
+
+हालांकि यह [मानक](https://eips.ethereum.org/EIPS/eip-20) में निर्दिष्ट नहीं है, आम तौर पर नए टोकन बनाने वाले फ़ंक्शन को [`mint`](https://ethereum.org/el/developers/tutorials/erc20-annotated-code/#the-_mint-and-_burn-functions-_mint-and-_burn) कहा जाता है।
+
+यदि हम `wARB` कंस्ट्रक्टर में देखें, तो हम देखते हैं कि मिंट फ़ंक्शन का नाम बदलकर किसी कारण से `mount` कर दिया गया है, और दक्षता के लिए पूरी राशि के बजाय प्रारंभिक आपूर्ति के पांचवें हिस्से के साथ पांच बार कॉल किया जाता है।
+
+```solidity
+ constructor () public {
+
+ _name = "Wrapped Arbitrum";
+ _symbol = "wARB";
+ _decimals = 18;
+ uint256 initialSupply = 1000000000000;
+
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ mount(deployer, initialSupply*(10**18)/5);
+ }
+```
+
+`mount` फ़ंक्शन भी संदिग्ध है।
+
+```solidity
+ function mount(address account, uint256 amount) public {
+ require(msg.sender == contract_owner, "ERC20: mint to the zero address");
+```
+
+`require` को देखते हुए, हम देखते हैं कि केवल अनुबंध स्वामी को मिंट करने की अनुमति है। यह वैध है। लेकिन त्रुटि संदेश _केवल स्वामी को मिंट करने की अनुमति है_ या ऐसा ही कुछ होना चाहिए। इसके बजाय, यह अप्रासंगिक _ERC20: मिंट टू द ज़ीरो एड्रेस_ है। ज़ीरो एड्रेस पर मिंट करने के लिए सही परीक्षण `require(account != address(0), "")` है, जिसे अनुबंध कभी जांचने की जहमत नहीं उठाता।
+
+```solidity
+ _totalSupply = _totalSupply.add(amount);
+ _balances[contract_owner] = _balances[contract_owner].add(amount);
+ emit Transfer(address(0), account, amount);
+ }
+```
+
+मिंटिंग से सीधे संबंधित दो और संदिग्ध तथ्य हैं:
+
+- एक `account` पैरामीटर है, जो संभवतः वह खाता है जिसे मिंट की गई राशि प्राप्त होनी चाहिए। लेकिन जो शेष राशि बढ़ती है वह वास्तव में `contract_owner` की है।
+
+- जबकि बढ़ी हुई शेष राशि `contract_owner` की है, उत्सर्जित इवेंट `account` को हस्तांतरण दिखाता है।
+
+### `auth` और `approver` दोनों क्यों? `mod` क्यों है जो कुछ नहीं करता है? {#why-both-autho-and-approver-why-the-mod-that-does-nothing}
+
+इस अनुबंध में तीन मॉडिफ़ायर हैं: `_mod_`, `auth`, और `approver`।
+
+```solidity
+ modifier _mod_(address sender, address recipient, uint256 amount){
+ _;
+ }
+```
+
+`_mod_` तीन पैरामीटर लेता है और उनके साथ कुछ नहीं करता है। इसे क्यों रखें?
+
+```solidity
+ modifier auth() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+ }
+
+ modifier approver() {
+ require(msg.sender == contract_owner, "Not allowed to interact");
+ _;
+ }
+```
+
+`auth` और `approver` अधिक समझ में आते हैं, क्योंकि वे जांचते हैं कि अनुबंध को `contract_owner` द्वारा कॉल किया गया था। हम उम्मीद करेंगे कि कुछ विशेषाधिकार प्राप्त कार्य, जैसे कि मिंटिंग, उस खाते तक सीमित हों। हालांकि, दो अलग-अलग फ़ंक्शन होने का क्या मतलब है जो _ठीक वही काम_ करते हैं?
+
+## हम स्वचालित रूप से क्या पता लगा सकते हैं? {#what-can-we-detect-automatically}
+
+हम Etherscan को देखकर देख सकते हैं कि `wARB` एक स्कैम टोकन है। हालांकि, यह एक केंद्रीकृत समाधान है। सिद्धांत रूप में, Etherscan को विकृत या हैक किया जा सकता है। स्वतंत्र रूप से यह पता लगाना बेहतर है कि कोई टोकन वैध है या नहीं।
+
+कुछ तरकीबें हैं जिनका उपयोग हम यह पहचानने के लिए कर सकते हैं कि एक ERC-20 टोकन संदिग्ध है (या तो एक स्कैम या बहुत खराब लिखा गया है), उनके द्वारा उत्सर्जित इवेंट्स को देखकर।
+
+## संदिग्ध `Approval` इवेंट्स {#suspicious-approval-events}
+
+[`Approval` इवेंट](https://eips.ethereum.org/EIPS/eip-20#approval) केवल एक सीधे अनुरोध के साथ होने चाहिए ([`Transfer` इवेंट](https://eips.ethereum.org/EIPS/eip-20#transfer-1) के विपरीत जो एक भत्ते के परिणामस्वरूप हो सकते हैं)। इस मुद्दे की विस्तृत व्याख्या के लिए [Solidity डॉक्स देखें](https://docs.soliditylang.org/en/v0.8.20/security-considerations.html#tx-origin) और यह कि अनुरोधों को सीधे क्यों होना चाहिए, न कि किसी अनुबंध द्वारा मध्यस्थता के बजाय।
+
+इसका मतलब है कि [बाह्य रूप से स्वामित्व वाले खाते](/developers/docs/accounts/#types-of-account) से खर्च को मंजूरी देने वाले `Approval` इवेंट उन लेनदेन से आने चाहिए जो उस खाते से उत्पन्न होते हैं, और जिनका गंतव्य ERC-20 अनुबंध है। बाह्य रूप से स्वामित्व वाले खाते से किसी भी अन्य प्रकार का अनुमोदन संदिग्ध है।
+
+यहाँ [इस तरह के इवेंट की पहचान करने वाला एक प्रोग्राम](https://github.com/qbzzt/20230915-scam-token-detection) है, जो [viem](https://viem.sh/) और [TypeScript](https://www.typescriptlang.org/docs/), जो टाइप सुरक्षा वाला एक जावास्क्रिप्ट संस्करण है, का उपयोग करता है। इसे चलाने के लिए:
+
+1. `.env.example` को `.env` में कॉपी करें।
+2. एक एथेरियम मेननेट नोड के लिए URL प्रदान करने के लिए `.env` संपादित करें।
+3. आवश्यक पैकेज स्थापित करने के लिए `pnpm install` चलाएँ।
+4. संदिग्ध अनुमोदनों की तलाश के लिए `pnpm susApproval` चलाएँ।
+
+यहाँ एक-एक पंक्ति की व्याख्या है:
+
+```typescript
+import {
+ Address,
+ TransactionReceipt,
+ createPublicClient,
+ http,
+ parseAbiItem,
+} from "viem"
+import { mainnet } from "viem/chains"
+```
+
+`viem` से टाइप परिभाषाएँ, फ़ंक्शन और चेन परिभाषा आयात करें।
+
+```typescript
+import { config } from "dotenv"
+config()
+```
+
+URL प्राप्त करने के लिए `.env` पढ़ें।
+
+```typescript
+const client = createPublicClient({
+ chain: mainnet,
+ transport: http(process.env.URL),
+})
+```
+
+एक Viem क्लाइंट बनाएँ। हमें केवल ब्लॉकचेन से पढ़ने की आवश्यकता है, इसलिए इस क्लाइंट को निजी कुंजी की आवश्यकता नहीं है।
+
+```typescript
+const testedAddress = "0xb047c8032b99841713b8e3872f06cf32beb27b82"
+const fromBlock = 16859812n
+const toBlock = 16873372n
+```
+
+संदिग्ध ERC-20 अनुबंध का पता, और वे ब्लॉक जिनके भीतर हम इवेंट्स की तलाश करेंगे। नोड प्रदाता आमतौर पर इवेंट्स पढ़ने की हमारी क्षमता को सीमित करते हैं क्योंकि बैंडविड्थ महंगी हो सकती है। सौभाग्य से `wARB` अठारह घंटे की अवधि के लिए उपयोग में नहीं था, इसलिए हम सभी इवेंट्स को देख सकते हैं (कुल मिलाकर केवल 13 थे)।
+
+```typescript
+const approvalEvents = await client.getLogs({
+ address: testedAddress,
+ fromBlock,
+ toBlock,
+ event: parseAbiItem(
+ "event Approval(address indexed _owner, address indexed _spender, uint256 _value)"
+ ),
+})
+```
+
+यह Viem से इवेंट जानकारी मांगने का तरीका है। जब हम इसे सटीक इवेंट हस्ताक्षर प्रदान करते हैं, जिसमें फ़ील्ड नाम शामिल हैं, तो यह हमारे लिए इवेंट को पार्स करता है।
+
+```typescript
+const isContract = async (addr: Address): boolean =>
+ await client.getBytecode({ address: addr })
+```
+
+हमारा एल्गोरिथम केवल बाह्य रूप से स्वामित्व वाले खातों पर लागू होता है। यदि `client.getBytecode` द्वारा कोई बाइटकोड लौटाया जाता है तो इसका मतलब है कि यह एक अनुबंध है और हमें बस इसे छोड़ देना चाहिए।
+
+यदि आपने पहले TypeScript का उपयोग नहीं किया है, तो फ़ंक्शन परिभाषा थोड़ी अजीब लग सकती है। हम इसे केवल यह नहीं बताते कि पहला (और एकमात्र) पैरामीटर `addr` कहलाता है, बल्कि यह भी कि यह `Address` प्रकार का है। इसी तरह, `: boolean` भाग TypeScript को बताता है कि फ़ंक्शन का वापसी मान एक बूलियन है।
+
+```typescript
+const getEventTxn = async (ev: Event): TransactionReceipt =>
+ await client.getTransactionReceipt({ hash: ev.transactionHash })
+```
+
+यह फ़ंक्शन एक इवेंट से लेनदेन की रसीद प्राप्त करता है। हमें यह सुनिश्चित करने के लिए रसीद की आवश्यकता है कि हम जानते हैं कि लेनदेन का गंतव्य क्या था।
+
+```typescript
+const suspiciousApprovalEvent = async (ev : Event) : (Event | null) => {
+```
+
+यह सबसे महत्वपूर्ण फ़ंक्शन है, जो वास्तव में यह तय करता है कि कोई इवेंट संदिग्ध है या नहीं। वापसी प्रकार, `(Event | null)`, TypeScript को बताता है कि यह फ़ंक्शन या तो एक `Event` या `null` लौटा सकता है। यदि इवेंट संदिग्ध नहीं है तो हम `null` लौटाते हैं।
+
+```typescript
+const owner = ev.args._owner
+```
+
+Viem में फ़ील्ड नाम हैं, इसलिए इसने हमारे लिए इवेंट को पार्स किया। `_owner` खर्च किए जाने वाले टोकन का स्वामी है।
+
+```typescript
+// अनुबंधों द्वारा अनुमोदन संदिग्ध नहीं हैं
+if (await isContract(owner)) return null
+```
+
+यदि स्वामी एक अनुबंध है, तो मान लें कि यह अनुमोदन संदिग्ध नहीं है। यह जांचने के लिए कि किसी अनुबंध का अनुमोदन संदिग्ध है या नहीं, हमें लेनदेन के पूर्ण निष्पादन का पता लगाना होगा ताकि यह देखा जा सके कि क्या यह कभी स्वामी अनुबंध तक पहुंचा, और क्या उस अनुबंध ने सीधे ERC-20 अनुबंध को कॉल किया। यह हमारी पसंद से कहीं अधिक संसाधन महंगा है।
+
+```typescript
+const txn = await getEventTxn(ev)
+```
+
+यदि अनुमोदन बाह्य रूप से स्वामित्व वाले खाते से आता है, तो वह लेनदेन प्राप्त करें जिसके कारण यह हुआ।
+
+```typescript
+// अनुमोदन संदिग्ध है यदि यह एक EOA स्वामी से आता है जो लेनदेन का `from` नहीं है
+if (owner.toLowerCase() != txn.from.toLowerCase()) return ev
+```
+
+हम केवल स्ट्रिंग समानता की जांच नहीं कर सकते क्योंकि पते हेक्साडेसिमल होते हैं, इसलिए उनमें अक्षर होते हैं। कभी-कभी, उदाहरण के लिए `txn.from` में, वे सभी अक्षर लोअरकेस होते हैं। अन्य मामलों में, जैसे `ev.args._owner`, पता [त्रुटि पहचान के लिए मिश्रित-केस](https://eips.ethereum.org/EIPS/eip-55) में है।
+
+लेकिन अगर लेनदेन स्वामी से नहीं है, और वह स्वामी बाह्य रूप से स्वामित्व में है, तो हमारे पास एक संदिग्ध लेनदेन है।
+
+```typescript
+// यह भी संदिग्ध है यदि लेनदेन का गंतव्य वह ERC-20 अनुबंध नहीं है जिसकी हम
+// जांच कर रहे हैं
+if (txn.to.toLowerCase() != testedAddress) return ev
+```
+
+इसी तरह, यदि लेनदेन का `to` पता, पहला अनुबंध जिसे कॉल किया गया, जांच के तहत ERC-20 अनुबंध नहीं है तो यह संदिग्ध है।
+
+```typescript
+ // यदि संदिग्ध होने का कोई कारण नहीं है, तो null लौटाएं।
+ return null
+}
+```
+
+यदि कोई भी शर्त सही नहीं है तो `Approval` इवेंट संदिग्ध नहीं है।
+
+```typescript
+const testPromises = approvalEvents.map((ev) => suspiciousApprovalEvent(ev))
+const testResults = (await Promise.all(testPromises)).filter((x) => x != null)
+
+console.log(testResults)
+```
+
+[एक `async` फ़ंक्शन](https://www.w3schools.com/js/js_async.asp) एक `Promise` ऑब्जेक्ट लौटाता है। सामान्य सिंटैक्स, `await x()` के साथ, हम प्रसंस्करण जारी रखने से पहले उस `Promise` के पूरा होने की प्रतीक्षा करते हैं। यह प्रोग्राम करना और अनुसरण करना सरल है, लेकिन यह अक्षम भी है। जब हम किसी विशिष्ट इवेंट के लिए `Promise` के पूरा होने की प्रतीक्षा कर रहे होते हैं, तो हम पहले से ही अगले इवेंट पर काम करना शुरू कर सकते हैं।
+
+यहाँ हम `Promise` ऑब्जेक्ट्स की एक सरणी बनाने के लिए [`map`](https://www.w3schools.com/jsref/jsref_map.asp) का उपयोग करते हैं। फिर हम उन सभी वादों के हल होने की प्रतीक्षा करने के लिए [`Promise.all`](https://www.javascripttutorial.net/es6/javascript-promise-all/) का उपयोग करते हैं। फिर हम गैर-संदिग्ध इवेंट्स को हटाने के लिए उन परिणामों को [`filter`](https://www.w3schools.com/jsref/jsref_filter.asp) करते हैं।
+
+### संदिग्ध `Transfer` इवेंट्स {#suspicious-transfer-events}
+
+स्कैम टोकन की पहचान करने का एक और संभावित तरीका यह देखना है कि क्या उनके पास कोई संदिग्ध हस्तांतरण है। उदाहरण के लिए, उन खातों से हस्तांतरण जिनमें उतने टोकन नहीं हैं। आप देख सकते हैं कि [इस परीक्षण को कैसे लागू किया जाए](https://github.com/qbzzt/20230915-scam-token-detection/blob/main/susTransfer.ts), लेकिन `wARB` में यह समस्या नहीं है।
+
+## निष्कर्ष {#conclusion}
+
+ERC-20 स्कैम का स्वचालित पता लगाना [गलत नकारात्मक](https://en.wikipedia.org/wiki/False_positives_and_false_negatives#False_negative_error) से ग्रस्त है, क्योंकि एक स्कैम एक पूरी तरह से सामान्य ERC-20 टोकन अनुबंध का उपयोग कर सकता है जो बस कुछ भी वास्तविक का प्रतिनिधित्व नहीं करता है। इसलिए आपको हमेशा _एक विश्वसनीय स्रोत से टोकन पता प्राप्त करने_ का प्रयास करना चाहिए।
+
+स्वचालित पता लगाना कुछ मामलों में मदद कर सकता है, जैसे कि DeFi टुकड़े, जहां कई टोकन होते हैं और उन्हें स्वचालित रूप से संभालने की आवश्यकता होती है। लेकिन हमेशा की तरह [केविएट एम्प्टर](https://www.investopedia.com/terms/c/caveatemptor.asp), अपना खुद का शोध करें, और अपने उपयोगकर्ताओं को भी ऐसा करने के लिए प्रोत्साहित करें।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/secret-state/index.md b/public/content/translations/hi/developers/tutorials/secret-state/index.md
new file mode 100644
index 00000000000..a585e6d85ec
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/secret-state/index.md
@@ -0,0 +1,741 @@
+---
+title: "एक गुप्त स्टेट के लिए ज़ीरो-नॉलेज का उपयोग"
+description: "ऑन-चेन गेम सीमित हैं क्योंकि वे कोई भी छिपी हुई जानकारी नहीं रख सकते हैं। इस ट्यूटोरियल को पढ़ने के बाद, एक पाठक एक गुप्त स्टेट, ऑफ़-चेन, कंपोनेंट के साथ सत्यापन योग्य गेम बनाने के लिए शून्य ज्ञान प्रमाण और सर्वर कंपोनेंट को संयोजित करने में सक्षम होगा। ऐसा करने की तकनीक को एक माइनस्वीपर गेम बनाकर प्रदर्शित किया जाएगा।"
+author: "ओरी पोमेरेन्ट्ज़"
+tags:
+ [
+ "सर्वर",
+ "ऑफ-चेन",
+ "केंद्रीकृत",
+ "ज़ीरो-नॉलेज",
+ "zokrates",
+ "mud"
+ ]
+skill: advanced
+lang: hi
+published: 2025-03-15
+---
+
+यह कई मामलों में महत्वपूर्ण है, लेकिन यहां नहीं।ब्लॉकचेन पर कोई रहस्य नहीं हैं। ब्लॉकचेन पर पोस्ट की गई हर चीज़ हर किसी के पढ़ने के लिए खुली है। यह आवश्यक है, क्योंकि ब्लॉकचेन इस पर आधारित है कि कोई भी इसे सत्यापित कर सकता है। हालांकि, गेम अक्सर गुप्त स्टेट पर निर्भर करते हैं। उदाहरण के लिए, [माइनस्वीपर](https://en.wikipedia.org/wiki/Minesweeper_\(video_game\)) गेम का कोई मतलब नहीं है अगर आप बस ब्लॉकचेन एक्सप्लोरर पर जाकर मैप देख सकते हैं।
+
+सबसे सरल समाधान गुप्त स्टेट को रखने के लिए एक [सर्वर कंपोनेंट](/developers/tutorials/server-components/) का उपयोग करना है। हालांकि, हम ब्लॉकचेन का उपयोग गेम डेवलपर द्वारा धोखाधड़ी को रोकने के लिए करते हैं। हमें सर्वर कंपोनेंट की ईमानदारी सुनिश्चित करने की आवश्यकता है। सर्वर स्टेट का हैश प्रदान कर सकता है, और यह साबित करने के लिए [शून्य ज्ञान प्रमाण](/zero-knowledge-proofs/#why-zero-knowledge-proofs-are-important) का उपयोग कर सकता है कि एक चाल के परिणाम की गणना के लिए उपयोग किया गया स्टेट सही है।
+
+इस लेख को पढ़ने के बाद आप जानेंगे कि इस तरह का सीक्रेट स्टेट होल्डिंग सर्वर, स्टेट दिखाने के लिए एक क्लाइंट और दोनों के बीच संचार के लिए एक ऑन-चेन कंपोनेंट कैसे बनाया जाए। मुख्य उपकरण जिनका हम उपयोग करेंगे वे हैं:
+
+| उपकरण | उद्देश्य | संस्करण पर सत्यापित |
+| --------------------------------------------- | ----------------------------------------------- | --------------------------------------: |
+| [Zokrates](https://zokrates.github.io/) | शून्य ज्ञान प्रमाण और उनका सत्यापन | 1.1.9 |
+| [Typescript](https://www.typescriptlang.org/) | सर्वर और क्लाइंट दोनों के लिए प्रोग्रामिंग भाषा | 5.4.2 |
+| [Node](https://nodejs.org/en) | सर्वर चलाना | 20.18.2 |
+| [Viem](https://viem.sh/) | ब्लॉकचेन के साथ संचार | 2.9.20 |
+| [MUD](https://mud.dev/) | ऑन-चेन डेटा प्रबंधन | 2.0.12 |
+| [React](https://react.dev/) | क्लाइंट यूज़र इंटरफ़ेस | 18.2.0 |
+| [Vite](https://vitejs.dev/) | क्लाइंट कोड सर्व करना | 4.2.1 |
+
+## माइनस्वीपर उदाहरण {#minesweeper}
+
+[माइनस्वीपर](https://en.wikipedia.org/wiki/Minesweeper_\(video_game\)) एक ऐसा गेम है जिसमें माइनफील्ड वाला एक गुप्त नक्शा होता है। खिलाड़ी एक विशिष्ट स्थान पर खुदाई करना चुनता है। यदि उस स्थान पर कोई माइन है, तो खेल खत्म। अन्यथा, खिलाड़ी को उस स्थान के आसपास के आठ चौकों में माइन की संख्या मिलती है।
+
+यह एप्लिकेशन [MUD](https://mud.dev/), का उपयोग करके लिखा गया है, एक फ्रेमवर्क जो हमें [की-वैल्यू डेटाबेस](https://aws.amazon.com/nosql/key-value/) का उपयोग करके ऑन-चेन डेटा स्टोर करने और उस डेटा को ऑफ-चेन घटकों के साथ स्वचालित रूप से सिंक्रनाइज़ करने देता है। सिंक्रोनाइज़ेशन के अलावा, MUD एक्सेस कंट्रोल प्रदान करना आसान बनाता है, और अन्य यूज़र्स के लिए हमारे एप्लिकेशन को बिना अनुमति के [विस्तार](https://mud.dev/guides/extending-a-world) करना आसान बनाता है।
+
+### माइनस्वीपर उदाहरण चलाना {#running-minesweeper-example}
+
+माइनस्वीपर उदाहरण चलाने के लिए:
+
+1. सुनिश्चित करें कि आपने [पूर्वापेक्षाएँ इंस्टॉल कर ली हैं](https://mud.dev/quickstart#prerequisites): [Node](https://mud.dev/quickstart#prerequisites), [Foundry](https://book.getfoundry.sh/getting-started/installation), [`git`](https://git-scm.com/downloads), [`pnpm`](https://git-scm.com/downloads), और [`mprocs`](https://github.com/pvolok/mprocs)।
+
+2. रिपॉजिटरी को क्लोन करें।
+
+ ```sh copy
+ git clone https://github.com/qbzzt/20240901-secret-state.git
+ ```
+
+3. पैकेज इंस्टॉल करें।
+
+ ```sh copy
+ cd 20240901-secret-state/
+ pnpm install
+ npm install -g mprocs
+ ```
+
+ यदि `pnpm install` के हिस्से के रूप में Foundry इंस्टॉल किया गया था, तो आपको कमांड-लाइन शेल को पुनरारंभ करने की आवश्यकता है।
+
+4. कॉन्ट्रैक्ट्स को संकलित करें
+
+ ```sh copy
+ cd packages/contracts
+ forge build
+ cd ../..
+ ```
+
+5. प्रोग्राम शुरू करें ([anvil](https://book.getfoundry.sh/anvil/) ब्लॉकचेन सहित) और प्रतीक्षा करें।
+
+ ```sh copy
+ mprocs
+ ```
+
+ ध्यान दें कि स्टार्टअप में लंबा समय लगता है। _contracts_ टैब पर स्क्रॉल करने के लिए पहले डाउन एरो का उपयोग करें ताकि MUD कॉन्ट्रैक्ट्स को डिप्लॉय होते देखा जा सके। जब आपको _Waiting for file changes…_ संदेश मिलता है, तो कॉन्ट्रैक्ट्स डिप्लॉय हो जाते हैं और आगे की प्रगति _server_ टैब में होगी। वहां, आप तब तक प्रतीक्षा करते हैं जब तक आपको _Verifier address: 0x...._ संदेश नहीं मिल जाता।
+
+ यदि यह चरण सफल होता है, तो आप `mprocs` स्क्रीन देखेंगे, जिसमें बाईं ओर विभिन्न प्रक्रियाएं और दाईं ओर वर्तमान में चयनित प्रक्रिया के लिए कंसोल आउटपुट होगा।
+
+ 
+
+ यदि `mprocs` के साथ कोई समस्या है, तो आप चार प्रक्रियाओं को मैन्युअल रूप से चला सकते हैं, प्रत्येक अपनी कमांड लाइन विंडो में:
+
+ - **Anvil**
+
+ ```sh
+ cd packages/contracts
+ anvil --base-fee 0 --block-time 2
+ ```
+
+ - **कॉन्ट्रैक्ट्स**
+
+ ```sh
+ cd packages/contracts
+ pnpm mud dev-contracts --rpc http://127.0.0.1:8545
+ ```
+
+ - **सर्वर**
+
+ ```sh
+ cd packages/server
+ pnpm start
+ ```
+
+ - **क्लाइंट**
+
+ ```sh
+ cd packages/client
+ pnpm run dev
+ ```
+
+6. अब आप [क्लाइंट](http://localhost:3000) पर ब्राउज़ कर सकते हैं, **नया गेम** पर क्लिक करें और खेलना शुरू करें।
+
+### टेबल्स {#tables}
+
+हमें ऑन-चेन पर [कई टेबल्स](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/mud.config.ts) की आवश्यकता है।
+
+- `Configuration`: यह टेबल एक सिंगलटन है, इसमें कोई की (key) और सिंगल रिकॉर्ड नहीं है। इसका उपयोग गेम कॉन्फ़िगरेशन जानकारी रखने के लिए किया जाता है:
+ - `height`: माइनफील्ड की ऊंचाई
+ - `width`: माइनफील्ड की चौड़ाई
+ - `numberOfBombs`: प्रत्येक माइनफील्ड में बमों की संख्या
+
+- `VerifierAddress`: यह टेबल भी एक सिंगलटन है। इसका उपयोग कॉन्फ़िगरेशन के एक हिस्से को रखने के लिए किया जाता है, जो वेरिफायर कॉन्ट्रैक्ट (`verifier`) का पता है। हम यह जानकारी `Configuration` टेबल में डाल सकते थे, लेकिन इसे एक अलग कंपोनेंट, सर्वर द्वारा सेट किया जाता है, इसलिए इसे एक अलग टेबल में रखना आसान है।
+
+- `PlayerGame`: की (key) खिलाड़ी का पता है। डेटा है:
+
+ - `gameId`: 32-बाइट मान जो उस मैप का हैश है जिस पर खिलाड़ी खेल रहा है (गेम आइडेंटिफ़ायर)।
+ - `win`: एक बूलियन जो बताता है कि क्या खिलाड़ी गेम जीत गया।
+ - `lose`: एक बूलियन जो बताता है कि क्या खिलाड़ी गेम हार गया।
+ - `digNumber`: खेल में सफल खुदाई की संख्या।
+
+- `GamePlayer`: यह टेबल `gameId` से खिलाड़ी के पते तक रिवर्स मैपिंग रखती है।
+
+- `Map`: की (key) तीन मानों का एक टपल है:
+
+ - `gameId`: 32-बाइट मान जो उस मैप का हैश है जिस पर खिलाड़ी खेल रहा है (गेम आइडेंटिफ़ायर)।
+ - `x` कोऑर्डिनेट
+ - `y` कोऑर्डिनेट
+
+ मान एक एकल संख्या है। यदि बम का पता चलता है तो यह 255 है। अन्यथा, यह उस स्थान के आसपास के बमों की संख्या प्लस एक है। हम केवल बमों की संख्या का उपयोग नहीं कर सकते हैं, क्योंकि डिफ़ॉल्ट रूप से EVM में सभी स्टोरेज और MUD में सभी पंक्ति मान शून्य होते हैं। हमें "खिलाड़ी ने अभी तक यहां खुदाई नहीं की है" और "खिलाड़ी ने यहां खुदाई की, और पाया कि आसपास शून्य बम हैं" के बीच अंतर करने की आवश्यकता है।
+
+इसके अलावा, क्लाइंट और सर्वर के बीच संचार ऑन-चेन कंपोनेंट के माध्यम से होता है। यह टेबल्स का उपयोग करके भी लागू किया गया है।
+
+- `PendingGame`: नया गेम शुरू करने के लिए अनसर्विसड अनुरोध।
+- `PendingDig`: किसी विशिष्ट गेम में किसी विशिष्ट स्थान पर खुदाई करने के लिए अनसर्विसड अनुरोध। यह एक [ऑफ-चेन टेबल](https://mud.dev/store/tables#types-of-tables) है, जिसका अर्थ है कि यह EVM स्टोरेज में नहीं लिखा जाता है, यह केवल इवेंट्स का उपयोग करके ऑफ-चेन पठनीय है।
+
+### निष्पादन और डेटा प्रवाह {#execution-data-flows}
+
+ये प्रवाह क्लाइंट, ऑन-चेन कंपोनेंट और सर्वर के बीच निष्पादन का समन्वय करते हैं।
+
+#### आरंभीकरण {#initialization-flow}
+
+जब आप `mprocs` चलाते हैं, तो ये चरण होते हैं:
+
+1. [`mprocs`](https://github.com/pvolok/mprocs) चार कंपोनेंट चलाता है:
+
+ - [Anvil](https://book.getfoundry.sh/anvil/), जो एक स्थानीय ब्लॉकचेन चलाता है
+ - [Contracts](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/contracts), जो MUD के लिए कॉन्ट्रैक्ट्स को कंपाइल (यदि आवश्यक हो) और डिप्लॉय करता है
+ - [Client](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/client), जो वेब ब्राउज़रों को UI और क्लाइंट कोड सर्व करने के लिए [Vite](https://vitejs.dev/) चलाता है।
+ - [Server](https://github.com/qbzzt/20240901-secret-state/tree/main/packages/server), जो सर्वर क्रियाएं करता है
+
+2. `contracts` पैकेज MUD कॉन्ट्रैक्ट्स को डिप्लॉय करता है और फिर [`PostDeploy.s.sol` स्क्रिप्ट](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/script/PostDeploy.s.sol) चलाता है। यह स्क्रिप्ट कॉन्फ़िगरेशन सेट करती है। github से कोड [एक 10x5 माइनफील्ड जिसमें आठ माइन हैं](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/script/PostDeploy.s.sol#L23) निर्दिष्ट करता है।
+
+3. [सर्वर](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts) [MUD सेट अप](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L6) करके शुरू होता है। अन्य बातों के अलावा, यह डेटा सिंक्रनाइज़ेशन को सक्रिय करता है, ताकि सर्वर की मेमोरी में संबंधित टेबल्स की एक प्रति मौजूद हो।
+
+4. सर्वर [`Configuration` टेबल बदलने पर](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L23) निष्पादित होने वाले एक फ़ंक्शन को सब्सक्राइब करता है। `PostDeploy.s.sol` के निष्पादित होने और टेबल को संशोधित करने के बाद [यह फ़ंक्शन](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L24-L168) कॉल किया जाता है।
+
+5. जब सर्वर आरंभीकरण फ़ंक्शन में कॉन्फ़िगरेशन होता है, तो [यह `zkFunctions` को कॉल करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L34-L35) [सर्वर के ज़ीरो-नॉलेज हिस्से](#using-zokrates-from-typescript) को आरंभ करने के लिए। यह तब तक नहीं हो सकता जब तक हमें कॉन्फ़िगरेशन नहीं मिल जाता क्योंकि ज़ीरो-नॉलेज फ़ंक्शंस को माइनफ़ील्ड की चौड़ाई और ऊंचाई स्थिरांक के रूप में होनी चाहिए।
+
+6. सर्वर के ज़ीरो-नॉलेज हिस्से को आरंभ करने के बाद, अगला कदम [ब्लॉकचेन पर ज़ीरो-नॉलेज सत्यापन कॉन्ट्रैक्ट को डिप्लॉय करना](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L42-L53) और MUD में वेरिफाई पते को सेट करना है।
+
+7. अंत में, हम अपडेट्स को सब्सक्राइब करते हैं ताकि हम देख सकें कि कोई खिलाड़ी [एक नया गेम शुरू करने](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L55-L71) या [एक मौजूदा गेम में खुदाई करने](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L73-L108) का अनुरोध कब करता है।
+
+#### नया गेम {#new-game-flow}
+
+यह तब होता है जब खिलाड़ी एक नया गेम का अनुरोध करता है।
+
+1. यदि इस खिलाड़ी के लिए कोई गेम प्रगति पर नहीं है, या एक है लेकिन शून्य के gameId के साथ है, तो क्लाइंट एक [नया गेम बटन](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175) प्रदर्शित करता है। जब यूज़र इस बटन को दबाता है, तो [React `newGame` फ़ंक्शन चलाता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L96)।
+
+2. [`newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/mud/createSystemCalls.ts#L43-L46) एक `System` कॉल है। MUD में सभी कॉल `World` कॉन्ट्रैक्ट के माध्यम से रूट किए जाते हैं, और ज्यादातर मामलों में आप `__` को कॉल करते हैं। इस मामले में, कॉल `app__newGame` के लिए है, जिसे MUD फिर [`GameSystem` में `newGame` को रूट करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L16-L22)।
+
+3. ऑन-चेन फ़ंक्शन जाँचता है कि खिलाड़ी का कोई गेम प्रगति पर नहीं है, और यदि नहीं है तो [`PendingGame` टेबल में अनुरोध जोड़ता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L21)।
+
+4. सर्वर `PendingGame` में बदलाव का पता लगाता है और [सब्सक्राइब किए गए फ़ंक्शन को चलाता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L55-L71)। यह फ़ंक्शन [`newGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L110-L114) को कॉल करता है, जो बदले में [`createGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L116-L144) को कॉल करता है।
+
+5. `createGame` सबसे पहले [उचित संख्या में माइन के साथ एक यादृच्छिक मैप बनाता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L120-L135)। फिर, यह Zokrates के लिए आवश्यक खाली बॉर्डर के साथ एक मैप बनाने के लिए [`makeMapBorders`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L147-L166) को कॉल करता है। अंत में, `createGame` मैप का हैश प्राप्त करने के लिए [`calculateMapHash`](#calculateMapHash) को कॉल करता है, जिसका उपयोग गेम आईडी के रूप में किया जाता है।
+
+6. `newGame` फ़ंक्शन `gamesInProgress` में नया गेम जोड़ता है।
+
+7. सर्वर आखिरी काम ऑन-चेन [`app__newGameResponse`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L38-L43) को कॉल करना है। यह फ़ंक्शन एक अलग `System`, [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol) में है, ताकि एक्सेस कंट्रोल को सक्षम किया जा सके। एक्सेस कंट्रोल [MUD कॉन्फ़िगरेशन फ़ाइल](https://mud.dev/config), [`mud.config.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/mud.config.ts#L67-L72) में परिभाषित है।
+
+ एक्सेस सूची केवल एक ही पते को `System` को कॉल करने की अनुमति देती है। यह सर्वर फ़ंक्शंस तक पहुंच को एक ही पते तक सीमित करता है, ताकि कोई भी सर्वर का प्रतिरूपण न कर सके।
+
+8. ऑन-चेन कंपोनेंट संबंधित टेबल्स को अपडेट करता है:
+
+ - `PlayerGame` में गेम बनाएं।
+ - `GamePlayer` में रिवर्स मैपिंग सेट करें।
+ - `PendingGame` से अनुरोध हटाएं।
+
+9. सर्वर `PendingGame` में बदलाव की पहचान करता है, लेकिन कुछ नहीं करता क्योंकि [`wantsGame`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L58-L60) गलत है।
+
+10. क्लाइंट पर [`gameRecord`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L143-L148) को खिलाड़ी के पते के लिए `PlayerGame` प्रविष्टि पर सेट किया गया है। जब `PlayerGame` बदलता है, तो `gameRecord` भी बदल जाता है।
+
+11. यदि `gameRecord` में कोई मान है, और गेम जीता या हारा नहीं गया है, तो क्लाइंट [मैप प्रदर्शित करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175-L190)।
+
+#### खुदाई {#dig-flow}
+
+1. खिलाड़ी [मैप सेल के बटन पर क्लिक करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L188), जो [`dig` फ़ंक्शन](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/mud/createSystemCalls.ts#L33-L36) को कॉल करता है। यह फ़ंक्शन [ऑन-चेन पर `dig` को कॉल करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L24-L32)।
+
+2. ऑन-चेन कंपोनेंट [कई सेनिटी जांच करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L25-L30), और यदि सफल होता है तो खुदाई अनुरोध को [`PendingDig`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/GameSystem.sol#L31) में जोड़ता है।
+
+3. सर्वर [`PendingDig` में बदलाव का पता लगाता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L73)। [यदि यह वैध है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L75-L84), तो यह [ज़ीरो-नॉलेज कोड को कॉल करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L86-L95) (नीचे समझाया गया है) परिणाम और एक प्रमाण दोनों उत्पन्न करने के लिए कि यह वैध है।
+
+4. [सर्वर](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L97-L107) [`digResponse`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L45-L64) को ऑन-चेन पर कॉल करता है।
+
+5. `digResponse` दो काम करता है। सबसे पहले, यह [ज़ीरो नॉलेज प्रूफ़](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L47-L61) की जाँच करता है। फिर, यदि प्रमाण जाँच में खरा उतरता है, तो यह परिणाम को वास्तव में संसाधित करने के लिए [`processDigResult`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L67-L86) को कॉल करता है।
+
+6. `processDigResult` जांचता है कि गेम [हार](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L76-L78) गया है या [जीत](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L83-L86) गया है, और [`Map`, ऑन-चेन मैप को अपडेट करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol#L80)।
+
+7. क्लाइंट स्वचालित रूप से अपडेट उठाता है और [खिलाड़ी को प्रदर्शित मैप को अपडेट करता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/client/src/App.tsx#L175-L190), और यदि लागू हो तो खिलाड़ी को बताता है कि यह जीत है या हार।
+
+## Zokrates का उपयोग करना {#using-zokrates}
+
+ऊपर बताए गए प्रवाह में हमने ज़ीरो-नॉलेज भागों को छोड़ दिया, उन्हें एक ब्लैक बॉक्स के रूप में माना। अब आइए इसे खोलते हैं और देखते हैं कि वह कोड कैसे लिखा गया है।
+
+### मैप को हैश करना {#hashing-map}
+
+[Poseidon](https://www.poseidon-hash.info), Zokrates हैश फ़ंक्शन जिसे हम उपयोग करते हैं, को लागू करने के लिए हम [इस JavaScript कोड](https://github.com/ZK-Plus/ICBC24_Tutorial_Compute-Offchain-Verify-onchain/tree/solutions/exercise) का उपयोग कर सकते हैं। हालांकि, यह तेज़ होगा, लेकिन यह सिर्फ Zokrates हैश फ़ंक्शन का उपयोग करने से अधिक जटिल होगा। यह एक ट्यूटोरियल है, और इसलिए कोड को सरलता के लिए अनुकूलित किया गया है, प्रदर्शन के लिए नहीं। इसलिए, हमें दो अलग-अलग Zokrates प्रोग्राम की आवश्यकता है, एक मैप के हैश की गणना करने के लिए (`hash`) और दूसरा वास्तव में मैप पर एक स्थान पर खुदाई के परिणाम का शून्य ज्ञान प्रमाण बनाने के लिए (`dig`)।
+
+### हैश फ़ंक्शन {#hash-function}
+
+यह वह फ़ंक्शन है जो एक मैप के हैश की गणना करता है। हम इस कोड पर लाइन-दर-लाइन जाएंगे।
+
+```
+import "hashes/poseidon/poseidon.zok" as poseidon;
+import "utils/pack/bool/pack128.zok" as pack128;
+```
+
+ये दो लाइनें [Zokrates स्टैंडर्ड लाइब्रेरी](https://zokrates.github.io/toolbox/stdlib.html) से दो फ़ंक्शन आयात करती हैं। [पहला फ़ंक्शन](https://github.com/Zokrates/ZoKrates/blob/latest/zokrates_stdlib/stdlib/hashes/poseidon/poseidon.zok) एक [Poseidon हैश](https://www.poseidon-hash.info/) है। यह [`field` तत्वों](https://zokrates.github.io/language/types.html#field) की एक सारणी लेता है और एक `field` लौटाता है।
+
+Zokrates में फ़ील्ड एलिमेंट आमतौर पर 256 बिट से कम लंबा होता है, लेकिन बहुत ज़्यादा नहीं। कोड को सरल बनाने के लिए, हम मैप को 512 बिट्स तक सीमित करते हैं, और चार फ़ील्ड्स की एक सरणी को हैश करते हैं, और प्रत्येक फ़ील्ड में हम केवल 128 बिट्स का उपयोग करते हैं। [`pack128` फ़ंक्शन](https://github.com/Zokrates/ZoKrates/blob/latest/zokrates_stdlib/stdlib/utils/pack/bool/pack128.zok) इस उद्देश्य के लिए 128 बिट्स की एक सरणी को `field` में बदलता है।
+
+```
+ def hashMap(bool[${width+2}][${height+2}] map) -> field {
+```
+
+यह लाइन एक फ़ंक्शन परिभाषा शुरू करती है। `hashMap` को `map` नामक एक एकल पैरामीटर मिलता है, जो एक द्वि-आयामी `bool`(ean) सरणी है। मैप का आकार `width+2` गुणा `height+2` है, जिसके कारण [नीचे बताए गए हैं](#why-map-border)।
+
+हम `${width+2}` और `${height+2}` का उपयोग कर सकते हैं क्योंकि Zokrates प्रोग्राम इस एप्लिकेशन में [टेम्पलेट स्ट्रिंग्स](https://www.w3schools.com/js/js_string_templates.asp) के रूप में संग्रहीत हैं। `${` और `}` के बीच के कोड का मूल्यांकन JavaScript द्वारा किया जाता है, और इस तरह प्रोग्राम का उपयोग विभिन्न मैप आकारों के लिए किया जा सकता है। मैप पैरामीटर में इसके चारों ओर एक स्थान चौड़ा बॉर्डर होता है जिसमें कोई बम नहीं होता है, यही कारण है कि हमें चौड़ाई और ऊंचाई में दो जोड़ना पड़ता है।
+
+रिटर्न वैल्यू एक `field` है जिसमें हैश होता है।
+
+```
+ bool[512] mut map1d = [false; 512];
+```
+
+मैप द्वि-आयामी है। हालांकि, `pack128` फ़ंक्शन द्वि-आयामी सरणियों के साथ काम नहीं करता है। तो हम पहले मैप को `map1d` का उपयोग करके 512-बाइट सरणी में समतल करते हैं। डिफ़ॉल्ट रूप से Zokrates चर स्थिरांक होते हैं, लेकिन हमें इस सरणी को एक लूप में मान निर्दिष्ट करने की आवश्यकता होती है, इसलिए हम इसे [`mut`](https://zokrates.github.io/language/variables.html#mutability) के रूप में परिभाषित करते हैं।
+
+हमें सरणी को आरंभ करने की आवश्यकता है क्योंकि Zokrates में `undefined` नहीं है। `[false; 512]` अभिव्यक्ति का अर्थ है [512 `false` मानों की एक सरणी](https://zokrates.github.io/language/types.html#declaration-and-initialization)।
+
+```
+ u32 mut counter = 0;
+```
+
+हमें `map1d` में पहले से भरे गए बिट्स और अभी तक नहीं भरे गए बिट्स के बीच अंतर करने के लिए एक काउंटर की भी आवश्यकता है।
+
+```
+ for u32 x in 0..${width+2} {
+```
+
+यह है कि आप Zokrates में एक [`for` लूप](https://zokrates.github.io/language/control_flow.html#for-loops) कैसे घोषित करते हैं। एक Zokrates `for` लूप में निश्चित सीमाएँ होनी चाहिए, क्योंकि जबकि यह एक लूप प्रतीत होता है, कंपाइलर वास्तव में इसे "अनरोल" करता है। अभिव्यक्ति `${width+2}` एक कंपाइल समय स्थिरांक है क्योंकि `width` TypeScript कोड द्वारा कंपाइलर को कॉल करने से पहले सेट किया जाता है।
+
+```
+ for u32 y in 0..${height+2} {
+ map1d[counter] = map[x][y];
+ counter = counter+1;
+ }
+ }
+```
+
+मैप में प्रत्येक स्थान के लिए, उस मान को `map1d` सरणी में डालें और काउंटर को बढ़ाएँ।
+
+```
+ field[4] hashMe = [
+ pack128(map1d[0..128]),
+ pack128(map1d[128..256]),
+ pack128(map1d[256..384]),
+ pack128(map1d[384..512])
+ ];
+```
+
+`map1d` से चार `field` मानों की एक सरणी बनाने के लिए `pack128`। Zokrates में `array[a..b]` का अर्थ है सरणी का वह टुकड़ा जो `a` से शुरू होता है और `b-1` पर समाप्त होता है।
+
+```
+ return poseidon(hashMe);
+}
+```
+
+इस सरणी को हैश में बदलने के लिए `poseidon` का उपयोग करें।
+
+### हैश प्रोग्राम {#hash-program}
+
+सर्वर को गेम पहचानकर्ता बनाने के लिए सीधे `hashMap` को कॉल करने की आवश्यकता है। हालांकि, Zokrates केवल `main` फ़ंक्शन को शुरू करने के लिए कॉल कर सकता है, इसलिए हम `main` के साथ एक प्रोग्राम बनाते हैं जो हैश फ़ंक्शन को कॉल करता है।
+
+```
+${hashFragment}
+
+def main(bool[${width+2}][${height+2}] map) -> field {
+ return hashMap(map);
+}
+```
+
+### डिग प्रोग्राम {#dig-program}
+
+यह एप्लिकेशन के ज़ीरो-नॉलेज भाग का दिल है, जहां हम उन प्रमाणों का उत्पादन करते हैं जिनका उपयोग खुदाई के परिणामों को सत्यापित करने के लिए किया जाता है।
+
+```
+${hashFragment}
+
+// स्थान (x,y) में माइन की संख्या
+def map2mineCount(bool[${width+2}][${height+2}] map, u32 x, u32 y) -> u8 {
+ return if map[x+1][y+1] { 1 } else { 0 };
+}
+```
+
+#### मैप बॉर्डर क्यों {#why-map-border}
+
+शून्य ज्ञान प्रमाण [अरिथमैटिक सर्किट](https://medium.com/web3studio/simple-explanations-of-arithmetic-circuits-and-zero-knowledge-proofs-806e59a79785) का उपयोग करते हैं, जिनका `if` स्टेटमेंट का कोई आसान समकक्ष नहीं होता है। इसके बजाय, वे [सशर्त ऑपरेटर](https://en.wikipedia.org/wiki/Ternary_conditional_operator) के समकक्ष का उपयोग करते हैं। यदि `a` शून्य या एक हो सकता है, तो आप `if a { b } else { c }` की गणना `ab+(1-a)c` के रूप में कर सकते हैं।
+
+इस वजह से, एक Zokrates `if` कथन हमेशा दोनों शाखाओं का मूल्यांकन करता है। उदाहरण के लिए, यदि आपके पास यह कोड है:
+
+```
+bool[5] arr = [false; 5];
+u32 index=10;
+return if index>4 { 0 } else { arr[index] }
+```
+
+यह त्रुटि देगा, क्योंकि इसे `arr[10]` की गणना करने की आवश्यकता है, भले ही वह मान बाद में शून्य से गुणा किया जाएगा।
+
+यही कारण है कि हमें नक्शे के चारों ओर एक स्थान चौड़ा बॉर्डर चाहिए। हमें एक स्थान के चारों ओर माइन्स की कुल संख्या की गणना करने की आवश्यकता है, और इसका मतलब है कि हमें उस स्थान से एक पंक्ति ऊपर और नीचे, बाईं ओर और दाईं ओर का स्थान देखना होगा जहाँ हम खुदाई कर रहे हैं। जिसका अर्थ है कि वे स्थान मैप ऐरे में मौजूद होने चाहिए जो Zokrates को प्रदान किया गया है।
+
+```
+def main(private bool[${width+2}][${height+2}] map, u32 x, u32 y) -> (field, u8) {
+```
+
+डिफ़ॉल्ट रूप से Zokrates प्रमाणों में उनके इनपुट शामिल होते हैं। यह जानने का कोई फायदा नहीं है कि किसी स्थान के आसपास पाँच माइन हैं जब तक कि आप वास्तव में यह नहीं जानते कि वह कौन सा स्थान है (और आप इसे केवल अपने अनुरोध से मेल नहीं खा सकते, क्योंकि तब प्रोवर अलग-अलग मानों का उपयोग कर सकता है और आपको इसके बारे में नहीं बता सकता है)। हालांकि, हमें Zokrates को प्रदान करते हुए मैप को गुप्त रखने की आवश्यकता है। समाधान एक `private` पैरामीटर का उपयोग करना है, जो प्रमाण द्वारा प्रकट _नहीं_ किया जाता है।
+
+यह दुरुपयोग के लिए एक और रास्ता खोलता है। प्रूवर सही निर्देशांक का उपयोग कर सकता है, लेकिन स्थान के चारों ओर किसी भी संख्या में माइन्स के साथ एक नक्शा बना सकता है, और संभवतः स्वयं स्थान पर भी। इस दुरुपयोग को रोकने के लिए, हम शून्य ज्ञान प्रमाण में मैप का हैश शामिल करते हैं, जो गेम आइडेंटिफ़ायर है।
+
+```
+ return (hashMap(map),
+```
+
+यहाँ रिटर्न वैल्यू एक टपल है जिसमें मैप हैश ऐरे के साथ-साथ खुदाई का परिणाम भी शामिल है।
+
+```
+ if map2mineCount(map, x, y) > 0 { 0xFF } else {
+```
+
+हम 255 का उपयोग एक विशेष मान के रूप में करते हैं यदि स्थान में ही एक बम हो।
+
+```
+ map2mineCount(map, x-1, y-1) + map2mineCount(map, x, y-1) + map2mineCount(map, x+1, y-1) +
+ map2mineCount(map, x-1, y) + map2mineCount(map, x+1, y) +
+ map2mineCount(map, x-1, y+1) + map2mineCount(map, x, y+1) + map2mineCount(map, x+1, y+1)
+ }
+ );
+}
+```
+
+यदि खिलाड़ी ने माइन नहीं मारा है, तो स्थान के आसपास के क्षेत्र के लिए माइन की गिनती जोड़ें और उसे वापस करें।
+
+### TypeScript से Zokrates का उपयोग करना {#using-zokrates-from-typescript}
+
+Zokrates का एक कमांड लाइन इंटरफ़ेस है, लेकिन इस प्रोग्राम में हम इसका उपयोग [TypeScript कोड](https://zokrates.github.io/toolbox/zokrates_js.html) में करते हैं।
+
+Zokrates परिभाषाओं वाली लाइब्रेरी को [`zero-knowledge.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts) कहा जाता है।
+
+```typescript
+import { initialize as zokratesInitialize } from "zokrates-js"
+```
+
+[Zokrates JavaScript बाइंडिंग](https://zokrates.github.io/toolbox/zokrates_js.html) आयात करें। हमें केवल [`initialize`](https://zokrates.github.io/toolbox/zokrates_js.html#initialize) फ़ंक्शन की आवश्यकता है क्योंकि यह एक वादा लौटाता है जो सभी Zokrates परिभाषाओं का समाधान करता है।
+
+```typescript
+export const zkFunctions = async (width: number, height: number) : Promise => {
+```
+
+Zokrates की तरह ही, हम भी केवल एक ही फ़ंक्शन निर्यात करते हैं, जो [एसिंक्रोनस](https://www.w3schools.com/js/js_async.asp) भी है। जब यह अंततः लौटता है, तो यह कई फ़ंक्शन प्रदान करता है जैसा कि हम नीचे देखेंगे।
+
+```typescript
+const zokrates = await zokratesInitialize()
+```
+
+Zokrates को इनिशियलाइज़ करें, लाइब्रेरी से वह सब कुछ प्राप्त करें जिसकी हमें आवश्यकता है।
+
+```typescript
+const hashFragment = `
+ import "utils/pack/bool/pack128.zok" as pack128;
+ import "hashes/poseidon/poseidon.zok" as poseidon;
+ .
+ .
+ .
+ }
+ `
+
+const hashProgram = `
+ ${hashFragment}
+ .
+ .
+ .
+ `
+
+const digProgram = `
+ ${hashFragment}
+ .
+ .
+ .
+ `
+```
+
+इसके बाद हमारे पास हैश फ़ंक्शन और दो Zokrates प्रोग्राम हैं जिन्हें हमने ऊपर देखा है।
+
+```typescript
+const digCompiled = zokrates.compile(digProgram)
+const hashCompiled = zokrates.compile(hashProgram)
+```
+
+यहां हम उन प्रोग्रामों को संकलित करते हैं।
+
+```typescript
+// ज़ीरो नॉलेज सत्यापन के लिए कुंजी बनाएँ।
+// उत्पादन प्रणाली पर आप एक सेटअप समारोह का उपयोग करना चाहेंगे।
+// (https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony)।
+const keySetupResults = zokrates.setup(digCompiled.program, "")
+const verifierKey = keySetupResults.vk
+const proverKey = keySetupResults.pk
+```
+
+एक प्रोडक्शन सिस्टम पर हम एक अधिक जटिल [सेटअप समारोह](https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony) का उपयोग कर सकते हैं, लेकिन यह एक प्रदर्शन के लिए काफी अच्छा है। यह कोई समस्या नहीं है कि यूज़र प्रोवर कुंजी जान सकते हैं - वे अभी भी इसका उपयोग चीजों को साबित करने के लिए नहीं कर सकते हैं जब तक कि वे सच न हों। क्योंकि हम एन्ट्रापी (दूसरा पैरामीटर, `""`) निर्दिष्ट करते हैं, परिणाम हमेशा समान होंगे।
+
+**ध्यान दें:** Zokrates प्रोग्रामों का संकलन और कुंजी निर्माण धीमी प्रक्रियाएं हैं। इन्हें हर बार दोहराने की कोई आवश्यकता नहीं है, केवल जब मैप का आकार बदलता है। एक प्रोडक्शन सिस्टम पर आप उन्हें एक बार करते हैं, और फिर आउटपुट को स्टोर करते हैं। मैं इसे यहाँ केवल सरलता के लिए नहीं कर रहा हूँ।
+
+#### `calculateMapHash` {#calculateMapHash}
+
+```typescript
+const calculateMapHash = function (hashMe: boolean[][]): string {
+ return (
+ "0x" +
+ BigInt(zokrates.computeWitness(hashCompiled, [hashMe]).output.slice(1, -1))
+ .toString(16)
+ .padStart(64, "0")
+ )
+}
+```
+
+[`computeWitness`](https://zokrates.github.io/toolbox/zokrates_js.html#computewitnessartifacts-args-options) फ़ंक्शन वास्तव में Zokrates प्रोग्राम चलाता है। यह दो फ़ील्ड के साथ एक संरचना लौटाता है: `output`, जो प्रोग्राम का आउटपुट एक JSON स्ट्रिंग के रूप में है, और `witness`, जो परिणाम का एक शून्य ज्ञान प्रमाण बनाने के लिए आवश्यक जानकारी है। यहाँ हमें केवल आउटपुट की आवश्यकता है।
+
+आउटपुट `"31337"` के रूप में एक स्ट्रिंग है, जो उद्धरण चिह्नों में संलग्न एक दशमलव संख्या है। लेकिन `viem` के लिए हमें जिस आउटपुट की आवश्यकता है, वह `0x60A7` के रूप में एक हेक्साडेसिमल संख्या है। तो हम उद्धरण चिह्नों को हटाने के लिए `.slice(1,-1)` का उपयोग करते हैं और फिर शेष स्ट्रिंग, जो एक दशमलव संख्या है, को [`BigInt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) में बदलने के लिए `BigInt` का उपयोग करते हैं। `.toString(16)` इस `BigInt` को एक हेक्साडेसिमल स्ट्रिंग में बदलता है, और `"0x"+` हेक्साडेसिमल संख्याओं के लिए मार्कर जोड़ता है।
+
+```typescript
+// परिणाम का ज़ीरो नॉलेज प्रमाण खोदें और लौटाएँ
+// (सर्वर-साइड कोड)
+```
+
+ज़ीरो नॉलेज प्रूफ़ में सार्वजनिक इनपुट (`x` और `y`) और परिणाम (मैप का हैश और बमों की संख्या) शामिल हैं।
+
+```typescript
+ const zkDig = function(map: boolean[][], x: number, y: number) : any {
+ if (x<0 || x>=width || y<0 || y>=height)
+ throw new Error("Trying to dig outside the map")
+```
+
+Zokrates में यह जांचना एक समस्या है कि कोई इंडेक्स सीमाओं से बाहर है या नहीं, इसलिए हम इसे यहाँ करते हैं।
+
+```typescript
+const runResults = zokrates.computeWitness(digCompiled, [map, `${x}`, `${y}`])
+```
+
+डिग प्रोग्राम निष्पादित करें।
+
+```typescript
+ const proof = zokrates.generateProof(
+ digCompiled.program,
+ runResults.witness,
+ proverKey)
+
+ return proof
+ }
+```
+
+[`generateProof`](https://zokrates.github.io/toolbox/zokrates_js.html#generateproofprogram-witness-provingkey-entropy) का उपयोग करें और प्रमाण लौटाएँ।
+
+```typescript
+const solidityVerifier = `
+ // Map size: ${width} x ${height}
+ \n${zokrates.exportSolidityVerifier(verifierKey)}
+ `
+```
+
+एक सॉलिडिटी वेरिफायर, एक स्मार्ट अनुबंध जिसे हम ब्लॉकचेन पर तैनात कर सकते हैं और `digCompiled.program` द्वारा उत्पन्न प्रमाणों को सत्यापित करने के लिए उपयोग कर सकते हैं।
+
+```typescript
+ return {
+ zkDig,
+ calculateMapHash,
+ solidityVerifier,
+ }
+}
+```
+
+अंत में, वह सब कुछ लौटाएं जिसकी अन्य कोड को आवश्यकता हो सकती है।
+
+## सुरक्षा परीक्षण {#security-tests}
+
+सुरक्षा परीक्षण महत्वपूर्ण हैं क्योंकि एक कार्यक्षमता बग अंततः खुद को प्रकट करेगा। लेकिन अगर एप्लिकेशन असुरक्षित है, तो यह संभवतः लंबे समय तक छिपा रहेगा, इससे पहले कि यह किसी ऐसे व्यक्ति द्वारा प्रकट हो जो धोखा दे रहा है और दूसरों के संसाधनों के साथ बच निकल रहा है।
+
+### अनुमतियाँ {#permissions}
+
+इस गेम में एक विशेषाधिकार प्राप्त इकाई है, सर्वर। यह एकमात्र यूज़र है जिसे [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol) में फ़ंक्शन कॉल करने की अनुमति है। हम [`cast`](https://book.getfoundry.sh/cast/) का उपयोग यह सत्यापित करने के लिए कर सकते हैं कि अनुमति प्राप्त फ़ंक्शनों के लिए कॉल केवल सर्वर खाते के रूप में ही अनुमत हैं।
+
+[सर्वर की निजी कुंजी `setupNetwork.ts` में है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/mud/setupNetwork.ts#L52)।
+
+1. `anvil` (ब्लॉकचेन) चलाने वाले कंप्यूटर पर, इन पर्यावरण चर को सेट करें।
+
+ ```sh copy
+ WORLD_ADDRESS=0x8d8b6b8414e1e3dcfd4168561b9be6bd3bf6ec4b
+ UNAUTHORIZED_KEY=0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a
+ AUTHORIZED_KEY=0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d
+ ```
+
+2. अनधिकृत पते के रूप में वेरिफायर पता सेट करने का प्रयास करने के लिए `cast` का उपयोग करें।
+
+ ```sh copy
+ cast send $WORLD_ADDRESS 'app__setVerifier(address)' `cast address-zero` --private-key $UNAUTHORIZED_KEY
+ ```
+
+ `cast` न केवल विफलता की रिपोर्ट करता है, बल्कि आप ब्राउज़र पर गेम में **MUD Dev Tools** खोल सकते हैं, **Tables** पर क्लिक कर सकते हैं, और **app\_\_VerifierAddress** का चयन कर सकते हैं। देखें कि पता शून्य नहीं है।
+
+3. वेरिफायर पता सर्वर के पते के रूप में सेट करें।
+
+ ```sh copy
+ cast send $WORLD_ADDRESS 'app__setVerifier(address)' `cast address-zero` --private-key $AUTHORIZED_KEY
+ ```
+
+ **app\_\_VerifiedAddress** में पता अब शून्य होना चाहिए।
+
+एक ही `System` में सभी MUD फ़ंक्शन एक ही एक्सेस कंट्रोल से गुजरते हैं, इसलिए मैं इस परीक्षण को पर्याप्त मानता हूं। यदि आप ऐसा नहीं करते हैं, तो आप [`ServerSystem`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/contracts/src/systems/ServerSystem.sol) में अन्य फ़ंक्शन देख सकते हैं।
+
+### ज़ीरो-नॉलेज का दुरुपयोग {#zero-knowledge-abuses}
+
+Zokrates को सत्यापित करने के लिए गणित इस ट्यूटोरियल (और मेरी क्षमताओं) के दायरे से बाहर है। हालांकि, हम यह सत्यापित करने के लिए ज़ीरो-नॉलेज कोड पर विभिन्न जांच चला सकते हैं कि यदि इसे सही तरीके से नहीं किया गया तो यह विफल हो जाता है। इन सभी परीक्षणों के लिए हमें [`zero-knowledge.ts`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts) को बदलना होगा और पूरे एप्लिकेशन को पुनरारंभ करना होगा। सर्वर प्रक्रिया को पुनरारंभ करना पर्याप्त नहीं है, क्योंकि यह एप्लिकेशन को एक असंभव स्थिति में डालता है (खिलाड़ी का एक गेम प्रगति पर है, लेकिन गेम अब सर्वर के लिए उपलब्ध नहीं है)।
+
+#### गलत उत्तर {#wrong-answer}
+
+सबसे सरल संभावना शून्य ज्ञान प्रमाण में गलत उत्तर प्रदान करना है। ऐसा करने के लिए, हम `zkDig` के अंदर जाते हैं और [लाइन 91 को संशोधित करते हैं](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L91):
+
+```ts
+proof.inputs[3] = "0x" + "1".padStart(64, "0")
+```
+
+इसका मतलब है कि हम हमेशा दावा करेंगे कि एक बम है, चाहे सही उत्तर कुछ भी हो। इस संस्करण के साथ खेलने का प्रयास करें, और आप `pnpm dev` स्क्रीन के **server** टैब में यह त्रुटि देखेंगे:
+
+```
+ cause: {
+ code: 3,
+ message: 'execution reverted: revert: Zero knowledge verification fail',
+ data: '0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000
+000000000000000000000000000000000000000000000000205a65726f206b6e6f776c6564676520766572696669636174696f6
+e206661696c'
+ },
+```
+
+तो इस तरह की धोखाधड़ी विफल हो जाती है।
+
+#### गलत प्रमाण {#wrong-proof}
+
+क्या होता है अगर हम सही जानकारी प्रदान करते हैं, लेकिन बस गलत प्रमाण डेटा है? अब, लाइन 91 को इससे बदलें:
+
+```ts
+proof.proof = {
+ a: ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+ b: [
+ ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+ ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+ ],
+ c: ["0x" + "1".padStart(64, "0"), "0x" + "2".padStart(64, "0")],
+}
+```
+
+यह अभी भी विफल रहता है, लेकिन अब यह बिना किसी कारण के विफल रहता है क्योंकि यह वेरिफायर कॉल के दौरान होता है।
+
+### एक यूज़र ज़ीरो ट्रस्ट कोड को कैसे सत्यापित कर सकता है? {#user-verify-zero-trust}
+
+स्मार्ट अनुबंधों को सत्यापित करना अपेक्षाकृत आसान है। आमतौर पर, डेवलपर स्रोत कोड को एक ब्लॉक एक्सप्लोरर पर प्रकाशित करता है, और ब्लॉक एक्सप्लोरर यह सत्यापित करता है कि स्रोत कोड [अनुबंध परिनियोजन लेनदेन](/developers/docs/smart-contracts/deploying/) में कोड में संकलित होता है। MUD `System` के मामले में यह [थोड़ा अधिक जटिल है](https://mud.dev/cli/verify), लेकिन बहुत अधिक नहीं।
+
+ज़ीरो-नॉलेज के साथ यह कठिन है। वेरिफायर में कुछ स्थिरांक शामिल हैं और उन पर कुछ गणनाएँ चलाता है। यह आपको नहीं बताता कि क्या साबित किया जा रहा है।
+
+```solidity
+ function verifyingKey() pure internal returns (VerifyingKey memory vk) {
+ vk.alpha = Pairing.G1Point(uint256(0x0f43f4fe7b5c2326fed4ac6ed2f4003ab9ab4ea6f667c2bdd77afb068617ee16), uint256(0x25a77832283f9726935219b5f4678842cda465631e72dbb24708a97ba5d0ce6f));
+ vk.beta = Pairing.G2Point([uint256(0x2cebd0fbd21aca01910581537b21ae4fed46bc0e524c055059aa164ba0a6b62b), uint256(0x18fd4a7bc386cf03a95af7163d5359165acc4e7961cb46519e6d9ee4a1e2b7e9)], [uint256(0x11449dee0199ef6d8eebfe43b548e875c69e7ce37705ee9a00c81fe52f11a009), uint256(0x066d0c83b32800d3f335bb9e8ed5e2924cf00e77e6ec28178592eac9898e1a00)]);
+```
+
+समाधान, कम से कम जब तक ब्लॉक एक्सप्लोरर अपने यूज़र इंटरफेस में Zokrates सत्यापन जोड़ने के आसपास नहीं आते, यह है कि एप्लिकेशन डेवलपर Zokrates प्रोग्राम उपलब्ध कराते हैं, और कम से कम कुछ यूज़र उन्हें उपयुक्त सत्यापन कुंजी के साथ स्वयं संकलित करते हैं।
+
+ऐसा करने के लिए:
+
+1. [Zokrates इंस्टॉल करें](https://zokrates.github.io/gettingstarted.html)।
+
+2. Zokrates प्रोग्राम के साथ एक फ़ाइल, `dig.zok` बनाएँ। नीचे दिया गया कोड मानता है कि आपने मूल मैप आकार, 10x5 रखा है।
+
+ ```zokrates
+ import "utils/pack/bool/pack128.zok" as pack128;
+ import "hashes/poseidon/poseidon.zok" as poseidon;
+
+ def hashMap(bool[12][7] map) -> field {
+ bool[512] mut map1d = [false; 512];
+ u32 mut counter = 0;
+
+ for u32 x in 0..12 {
+ for u32 y in 0..7 {
+ map1d[counter] = map[x][y];
+ counter = counter+1;
+ }
+ }
+
+ field[4] hashMe = [
+ pack128(map1d[0..128]),
+ pack128(map1d[128..256]),
+ pack128(map1d[256..384]),
+ pack128(map1d[384..512])
+ ];
+
+ return poseidon(hashMe);
+ }
+
+
+ // स्थान (x,y) में माइन की संख्या
+ def map2mineCount(bool[12][7] map, u32 x, u32 y) -> u8 {
+ return if map[x+1][y+1] { 1 } else { 0 };
+ }
+
+ def main(private bool[12][7] map, u32 x, u32 y) -> (field, u8) {
+ return (hashMap(map) ,
+ if map2mineCount(map, x, y) > 0 { 0xFF } else {
+ map2mineCount(map, x-1, y-1) + map2mineCount(map, x, y-1) + map2mineCount(map, x+1, y-1) +
+ map2mineCount(map, x-1, y) + map2mineCount(map, x+1, y) +
+ map2mineCount(map, x-1, y+1) + map2mineCount(map, x, y+1) + map2mineCount(map, x+1, y+1)
+ }
+ );
+ }
+ ```
+
+3. Zokrates कोड संकलित करें और सत्यापन कुंजी बनाएँ। सत्यापन कुंजी को उसी एन्ट्रापी के साथ बनाया जाना चाहिए जिसका उपयोग मूल सर्वर में किया गया था, [इस मामले में एक खाली स्ट्रिंग](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L67)।
+
+ ```sh copy
+ zokrates compile --input dig.zok
+ zokrates setup -e ""
+ ```
+
+4. Solidity वेरिफायर को स्वयं बनाएँ, और सत्यापित करें कि यह ब्लॉकचेन पर मौजूद वाले के साथ कार्यात्मक रूप से समान है (सर्वर एक टिप्पणी जोड़ता है, लेकिन यह महत्वपूर्ण नहीं है)।
+
+ ```sh copy
+ zokrates export-verifier
+ diff verifier.sol ~/20240901-secret-state/packages/contracts/src/verifier.sol
+ ```
+
+## डिज़ाइन निर्णय {#design}
+
+किसी भी पर्याप्त रूप से जटिल एप्लिकेशन में प्रतिस्पर्धी डिज़ाइन लक्ष्य होते हैं जिनके लिए ट्रेड-ऑफ की आवश्यकता होती है। आइए कुछ ट्रेडऑफ देखें और वर्तमान समाधान अन्य विकल्पों की तुलना में क्यों बेहतर है।
+
+### ज़ीरो-नॉलेज क्यों {#why-zero-knowledge}
+
+माइनस्वीपर के लिए आपको वास्तव में ज़ीरो-नॉलेज की आवश्यकता नहीं है। सर्वर हमेशा मैप रख सकता है, और फिर गेम खत्म होने पर बस इसे पूरी तरह से प्रकट कर सकता है। फिर, खेल के अंत में, स्मार्ट अनुबंध मैप हैश की गणना कर सकता है, सत्यापित कर सकता है कि यह मेल खाता है, और यदि यह सर्वर को दंडित नहीं करता है या खेल को पूरी तरह से अनदेखा करता है।
+
+मैंने इस सरल समाधान का उपयोग नहीं किया क्योंकि यह केवल एक अच्छी तरह से परिभाषित अंत स्थिति वाले छोटे खेलों के लिए काम करता है। जब कोई खेल संभावित रूप से अनंत होता है ([स्वायत्त दुनिया](https://0xparc.org/blog/autonomous-worlds) के मामले में), तो आपको एक ऐसे समाधान की आवश्यकता होती है जो इसे प्रकट किए _बिना_ स्थिति को साबित करे।
+
+एक ट्यूटोरियल के रूप में इस लेख को एक छोटे गेम की आवश्यकता थी जो समझने में आसान हो, लेकिन यह तकनीक लंबे समय तक चलने वाले गेम के लिए सबसे उपयोगी है।
+
+### Zokrates क्यों? {#why-zokrates}
+
+[Zokrates](https://zokrates.github.io/) एकमात्र उपलब्ध ज़ीरो-नॉलेज लाइब्रेरी नहीं है, लेकिन यह एक सामान्य, [इंपरेटिव](https://en.wikipedia.org/wiki/Imperative_programming) प्रोग्रामिंग भाषा के समान है और बूलियन वेरिएबल्स का समर्थन करती है।
+
+आपके आवेदन के लिए, विभिन्न आवश्यकताओं के साथ, आप [सर्कम](https://docs.circom.io/getting-started/installation/) या [काहिरा](https://www.cairo-lang.org/tutorials/getting-started-with-cairo/) का उपयोग करना पसंद कर सकते हैं।
+
+### Zokrates को कब संकलित करें {#when-compile-zokrates}
+
+इस प्रोग्राम में हम Zokrates प्रोग्राम को [हर बार जब सर्वर शुरू होता है](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L60-L61) संकलित करते हैं। यह स्पष्ट रूप से संसाधनों की बर्बादी है, लेकिन यह एक ट्यूटोरियल है, जिसे सरलता के लिए अनुकूलित किया गया है।
+
+यदि मैं एक उत्पादन-स्तर का एप्लिकेशन लिख रहा होता, तो मैं जांचता कि क्या मेरे पास इस माइनफील्ड आकार पर संकलित Zokrates प्रोग्राम के साथ एक फ़ाइल है, और यदि ऐसा है तो उसका उपयोग करता। यही बात ऑन-चेन पर एक वेरिफायर अनुबंध को तैनात करने के लिए भी सच है।
+
+### वेरिफायर और प्रोवर कुंजियाँ बनाना {#key-creation}
+
+[कुंजी निर्माण](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L63-L69) एक और शुद्ध गणना है जिसे किसी दिए गए माइनफ़ील्ड आकार के लिए एक से अधिक बार करने की आवश्यकता नहीं है। फिर से, यह केवल सरलता के लिए एक बार किया जाता है।
+
+इसके अतिरिक्त, हम [एक सेटअप समारोह](https://zokrates.github.io/toolbox/trusted_setup.html#initializing-a-phase-2-ceremony) का उपयोग कर सकते हैं। सेटअप समारोह का लाभ यह है कि शून्य ज्ञान प्रमाण पर धोखा देने के लिए आपको प्रत्येक भागीदार से या तो एन्ट्रॉपी या कुछ मध्यवर्ती परिणाम की आवश्यकता होती है। यदि कम से कम एक समारोह भागीदार ईमानदार है और उस जानकारी को हटा देता है, तो शून्य ज्ञान प्रमाण कुछ हमलों से सुरक्षित हैं। हालांकि, यह सत्यापित करने के लिए _कोई तंत्र नहीं_ है कि जानकारी हर जगह से हटा दी गई है। यदि शून्य ज्ञान प्रमाण गंभीर रूप से महत्वपूर्ण हैं, तो आप सेटअप समारोह में भाग लेना चाहेंगे।
+
+यहां हम [tau की स्थायी शक्तियों](https://github.com/privacy-scaling-explorations/perpetualpowersoftau) पर भरोसा करते हैं, जिसमें दर्जनों प्रतिभागी थे। यह शायद काफी सुरक्षित और बहुत सरल है। हम कुंजी निर्माण के दौरान एन्ट्रापी भी नहीं जोड़ते हैं, जिससे यूज़र्स के लिए [ज़ीरो-नॉलेज कॉन्फ़िगरेशन को सत्यापित करना](#user-verify-zero-trust) आसान हो जाता है।
+
+### कहां सत्यापित करें {#where-verification}
+
+हम शून्य ज्ञान प्रमाण को या तो ऑन-चेन (जिसमें गैस लगती है) या क्लाइंट में ([`verify`](https://zokrates.github.io/toolbox/zokrates_js.html#verifyverificationkey-proof) का उपयोग करके) सत्यापित कर सकते हैं। मैंने पहला चुना, क्योंकि यह आपको [वेरिफायर को सत्यापित करने](#user-verify-zero-trust) देता है और फिर भरोसा करता है कि जब तक इसके लिए अनुबंध का पता समान रहता है तब तक यह नहीं बदलता है। यदि सत्यापन क्लाइंट पर किया जाता, तो आपको हर बार क्लाइंट डाउनलोड करने पर प्राप्त कोड को सत्यापित करना पड़ता।
+
+इसके अलावा, जबकि यह गेम सिंगल प्लेयर है, बहुत सारे ब्लॉकचेन गेम मल्टी-प्लेयर हैं। ऑन-चेन सत्यापन का मतलब है कि आप शून्य ज्ञान प्रमाण केवल एक बार सत्यापित करते हैं। इसे क्लाइंट में करने के लिए प्रत्येक क्लाइंट को स्वतंत्र रूप से सत्यापित करने की आवश्यकता होगी।
+
+### TypeScript या Zokrates में मैप को समतल करें? {#where-flatten}
+
+सामान्य तौर पर, जब प्रसंस्करण या तो TypeScript या Zokrates में किया जा सकता है, तो इसे TypeScript में करना बेहतर होता है, जो बहुत तेज है, और इसके लिए शून्य ज्ञान प्रमाण की आवश्यकता नहीं होती है। यही कारण है, उदाहरण के लिए, कि हम Zokrates को हैश प्रदान नहीं करते हैं और इसे सत्यापित करने के लिए कहते हैं कि यह सही है। हैशिंग Zokrates के अंदर किया जाना चाहिए, लेकिन लौटाए गए हैश और ऑन-चेन हैश के बीच का मिलान इसके बाहर हो सकता है।
+
+हालांकि, हम अभी भी [Zokrates में मैप को समतल करते हैं](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L15-L20), जबकि हम इसे TypeScript में कर सकते थे। कारण यह है कि अन्य विकल्प, मेरी राय में, बदतर हैं।
+
+- Zokrates कोड को बूलियन की एक-आयामी सरणी प्रदान करें, और द्वि-आयामी मानचित्र प्राप्त करने के लिए `x*(height+2)
+ +y` जैसे व्यंजक का उपयोग करें। यह [कोड](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/zero-knowledge.ts#L44-L47) को कुछ हद तक अधिक जटिल बना देगा, इसलिए मैंने फैसला किया कि प्रदर्शन लाभ एक ट्यूटोरियल के लिए इसके लायक नहीं है।
+
+- Zokrates को एक-आयामी सरणी और दो-आयामी सरणी दोनों भेजें। हालाँकि, इस समाधान से हमें कुछ भी हासिल नहीं होता है। Zokrates कोड को यह सत्यापित करना होगा कि उसे प्रदान की गई एक-आयामी सरणी वास्तव में दो-आयामी सरणी का सही प्रतिनिधित्व है। तो प्रदर्शन में कोई लाभ नहीं होगा।
+
+- Zokrates में द्वि-आयामी सरणी को समतल करें। यह सबसे सरल विकल्प है, इसलिए मैंने इसे चुना।
+
+### मानचित्र कहाँ संग्रहीत करें {#where-store-maps}
+
+इस एप्लिकेशन में [`gamesInProgress`](https://github.com/qbzzt/20240901-secret-state/blob/main/packages/server/src/app.ts#L20) केवल मेमोरी में एक चर है। इसका मतलब है कि यदि आपका सर्वर मर जाता है और उसे पुनरारंभ करने की आवश्यकता होती है, तो उसमें संग्रहीत सभी जानकारी खो जाती है। खिलाड़ी न केवल अपना खेल जारी रखने में असमर्थ हैं, बल्कि वे एक नया खेल भी शुरू नहीं कर सकते क्योंकि ऑन-चेन घटक को लगता है कि उनका अभी भी एक खेल चल रहा है।
+
+यह स्पष्ट रूप से एक उत्पादन प्रणाली के लिए एक खराब डिज़ाइन है, जिसमें आप इस जानकारी को एक डेटाबेस में संग्रहीत करेंगे। मैंने यहाँ केवल एक चर का उपयोग किया है क्योंकि यह एक ट्यूटोरियल है और सरलता मुख्य विचार है।
+
+## निष्कर्ष: किन परिस्थितियों में यह उपयुक्त तकनीक है? {#conclusion}
+
+तो, अब आप जानते हैं कि एक सर्वर के साथ एक गेम कैसे लिखना है जो गुप्त स्थिति को संग्रहीत करता है जो ऑन-चेन से संबंधित नहीं है। लेकिन किन मामलों में आपको ऐसा करना चाहिए? दो मुख्य विचार हैं।
+
+- _लंबे समय तक चलने वाला गेम_: [जैसा कि ऊपर उल्लेख किया गया है](#why-zero-knowledge), एक छोटे गेम में आप गेम खत्म होने के बाद बस स्थिति प्रकाशित कर सकते हैं और तब सब कुछ सत्यापित करवा सकते हैं। लेकिन यह एक विकल्प नहीं है जब खेल में लंबा या अनिश्चित समय लगता है, और स्थिति को गुप्त रखने की आवश्यकता होती है।
+
+- _कुछ केंद्रीकरण स्वीकार्य_: शून्य ज्ञान प्रमाण अखंडता को सत्यापित कर सकते हैं, कि कोई इकाई परिणामों में हेरफेर नहीं कर रही है। वे यह सुनिश्चित नहीं कर सकते कि इकाई अभी भी उपलब्ध होगी और संदेशों का जवाब देगी। उन स्थितियों में जहां उपलब्धता को भी विकेंद्रीकृत करने की आवश्यकता होती है, शून्य ज्ञान प्रमाण एक पर्याप्त समाधान नहीं हैं, और आपको [मल्टी-पार्टी कंप्यूटेशन](https://en.wikipedia.org/wiki/Secure_multi-party_computation) की आवश्यकता है।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
+
+### आभार {#acknowledgements}
+
+- अल्वारो अलोंसो ने इस लेख का एक मसौदा पढ़ा और ज़ोक्रेट्स के बारे में मेरी कुछ गलतफहमियों को दूर किया।
+
+कोई भी शेष त्रुटि मेरी जिम्मेदारी है।
diff --git a/public/content/translations/hi/developers/tutorials/secure-development-workflow/index.md b/public/content/translations/hi/developers/tutorials/secure-development-workflow/index.md
new file mode 100644
index 00000000000..5dafe34fc33
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/secure-development-workflow/index.md
@@ -0,0 +1,52 @@
+---
+title: "स्मार्ट अनुबंध सुरक्षा जांचसूची"
+description: "सुरक्षित स्मार्ट अनुबंध लिखने के लिए एक सुझाया गया कार्यप्रवाह"
+author: "Trailofbits"
+tags: [ "स्मार्ट अनुबंध", "सुरक्षा", "सोलिडीटी" ]
+skill: intermediate
+lang: hi
+published: 2020-09-07
+source: "सुरक्षित अनुबंध बनाना"
+sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/workflow.md
+---
+
+## स्मार्ट अनुबंध विकास जांचसूची {#smart-contract-development-checklist}
+
+यहां एक उच्च-स्तरीय प्रक्रिया है जिसका पालन करने की हम अनुशंसा करते हैं जब आप अपने स्मार्ट अनुबंध लिखते हैं।
+
+ज्ञात सुरक्षा समस्याओं के लिए जांच करें:
+
+- [Slither](https://github.com/crytic/slither) के साथ अपने अनुबंधों की समीक्षा करें। इसमें सामान्य कमजोरियों के लिए 40 से अधिक अंतर्निहित डिटेक्टर हैं। नए कोड के साथ हर चेक-इन पर इसे चलाएं और सुनिश्चित करें कि यह एक साफ रिपोर्ट प्राप्त करता है (या कुछ मुद्दों को शांत करने के लिए ट्रायज मोड का उपयोग करें)।
+- [Crytic](https://crytic.io/) के साथ अपने अनुबंधों की समीक्षा करें। यह उन 50 समस्याओं की जांच करता है जो Slither नहीं करता है। Crytic आपकी टीम को एक-दूसरे के काम पर नज़र रखने में भी मदद कर सकता है, GitHub पर पुल रिक्वेस्ट में सुरक्षा समस्याओं को आसानी से सामने लाकर।
+
+अपने अनुबंध की विशेष विशेषताओं पर विचार करें:
+
+- क्या आपके अनुबंध अपग्रेड करने योग्य हैं? त्रुटियों के लिए अपने अपग्रेडेबिलिटी कोड की समीक्षा [`slither-check-upgradeability`](https://github.com/crytic/slither/wiki/Upgradeability-Checks) या [Crytic](https://blog.trailofbits.com/2020/06/12/upgradeable-contracts-made-safer-with-crytic/) के साथ करें। हमने 17 तरीकों का दस्तावेजीकरण किया है जिनसे अपग्रेड गलत हो सकते हैं।
+- क्या आपके अनुबंध ERCs के अनुरूप होने का दावा करते हैं? उन्हें [`slither-check-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) से जांचें। यह उपकरण तुरंत छह सामान्य विशिष्टताओं से विचलन की पहचान करता है।
+- क्या आप तीसरे पक्ष के टोकन के साथ एकीकृत करते हैं? बाहरी अनुबंधों पर भरोसा करने से पहले हमारी [टोकन एकीकरण जांचसूची](/developers/tutorials/token-integration-checklist/) की समीक्षा करें।
+
+अपने कोड की महत्वपूर्ण सुरक्षा विशेषताओं का दृष्टिगत रूप से निरीक्षण करें:
+
+- Slither के [inheritance-graph](https://github.com/trailofbits/slither/wiki/Printer-documentation#inheritance-graph) प्रिंटर की समीक्षा करें। अनजाने में शैडोइंग और C3 लाइनाइराइजेशन समस्याओं से बचें।
+- Slither के [function-summary](https://github.com/trailofbits/slither/wiki/Printer-documentation#function-summary) प्रिंटर की समीक्षा करें। यह फ़ंक्शन दृश्यता और एक्सेस नियंत्रण की रिपोर्ट करता है।
+- Slither के [vars-and-auth](https://github.com/trailofbits/slither/wiki/Printer-documentation#variables-written-and-authorization) प्रिंटर की समीक्षा करें। यह स्टेट वेरिएबल्स पर एक्सेस नियंत्रण की रिपोर्ट करता है।
+
+महत्वपूर्ण सुरक्षा गुणों का दस्तावेजीकरण करें और उनका मूल्यांकन करने के लिए स्वचालित परीक्षण जनरेटर का उपयोग करें:
+
+- अपने कोड के लिए [सुरक्षा गुणों का दस्तावेजीकरण करना सीखें](/developers/tutorials/guide-to-smart-contract-security-tools/)। शुरुआत में यह कठिन है, लेकिन एक अच्छा परिणाम प्राप्त करने के लिए यह एकमात्र सबसे महत्वपूर्ण गतिविधि है। इस ट्यूटोरियल में किसी भी उन्नत तकनीक का उपयोग करने के लिए यह एक पूर्वापेक्षा भी है।
+- [Echidna](https://github.com/crytic/echidna) और [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html) के साथ उपयोग के लिए Solidity में सुरक्षा गुण परिभाषित करें। अपनी स्टेट मशीन, एक्सेस नियंत्रण, अंकगणितीय संचालन, बाहरी इंटरैक्शन और मानकों के अनुरूपता पर ध्यान केंद्रित करें।
+- [Slither के Python API](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) के साथ सुरक्षा गुण परिभाषित करें। इनहेरिटेंस, वेरिएबल निर्भरता, एक्सेस नियंत्रण और अन्य संरचनात्मक मुद्दों पर ध्यान दें।
+- [Crytic](https://crytic.io) के साथ हर कमिट पर अपने प्रॉपर्टी परीक्षण चलाएं। Crytic सुरक्षा प्रॉपर्टी परीक्षणों का उपभोग और मूल्यांकन कर सकता है ताकि आपकी टीम का हर कोई आसानी से देख सके कि वे GitHub पर पास हो गए हैं। विफल परीक्षण कमिट को ब्लॉक कर सकते हैं।
+
+अंत में, उन मुद्दों से सावधान रहें जो स्वचालित उपकरण आसानी से नहीं खोज सकते हैं:
+
+- गोपनीयता की कमी: हर कोई आपके लेन-देन को देख सकता है जब वे पूल में कतार में होते हैं
+- लेन-देन को फ्रंट रनिंग करना
+- क्रिप्टोग्राफिक संचालन
+- बाहरी DeFi घटकों के साथ जोखिम भरा इंटरैक्शन
+
+## मदद के लिए पूछें {#ask-for-help}
+
+[एथेरियम ऑफिस ऑवर्स](https://calendly.com/dan-trailofbits/office-hours) हर मंगलवार दोपहर को चलते हैं। ये 1-घंटे, 1-ऑन-1 सत्र हमें सुरक्षा के बारे में आपके किसी भी प्रश्न को पूछने, हमारे उपकरणों का उपयोग करके समस्या निवारण करने और विशेषज्ञों से आपके वर्तमान दृष्टिकोण के बारे में प्रतिक्रिया प्राप्त करने का एक अवसर हैं। हम इस गाइड के माध्यम से काम करने में आपकी मदद करेंगे।
+
+हमारे Slack में शामिल हों: [Empire Hacking](https://join.slack.com/t/empirehacking/shared_invite/zt-h97bbrj8-1jwuiU33nnzg67JcvIciUw) । यदि आपके कोई प्रश्न हैं तो हम #crytic और #ethereum चैनलों में हमेशा उपलब्ध हैं।
diff --git a/public/content/translations/hi/developers/tutorials/send-token-ethersjs/index.md b/public/content/translations/hi/developers/tutorials/send-token-ethersjs/index.md
new file mode 100644
index 00000000000..7ece0a4a44d
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/send-token-ethersjs/index.md
@@ -0,0 +1,210 @@
+---
+title: "ethers.js का उपयोग करके टोकन भेजना"
+description: "ethers.js का उपयोग करके टोकन भेजने के लिए शुरुआती लोगों के लिए अनुकूल गाइड।"
+author: Kim YongJun
+tags: [ "ETHERS.JS", "ERC-20", "टोकन" ]
+skill: beginner
+lang: hi
+published: 2021-04-06
+---
+
+## ethers.js(5.0) का उपयोग करके टोकन भेजें {#send-token}
+
+### इस ट्यूटोरियल में आप जानेंगे कि कैसे {#you-learn-about}
+
+- ethers.js आयात करें
+- टोकन ट्रांसफर करें
+- नेटवर्क ट्रैफिक स्थिति के अनुसार गैस मूल्य सेट करें
+
+### शुरू करने के लिए {#to-get-started}
+
+शुरू करने के लिए, हमें सबसे पहले अपने जावास्क्रिप्ट में ethers.js लाइब्रेरी को आयात करना होगा
+ethers.js(5.0) शामिल करें
+
+### इंस्टॉल करना {#install-ethersjs}
+
+```shell
+/home/ricmoo> npm install --save ethers
+```
+
+ब्राउज़र में ES6
+
+```html
+
+```
+
+ब्राउज़र में ES3(UMD)
+
+```html
+
+```
+
+### पैरामीटर्स {#param}
+
+1. **`contract_address`**: टोकन कॉन्ट्रैक्ट पता (जब आप जिस टोकन को ट्रांसफर करना चाहते हैं, वह ईथर नहीं है, तो कॉन्ट्रैक्ट पता की आवश्यकता होती है)
+2. **`send_token_amount`**: वह राशि जो आप रिसीवर को भेजना चाहते हैं
+3. **`to_address`**: रिसीवर का पता
+4. **`send_account`**: प्रेषक का पता
+5. **`private_key`**: लेनदेन पर हस्ताक्षर करने और वास्तव में टोकन ट्रांसफर करने के लिए प्रेषक की निजी कुंजी
+
+## सूचना {#notice}
+
+`signTransaction(tx)` को हटा दिया गया है क्योंकि `sendTransaction()` इसे आंतरिक रूप से करता है।
+
+## भेजने की प्रक्रिया {#procedure}
+
+### 1. नेटवर्क से कनेक्ट करें (टेस्टनेट) {#connect-to-network}
+
+#### प्रोवाइडर सेट करें (Infura) {#set-provider}
+
+Ropsten टेस्टनेट से कनेक्ट करें
+
+```javascript
+window.ethersProvider = new ethers.providers.InfuraProvider("ropsten")
+```
+
+### २. वॉलेट बनाएँ {#create-wallet}
+
+```javascript
+let wallet = new ethers.Wallet(private_key)
+```
+
+### 3. वॉलेट को नेट से कनेक्ट करें {#connect-wallet-to-net}
+
+```javascript
+let walletSigner = wallet.connect(window.ethersProvider)
+```
+
+### 4. वर्तमान गैस मूल्य प्राप्त करें {#get-gas}
+
+```javascript
+window.ethersProvider.getGasPrice() // गैस मूल्य
+```
+
+### 5. लेनदेन को परिभाषित करें {#define-transaction}
+
+नीचे परिभाषित ये चर `send_token()` पर निर्भर हैं
+
+### लेनदेन पैरामीटर्स {#transaction-params}
+
+1. **`send_account`**: टोकन प्रेषक का पता
+2. **`to_address`**: टोकन रिसीवर का पता
+3. **`send_token_amount`**: भेजे जाने वाले टोकन की राशि
+4. **`gas_limit`**: गैस सीमा
+5. **`gas_price`**: गैस मूल्य
+
+[कैसे उपयोग करें इसके लिए नीचे देखें](#how-to-use)
+
+```javascript
+const tx = {
+ from: send_account,
+ to: to_address,
+ value: ethers.utils.parseEther(send_token_amount),
+ nonce: window.ethersProvider.getTransactionCount(send_account, "latest"),
+ gasLimit: ethers.utils.hexlify(gas_limit), // 100000
+ gasPrice: gas_price,
+}
+```
+
+### 6. ट्रांसफर करें {#transfer}
+
+```javascript
+walletSigner.sendTransaction(tx).then((transaction) => {
+ console.dir(transaction)
+ alert("भेजना समाप्त!")
+})
+```
+
+## इसका उपयोग कैसे करें {#how-to-use}
+
+```javascript
+let private_key =
+ "41559d28e936dc92104ff30691519693fc753ffbee6251a611b9aa1878f12a4d"
+let send_token_amount = "1"
+let to_address = "0x4c10D2734Fb76D3236E522509181CC3Ba8DE0e80"
+let send_address = "0xda27a282B5B6c5229699891CfA6b900A716539E6"
+let gas_limit = "0x100000"
+let wallet = new ethers.Wallet(private_key)
+let walletSigner = wallet.connect(window.ethersProvider)
+let contract_address = ""
+window.ethersProvider = new ethers.providers.InfuraProvider("ropsten")
+
+send_token(
+ contract_address,
+ send_token_amount,
+ to_address,
+ send_address,
+ private_key
+)
+```
+
+### सफलता! {#success}
+
+
+
+## send_token() {#send-token-method}
+
+```javascript
+function send_token(
+ contract_address,
+ send_token_amount,
+ to_address,
+ send_account,
+ private_key
+) {
+ let wallet = new ethers.Wallet(private_key)
+ let walletSigner = wallet.connect(window.ethersProvider)
+
+ window.ethersProvider.getGasPrice().then((currentGasPrice) => {
+ let gas_price = ethers.utils.hexlify(parseInt(currentGasPrice))
+ console.log(`gas_price: ${gas_price}`)
+
+ if (contract_address) {
+ // सामान्य टोकन भेजना
+ let contract = new ethers.Contract(
+ contract_address,
+ send_abi,
+ walletSigner
+ )
+
+ // कितने टोकन?
+ let numberOfTokens = ethers.utils.parseUnits(send_token_amount, 18)
+ console.log(`numberOfTokens: ${numberOfTokens}`)
+
+ // टोकन भेजें
+ contract.transfer(to_address, numberOfTokens).then((transferResult) => {
+ console.dir(transferResult)
+ alert("टोकन भेज दिया गया")
+ })
+ } // ईथर भेजें
+ else {
+ const tx = {
+ from: send_account,
+ to: to_address,
+ value: ethers.utils.parseEther(send_token_amount),
+ nonce: window.ethersProvider.getTransactionCount(
+ send_account,
+ "latest"
+ ),
+ gasLimit: ethers.utils.hexlify(gas_limit), // 100000
+ gasPrice: gas_price,
+ }
+ console.dir(tx)
+ try {
+ walletSigner.sendTransaction(tx).then((transaction) => {
+ console.dir(transaction)
+ alert("भेजना समाप्त!")
+ })
+ } catch (error) {
+ alert("भेजने में विफल!!")
+ }
+ }
+ })
+}
+```
diff --git a/public/content/translations/hi/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md b/public/content/translations/hi/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
new file mode 100644
index 00000000000..d322948be11
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/sending-transactions-using-web3-and-alchemy/index.md
@@ -0,0 +1,208 @@
+---
+title: "Web3 का उपयोग करके लेन-देन भेजना"
+description: "यह Web3 का उपयोग करके एथेरियम लेन-देन भेजने के लिए एक शुरुआती अनुकूल मार्गदर्शिका है। एथेरियम ब्लॉकचेन पर लेन-देन भेजने के लिए तीन मुख्य चरण हैं: बनाना, हस्ताक्षर करना और प्रसारित करना। हम तीनों पर गौर करेंगे।"
+author: "एलन हैल्पर्न"
+tags: [ "लेनदेन", "web3.js", "एल्केमी" ]
+skill: beginner
+lang: hi
+published: 2020-11-04
+source: "Alchemy दस्तावेज़"
+sourceUrl: https://docs.alchemy.com/alchemy/tutorials/sending-txs
+---
+
+यह Web3 का उपयोग करके एथेरियम लेन-देन भेजने के लिए एक शुरुआती अनुकूल मार्गदर्शिका है। एथेरियम ब्लॉकचेन पर लेन-देन भेजने के लिए तीन मुख्य चरण हैं: बनाना, हस्ताक्षर करना और प्रसारित करना। हम तीनों पर गौर करेंगे, उम्मीद है कि आपके मन में उठने वाले सभी सवालों का जवाब मिल जाएगा! इस ट्यूटोरियल में, हम अपने लेन-देन को एथेरियम श्रृंखला पर भेजने के लिए [Alchemy](https://www.alchemy.com/) का उपयोग करेंगे। आप [यहां एक मुफ्त Alchemy खाता बना सकते हैं](https://auth.alchemyapi.io/signup)।
+
+**नोट:** यह मार्गदर्शिका आपके ऐप के लिए _बैकएंड_ पर आपके लेन-देन पर हस्ताक्षर करने के लिए है। यदि आप फ्रंटएंड पर अपने लेन-देन पर हस्ताक्षर को एकीकृत करना चाहते हैं, तो [ब्राउज़र प्रदाता के साथ Web3 को एकीकृत करने](https://docs.alchemy.com/reference/api-overview#with-a-browser-provider) की जांच करें।
+
+## मूल बातें {#the-basics}
+
+जब अधिकांश ब्लॉकचेन डेवलपर पहली बार शुरुआत करते हैं, तो उनकी तरह, आपने भी शायद इस बारे में कुछ शोध किया होगा कि लेन-देन कैसे भेजा जाए (कुछ ऐसा जो बहुत आसान होना चाहिए) और आप कई गाइडों से गुजरे होंगे, जिनमें से हर एक अलग-अलग बातें कह रहा होगा और आपको थोड़ा अभिभूत और भ्रमित कर दिया होगा। यदि आप भी इसी स्थिति में हैं, तो चिंता न करें; हम सभी किसी न किसी समय थे! तो, शुरू करने से पहले, आइए कुछ बातों को स्पष्ट कर लें:
+
+### 1. Alchemy आपकी निजी कुंजियों को संग्रहीत नहीं करता है {#alchemy-does-not-store-your-private-keys}
+
+- इसका मतलब है कि Alchemy आपकी ओर से लेन-देन पर हस्ताक्षर और भेज नहीं सकता है। इसका कारण सुरक्षा उद्देश्य हैं। Alchemy आपसे कभी भी आपकी निजी कुंजी साझा करने के लिए नहीं कहेगा, और आपको कभी भी अपनी निजी कुंजी को किसी होस्ट किए गए नोड (या इस मामले में किसी के साथ) के साथ साझा नहीं करना चाहिए।
+- आप Alchemy के कोर API का उपयोग करके ब्लॉकचेन से पढ़ सकते हैं, लेकिन उस पर लिखने के लिए आपको अपने लेन-देन पर हस्ताक्षर करने के लिए कुछ और उपयोग करने की आवश्यकता होगी, इससे पहले कि आप उन्हें Alchemy के माध्यम से भेजें (यह किसी भी अन्य [नोड सेवा](/developers/docs/nodes-and-clients/nodes-as-a-service/) के लिए समान है)।
+
+### 2. “हस्ताक्षरकर्ता” क्या है? {#what-is-a-signer}
+
+- हस्ताक्षरकर्ता आपकी निजी कुंजी का उपयोग करके आपके लिए लेन-देन पर हस्ताक्षर करेंगे। इस ट्यूटोरियल में हम अपने लेन-देन पर हस्ताक्षर करने के लिए [Alchemy web3](https://docs.alchemyapi.io/alchemy/documentation/alchemy-web3) का उपयोग करेंगे, लेकिन आप किसी अन्य वेब3 लाइब्रेरी का भी उपयोग कर सकते हैं।
+- फ्रंटएंड पर, हस्ताक्षरकर्ता का एक अच्छा उदाहरण [MetaMask](https://metamask.io/) होगा, जो आपकी ओर से लेन-देन पर हस्ताक्षर करेगा और भेजेगा।
+
+### 3. मुझे अपने लेन-देन पर हस्ताक्षर करने की आवश्यकता क्यों है? {#why-do-i-need-to-sign-my-transactions}
+
+- एथेरियम नेटवर्क पर लेन-देन भेजने के इच्छुक प्रत्येक यूज़र को लेन-देन पर हस्ताक्षर करना होगा (अपनी निजी कुंजी का उपयोग करके), ताकि यह सत्यापित हो सके कि लेन-देन का मूल वही है जो वह होने का दावा करता है।
+- इस निजी कुंजी की सुरक्षा करना बहुत महत्वपूर्ण है, क्योंकि इस तक पहुंच आपके एथेरियम खाते पर पूर्ण नियंत्रण प्रदान करती है, जो आपको (या पहुंच वाले किसी भी व्यक्ति को) आपकी ओर से लेन-देन करने की अनुमति देती है।
+
+### 4. मैं अपनी निजी कुंजी की सुरक्षा कैसे करूं? {#how-do-i-protect-my-private-key}
+
+- अपनी निजी कुंजी की सुरक्षा और लेन-देन भेजने के लिए इसका उपयोग करने के कई तरीके हैं। इस ट्यूटोरियल में हम एक `.env` फ़ाइल का उपयोग करेंगे। हालांकि, आप एक अलग प्रदाता का भी उपयोग कर सकते हैं जो निजी कुंजियों को संग्रहीत करता है, एक कीस्टोर फ़ाइल का उपयोग कर सकते हैं, या अन्य विकल्प भी हैं।
+
+### 5. `eth_sendTransaction` और `eth_sendRawTransaction` के बीच क्या अंतर है? {#difference-between-send-and-send-raw}
+
+`eth_sendTransaction` और `eth_sendRawTransaction` दोनों एथेरियम API फ़ंक्शन हैं जो एथेरियम नेटवर्क पर एक लेन-देन प्रसारित करते हैं ताकि इसे भविष्य के ब्लॉक में जोड़ा जा सके। वे लेन-देन पर हस्ताक्षर को संभालने के तरीके में भिन्न हैं।
+
+- [`eth_sendTransaction`](https://docs.web3js.org/api/web3-eth/function/sendTransaction) का उपयोग _बिना हस्ताक्षर वाले_ लेन-देन भेजने के लिए किया जाता है, जिसका अर्थ है कि जिस नोड को आप भेज रहे हैं, उसे आपकी निजी कुंजी का प्रबंधन करना होगा ताकि वह इसे श्रृंखला में प्रसारित करने से पहले लेन-देन पर हस्ताक्षर कर सके। चूंकि Alchemy यूज़र की निजी कुंजियों को नहीं रखता है, इसलिए वे इस विधि का समर्थन नहीं करते हैं।
+- [`eth_sendRawTransaction`](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction) का उपयोग उन लेन-देनों को प्रसारित करने के लिए किया जाता है जिन पर पहले ही हस्ताक्षर किए जा चुके हैं। इसका मतलब है कि आपको पहले [`signTransaction(tx, private_key)`](https://docs.web3js.org/api/web3-eth-accounts/function/signTransaction) का उपयोग करना होगा, फिर परिणाम को `eth_sendRawTransaction` में पास करना होगा।
+
+web3 का उपयोग करते समय, `eth_sendRawTransaction` को [web3.eth.sendSignedTransaction](https://docs.web3js.org/api/web3-eth/function/sendSignedTransaction) फ़ंक्शन को कॉल करके एक्सेस किया जाता है।
+
+इस ट्यूटोरियल में हम इसी का उपयोग करेंगे।
+
+### 6. web3 लाइब्रेरी क्या है? {#what-is-the-web3-library}
+
+- Web3.js मानक JSON-RPC कॉल के आसपास एक रैपर लाइब्रेरी है जिसका उपयोग एथेरियम विकास में काफी आम है।
+- विभिन्न भाषाओं के लिए कई वेब3 लाइब्रेरी हैं। इस ट्यूटोरियल में हम [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) का उपयोग करेंगे जो जावास्क्रिप्ट में लिखा गया है। आप [यहां](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries) [ethers.js](https://docs.ethers.org/v5/) जैसे अन्य विकल्प देख सकते हैं।
+
+ठीक है, अब जब हमने इनमें से कुछ सवालों को हल कर लिया है, तो आइए ट्यूटोरियल पर आगे बढ़ें। Alchemy के [डिस्कॉर्ड](https://discord.gg/gWuC7zB) में किसी भी समय सवाल पूछने के लिए स्वतंत्र महसूस करें!
+
+### 7. सुरक्षित, गैस-अनुकूलित और निजी लेन-देन कैसे भेजें? {#how-to-send-secure-gas-optimized-and-private-transactions}
+
+- [Alchemy के पास Transact API का एक सूट है](https://docs.alchemy.com/reference/transact-api-quickstart)। आप इनका उपयोग प्रबलित लेन-देन भेजने, लेन-देन होने से पहले उनका अनुकरण करने, निजी लेन-देन भेजने और गैस-अनुकूलित लेन-देन भेजने के लिए कर सकते हैं
+- जब आपके लेन-देन को मेमपूल से निकालकर श्रृंखला में जोड़ा जाता है, तो आपको सूचित करने के लिए आप [Notify API](https://docs.alchemy.com/docs/alchemy-notify) का भी उपयोग कर सकते हैं
+
+**नोट:** इस गाइड के लिए एक Alchemy खाता, एक एथेरियम पता या MetaMask वॉलेट, NodeJs और npm इंस्टॉल होना आवश्यक है। यदि नहीं, तो इन चरणों का पालन करें:
+
+1. [एक मुफ्त Alchemy खाता बनाएं](https://auth.alchemyapi.io/signup)
+2. [MetaMask खाता बनाएं](https://metamask.io/) (या एक एथेरियम पता प्राप्त करें)
+3. [NodeJs और NPM इंस्टॉल करने के लिए इन चरणों का पालन करें](https://docs.alchemy.com/alchemy/guides/alchemy-for-macs)
+
+## अपना लेन-देन भेजने के चरण {#steps-to-sending-your-transaction}
+
+### 1. Sepolia टेस्टनेट पर एक Alchemy ऐप बनाएं {#create-an-alchemy-app-on-the-sepolia-testnet}
+
+अपने [Alchemy डैशबोर्ड](https://dashboard.alchemyapi.io/) पर जाएं और एक नया ऐप बनाएं, अपने नेटवर्क के लिए Sepolia (या कोई अन्य टेस्टनेट) चुनें।
+
+### 2. Sepolia फॉसेट से ETH का अनुरोध करें {#request-eth-from-sepolia-faucet}
+
+ETH प्राप्त करने के लिए [Alchemy Sepolia फॉसेट](https://www.sepoliafaucet.com/) पर दिए गए निर्देशों का पालन करें। यह सुनिश्चित कर लें कि आप अपना **Sepolia** एथेरियम पता (MetaMask से) शामिल करें, न कि कोई अन्य नेटवर्क। निर्देशों का पालन करने के बाद, दोबारा जांच लें कि आपको अपने वॉलेट में ETH प्राप्त हो गया है।
+
+### 3. एक नई प्रोजेक्ट डायरेक्टरी बनाएं और उसमें `cd` करें {#create-a-new-project-direction}
+
+कमांड लाइन (macs के लिए टर्मिनल) से एक नई प्रोजेक्ट डायरेक्टरी बनाएं और उसमें नेविगेट करें:
+
+```
+mkdir sendtx-example
+cd sendtx-example
+```
+
+### 4. Alchemy Web3 (या कोई भी web3 लाइब्रेरी) इंस्टॉल करें {#install-alchemy-web3}
+
+[Alchemy Web3](https://docs.alchemy.com/reference/api-overview) इंस्टॉल करने के लिए अपनी प्रोजेक्ट डायरेक्टरी में निम्नलिखित कमांड चलाएं:
+
+नोट, यदि आप ethers.js लाइब्रेरी का उपयोग करना चाहते हैं, तो [यहां दिए गए निर्देशों का पालन करें](https://docs.alchemy.com/docs/how-to-send-transactions-on-ethereum)।
+
+```
+npm install @alch/alchemy-web3
+```
+
+### 5. dotenv इंस्टॉल करें {#install-dotenv}
+
+हम अपनी API कुंजी और निजी कुंजी को सुरक्षित रूप से संग्रहीत करने के लिए एक `.env` फ़ाइल का उपयोग करेंगे।
+
+```
+npm install dotenv --save
+```
+
+### 6. `.env` फ़ाइल बनाएं {#create-the-dotenv-file}
+
+अपनी प्रोजेक्ट डायरेक्टरी में एक `.env` फ़ाइल बनाएं और निम्नलिखित जोड़ें ("`your-api-url`" और "`your-private-key`" को बदलते हुए)
+
+- अपना Alchemy API URL खोजने के लिए, अपने डैशबोर्ड पर अभी बनाए गए ऐप के ऐप विवरण पृष्ठ पर जाएँ, ऊपरी दाएँ कोने में “कुंजी देखें” पर क्लिक करें, और HTTP URL प्राप्त करें।
+- MetaMask का उपयोग करके अपनी निजी कुंजी खोजने के लिए, इस [गाइड](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) को देखें।
+
+```
+API_URL = "your-api-url"
+PRIVATE_KEY = "your-private-key"
+```
+
+
+
+
+.env को कमिट न करें! कृपया यह सुनिश्चित कर लें कि आप अपनी .env फ़ाइल को किसी के साथ साझा या उजागर न करें, क्योंकि ऐसा करने से आप अपने रहस्यों से समझौता कर रहे हैं। यदि आप संस्करण नियंत्रण का उपयोग कर रहे हैं, तो अपनी .env को gitignore फ़ाइल में जोड़ें।
+
+
+
+
+### 7. `sendTx.js` फ़ाइल बनाएँ {#create-sendtx-js}
+
+बहुत बढ़िया, अब जब हमारा संवेदनशील डेटा एक `.env` फ़ाइल में सुरक्षित है, तो चलिए कोडिंग शुरू करते हैं। हमारे लेन-देन भेजने के उदाहरण के लिए, हम ETH को Sepolia फॉसेट पर वापस भेजेंगे।
+
+एक `sendTx.js` फ़ाइल बनाएं, जहां हम अपने उदाहरण लेन-देन को कॉन्फ़िगर और भेजेंगे, और इसमें कोड की निम्नलिखित पंक्तियाँ जोड़ें:
+
+```
+async function main() {
+ require('dotenv').config();
+ const { API_URL, PRIVATE_KEY } = process.env;
+ const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
+ const web3 = createAlchemyWeb3(API_URL);
+ const myAddress = '0x610Ae88399fc1687FA7530Aac28eC2539c7d6d63' //TODO: इस पते को अपने सार्वजनिक पते से बदलें
+
+ const nonce = await web3.eth.getTransactionCount(myAddress, 'latest'); // नॉन्स 0 से गिनती शुरू करता है
+
+ const transaction = {
+ 'to': '0x31B98D14007bDEe637298086988A0bBd31184523', // eth वापस करने के लिए फॉसेट का पता
+ 'value': 1000000000000000000, // 1 ETH
+ 'gas': 30000,
+ 'nonce': nonce,
+ // संदेश भेजने या स्मार्ट अनुबंध निष्पादित करने के लिए वैकल्पिक डेटा फ़ील्ड
+ };
+
+ const signedTx = await web3.eth.accounts.signTransaction(transaction, PRIVATE_KEY);
+
+ web3.eth.sendSignedTransaction(signedTx.rawTransaction, function(error, hash) {
+ if (!error) {
+ console.log("🎉 आपके लेन-देन का हैश है: ", hash, "\n अपने लेन-देन की स्थिति देखने के लिए Alchemy के Mempool की जाँच करें!");
+ } else {
+ console.log("❗आपका लेन-देन सबमिट करते समय कुछ गलत हो गया:", error)
+ }
+ });
+}
+
+main();
+```
+
+यह सुनिश्चित करें कि **लाइन 6** पर दिए गए पते को आप अपने सार्वजनिक पते से बदल दें।
+
+अब, इस कोड को चलाने से पहले, आइए यहां कुछ घटकों के बारे में बात करते हैं।
+
+- `nonce`: नॉन्स विनिर्देशन का उपयोग आपके पते से भेजे गए लेन-देन की संख्या का ट्रैक रखने के लिए किया जाता है। हमें सुरक्षा उद्देश्यों और [रीप्ले हमलों](https://docs.alchemyapi.io/resources/blockchain-glossary#account-nonce) को रोकने के लिए इसकी आवश्यकता है। अपने पते से भेजे गए लेन-देनों की संख्या प्राप्त करने के लिए हम [getTransactionCount](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc#eth_gettransactioncount) का उपयोग करते हैं।
+- `transaction`: लेन-देन ऑब्जेक्ट के कुछ पहलू हैं जिन्हें हमें निर्दिष्ट करने की आवश्यकता है
+ - `to`: यह वह पता है जिस पर हम ETH भेजना चाहते हैं। इस मामले में, हम ETH को उस [Sepolia फॉसेट](https://sepoliafaucet.com/) पर वापस भेज रहे हैं, जिससे हमने शुरू में अनुरोध किया था।
+ - `value`: यह वह राशि है जिसे हम भेजना चाहते हैं, जो Wei में निर्दिष्ट है जहाँ 10^18 Wei = 1 ETH
+ - `gas`: आपके लेन-देन के साथ शामिल करने के लिए गैस की सही मात्रा निर्धारित करने के कई तरीके हैं। Alchemy के पास एक [गैस मूल्य वेबहुक](https://docs.alchemyapi.io/guides/alchemy-notify#address-activity-1) भी है जो आपको सूचित करता है जब गैस की कीमत एक निश्चित सीमा के भीतर आती है। मेननेट लेन-देन के लिए, शामिल की जाने वाली गैस की सही मात्रा निर्धारित करने के लिए [ETH गैस स्टेशन](https://ethgasstation.info/) जैसे गैस अनुमानक की जांच करना एक अच्छा अभ्यास है। 21000 गैस की न्यूनतम राशि है जिसका उपयोग एथेरियम पर एक ऑपरेशन करेगा, इसलिए यह सुनिश्चित करने के लिए कि हमारा लेन-देन निष्पादित होगा, हम यहां 30000 डालते हैं।
+ - `nonce`: ऊपर नॉन्स की परिभाषा देखें। नॉन्स शून्य से गिनती शुरू करता है।
+ - [वैकल्पिक] डेटा: आपके ट्रांसफ़र के साथ अतिरिक्त जानकारी भेजने, या स्मार्ट अनुबंध को कॉल करने के लिए उपयोग किया जाता है, बैलेंस ट्रांसफ़र के लिए आवश्यक नहीं है, नीचे दिए गए नोट को देखें।
+- `signedTx`: हमारे लेन-देन ऑब्जेक्ट पर हस्ताक्षर करने के लिए हम अपनी `PRIVATE_KEY` के साथ `signTransaction` विधि का उपयोग करेंगे
+- `sendSignedTransaction`: एक बार जब हमारे पास एक हस्ताक्षरित लेन-देन हो जाता है, तो हम इसे `sendSignedTransaction` का उपयोग करके बाद के ब्लॉक में शामिल करने के लिए भेज सकते हैं
+
+**डेटा पर एक नोट**
+एथेरियम में दो मुख्य प्रकार के लेन-देन भेजे जा सकते हैं।
+
+- बैलेंस ट्रांसफ़र: एक पते से दूसरे पते पर ETH भेजें। कोई डेटा फ़ील्ड आवश्यक नहीं है, हालांकि, यदि आप अपने लेन-देन के साथ अतिरिक्त जानकारी भेजना चाहते हैं, तो आप इस फ़ील्ड में उस जानकारी को HEX प्रारूप में शामिल कर सकते हैं।
+ - उदाहरण के लिए, मान लीजिए कि हम एक IPFS दस्तावेज़ के हैश को एथेरियम श्रृंखला में लिखना चाहते हैं ताकि इसे एक अपरिवर्तनीय टाइमस्टैम्प दिया जा सके। हमारा डेटा फ़ील्ड तब डेटा जैसा दिखना चाहिए: `web3.utils.toHex(‘IPFS hash‘)`। और अब कोई भी श्रृंखला से पूछताछ कर सकता है और देख सकता है कि वह दस्तावेज़ कब जोड़ा गया था।
+- स्मार्ट अनुबंध लेन-देन: श्रृंखला पर कुछ स्मार्ट अनुबंध कोड निष्पादित करें। इस मामले में, डेटा फ़ील्ड में वह स्मार्ट फ़ंक्शन होना चाहिए जिसे आप किसी भी पैरामीटर के साथ निष्पादित करना चाहते हैं।
+ - एक व्यावहारिक उदाहरण के लिए, इस [हैलो वर्ल्ड ट्यूटोरियल](https://docs.alchemyapi.io/alchemy/tutorials/hello-world-smart-contract#step-8-create-the-transaction) में चरण 8 देखें।
+
+### 8. `node sendTx.js` का उपयोग करके कोड चलाएं {#run-the-code-using-node-sendtx-js}
+
+अपने टर्मिनल या कमांड लाइन पर वापस नेविगेट करें और चलाएं:
+
+```
+node sendTx.js
+```
+
+### 9. मेमपूल में अपना लेन-देन देखें {#see-your-transaction-in-the-mempool}
+
+अपने Alchemy डैशबोर्ड में [मेमपूल पेज](https://dashboard.alchemyapi.io/mempool) खोलें और अपना लेन-देन खोजने के लिए आपके द्वारा बनाए गए ऐप के आधार पर फ़िल्टर करें। यह वह जगह है जहां हम अपने लेन-देन को लंबित स्थिति से माइन की गई स्थिति (यदि सफल हो) या छोड़ी गई स्थिति (यदि असफल हो) में बदलते हुए देख सकते हैं। इसे “सभी” पर रखना सुनिश्चित करें ताकि आप “माइन किए गए”, “लंबित” और “छोड़े गए” लेन-देन को कैप्चर कर सकें। आप `0x31b98d14007bdee637298086988a0bbd31184523` पते पर भेजे गए लेन-देनों की तलाश करके भी अपना लेन-देन खोज सकते हैं।
+
+एक बार जब आप अपना लेन-देन पा लेते हैं, तो उसका विवरण देखने के लिए, tx हैश चुनें, जो आपको इस तरह के दृश्य पर ले जाएगा:
+
+
+
+वहां से आप लाल रंग में घेरे गए आइकन पर क्लिक करके Etherscan पर अपना लेन-देन देख सकते हैं!
+
+**यिप्पी!** आपने अभी-अभी Alchemy का उपयोग करके अपना पहला एथेरियम लेन-देन भेजा है 🎉\*\*
+
+_इस गाइड के बारे में प्रतिक्रिया और सुझावों के लिए, कृपया Alchemy के [डिस्कॉर्ड](https://discord.gg/A39JVCM) पर Elan को संदेश भेजें!_
+
+_मूल रूप से [https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy](https://docs.alchemyapi.io/tutorials/sending-transactions-using-web3-and-alchemy) पर प्रकाशित_
diff --git a/public/content/translations/hi/developers/tutorials/server-components/index.md b/public/content/translations/hi/developers/tutorials/server-components/index.md
new file mode 100644
index 00000000000..926ace06287
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/server-components/index.md
@@ -0,0 +1,295 @@
+---
+title: "वेब3 ऐप्स के लिए सर्वर कंपोनेंट्स और एजेंट"
+description: "इस ट्यूटोरियल को पढ़ने के बाद, आप TypeScript सर्वर लिखने में सक्षम होंगे जो एक ब्लॉकचेन पर इवेंट्स को सुनते हैं और तदनुसार अपने स्वयं के ट्रांज़ैक्शन के साथ प्रतिक्रिया करते हैं। यह आपको केंद्रीकृत एप्लिकेशन लिखने में सक्षम करेगा (क्योंकि सर्वर विफलता का एक बिंदु है), लेकिन वेब3 एंटिटीज़ के साथ इंटरैक्ट कर सकता है। इन्हीं तकनीकों का उपयोग एक ऐसा एजेंट लिखने के लिए भी किया जा सकता है जो बिना किसी मानवीय हस्तक्षेप के ऑन-चेन इवेंट्स पर प्रतिक्रिया देता है।"
+
+author: "ओरी पोमेरेन्ट्ज़"
+lang: hi
+tags: [ "एजेंट", "सर्वर", "ऑफ-चेन" ]
+skill: beginner
+published: 2024-07-15
+---
+
+## परिचय {#introduction}
+
+अधिकांश मामलों में, एक विकेंद्रीकृत ऐप सॉफ़्टवेयर को वितरित करने के लिए एक सर्वर का उपयोग करता है, लेकिन सभी वास्तविक इंटरैक्शन क्लाइंट (आमतौर पर, वेब ब्राउज़र) और ब्लॉकचेन के बीच होती है।
+
+
+
+हालांकि, कुछ ऐसे मामले हैं जहां एक एप्लिकेशन को स्वतंत्र रूप से चलने वाले सर्वर कंपोनेंट से लाभ होगा। ऐसा सर्वर ट्रांज़ैक्शन जारी करके इवेंट्स और अन्य स्रोतों, जैसे कि API, से आने वाले अनुरोधों का जवाब देने में सक्षम होगा।
+
+
+
+ऐसे सर्वर द्वारा पूरे किए जा सकने वाले कई संभावित कार्य हैं।
+
+- गुप्त स्टेट का धारक। गेमिंग में यह अक्सर उपयोगी होता है कि गेम को ज्ञात सभी जानकारी खिलाड़ियों के लिए उपलब्ध न हो। हालांकि, _ब्लॉकचेन पर कोई रहस्य नहीं होते हैं_, ब्लॉकचेन में मौजूद कोई भी जानकारी किसी के लिए भी पता लगाना आसान है। इसलिए, यदि गेम स्टेट के किसी हिस्से को गुप्त रखा जाना है, तो इसे कहीं और संग्रहीत किया जाना चाहिए (और संभवतः उस स्टेट के प्रभावों को [शून्य-ज्ञान प्रमाण](/zero-knowledge-proofs) का उपयोग करके सत्यापित किया जाना चाहिए)।
+
+- केंद्रीकृत ओरेकल। यदि स्टेक पर्याप्त रूप से कम हैं, तो एक बाहरी सर्वर जो ऑनलाइन कुछ जानकारी पढ़ता है और फिर उसे चेन पर पोस्ट करता है, [ओरेकल](/developers/docs/oracles/) के रूप में उपयोग करने के लिए पर्याप्त हो सकता है।
+
+- एजेंट। ब्लॉकचेन पर इसे सक्रिय करने के लिए ट्रांज़ैक्शन के बिना कुछ भी नहीं होता है। एक सर्वर किसी यूज़र की ओर से [आर्बिट्रेज](/developers/docs/mev/#mev-examples-dex-arbitrage) जैसे कार्य करने के लिए कार्य कर सकता है जब अवसर स्वयं प्रस्तुत होता है।
+
+## नमूना प्रोग्राम {#sample-program}
+
+आप [github](https://github.com/qbzzt/20240715-server-component) पर एक नमूना सर्वर देख सकते हैं। यह सर्वर Hardhat के Greeter के एक संशोधित संस्करण, [इस कॉन्ट्रैक्ट](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=contract_code) से आने वाले इवेंट्स को सुनता है। जब ग्रीटिंग बदल दी जाती है, तो यह उसे वापस बदल देता है।
+
+इसे चलाने के लिए:
+
+1. रिपॉजिटरी को क्लोन करें।
+
+ ```sh copy
+ git clone https://github.com/qbzzt/20240715-server-component.git
+ cd 20240715-server-component
+ ```
+
+2. आवश्यक पैकेज इंस्टॉल करें। यदि आपके पास यह पहले से नहीं है, तो [पहले नोड इंस्टॉल करें](https://nodejs.org/en/download/package-manager)।
+
+ ```sh copy
+ npm install
+ ```
+
+3. Holesky टेस्टनेट पर ETH वाले खाते की निजी चाबी को निर्दिष्ट करने के लिए `.env` को संपादित करें। यदि आपके पास Holesky पर ETH नहीं है, तो आप [इस फोसेट का उपयोग](https://holesky-faucet.pk910.de/) कर सकते हैं।
+
+ ```sh filename=".env" copy
+ PRIVATE_KEY=0x
+ ```
+
+4. सर्वर शुरू करें।
+
+ ```sh copy
+ npm start
+ ```
+
+5. [एक ब्लॉक खोजकर्ता](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=write_contract) पर जाएं, और निजी चाबी वाले पते से भिन्न पते का उपयोग करके ग्रीटिंग को संशोधित करें। देखें कि ग्रीटिंग स्वचालित रूप से वापस संशोधित हो जाती है।
+
+### यह कैसे काम करता है? {#how-it-works}
+
+सर्वर कंपोनेंट कैसे लिखना है, यह समझने का सबसे आसान तरीका नमूने को एक-एक लाइन करके देखना है।
+
+#### `src/app.ts` {#src-app-ts}
+
+प्रोग्राम का अधिकांश हिस्सा [`src/app.ts`](https://github.com/qbzzt/20240715-server-component/blob/main/src/app.ts) में निहित है।
+
+##### आवश्यक ऑब्जेक्ट बनाना
+
+```typescript
+import {
+ createPublicClient,
+ createWalletClient,
+ getContract,
+ http,
+ Address,
+} from "viem"
+```
+
+ये वे [Viem](https://viem.sh/) एंटिटीज़ हैं जिनकी हमें आवश्यकता है, फ़ंक्शन और [`Address` टाइप](https://viem.sh/docs/glossary/types#address)। यह सर्वर [TypeScript](https://www.typescriptlang.org/) में लिखा गया है, जो JavaScript का एक एक्सटेंशन है जो इसे [स्ट्रॉन्गली टाइप्ड](https://en.wikipedia.org/wiki/Strong_and_weak_typing) बनाता है।
+
+```typescript
+import { privateKeyToAccount } from "viem/accounts"
+```
+
+[यह फ़ंक्शन](https://viem.sh/docs/accounts/privateKey) हमें एक निजी चाबी के अनुरूप वॉलेट जानकारी, जिसमें पता भी शामिल है, उत्पन्न करने देता है।
+
+```typescript
+import { holesky } from "viem/chains"
+```
+
+Viem में ब्लॉकचेन का उपयोग करने के लिए आपको इसकी परिभाषा आयात करनी होगी। इस मामले में, हम [Holesky](https://github.com/eth-clients/holesky) टेस्ट ब्लॉकचेन से कनेक्ट करना चाहते हैं।
+
+```typescript
+// इस तरह हम .env में परिभाषाओं को process.env में जोड़ते हैं।
+import * as dotenv from "dotenv"
+dotenv.config()
+```
+
+इस तरह हम `.env` को एनवायरनमेंट में पढ़ते हैं। हमें इसकी निजी चाबी के लिए आवश्यकता है (बाद में देखें)।
+
+```typescript
+const greeterAddress : Address = "0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6"
+const greeterABI = [
+ {
+ "inputs": [
+ {
+ "internalType": "string",
+ "name": "_greeting",
+ "type": "string"
+ }
+ ],
+ "stateMutability": "nonpayable",
+ "type": "constructor"
+ },
+ .
+ .
+ .
+ {
+ "inputs": [
+ {
+ "internalType": "string",
+ "name": "_greeting",
+ "type": "string"
+ }
+ ],
+ "name": "setGreeting",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ }
+] as const
+```
+
+किसी कॉन्ट्रैक्ट का उपयोग करने के लिए हमें उसके पते और उसके लिए [ABI](/glossary/#abi) की आवश्यकता होती है। हम यहां दोनों प्रदान करते हैं।
+
+JavaScript (और इसलिए TypeScript) में आप किसी कॉन्सटेंट को एक नया मान असाइन नहीं कर सकते, लेकिन आप उसमें संग्रहीत ऑब्जेक्ट को _संशोधित_ कर सकते हैं। `as const` प्रत्यय का उपयोग करके हम TypeScript को बता रहे हैं कि सूची स्वयं कॉन्सटेंट है और इसे बदला नहीं जा सकता है।
+
+```typescript
+const publicClient = createPublicClient({
+ chain: holesky,
+ transport: http(),
+})
+```
+
+एक Viem [पब्लिक क्लाइंट](https://viem.sh/docs/clients/public.html) बनाएँ। पब्लिक क्लाइंट के पास संलग्न निजी चाबी नहीं होती है, और इसलिए वे ट्रांज़ैक्शन नहीं भेज सकते। वे [`view` फ़ंक्शन](https://www.tutorialspoint.com/solidity/solidity_view_functions.htm) को कॉल कर सकते हैं, खाते की शेष राशि पढ़ सकते हैं, आदि।
+
+```typescript
+const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)
+```
+
+एनवायरनमेंट वैरिएबल [`process.env`](https://www.totaltypescript.com/how-to-strongly-type-process-env) में उपलब्ध हैं। हालांकि, TypeScript स्ट्रॉन्गली टाइप्ड है। एक एनवायरनमेंट वैरिएबल कोई भी स्ट्रिंग, या खाली हो सकता है, इसलिए एक एनवायरनमेंट वैरिएबल का टाइप `string | undefined` होता है। हालांकि, Viem में एक की को `0x${string}` (`0x` के बाद एक स्ट्रिंग) के रूप में परिभाषित किया गया है। यहां हम TypeScript को बताते हैं कि `PRIVATE_KEY` एनवायरनमेंट वैरिएबल उस टाइप का होगा। यदि ऐसा नहीं है, तो हमें एक रनटाइम एरर मिलेगा।
+
+[`privateKeyToAccount`](https://viem.sh/docs/accounts/privateKey) फ़ंक्शन तब इस निजी चाबी का उपयोग करके एक पूर्ण खाता ऑब्जेक्ट बनाता है।
+
+```typescript
+const walletClient = createWalletClient({
+ account,
+ chain: holesky,
+ transport: http(),
+})
+```
+
+इसके बाद, हम एक [वॉलेट क्लाइंट](https://viem.sh/docs/clients/wallet) बनाने के लिए खाता ऑब्जेक्ट का उपयोग करते हैं। इस क्लाइंट के पास एक निजी चाबी और एक पता होता है, इसलिए इसका उपयोग ट्रांज़ैक्शन भेजने के लिए किया जा सकता है।
+
+```typescript
+const greeter = getContract({
+ address: greeterAddress,
+ abi: greeterABI,
+ client: { public: publicClient, wallet: walletClient },
+})
+```
+
+अब जब हमारे पास सभी पूर्वापेक्षाएँ हैं, तो हम अंततः एक [कॉन्ट्रैक्ट इंस्टेंस](https://viem.sh/docs/contract/getContract) बना सकते हैं। हम ऑन-चेन कॉन्ट्रैक्ट के साथ संवाद करने के लिए इस कॉन्ट्रैक्ट इंस्टेंस का उपयोग करेंगे।
+
+##### ब्लॉकचेन से पढ़ना
+
+```typescript
+console.log(`Current greeting:`, await greeter.read.greet())
+```
+
+जो कॉन्ट्रैक्ट फ़ंक्शन केवल पढ़ने के लिए हैं ([`view`](https://www.tutorialspoint.com/solidity/solidity_view_functions.htm) और [`pure`](https://www.tutorialspoint.com/solidity/solidity_pure_functions.htm)) वे `read` के अंतर्गत उपलब्ध हैं। इस मामले में, हम इसका उपयोग [`greet`](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=read_contract#cfae3217) फ़ंक्शन तक पहुँचने के लिए करते हैं, जो ग्रीटिंग लौटाता है।
+
+JavaScript सिंगल-थ्रेडेड है, इसलिए जब हम एक लंबे समय तक चलने वाली प्रक्रिया शुरू करते हैं तो हमें यह [निर्दिष्ट करने की आवश्यकता होती है कि हम इसे एसिंक्रोनस रूप से करते हैं](https://eloquentjavascript.net/11_async.html#h-XvLsfAhtsE)। ब्लॉकचेन को कॉल करने के लिए, यहां तक कि केवल पढ़ने के ऑपरेशन के लिए भी, कंप्यूटर और ब्लॉकचेन नोड के बीच एक राउंड-ट्रिप की आवश्यकता होती है। यही कारण है कि हम यहां निर्दिष्ट करते हैं कि कोड को परिणाम के लिए `await` करने की आवश्यकता है।
+
+यदि आप इस काम के तरीके में रुचि रखते हैं तो आप [इसके बारे में यहां पढ़ सकते हैं](https://www.w3schools.com/js/js_promise.asp), लेकिन व्यावहारिक रूप से आपको बस यह जानना है कि यदि आप एक ऐसा ऑपरेशन शुरू करते हैं जिसमें लंबा समय लगता है, तो आप परिणामों का `await` करते हैं, और ऐसा करने वाले किसी भी फ़ंक्शन को `async` के रूप में घोषित किया जाना चाहिए।
+
+##### ट्रांज़ैक्शन जारी करना
+
+```typescript
+const setGreeting = async (greeting: string): Promise => {
+```
+
+यह वह फ़ंक्शन है जिसे आप ग्रीटिंग बदलने वाले ट्रांज़ैक्शन को जारी करने के लिए कॉल करते हैं। चूंकि यह एक लंबा ऑपरेशन है, फ़ंक्शन को `async` के रूप में घोषित किया गया है। आंतरिक कार्यान्वयन के कारण, किसी भी `async` फ़ंक्शन को एक `Promise` ऑब्जेक्ट लौटाना होता है। इस मामले में, `Promise` का मतलब है कि हम यह निर्दिष्ट नहीं करते हैं कि `Promise` में वास्तव में क्या लौटाया जाएगा।
+
+```typescript
+const txHash = await greeter.write.setGreeting([greeting])
+```
+
+कॉन्ट्रैक्ट इंस्टेंस के `write` फ़ील्ड में वे सभी फ़ंक्शन होते हैं जो ब्लॉकचेन स्टेट में लिखते हैं (वे जिन्हें ट्रांज़ैक्शन भेजने की आवश्यकता होती है), जैसे कि [`setGreeting`](https://eth-holesky.blockscout.com/address/0xB8f6460Dc30c44401Be26B0d6eD250873d8a50A6?tab=write_contract#a4136862)। पैरामीटर, यदि कोई हों, एक सूची के रूप में प्रदान किए जाते हैं, और फ़ंक्शन ट्रांज़ैक्शन का हैश लौटाता है।
+
+```typescript
+ console.log(`Working on a fix, see https://eth-holesky.blockscout.com/tx/${txHash}`)
+
+ return txHash
+}
+```
+
+ट्रांज़ैक्शन के हैश की रिपोर्ट करें (इसे देखने के लिए ब्लॉक खोजकर्ता के URL के हिस्से के रूप में) और इसे लौटाएँ।
+
+##### इवेंट्स का जवाब देना
+
+```typescript
+greeter.watchEvent.SetGreeting({
+```
+
+[`watchEvent` फ़ंक्शन](https://viem.sh/docs/actions/public/watchEvent) आपको यह निर्दिष्ट करने देता है कि जब कोई इवेंट उत्सर्जित होता है तो एक फ़ंक्शन चलाना है। यदि आप केवल एक प्रकार के इवेंट (इस मामले में, `SetGreeting`) की परवाह करते हैं, तो आप खुद को उस इवेंट प्रकार तक सीमित करने के लिए इस सिंटैक्स का उपयोग कर सकते हैं।
+
+```typescript
+ onLogs: logs => {
+```
+
+`onLogs` फ़ंक्शन को तब कॉल किया जाता है जब लॉग एंट्री होती हैं। एथेरियम में "लॉग" और "इवेंट" आमतौर पर विनिमेय होते हैं।
+
+```typescript
+console.log(
+ `Address ${logs[0].args.sender} changed the greeting to ${logs[0].args.greeting}`
+)
+```
+
+कई इवेंट्स हो सकते हैं, लेकिन सरलता के लिए हम केवल पहले वाले की परवाह करते हैं। `logs[0].args` इवेंट के तर्क हैं, इस मामले में `sender` और `greeting`।
+
+```typescript
+ if (logs[0].args.sender != account.address)
+ setGreeting(`${account.address} insists on it being Hello!`)
+ }
+})
+```
+
+यदि प्रेषक यह सर्वर _नहीं_ है, तो ग्रीटिंग बदलने के लिए `setGreeting` का उपयोग करें।
+
+#### `package.json` {#package-json}
+
+[यह फ़ाइल](https://github.com/qbzzt/20240715-server-component/blob/main/package.json) [Node.js](https://nodejs.org/en) कॉन्फ़िगरेशन को नियंत्रित करती है। यह लेख केवल महत्वपूर्ण परिभाषाओं की व्याख्या करता है।
+
+```json
+{
+ "main": "dist/index.js",
+```
+
+यह परिभाषा निर्दिष्ट करती है कि कौन सी JavaScript फ़ाइल चलानी है।
+
+```json
+ "scripts": {
+ "start": "tsc && node dist/app.js",
+ },
+```
+
+स्क्रिप्ट विभिन्न एप्लिकेशन एक्शन हैं। इस मामले में, हमारे पास केवल `start` है, जो सर्वर को कंपाइल करता है और फिर चलाता है। `tsc` कमांड `typescript` पैकेज का हिस्सा है और TypeScript को JavaScript में कंपाइल करता है। यदि आप इसे मैन्युअल रूप से चलाना चाहते हैं, तो यह `node_modules/.bin` में स्थित है। दूसरा कमांड सर्वर चलाता है।
+
+```json
+ "type": "module",
+```
+
+JavaScript नोड एप्लिकेशन कई प्रकार के होते हैं। `module` प्रकार हमें शीर्ष स्तर के कोड में `await` रखने की अनुमति देता है, जो तब महत्वपूर्ण होता है जब आप धीमे (और इसलिए एसिंक्रोनस) ऑपरेशन करते हैं।
+
+```json
+ "devDependencies": {
+ "@types/node": "^20.14.2",
+ "typescript": "^5.4.5"
+ },
+```
+
+ये वे पैकेज हैं जो केवल डेवलपमेंट के लिए आवश्यक हैं। यहां हमें `typescript` की आवश्यकता है और क्योंकि हम इसे Node.js के साथ उपयोग कर रहे हैं, हम नोड वैरिएबल और ऑब्जेक्ट, जैसे `process`, के लिए भी टाइप प्राप्त कर रहे हैं। [`^` नोटेशन](https://github.com/npm/node-semver?tab=readme-ov-file#caret-ranges-123-025-004) का अर्थ है वह संस्करण या एक उच्च संस्करण जिसमें ब्रेकिंग परिवर्तन नहीं हैं। संस्करण संख्याओं के अर्थ के बारे में अधिक जानकारी के लिए [यहां](https://semver.org) देखें।
+
+```json
+ "dependencies": {
+ "dotenv": "^16.4.5",
+ "viem": "2.14.1"
+ }
+}
+```
+
+ये वे पैकेज हैं जो रनटाइम पर, `dist/app.js` चलाते समय आवश्यक होते हैं।
+
+## निष्कर्ष {#conclusion}
+
+हमारे द्वारा यहां बनाया गया केंद्रीकृत सर्वर अपना काम करता है, जो एक यूज़र के लिए एजेंट के रूप में कार्य करना है। कोई भी और जो चाहता है कि डैप काम करता रहे और गैस खर्च करने को तैयार हो, वह अपने पते के साथ सर्वर का एक नया इंस्टेंस चला सकता है।
+
+हालांकि, यह केवल तभी काम करता है जब केंद्रीकृत सर्वर के कार्यों को आसानी से सत्यापित किया जा सके। यदि केंद्रीकृत सर्वर के पास कोई गुप्त स्टेट जानकारी है, या कठिन गणनाएँ चलाता है, तो यह एक केंद्रीकृत इकाई है जिस पर आपको एप्लिकेशन का उपयोग करने के लिए भरोसा करने की आवश्यकता है, जो कि ठीक वही है जिससे ब्लॉकचेन बचने की कोशिश करते हैं। भविष्य के एक लेख में मैं यह दिखाने की योजना बना रहा हूं कि इस समस्या से निपटने के लिए [शून्य-ज्ञान प्रमाण](/zero-knowledge-proofs) का उपयोग कैसे करें।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
diff --git a/public/content/translations/hi/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md b/public/content/translations/hi/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
new file mode 100644
index 00000000000..772537e9e91
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
@@ -0,0 +1,92 @@
+---
+title: "जावास्क्रिप्ट में एथेरियम ब्लॉकचेन का उपयोग करने के लिए web3.js सेट अप करें"
+description: "जावास्क्रिप्ट एप्लिकेशन से एथेरियम ब्लॉकचेन के साथ इंटरैक्ट करने के लिए web3.js लाइब्रेरी को सेट अप और कॉन्फ़िगर करना सीखें।"
+author: "jdourlens"
+tags: [ "web3.js", "javascript" ]
+skill: beginner
+lang: hi
+published: 2020-04-11
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/setup-web3js-to-use-the-ethereum-blockchain-in-javascript/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+इस ट्यूटोरियल में, हम देखेंगे कि एथेरियम ब्लॉकचेन के साथ इंटरैक्ट करने के लिए [web3.js](https://web3js.readthedocs.io/) के साथ कैसे शुरुआत करें। Web3.js का उपयोग फ्रंटएंड और बैकएंड दोनों में ब्लॉकचेन से डेटा पढ़ने या लेनदेन करने और यहां तक कि स्मार्ट अनुबंध डिप्लॉय करने के लिए भी किया जा सकता है।
+
+पहला कदम अपने प्रोजेक्ट में web3.js को शामिल करना है। इसे वेब पेज में उपयोग करने के लिए, आप JSDeliver जैसे CDN का उपयोग करके सीधे लाइब्रेरी को आयात कर सकते हैं।
+
+```html
+
+```
+
+यदि आप अपने बैकएंड या बिल्ड का उपयोग करने वाले फ्रंटएंड प्रोजेक्ट में उपयोग के लिए लाइब्रेरी इंस्टॉल करना पसंद करते हैं तो आप इसे npm का उपयोग करके इंस्टॉल कर सकते हैं:
+
+```bash
+npm install web3 --save
+```
+
+फिर Web3.js को Node.js स्क्रिप्ट या Browserify फ्रंटएंड प्रोजेक्ट में आयात करने के लिए, आप जावास्क्रिप्ट की निम्न पंक्ति का उपयोग कर सकते हैं:
+
+```js
+const Web3 = require("web3")
+```
+
+अब जब हमने प्रोजेक्ट में लाइब्रेरी को शामिल कर लिया है तो हमें इसे शुरू करने की आवश्यकता है। आपके प्रोजेक्ट को ब्लॉकचेन के साथ संचार करने में सक्षम होना चाहिए। अधिकांश एथेरियम लाइब्रेरी RPC कॉल के माध्यम से [नोड](/developers/docs/nodes-and-clients/) के साथ संचार करती हैं। हमारे Web3 प्रदाता को शुरू करने के लिए, हम प्रदाता के URL को कंस्ट्रक्टर के रूप में पास करके एक Web3 इंस्टेंस को इंस्टैंशिएट करेंगे। यदि आपके कंप्यूटर पर कोई नोड या [गनाचे इंस्टेंस चल रहा है](https://ethereumdev.io/testing-your-smart-contract-with-existing-protocols-ganache-fork/), तो यह इस तरह दिखेगा:
+
+```js
+const web3 = new Web3("http://localhost:8545")
+```
+
+यदि आप सीधे होस्टेड नोड का उपयोग करना चाहते हैं, तो आप [नोड्स ऐज़ अ सर्विस](/developers/docs/nodes-and-clients/nodes-as-a-service) पर विकल्प पा सकते हैं।
+
+```js
+const web3 = new Web3("https://cloudflare-eth.com")
+```
+
+यह परीक्षण करने के लिए कि हमने अपने Web3 इंस्टेंस को सही ढंग से कॉन्फ़िगर किया है, हम `getBlockNumber` फ़ंक्शन का उपयोग करके नवीनतम ब्लॉक नंबर प्राप्त करने का प्रयास करेंगे। यह फ़ंक्शन एक पैरामीटर के रूप में कॉलबैक स्वीकार करता है और एक पूर्णांक के रूप में ब्लॉक नंबर लौटाता है।
+
+```js
+var Web3 = require("web3")
+const web3 = new Web3("https://cloudflare-eth.com")
+
+web3.eth.getBlockNumber(function (error, result) {
+ console.log(result)
+})
+```
+
+यदि आप इस प्रोग्राम को निष्पादित करते हैं, तो यह बस नवीनतम ब्लॉक नंबर प्रिंट करेगा: ब्लॉकचेन का शीर्ष। आप अपने कोड में कॉलबैक नेस्टिंग से बचने के लिए `await/async` फ़ंक्शन कॉल का भी उपयोग कर सकते हैं:
+
+```js
+async function getBlockNumber() {
+ const latestBlockNumber = await web3.eth.getBlockNumber()
+ console.log(latestBlockNumber)
+ return latestBlockNumber
+}
+
+getBlockNumber()
+```
+
+आप [आधिकारिक web3.js प्रलेखन](https://docs.web3js.org/) में Web3 इंस्टेंस पर उपलब्ध सभी फ़ंक्शन देख सकते हैं।
+
+अधिकांश Web3 लाइब्रेरी एसिंक्रोनस हैं क्योंकि बैकग्राउंड में लाइब्रेरी नोड पर JSON-RPC कॉल करती है जो परिणाम वापस भेजती है।
+
+(<पहला स्टैक मान, यदि कोई हो>,<दूसरा स्टैक मान, यदि कोई हो>...)` होता है।
+
+```solidity
+
+ _retVal = _retVal >> (256-length*8);
+```
+
+केवल सबसे महत्वपूर्ण `length` बाइट्स फ़ील्ड का हिस्सा हैं, इसलिए हम अन्य मानों से छुटकारा पाने के लिए [राइट-शिफ्ट](https://en.wikipedia.org/wiki/Logical_shift) करते हैं।
+इसका अतिरिक्त लाभ यह है कि यह मान को फ़ील्ड के दाईं ओर ले जाता है, इसलिए यह मान स्वयं है बजाय मान गुणा 256something के।
+
+```solidity
+
+ return _retVal;
+ }
+
+
+ fallback() external {
+```
+
+जब एक Solidity अनुबंध के लिए एक कॉल किसी भी फ़ंक्शन हस्ताक्षर से मेल नहीं खाती है, तो यह [the `fallback()` फ़ंक्शन](https://docs.soliditylang.org/en/v0.8.12/contracts.html#fallback-function) को कॉल करता है (यह मानते हुए कि एक है)।
+`CalldataInterpreter` के मामले में, _कोई_ भी कॉल यहां पहुंचती है क्योंकि कोई अन्य `external` या `public` फ़ंक्शन नहीं हैं।
+
+```solidity
+ uint _func;
+
+ _func = calldataVal(0, 1);
+```
+
+कॉलडेटा का पहला बाइट पढ़ें, जो हमें फ़ंक्शन बताता है।
+दो कारण हैं कि कोई फ़ंक्शन यहां उपलब्ध क्यों नहीं होगा:
+
+1. `pure` या `view` फ़ंक्शन स्थिति नहीं बदलते हैं और गैस की लागत नहीं लेते हैं (जब ऑफ-चेन कहा जाता है)।
+ उनकी गैस लागत को कम करने की कोशिश करने का कोई मतलब नहीं है।
+2. फ़ंक्शन जो [`msg.sender`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#block-and-transaction-properties) पर निर्भर करते हैं।
+ `msg.sender` का मान `CalldataInterpreter` का पता होगा, न कि कॉलर का।
+
+दुर्भाग्य से, [ERC-20 विनिर्देशों को देखते हुए](https://eips.ethereum.org/EIPS/eip-20), यह केवल एक फ़ंक्शन, `transfer` छोड़ता है।
+यह हमें केवल दो कार्यों के साथ छोड़ देता है: `transfer` (क्योंकि हम `transferFrom` को कॉल कर सकते हैं) और `faucet` (क्योंकि हम जिसने हमें कॉल किया है, उसे टोकन वापस ट्रांसफर कर सकते हैं)।
+
+```solidity
+
+ // कॉलडेटा से जानकारी का उपयोग करके
+ // टोकन की स्थिति बदलने के तरीकों को कॉल करें
+
+ // फोसेट
+ if (_func == 1) {
+```
+
+`faucet()` पर एक कॉल, जिसमें पैरामीटर नहीं हैं।
+
+```solidity
+ token.faucet();
+ token.transfer(msg.sender,
+ token.balanceOf(address(this)));
+ }
+```
+
+जब हम `token.faucet()` को कॉल करते हैं तो हमें टोकन मिलते हैं। हालांकि, प्रॉक्सी अनुबंध के रूप में, हमें टोकन की **आवश्यकता** नहीं है।
+EOA (बाहरी स्वामित्व वाला खाता) या हमें कॉल करने वाले अनुबंध को इसकी आवश्यकता है।
+इसलिए हम अपने सभी टोकन उस व्यक्ति को हस्तांतरित करते हैं जिसने हमें बुलाया था।
+
+```solidity
+ // ट्रांसफर (मान लें कि हमारे पास इसके लिए भत्ता है)
+ if (_func == 2) {
+```
+
+टोकन ट्रांसफर करने के लिए दो पैरामीटर की आवश्यकता होती है: गंतव्य पता और राशि।
+
+```solidity
+ token.transferFrom(
+ msg.sender,
+```
+
+हम केवल कॉल करने वालों को उनके स्वामित्व वाले टोकन को स्थानांतरित करने की अनुमति देते हैं
+
+```solidity
+ address(uint160(calldataVal(1, 20))),
+```
+
+गंतव्य पता बाइट #1 पर शुरू होता है (बाइट #0 फ़ंक्शन है)।
+एक पते के रूप में, यह 20-बाइट्स लंबा है।
+
+```solidity
+ calldataVal(21, 2)
+```
+
+इस विशेष अनुबंध के लिए हम मानते हैं कि कोई भी व्यक्ति जो अधिकतम संख्या में टोकन स्थानांतरित करना चाहता है, वह दो बाइट्स (65536 से कम) में फिट बैठता है।
+
+```solidity
+ );
+ }
+```
+
+कुल मिलाकर, एक हस्तांतरण में 35 बाइट्स कॉलडेटा लगते हैं:
+
+| सेक्शन | लंबाई | बाइट्स |
+| ---------------- | ----: | -----: |
+| फ़ंक्शन चयनकर्ता | 1 | 0 |
+| गंतव्य पता | 32 | 1-32 |
+| राशि | 2 | 33-34 |
+
+```solidity
+ } // फॉलबैक
+
+} // अनुबंध CalldataInterpreter
+```
+
+### test.js {#test-js}
+
+[यह जावास्क्रिप्ट यूनिट परीक्षण](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/test/test.js) हमें दिखाता है कि इस तंत्र का उपयोग कैसे करें (और यह कैसे सत्यापित करें कि यह सही तरीके से काम करता है)।
+मैं यह मानने जा रहा हूं कि आप [chai](https://www.chaijs.com/) और [ethers](https://docs.ethers.io/v5/) को समझते हैं और केवल उन हिस्सों की व्याख्या करते हैं जो विशेष रूप से अनुबंध पर लागू होते हैं।
+
+```js
+const { expect } = require("chai");
+
+describe("CalldataInterpreter", function () {
+ it("Should let us use tokens", async function () {
+ const Token = await ethers.getContractFactory("OrisUselessToken")
+ const token = await Token.deploy()
+ await token.deployed()
+ console.log("Token addr:", token.address)
+
+ const Cdi = await ethers.getContractFactory("CalldataInterpreter")
+ const cdi = await Cdi.deploy(token.address)
+ await cdi.deployed()
+ console.log("CalldataInterpreter addr:", cdi.address)
+
+ const signer = await ethers.getSigner()
+```
+
+हम दोनों अनुबंधों को परिनियोजित करके शुरू करते हैं।
+
+```javascript
+ // खेलने के लिए टोकन प्राप्त करें
+ const faucetTx = {
+```
+
+हम लेनदेन बनाने के लिए सामान्य रूप से उपयोग किए जाने वाले उच्च-स्तरीय कार्यों (जैसे `token.faucet()`) का उपयोग नहीं कर सकते हैं, क्योंकि हम ABI का पालन नहीं करते हैं।
+इसके बजाय, हमें स्वयं लेनदेन का निर्माण करना होगा और फिर उसे भेजना होगा।
+
+```javascript
+ to: cdi.address,
+ data: "0x01"
+```
+
+लेनदेन के लिए हमें दो पैरामीटर प्रदान करने की आवश्यकता है:
+
+1. `to`, गंतव्य पता।
+ यह कॉलडेटा इंटरप्रेटर अनुबंध है।
+2. `data`, भेजने के लिए कॉलडेटा।
+ एक फोसेट कॉल के मामले में, डेटा एक बाइट, `0x01` है।
+
+```javascript
+
+ }
+ await (await signer.sendTransaction(faucetTx)).wait()
+```
+
+हम [हस्ताक्षरकर्ता की `sendTransaction` विधि](https://docs.ethers.io/v5/api/signer/#Signer-sendTransaction) को कॉल करते हैं क्योंकि हमने पहले ही गंतव्य (`faucetTx.to`) निर्दिष्ट कर दिया है और हमें लेनदेन पर हस्ताक्षर करने की आवश्यकता है।
+
+```javascript
+// जांचें कि फोसेट टोकन सही ढंग से प्रदान करता है या नहीं
+expect(await token.balanceOf(signer.address)).to.equal(1000)
+```
+
+यहां हम शेष राशि की पुष्टि करते हैं।
+`view` फ़ंक्शन पर गैस बचाने की कोई आवश्यकता नहीं है, इसलिए हम बस उन्हें सामान्य रूप से चलाते हैं।
+
+```javascript
+// CDI को एक भत्ता दें (अनुमोदन को प्रॉक्सी नहीं किया जा सकता है)
+const approveTX = await token.approve(cdi.address, 10000)
+await approveTX.wait()
+expect(await token.allowance(signer.address, cdi.address)).to.equal(10000)
+```
+
+स्थानांतरण करने में सक्षम होने के लिए कॉलडेटा दुभाषिया को एक भत्ता दें।
+
+```javascript
+// टोकन ट्रांसफर करें
+const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
+const transferTx = {
+ to: cdi.address,
+ data: "0x02" + destAddr.slice(2, 42) + "0100",
+}
+```
+
+एक स्थानांतरण लेनदेन बनाएं। पहला बाइट "0x02" है, इसके बाद गंतव्य पता है, और अंत में राशि (0x0100, जो दशमलव में 256 है)।
+
+```javascript
+ await (await signer.sendTransaction(transferTx)).wait()
+
+ // जांचें कि हमारे पास 256 टोकन कम हैं
+ expect (await token.balanceOf(signer.address)).to.equal(1000-256)
+
+ // और यह कि हमारे गंतव्य को वे मिल गए हैं
+ expect (await token.balanceOf(destAddr)).to.equal(256)
+ }) // यह
+}) // वर्णन
+```
+
+## जब आप गंतव्य अनुबंध को नियंत्रित करते हैं तो लागत कम करना {#reducing-the-cost-when-you-do-control-the-destination-contract}
+
+यदि आपका गंतव्य अनुबंध पर नियंत्रण है, तो आप ऐसे फ़ंक्शन बना सकते हैं जो `msg.sender` जांच को बायपास करते हैं क्योंकि वे कॉलडेटा दुभाषिया पर भरोसा करते हैं।
+[आप `control-contract` शाखा में यहां इसका एक उदाहरण देख सकते हैं](https://github.com/qbzzt/ethereum.org-20220330-shortABI/tree/control-contract)।
+
+यदि अनुबंध केवल बाहरी लेनदेन का जवाब दे रहा होता, तो हम केवल एक अनुबंध के साथ काम चला सकते थे।
+हालांकि, यह [कंपोज़ेबिलिटी](/developers/docs/smart-contracts/composability/) को तोड़ देगा।
+सामान्य ERC-20 कॉल का जवाब देने वाला एक अनुबंध होना बहुत बेहतर है, और दूसरा अनुबंध जो छोटे कॉल डेटा के साथ लेनदेन का जवाब देता है।
+
+### Token.sol {#token-sol-2}
+
+इस उदाहरण में हम `Token.sol` को संशोधित कर सकते हैं।
+यह हमें कई ऐसे कार्य करने देता है जिन्हें केवल प्रॉक्सी ही कॉल कर सकता है।
+यहां नए हिस्से दिए गए हैं:
+
+```solidity
+ // CalldataInterpreter पते को निर्दिष्ट करने के लिए अनुमत एकमात्र पता
+ address owner;
+
+ // The CalldataInterpreter address
+ address proxy = address(0);
+```
+
+ERC-20 अनुबंध को अधिकृत प्रॉक्सी की पहचान जानने की आवश्यकता है।
+हालांकि, हम इस चर को कंस्ट्रक्टर में सेट नहीं कर सकते हैं, क्योंकि हम अभी तक मान नहीं जानते हैं।
+यह अनुबंध पहले इंस्टेंट किया गया है क्योंकि प्रॉक्सी अपने कंस्ट्रक्टर में टोकन के पते की अपेक्षा करता है।
+
+```solidity
+ /**
+ * @dev ERC20 कंस्ट्रक्टर को कॉल करता है।
+ */
+ constructor(
+ ) ERC20("Oris useless token-2", "OUT-2") {
+ owner = msg.sender;
+ }
+```
+
+निर्माता का पता (जिसे `owner` कहा जाता है) यहां संग्रहीत किया जाता है क्योंकि प्रॉक्सी सेट करने के लिए यह एकमात्र पता है।
+
+```solidity
+ /**
+ * @dev प्रॉक्सी (CalldataInterpreter) के लिए पता सेट करें।
+ * मालिक द्वारा केवल एक बार कॉल किया जा सकता है
+ */
+ function setProxy(address _proxy) external {
+ require(msg.sender == owner, "Can only be called by owner");
+ require(proxy == address(0), "Proxy is already set");
+
+ proxy = _proxy;
+ } // फ़ंक्शन setProxy
+```
+
+प्रॉक्सी के पास विशेषाधिकार प्राप्त पहुंच है, क्योंकि यह सुरक्षा जांच को बायपास कर सकता है।
+यह सुनिश्चित करने के लिए कि हम प्रॉक्सी पर भरोसा कर सकते हैं, हम केवल `owner` को इस फ़ंक्शन को कॉल करने देते हैं, और केवल एक बार।
+एक बार जब `proxy` का वास्तविक मान (शून्य नहीं) हो जाता है, तो वह मान नहीं बदल सकता है, इसलिए भले ही मालिक दुष्ट बनने का फैसला करता है, या इसके लिए मेमोनिक का खुलासा हो जाता है, हम अभी भी सुरक्षित हैं।
+
+```solidity
+ /**
+ * @dev कुछ फंक्शन केवल प्रॉक्सी द्वारा ही कॉल किए जा सकते हैं।
+ */
+ modifier onlyProxy {
+```
+
+यह एक [`modifier` फ़ंक्शन](https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm) है, यह अन्य फ़ंक्शन के काम करने के तरीके को संशोधित करता है।
+
+```solidity
+ require(msg.sender == proxy);
+```
+
+सबसे पहले, सत्यापित करें कि हमें प्रॉक्सी द्वारा बुलाया गया था और किसी और ने नहीं।
+यदि नहीं, तो `revert`।
+
+```solidity
+ _;
+ }
+```
+
+यदि हां, तो उस फ़ंक्शन को चलाएं जिसे हम संशोधित करते हैं।
+
+```solidity
+ /* फ़ंक्शन जो प्रॉक्सी को वास्तव में खातों के लिए प्रॉक्सी करने की अनुमति देते हैं */
+
+ function transferProxy(address from, address to, uint256 amount)
+ public virtual onlyProxy() returns (bool)
+ {
+ _transfer(from, to, amount);
+ return true;
+ }
+
+ function approveProxy(address from, address spender, uint256 amount)
+ public virtual onlyProxy() returns (bool)
+ {
+ _approve(from, spender, amount);
+ return true;
+ }
+
+ function transferFromProxy(
+ address spender,
+ address from,
+ address to,
+ uint256 amount
+ ) public virtual onlyProxy() returns (bool)
+ {
+ _spendAllowance(from, spender, amount);
+ _transfer(from, to, amount);
+ return true;
+ }
+```
+
+ये तीन ऑपरेशन हैं जिनके लिए सामान्य रूप से संदेश को सीधे टोकन स्थानांतरित करने या भत्ता स्वीकृत करने वाली इकाई से आने की आवश्यकता होती है।
+यहां हमारे पास एक प्रॉक्सी संस्करण है जो इन कार्यों को करता है:
+
+1. `onlyProxy()` द्वारा संशोधित किया गया है ताकि किसी और को उन्हें नियंत्रित करने की अनुमति न हो।
+2. एक अतिरिक्त पैरामीटर के रूप में वह पता प्राप्त करता है जो सामान्य रूप से `msg.sender` होगा।
+
+### CalldataInterpreter.sol {#calldatainterpreter-sol-2}
+
+कॉलडेटा दुभाषिया ऊपर वाले के लगभग समान है, सिवाय इसके कि प्रॉक्सी किए गए फ़ंक्शन को `msg.sender` पैरामीटर प्राप्त होता है और `transfer` के लिए भत्ते की कोई आवश्यकता नहीं होती है।
+
+```solidity
+ // ट्रांसफर (भत्ते की कोई आवश्यकता नहीं)
+ if (_func == 2) {
+ token.transferProxy(
+ msg.sender,
+ address(uint160(calldataVal(1, 20))),
+ calldataVal(21, 2)
+ );
+ }
+
+ // स्वीकार
+ if (_func == 3) {
+ token.approveProxy(
+ msg.sender,
+ address(uint160(calldataVal(1, 20))),
+ calldataVal(21, 2)
+ );
+ }
+
+ // transferFrom
+ if (_func == 4) {
+ token.transferFromProxy(
+ msg.sender,
+ address(uint160(calldataVal( 1, 20))),
+ address(uint160(calldataVal(21, 20))),
+ calldataVal(41, 2)
+ );
+ }
+```
+
+### Test.js {#test-js-2}
+
+पिछले परीक्षण कोड और इस एक के बीच कुछ बदलाव हैं।
+
+```js
+const Cdi = await ethers.getContractFactory("CalldataInterpreter")
+const cdi = await Cdi.deploy(token.address)
+await cdi.deployed()
+await token.setProxy(cdi.address)
+```
+
+हमें ERC-20 अनुबंध को यह बताने की आवश्यकता है कि किस प्रॉक्सी पर भरोसा करना है
+
+```js
+console.log("CalldataInterpreter addr:", cdi.address)
+
+// भत्ते को सत्यापित करने के लिए दो हस्ताक्षरकर्ताओं की आवश्यकता है
+const signers = await ethers.getSigners()
+const signer = signers[0]
+const poorSigner = signers[1]
+```
+
+`approve()` और `transferFrom()` की जांच के लिए हमें दूसरे हस्ताक्षरकर्ता की आवश्यकता है।
+हम इसे `poorSigner` कहते हैं क्योंकि इसे हमारे कोई टोकन नहीं मिलते हैं (निश्चित रूप से, इसमें ETH होना आवश्यक है)।
+
+```js
+// टोकन ट्रांसफर करें
+const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
+const transferTx = {
+ to: cdi.address,
+ data: "0x02" + destAddr.slice(2, 42) + "0100",
+}
+await (await signer.sendTransaction(transferTx)).wait()
+```
+
+क्योंकि ERC-20 अनुबंध प्रॉक्सी (`cdi`) पर भरोसा करता है, हमें स्थानान्तरण को रिले करने के लिए एक भत्ते की आवश्यकता नहीं है।
+
+```js
+// अनुमोदन और transferFrom
+const approveTx = {
+ to: cdi.address,
+ data: "0x03" + poorSigner.address.slice(2, 42) + "00FF",
+}
+await (await signer.sendTransaction(approveTx)).wait()
+
+const destAddr2 = "0xE1165C689C0c3e9642cA7606F5287e708d846206"
+
+const transferFromTx = {
+ to: cdi.address,
+ data: "0x04" + signer.address.slice(2, 42) + destAddr2.slice(2, 42) + "00FF",
+}
+await (await poorSigner.sendTransaction(transferFromTx)).wait()
+
+// जांचें कि approve / transferFrom कॉम्बो सही तरीके से किया गया था
+expect(await token.balanceOf(destAddr2)).to.equal(255)
+```
+
+दो नए कार्यों का परीक्षण करें।
+ध्यान दें कि `transferFromTx` के लिए दो पता पैरामीटर की आवश्यकता होती है: भत्ता देने वाला और प्राप्त करने वाला।
+
+## निष्कर्ष {#conclusion}
+
+[Optimism](https://medium.com/ethereum-optimism/the-road-to-sub-dollar-transactions-part-2-compression-edition-6bb2890e3e92) और [Arbitrum](https://developer.offchainlabs.com/docs/special_features) दोनों ही L1 पर लिखे गए कॉलडेटा के आकार को कम करने और इसलिए लेनदेन की लागत को कम करने के तरीके खोज रहे हैं।
+हालांकि, सामान्य समाधानों की तलाश करने वाले बुनियादी ढांचा प्रदाताओं के रूप में, हमारी क्षमताएं सीमित हैं।
+डैप डेवलपर के रूप में, आपके पास एप्लिकेशन-विशिष्ट ज्ञान है, जो आपको अपने कॉलडेटा को सामान्य समाधान की तुलना में कहीं बेहतर तरीके से अनुकूलित करने देता है।
+उम्मीद है, यह लेख आपको अपनी आवश्यकताओं के लिए आदर्श समाधान खोजने में मदद करेगा।
+
+[मेरे और काम के लिए यहाँ देखें](https://cryptodocguy.pro/)।
+
diff --git a/public/content/translations/hi/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/hi/developers/tutorials/smart-contract-security-guidelines/index.md
new file mode 100644
index 00000000000..ee7da1a6735
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/smart-contract-security-guidelines/index.md
@@ -0,0 +1,91 @@
+---
+title: "स्मार्ट अनुबंध सुरक्षा दिशानिर्देश"
+description: "अपना डैप बनाते समय ध्यान रखने योग्य सुरक्षा दिशानिर्देशों की एक चेकलिस्ट"
+author: "Trailofbits"
+tags: [ "सोलिडीटी", "स्मार्ट अनुबंध", "सुरक्षा" ]
+skill: intermediate
+lang: hi
+published: 2020-09-06
+source: "सुरक्षित अनुबंध बनाना"
+sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md
+---
+
+अधिक सुरक्षित स्मार्ट अनुबंध बनाने के लिए इन उच्च-स्तरीय सिफारिशों का पालन करें।
+
+## डिज़ाइन दिशानिर्देश {#design-guidelines}
+
+कोड की कोई भी पंक्ति लिखने से पहले, अनुबंध के डिज़ाइन पर समय से पहले चर्चा की जानी चाहिए।
+
+### प्रलेखन और विनिर्देश {#documentation-and-specifications}
+
+प्रलेखन विभिन्न स्तरों पर लिखा जा सकता है, और अनुबंधों को लागू करते समय अपडेट किया जाना चाहिए:
+
+- **सिस्टम का एक सरल अंग्रेजी विवरण**, यह बताते हुए कि अनुबंध क्या करते हैं और कोडबेस पर कोई भी धारणा।
+- **स्कीमा और आर्किटेक्चरल आरेख**, जिसमें अनुबंध इंटरैक्शन और सिस्टम की स्टेट मशीन शामिल हैं। [Slither प्रिंटर](https://github.com/crytic/slither/wiki/Printer-documentation) इन स्कीमा को बनाने में मदद कर सकते हैं।
+- **संपूर्ण कोड प्रलेखन**, सॉलिडिटी के लिए [Natspec प्रारूप](https://docs.soliditylang.org/en/develop/natspec-format.html) का उपयोग किया जा सकता है।
+
+### ऑन-चेन बनाम ऑफ-चेन गणना {#onchain-vs-offchain-computation}
+
+- **जितना हो सके उतना कोड ऑफ-चेन रखें।** ऑन-चेन परत को छोटा रखें। ऑफ-चेन कोड के साथ डेटा को इस तरह से प्री-प्रोसेस करें कि ऑन-चेन सत्यापन सरल हो। क्या आपको एक क्रमित सूची की आवश्यकता है? सूची को ऑफ-चेन सॉर्ट करें, फिर केवल ऑन-चेन इसके क्रम की जांच करें।
+
+### अपग्रेडेबिलिटी {#upgradeability}
+
+हमने [हमारे ब्लॉगपोस्ट](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/) में विभिन्न अपग्रेडेबिलिटी समाधानों पर चर्चा की। कोई भी कोड लिखने से पहले अपग्रेडेबिलिटी का समर्थन करना है या नहीं, यह सोच-समझकर चुनें। यह निर्णय प्रभावित करेगा कि आप अपने कोड की संरचना कैसे करते हैं। सामान्य तौर पर, हम अनुशंसा करते हैं:
+
+- **अपग्रेडेबिलिटी पर [अनुबंध माइग्रेशन](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/) को प्राथमिकता देना।** माइग्रेशन सिस्टम में अपग्रेड करने योग्य सिस्टम के समान कई फायदे हैं, बिना उनकी कमियों के।
+- **delegatecallproxy वाले पैटर्न पर डेटा पृथक्करण पैटर्न का उपयोग करना।** यदि आपके प्रोजेक्ट में एक स्पष्ट एब्स्ट्रैक्शन पृथक्करण है, तो डेटा पृथक्करण का उपयोग करके अपग्रेडेबिलिटी के लिए केवल कुछ समायोजन की आवश्यकता होगी। delegatecallproxy के लिए EVM विशेषज्ञता की आवश्यकता होती है और इसमें त्रुटियों की बहुत अधिक संभावना होती है।
+- **परिनियोजन से पहले माइग्रेशन/अपग्रेड प्रक्रिया का दस्तावेजीकरण करें।** यदि आपको बिना किसी दिशानिर्देश के तनाव में प्रतिक्रिया देनी पड़ती है, तो आप गलतियाँ करेंगे। पालन की जाने वाली प्रक्रिया को पहले से लिख लें। इसमें शामिल होना चाहिए:
+ - वे कॉल जो नए अनुबंधों को आरंभ करते हैं
+ - कुंजियाँ कहाँ संग्रहीत हैं और उन तक कैसे पहुँचें
+ - परिनियोजन की जाँच कैसे करें! एक पोस्ट-डिप्लॉयमेंट स्क्रिप्ट विकसित और परीक्षण करें।
+
+## कार्यान्वयन दिशानिर्देश {#implementation-guidelines}
+
+**सरलता के लिए प्रयास करें।** हमेशा उस सरलतम समाधान का उपयोग करें जो आपके उद्देश्य के लिए उपयुक्त हो। आपकी टीम का कोई भी सदस्य आपके समाधान को समझने में सक्षम होना चाहिए।
+
+### फ़ंक्शन संरचना {#function-composition}
+
+आपके कोडबेस की वास्तुकला को आपके कोड की समीक्षा करना आसान बनाना चाहिए। ऐसी वास्तुशिल्प पसंदों से बचें जो इसकी शुद्धता के बारे में तर्क करने की क्षमता को कम करती हैं।
+
+- **अपने सिस्टम के तर्क को विभाजित करें**, या तो कई अनुबंधों के माध्यम से या समान कार्यों को एक साथ समूहित करके (उदाहरण के लिए, प्रमाणीकरण, अंकगणित, ...)।
+- **एक स्पष्ट उद्देश्य के साथ छोटे फ़ंक्शन लिखें।** यह आसान समीक्षा की सुविधा प्रदान करेगा और व्यक्तिगत घटकों के परीक्षण की अनुमति देगा।
+
+### इन्हेरिटेंस {#inheritance}
+
+- **इन्हेरिटेंस को प्रबंधनीय रखें।** तर्क को विभाजित करने के लिए इन्हेरिटेंस का उपयोग किया जाना चाहिए, हालांकि, आपके प्रोजेक्ट का लक्ष्य इन्हेरिटेंस ट्री की गहराई और चौड़ाई को कम करना होना चाहिए।
+- **अनुबंधों के पदानुक्रम की जांच के लिए Slither के [इन्हेरिटेंस प्रिंटर](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph) का उपयोग करें।** इन्हेरिटेंस प्रिंटर आपको पदानुक्रम के आकार की समीक्षा करने में मदद करेगा।
+
+### घटनाएँ {#events}
+
+- **सभी महत्वपूर्ण परिचालनों को लॉग करें।** इवेंट्स विकास के दौरान अनुबंध को डीबग करने में मदद करेंगे, और परिनियोजन के बाद इसकी निगरानी करेंगे।
+
+### ज्ञात नुकसानों से बचें {#avoid-known-pitfalls}
+
+- **सबसे आम सुरक्षा मुद्दों से अवगत रहें।** सामान्य मुद्दों के बारे में जानने के लिए कई ऑनलाइन संसाधन हैं, जैसे [Ethernaut CTF](https://ethernaut.openzeppelin.com/), [Capture the Ether](https://capturetheether.com/), या [Not so smart contracts](https://github.com/crytic/not-so-smart-contracts/)।
+- **[सॉलिडिटी प्रलेखन](https://docs.soliditylang.org/en/latest/) में चेतावनियों के अनुभागों से अवगत रहें।** चेतावनी अनुभाग आपको भाषा के गैर-स्पष्ट व्यवहार के बारे में सूचित करेंगे।
+
+### निर्भरताएँ {#dependencies}
+
+- **अच्छी तरह से परीक्षण की गई लाइब्रेरी का उपयोग करें।** अच्छी तरह से परीक्षण की गई लाइब्रेरी से कोड आयात करना आपके द्वारा बग्गी कोड लिखने की संभावना को कम कर देगा। यदि आप एक ERC20 अनुबंध लिखना चाहते हैं, तो [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20) का उपयोग करें।
+- **एक निर्भरता प्रबंधक का उपयोग करें; कोड कॉपी-पेस्ट करने से बचें।** यदि आप किसी बाहरी स्रोत पर भरोसा करते हैं, तो आपको इसे मूल स्रोत के साथ अद्यतन रखना होगा।
+
+### परीक्षण और सत्यापन {#testing-and-verification}
+
+- **संपूर्ण यूनिट-टेस्ट लिखें।** उच्च-गुणवत्ता वाले सॉफ़्टवेयर बनाने के लिए एक व्यापक परीक्षण सूट महत्वपूर्ण है।
+- **[Slither](https://github.com/crytic/slither), [Echidna](https://github.com/crytic/echidna) और [Manticore](https://github.com/trailofbits/manticore) कस्टम जांच और गुण लिखें।** स्वचालित उपकरण यह सुनिश्चित करने में मदद करेंगे कि आपका अनुबंध सुरक्षित है। कुशल जांच और गुण कैसे लिखें, यह जानने के लिए इस गाइड के बाकी हिस्सों की समीक्षा करें।
+- **[crytic.io](https://crytic.io/) का उपयोग करें।** Crytic GitHub के साथ एकीकृत होता है, निजी Slither डिटेक्टरों तक पहुंच प्रदान करता है, और Echidna से कस्टम प्रॉपर्टी जांच चलाता है।
+
+### Solidity {#solidity}
+
+- **सॉलिडिटी 0.4 और 0.6 पर सॉलिडिटी 0.5 को प्राथमिकता दें।** हमारी राय में, सॉलिडिटी 0.5, 0.4 की तुलना में अधिक सुरक्षित है और इसमें बेहतर अंतर्निहित प्रथाएं हैं। सॉलिडिटी 0.6 उत्पादन के लिए बहुत अस्थिर साबित हुआ है और इसे परिपक्व होने के लिए समय चाहिए।
+- **संकलन के लिए एक स्थिर रिलीज का उपयोग करें; चेतावनियों की जांच के लिए नवीनतम रिलीज का उपयोग करें।** जांचें कि आपके कोड में नवीनतम कंपाइलर संस्करण के साथ कोई रिपोर्ट की गई समस्या नहीं है। हालांकि, सॉलिडिटी का एक तेज़ रिलीज़ चक्र है और इसमें कंपाइलर बग का इतिहास है, इसलिए हम परिनियोजन के लिए नवीनतम संस्करण की अनुशंसा नहीं करते हैं (Slither की [solc संस्करण अनुशंसा](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33) देखें)।
+- **इनलाइन असेंबली का उपयोग न करें।** असेंबली के लिए EVM विशेषज्ञता की आवश्यकता होती है। यदि आपने येलो पेपर में _महारत हासिल_ नहीं की है तो EVM कोड न लिखें।
+
+## परिनियोजन दिशानिर्देश {#deployment-guidelines}
+
+एक बार जब अनुबंध विकसित और परिनियोजित हो जाता है:
+
+- **अपने अनुबंधों की निगरानी करें।** लॉग देखें, और अनुबंध या वॉलेट से छेड़छाड़ की स्थिति में प्रतिक्रिया करने के लिए तैयार रहें।
+- **अपनी संपर्क जानकारी [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts) में जोड़ें।** यह सूची तीसरे पक्षों को आपसे संपर्क करने में मदद करती है यदि किसी सुरक्षा दोष का पता चलता है।
+- **विशेषाधिकार प्राप्त यूज़र्स के वॉलेट सुरक्षित करें।** यदि आप हार्डवेयर वॉलेट में कुंजियाँ संग्रहीत करते हैं तो हमारी [सर्वोत्तम प्रथाओं](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/) का पालन करें।
+- **घटना प्रतिक्रिया योजना रखें।** इस पर विचार करें कि आपके स्मार्ट अनुबंधों से छेड़छाड़ की जा सकती है। भले ही आपके अनुबंध बग से मुक्त हों, एक हमलावर अनुबंध के मालिक की कुंजियों पर नियंत्रण कर सकता है।
diff --git a/public/content/translations/hi/developers/tutorials/stealth-addr/index.md b/public/content/translations/hi/developers/tutorials/stealth-addr/index.md
new file mode 100644
index 00000000000..0cead47ed5c
--- /dev/null
+++ b/public/content/translations/hi/developers/tutorials/stealth-addr/index.md
@@ -0,0 +1,443 @@
+---
+title: "गोपनीय पतों का उपयोग करना"
+description: "गोपनीय पते यूज़र्स को गुमनाम रूप से संपत्ति स्थानांतरित करने की अनुमति देते हैं। इस लेख को पढ़ने के बाद, आप निम्न में सक्षम होंगे: यह समझाएँ कि गोपनीय पते क्या हैं और वे कैसे काम करते हैं, समझें कि गुमनामी बनाए रखने वाले तरीके से गोपनीय पतों का उपयोग कैसे करें, और एक वेब-आधारित एप्लिकेशन लिखें जो गोपनीय पतों का उपयोग करता है।"
+author: "ओरी पोमेरेन्ट्ज़"
+tags:
+ [
+ "गोपनीय पता",
+ "गोपनीयता",
+ "क्रिप्टोग्राफ़ी",
+ "rust",
+ "wasm"
+ ]
+skill: intermediate
+published: 2025-11-30
+lang: hi
+sidebarDepth: 3
+---
+
+आप बिल हैं। उन कारणों से जिन पर हम चर्चा नहीं करेंगे, आप "पूरी दुनिया की रानी के लिए एलिस" अभियान को दान देना चाहते हैं और चाहते हैं कि एलिस को पता चले कि आपने दान दिया है ताकि अगर वह जीतती है तो वह आपको पुरस्कृत करेगी। दुर्भाग्य से, उसकी जीत की गारंटी नहीं है। एक प्रतिस्पर्धी अभियान है, "सौर मंडल की महारानी के लिए कैरल"। यदि कैरल जीत जाती है, और उसे पता चलता है कि आपने ऐलिस को दान दिया है, तो आप मुश्किल में पड़ जाएँगे। तो आप अपने खाते से एलिस के खाते में सिर्फ 200 ETH स्थानांतरित नहीं कर सकते।
+
+[ERC-5564](https://eips.ethereum.org/EIPS/eip-5564) के पास इसका समाधान है। यह ERC बताता है कि गुमनाम स्थानांतरण के लिए [गोपनीय पतों](https://nerolation.github.io/stealth-utils) का उपयोग कैसे करें।
+
+**चेतावनी**: गोपनीय पतों के पीछे की क्रिप्टोग्राफी, जहाँ तक हम जानते हैं, सुदृढ़ है। हालाँकि, इसमें संभावित साइड-चैनल हमले हो सकते हैं। [नीचे](#go-wrong), आप देखेंगे कि इस जोखिम को कम करने के लिए आप क्या कर सकते हैं।
+
+## गोपनीय पते कैसे काम करते हैं {#how}
+
+यह लेख दो तरीकों से गोपनीय पतों को समझाने का प्रयास करेगा। पहला है [उनका उपयोग कैसे करें](#how-use)। यह भाग लेख के बाकी हिस्सों को समझने के लिए पर्याप्त है। फिर, [इसके पीछे के गणित की व्याख्या](#how-math) है। यदि आप क्रिप्टोग्राफी में रुचि रखते हैं, तो इस भाग को भी पढ़ें।
+
+### सरल संस्करण (गोपनीय पतों का उपयोग कैसे करें) {#how-use}
+
+एलिस दो निजी कुंजियाँ बनाती है और संबंधित सार्वजनिक कुंजियाँ प्रकाशित करती है (जिन्हें एक एकल दोहरी-लंबाई वाले मेटा-पते में जोड़ा जा सकता है)। बिल भी एक निजी कुंजी बनाता है और संबंधित सार्वजनिक कुंजी प्रकाशित करता है।
+
+एक पक्ष की सार्वजनिक कुंजी और दूसरे की निजी कुंजी का उपयोग करके, आप केवल एलिस और बिल को ज्ञात एक साझा रहस्य प्राप्त कर सकते हैं (इसे केवल सार्वजनिक कुंजियों से प्राप्त नहीं किया जा सकता है)। इस साझा रहस्य का उपयोग करके, बिल गोपनीय पता प्राप्त करता है और उसमें संपत्ति भेज सकता है।
+
+एलिस को भी साझा रहस्य से पता मिलता है, लेकिन क्योंकि वह अपने द्वारा प्रकाशित सार्वजनिक कुंजियों की निजी कुंजियाँ जानती है, वह उस पते से निकासी करने वाली निजी कुंजी भी प्राप्त कर सकती है।
+
+### गणित (गोपनीय पते इस तरह क्यों काम करते हैं) {#how-math}
+
+मानक गोपनीय पते कम कुंजी बिट्स के साथ बेहतर प्रदर्शन पाने के लिए [एलिप्टिक-कर्व क्रिप्टोग्राफी (ECC)](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/#elliptic-curves-building-blocks-of-a-better-trapdoor) का उपयोग करते हैं, जबकि सुरक्षा का समान स्तर बनाए रखते हैं। लेकिन ज़्यादातर हम इसे अनदेखा कर सकते हैं और मान सकते हैं कि हम नियमित अंकगणित का उपयोग कर रहे हैं।
+
+एक संख्या है जिसे हर कोई जानता है, _G_। आप _G_ से गुणा कर सकते हैं। लेकिन ECC की प्रकृति के कारण, _G_ से विभाजित करना व्यावहारिक रूप से असंभव है। जिस तरह से एथेरियम में सार्वजनिक कुंजी क्रिप्टोग्राफी आम तौर पर काम करती है, वह यह है कि आप एक निजी कुंजी, _Ppriv_, का उपयोग लेनदेन पर हस्ताक्षर करने के लिए कर सकते हैं जिन्हें फिर एक सार्वजनिक कुंजी, _Ppub = GPpriv_ द्वारा सत्यापित किया जाता है।
+
+एलिस दो निजी कुंजियाँ, _Kpriv_ और _Vpriv_ बनाती है। _Kpriv_ का उपयोग गोपनीय पते से पैसे खर्च करने के लिए किया जाएगा, और _Vpriv_ का उपयोग एलिस से संबंधित पतों को देखने के लिए किया जाएगा। एलिस फिर सार्वजनिक कुंजियाँ प्रकाशित करती है: _Kpub = GKpriv_ और _Vpub = GVpriv_
+
+बिल एक तीसरी निजी कुंजी, _Rpriv_ बनाता है, और _Rpub = GRpriv_ को एक केंद्रीय रजिस्ट्री में प्रकाशित करता है (बिल इसे एलिस को भी भेज सकता था, लेकिन हम मानते हैं कि कैरल सुन रही है)।
+
+बिल _RprivVpub = GRprivVpriv_ की गणना करता है, जिसके बारे में वह उम्मीद करता है कि एलिस भी जानती होगी (नीचे समझाया गया है)। इस मान को _S_, साझा रहस्य कहा जाता है। यह बिल को एक सार्वजनिक कुंजी देता है, _Ppub = Kpub+G\*hash(S)_। इस सार्वजनिक कुंजी से, वह एक पते की गणना कर सकता है और जो भी संसाधन वह चाहता है उसे भेज सकता है। भविष्य में, यदि एलिस जीत जाती है, तो बिल उसे _Rpriv_ बताकर यह साबित कर सकता है कि संसाधन उसकी ओर से आए थे।
+
+एलिस _RpubVpriv = GRprivVpriv_ की गणना करती है। यह उसे वही साझा रहस्य, _S_ देता है। क्योंकि वह निजी कुंजी, _Kpriv_ जानती है, वह _Ppriv = Kpriv+hash(S)_ की गणना कर सकती है। यह कुंजी उसे उस पते में संपत्ति तक पहुँचने देती है जो _Ppub = GPpriv = GKpriv+G\*hash(S) = Kpub+G\*hash(S)_ से प्राप्त होता है।
+
+हमारे पास एक अलग देखने वाली कुंजी है ताकि एलिस डेव की वर्ल्ड डॉमिनेशन कैंपेन सर्विसेज को सब-कॉन्ट्रैक्ट दे सके। एलिस डेव को सार्वजनिक पतों को जानने देने और अधिक पैसे उपलब्ध होने पर उसे सूचित करने के लिए तैयार है, लेकिन वह नहीं चाहती कि वह उसके अभियान का पैसा खर्च करे।
+
+क्योंकि देखने और खर्च करने के लिए अलग-अलग कुंजियों का उपयोग होता है, एलिस डेव को _Vpriv_ दे सकती है। तब डेव _S = RpubVpriv = GRprivVpriv_ की गणना कर सकता है और इस तरह सार्वजनिक कुंजियाँ (_Ppub = Kpub+G\*hash(S)_) प्राप्त कर सकता है। लेकिन _Kpriv_ के बिना डेव निजी कुंजी प्राप्त नहीं कर सकता।
+
+सारांश में, ये विभिन्न प्रतिभागियों द्वारा ज्ञात मान हैं।
+
+| एलिस | प्रकाशित | बिल | डेव | |
+| ------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------------------------------------------- |
+| G | G | G | G | |
+| _Kpriv_ | – | – | – | |
+| _Vpriv_ | – | – | _Vpriv_ | |
+| _Kpub = GKpriv_ | _Kpub_ | _Kpub_ | _Kpub_ | |
+| _Vpub = GVpriv_ | _Vpub_ | _Vpub_ | _Vpub_ | |
+| – | – | _Rpriv_ | – | |
+| _Rpub_ | _Rpub_ | _Rpub = GRpriv_ | _Rpub_ | |
+| _S = RpubVpriv = GRprivVpriv_ | – | _S = RprivVpub = GRprivVpriv_ | _S = _RpubVpriv_ = GRprivVpriv_ | |
+| _Ppub = Kpub+G\*hash(S)_ | – | _Ppub = Kpub+G\*hash(S)_ | _Ppub = Kpub+G\*hash(S)_ | |
+| _पता=f(Ppub)_ | – | _पता=f(Ppub)_ | _पता=f(Ppub)_ | _पता=f(Ppub)_ |
+| _Ppriv = Kpriv+hash(S)_ | – | – | – | |
+
+## जब गोपनीय पते गलत हो जाते हैं {#go-wrong}
+
+_ब्लॉकचेन पर कोई रहस्य नहीं हैं_। हालांकि गोपनीय पते आपको गोपनीयता प्रदान कर सकते हैं, वह गोपनीयता ट्रैफिक विश्लेषण के प्रति संवेदनशील है। एक मामूली उदाहरण लेने के लिए, कल्पना करें कि बिल एक पते को फंड करता है और तुरंत एक _Rpub_ मान प्रकाशित करने के लिए एक लेनदेन भेजता है। एलिस के _Vpriv_ के बिना, हम यह सुनिश्चित नहीं कर सकते कि यह एक गोपनीय पता है, लेकिन शर्त लगाने का यही तरीका है। फिर, हम एक और लेनदेन देखते हैं जो उस पते से सभी ETH को एलिस के अभियान निधि पते पर स्थानांतरित करता है। हम इसे साबित नहीं कर सकते हैं, लेकिन यह संभावना है कि बिल ने अभी-अभी एलिस के अभियान को दान दिया है। कैरल निश्चित रूप से ऐसा ही सोचेगी।
+
+बिल के लिए _Rpub_ के प्रकाशन को गोपनीय पते की फंडिंग से अलग करना आसान है (उन्हें अलग-अलग समय पर, अलग-अलग पतों से करें)। हालाँकि, यह अपर्याप्त है। कैरल जिस पैटर्न की तलाश करती है वह यह है कि बिल एक पते को फंड करता है, और फिर एलिस का अभियान फंड उससे निकासी करता है।
+
+एक समाधान यह है कि एलिस का अभियान सीधे पैसे की निकासी न करे, बल्कि इसका उपयोग किसी तीसरे पक्ष को भुगतान करने के लिए करे। यदि एलिस का अभियान डेव की वर्ल्ड डॉमिनेशन कैंपेन सर्विसेज को 10 ETH भेजता है, तो कैरल को केवल यह पता चलता है कि बिल ने डेव के ग्राहकों में से एक को दान दिया है। यदि डेव के पास पर्याप्त ग्राहक हैं, तो कैरल यह नहीं जान पाएगी कि बिल ने एलिस को दान दिया है जो उसके साथ प्रतिस्पर्धा करती है, या एडम, अल्बर्ट, या अबीगैल को, जिनकी कैरल को परवाह नहीं है। एलिस भुगतान के साथ एक हैश किया हुआ मान शामिल कर सकती है, और फिर डेव को प्रीइमेज प्रदान कर सकती है, यह साबित करने के लिए कि यह उसका दान था। वैकल्पिक रूप से, जैसा कि ऊपर उल्लेख किया गया है, यदि एलिस डेव को अपना _Vpriv_ देती है, तो वह पहले से ही जानता है कि भुगतान किससे आया है।
+
+इस समाधान के साथ मुख्य समस्या यह है कि इसमें एलिस को गोपनीयता की परवाह करने की आवश्यकता होती है जब उस गोपनीयता से बिल को लाभ होता है। एलिस अपनी प्रतिष्ठा बनाए रखना चाह सकती है ताकि बिल का दोस्त बॉब भी उसे दान दे। लेकिन यह भी संभव है कि उसे बिल को बेनकाब करने में कोई आपत्ति न हो, क्योंकि तब उसे डर होगा कि अगर कैरल जीत गई तो क्या होगा। बिल शायद एलिस को और भी अधिक समर्थन प्रदान करेगा।
+
+### कई गोपनीय परतों का उपयोग करना {#multi-layer}
+
+बिल की गोपनीयता को बनाए रखने के लिए एलिस पर निर्भर रहने के बजाय, बिल इसे स्वयं कर सकता है। वह काल्पनिक लोगों, बॉब और बेला के लिए कई मेटा-पते उत्पन्न कर सकता है। बिल फिर बॉब को ETH भेजता है, और "बॉब" (जो वास्तव में बिल है) इसे बेला को भेजता है। "बेला" (जो बिल भी है) इसे एलिस को भेजती है।
+
+कैरल अभी भी ट्रैफिक विश्लेषण कर सकती है और बिल-से-बॉब-से-बेला-से-एलिस पाइपलाइन देख सकती है। हालाँकि, यदि "बॉब" और "बेला" अन्य उद्देश्यों के लिए भी ETH का उपयोग करते हैं, तो यह प्रतीत नहीं होगा कि बिल ने एलिस को कुछ भी स्थानांतरित किया है, भले ही एलिस तुरंत गोपनीय पते से अपने ज्ञात अभियान पते पर निकासी कर ले।
+
+## एक गोपनीय-पता एप्लिकेशन लिखना {#write-app}
+
+यह लेख एक गोपनीय-पता एप्लिकेशन की व्याख्या करता है जो [GitHub पर उपलब्ध है](https://github.com/qbzzt/251022-stealth-addresses.git)।
+
+### उपकरण {#tools}
+
+एक [टाइपस्क्रिप्ट गोपनीय पता लाइब्रेरी](https://github.com/ScopeLift/stealth-address-sdk) है जिसका हम उपयोग कर सकते हैं। हालाँकि, क्रिप्टोग्राफ़िक संचालन CPU-गहन हो सकते हैं। मैं उन्हें [Rust](https://rust-lang.org/) जैसी संकलित भाषा में लागू करना पसंद करता हूँ, और ब्राउज़र में कोड चलाने के लिए [WASM](https://webassembly.org/) का उपयोग करता हूँ।
+
+हम [Vite](https://vite.dev/) और [React](https://react.dev/) का उपयोग करने जा रहे हैं। ये उद्योग-मानक उपकरण हैं; यदि आप इनसे परिचित नहीं हैं, तो आप [इस ट्यूटोरियल](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) का उपयोग कर सकते हैं। Vite का उपयोग करने के लिए, हमें Node की आवश्यकता है।
+
+### गोपनीय पतों को क्रिया में देखें {#in-action}
+
+1. आवश्यक उपकरण स्थापित करें: [Rust](https://rust-lang.org/tools/install/) और [Node](https://nodejs.org/en/download)।
+
+2. GitHub रिपॉजिटरी को क्लोन करें।
+
+ ```sh
+ git clone https://github.com/qbzzt/251022-stealth-addresses.git
+ cd 251022-stealth-addresses
+ ```
+
+3. आवश्यक शर्तें स्थापित करें और Rust कोड संकलित करें।
+
+ ```sh
+ cd src/rust-wasm
+ rustup target add wasm32-unknown-unknown
+ cargo install wasm-pack
+ wasm-pack build --target web
+ ```
+
+4. वेब सर्वर शुरू करें।
+
+ ```sh
+ cd ../..
+ npm install
+ npm run dev
+ ```
+
+5. [एप्लिकेशन](http://localhost:5173/) पर ब्राउज़ करें। इस एप्लिकेशन पेज में दो फ्रेम हैं: एक एलिस के यूज़र इंटरफेस के लिए और दूसरा बिल के लिए। दोनों फ्रेम संवाद नहीं करते हैं; वे केवल सुविधा के लिए एक ही पेज पर हैं।
+
+6. एलिस के रूप में, **एक गोपनीय मेटा-पता उत्पन्न करें** पर क्लिक करें। यह नया गोपनीय पता और संबंधित निजी कुंजियाँ प्रदर्शित करेगा। गोपनीय मेटा-पते को क्लिपबोर्ड पर कॉपी करें।
+
+7. बिल के रूप में, नया गोपनीय मेटा-पता पेस्ट करें और **एक पता उत्पन्न करें** पर क्लिक करें। यह आपको एलिस के लिए फंड करने का पता देता है।
+
+8. पते और बिल की सार्वजनिक कुंजी को कॉपी करें और उन्हें एलिस के यूज़र इंटरफेस के "बिल द्वारा उत्पन्न पते के लिए निजी कुंजी" क्षेत्र में पेस्ट करें। एक बार जब वे फ़ील्ड भर दिए जाते हैं, तो आप उस पते पर संपत्ति तक पहुँचने के लिए निजी कुंजी देखेंगे।
+
+9. आप यह सुनिश्चित करने के लिए [एक ऑनलाइन कैलकुलेटर](https://iancoleman.net/ethereum-private-key-to-address/) का उपयोग कर सकते हैं कि निजी कुंजी पते से मेल खाती है।
+
+### प्रोग्राम कैसे काम करता है {#how-the-program-works}
+
+#### WASM घटक {#wasm}
+
+WASM में संकलित होने वाला स्रोत कोड [Rust](https://rust-lang.org/) में लिखा गया है। आप इसे [`src/rust_wasm/src/lib.rs`](https://github.com/qbzzt/251022-stealth-addresses/blob/main/src/rust-wasm/src/lib.rs) में देख सकते हैं। यह कोड मुख्य रूप से JavaScript कोड और [`eth-stealth-addresses` लाइब्रेरी](https://github.com/kassandraoftroy/eth-stealth-addresses) के बीच एक इंटरफ़ेस है।
+
+**`Cargo.toml`**
+
+Rust में [`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html) JavaScript में [`package.json`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) के अनुरूप है। इसमें पैकेज जानकारी, निर्भरता घोषणाएँ आदि शामिल हैं।
+
+```toml
+[package]
+name = "rust-wasm"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+eth-stealth-addresses = "0.1.0"
+hex = "0.4.3"
+wasm-bindgen = "0.2.104"
+getrandom = { version = "0.2", features = ["js"] }
+```
+
+[`getrandom`](https://docs.rs/getrandom/latest/getrandom/) पैकेज को यादृच्छिक मान उत्पन्न करने की आवश्यकता है। यह केवल एल्गोरिथम माध्यमों से नहीं किया जा सकता है; इसके लिए एन्ट्रापी के स्रोत के रूप में एक भौतिक प्रक्रिया तक पहुंच की आवश्यकता होती है। यह परिभाषा निर्दिष्ट करती है कि हम जिस ब्राउज़र में चल रहे हैं, उससे पूछकर वह एन्ट्रापी प्राप्त करेंगे।
+
+```toml
+console_error_panic_hook = "0.1.7"
+```
+
+[यह लाइब्रेरी](https://docs.rs/console_error_panic_hook/latest/console_error_panic_hook/) हमें अधिक सार्थक त्रुटि संदेश देती है जब WASM कोड पैनिक करता है और जारी नहीं रह सकता है।
+
+```toml
+[lib]
+crate-type = ["cdylib", "rlib"]
+```
+
+WASM कोड बनाने के लिए आवश्यक आउटपुट प्रकार।
+
+**`lib.rs`**
+
+यह वास्तविक Rust कोड है।
+
+```rust
+use wasm_bindgen::prelude::*;
+```
+
+Rust से WASM पैकेज बनाने के लिए परिभाषाएँ। वे [यहां](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/index.html) प्रलेखित हैं।
+
+```rust
+use eth_stealth_addresses::{
+ generate_stealth_meta_address,
+ generate_stealth_address,
+ compute_stealth_key
+};
+```
+
+वे फ़ंक्शन जिनकी हमें [`eth-stealth-addresses` लाइब्रेरी](https://github.com/kassandraoftroy/eth-stealth-addresses) से आवश्यकता है।
+
+```rust
+use hex::{decode,encode};
+```
+
+Rust आमतौर पर मानों के लिए बाइट [ऐरे](https://doc.rust-lang.org/std/primitive.array.html) (`[u8; ]`) का उपयोग करता है। लेकिन JavaScript में, हम आमतौर पर हेक्साडेसिमल स्ट्रिंग्स का उपयोग करते हैं। [`hex` लाइब्रेरी](https://docs.rs/hex/latest/hex/) हमारे लिए एक प्रतिनिधित्व से दूसरे में अनुवाद करती है।
+
+```rust
+#[wasm_bindgen]
+```
+
+JavaScript से इस फ़ंक्शन को कॉल करने में सक्षम होने के लिए WASM बाइंडिंग उत्पन्न करें।
+
+```rust
+pub fn wasm_generate_stealth_meta_address() -> String {
+```
+
+कई फ़ील्ड वाले ऑब्जेक्ट को वापस करने का सबसे आसान तरीका JSON स्ट्रिंग वापस करना है।
+
+```rust
+ let (address, spend_private_key, view_private_key) =
+ generate_stealth_meta_address();
+```
+
+[`generate_stealth_meta_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_meta_address.html) तीन फ़ील्ड लौटाता है:
+
+- मेटा-पता (_Kpub_ और _Vpub_)
+- देखने वाली निजी कुंजी (_Vpriv_)
+- खर्च करने वाली निजी कुंजी (_Kpriv_)
+
+[टपल](https://doc.rust-lang.org/std/primitive.tuple.html) सिंटैक्स हमें उन मानों को फिर से अलग करने देता है।
+
+```rust
+ format!("{{\"address\":\"{}\",\"view_private_key\":\"{}\",\"spend_private_key\":\"{}\"}}",
+ encode(address),
+ encode(view_private_key),
+ encode(spend_private_key)
+ )
+}
+```
+
+JSON-एन्कोडेड स्ट्रिंग उत्पन्न करने के लिए [`format!`](https://doc.rust-lang.org/std/fmt/index.html) मैक्रो का उपयोग करें। ऐरे को हेक्स स्ट्रिंग्स में बदलने के लिए [`hex::encode`](https://docs.rs/hex/latest/hex/fn.encode.html) का उपयोग करें।
+
+```rust
+fn str_to_array(s: &str) -> Option<[u8; N]> {
+```
+
+यह फ़ंक्शन एक हेक्स स्ट्रिंग (JavaScript द्वारा प्रदान किया गया) को बाइट ऐरे में बदलता है। हम इसका उपयोग JavaScript कोड द्वारा प्रदान किए गए मानों को पार्स करने के लिए करते हैं। यह फ़ंक्शन इस वजह से जटिल है कि Rust ऐरे और वेक्टर को कैसे संभालता है।
+
+`` एक्सप्रेशन को [जेनेरिक](https://doc.rust-lang.org/book/ch10-01-syntax.html) कहा जाता है। `N` एक पैरामीटर है जो लौटाए गए ऐरे की लंबाई को नियंत्रित करता है। फ़ंक्शन को वास्तव में `str_to_array::` कहा जाता है, जहाँ `n` ऐरे की लंबाई है।
+
+वापसी मान `Option<[u8; N]>` है, जिसका अर्थ है कि लौटाया गया ऐरे [वैकल्पिक](https://doc.rust-lang.org/std/option/) है। यह Rust में उन फ़ंक्शन के लिए एक विशिष्ट पैटर्न है जो विफल हो सकते हैं।
+
+उदाहरण के लिए, यदि हम `str_to_array::10("bad060a7")` को कॉल करते हैं, तो फ़ंक्शन को एक दस-मान ऐरे लौटाना चाहिए, लेकिन इनपुट केवल चार बाइट्स का है। फ़ंक्शन को विफल होना चाहिए, और यह `None` लौटाकर ऐसा करता है। `str_to_array::4("bad060a7")` के लिए वापसी मान `Some<[0xba, 0xd0, 0x60, 0xa7]>` होगा।
+
+```rust
+ // decode returns Result, _>
+ let vec = decode(s).ok()?;
+```
+
+[`hex::decode`](https://docs.rs/hex/latest/hex/fn.decode.html) फ़ंक्शन एक `Result, FromHexError>` लौटाता है। [`Result`](https://doc.rust-lang.org/std/result/) प्रकार में या तो एक सफल परिणाम (`Ok(value)`) या एक त्रुटि (`Err(error)`) हो सकती है।
+
+`.ok()` विधि `Result` को `Option` में बदल देती है, जिसका मान या तो सफल होने पर `Ok()` मान होता है या नहीं होने पर `None` होता है। अंत में, [प्रश्न चिह्न ऑपरेटर](https://doc.rust-lang.org/std/option/#the-question-mark-operator-) वर्तमान फ़ंक्शन को समाप्त कर देता है और यदि `Option` खाली है तो `None` लौटाता है। अन्यथा, यह मान को अनरैप करता है और उसे लौटाता है (इस मामले में, `vec` को एक मान निर्दिष्ट करने के लिए)।
+
+यह त्रुटियों को संभालने के लिए एक अजीब तरह से जटिल तरीका लगता है, लेकिन `Result` और `Option` यह सुनिश्चित करते हैं कि सभी त्रुटियों को किसी न किसी तरह से संभाला जाए।
+
+```rust
+ if vec.len() != N { return None; }
+```
+
+यदि बाइट्स की संख्या गलत है, तो यह एक विफलता है, और हम `None` लौटाते हैं।
+
+```rust
+ // try_into consumes vec and attempts to make [u8; N]
+ let array: [u8; N] = vec.try_into().ok()?;
+```
+
+Rust में दो ऐरे प्रकार होते हैं। [ऐरे](https://doc.rust-lang.org/std/primitive.array.html) का एक निश्चित आकार होता है। [वेक्टर](https://doc.rust-lang.org/std/vec/index.html) बढ़ और घट सकते हैं। `hex::decode` एक वेक्टर लौटाता है, लेकिन `eth_stealth_addresses` लाइब्रेरी ऐरे प्राप्त करना चाहती है। [`.try_into()`](https://doc.rust-lang.org/std/convert/trait.TryInto.html#required-methods) एक मान को दूसरे प्रकार में परिवर्तित करता है, उदाहरण के लिए, एक वेक्टर को एक ऐरे में।
+
+```rust
+ Some(array)
+}
+```
+
+Rust को किसी फ़ंक्शन के अंत में मान लौटाते समय [`return`](https://doc.rust-lang.org/std/keyword.return.html) कीवर्ड का उपयोग करने की आवश्यकता नहीं होती है।
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_generate_stealth_address(stealth_address: &str) -> Option {
+```
+
+यह फ़ंक्शन एक सार्वजनिक मेटा-पता प्राप्त करता है, जिसमें _Vpub_ और _Kpub_ दोनों शामिल हैं। यह गोपनीय पता, प्रकाशित करने के लिए सार्वजनिक कुंजी (_Rpub_), और एक-बाइट स्कैन मान लौटाता है जो उन प्रकाशित पतों की पहचान को गति देता है जो एलिस के हो सकते हैं।
+
+स्कैन मान साझा रहस्य (_S = GRprivVpriv_) का हिस्सा है। यह मान एलिस के लिए उपलब्ध है, और इसकी जाँच करना यह जाँचने की तुलना में बहुत तेज़ है कि _f(Kpub+G\*hash(S))_ प्रकाशित पते के बराबर है या नहीं।
+
+```rust
+ let (address, r_pub, scan) =
+ generate_stealth_address(&str_to_array::<66>(stealth_address)?);
+```
+
+हम लाइब्रेरी के [`generate_stealth_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_address.html) का उपयोग करते हैं।
+
+```rust
+ format!("{{\"address\":\"{}\",\"rPub\":\"{}\",\"scan\":\"{}\"}}",
+ encode(address),
+ encode(r_pub),
+ encode(&[scan])
+ ).into()
+}
+```
+
+JSON-एन्कोडेड आउटपुट स्ट्रिंग तैयार करें।
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_compute_stealth_key(
+ address: &str,
+ bill_pub_key: &str,
+ view_private_key: &str,
+ spend_private_key: &str
+) -> Option {
+ .
+ .
+ .
+}
+```
+
+यह फ़ंक्शन लाइब्रेरी के [`compute_stealth_key`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.compute_stealth_key.html) का उपयोग पते से निकासी के लिए निजी कुंजी (_Rpriv_) की गणना करने के लिए करता है। इस गणना के लिए इन मानों की आवश्यकता होती है:
+
+- पता (_पता=f(Ppub)_)
+- बिल द्वारा उत्पन्न सार्वजनिक कुंजी (_Rpub_)
+- व्यू निजी कुंजी (_Vpriv_)
+- स्पेंड निजी कुंजी (_Kpriv_)
+
+```rust
+#[wasm_bindgen(start)]
+```
+
+[`#[wasm_bindgen(start)]`](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-rust-exports/start.html) निर्दिष्ट करता है कि फ़ंक्शन तब निष्पादित होता है जब WASM कोड प्रारंभ किया जाता है।
+
+```rust
+pub fn main() {
+ console_error_panic_hook::set_once();
+}
+```
+
+यह कोड निर्दिष्ट करता है कि पैनिक आउटपुट JavaScript कंसोल पर भेजा जाए। इसे क्रिया में देखने के लिए, एप्लिकेशन का उपयोग करें और बिल को एक अमान्य मेटा-पता दें (बस एक हेक्साडेसिमल अंक बदलें)। आपको JavaScript कंसोल में यह त्रुटि दिखाई देगी:
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs:701:9:
+assertion `left == right` failed
+ left: 0
+ right: 1
+```
+
+इसके बाद एक स्टैक ट्रेस होता है। फिर बिल को वैध मेटा-पता दें, और एलिस को या तो एक अमान्य पता या एक अमान्य सार्वजनिक कुंजी दें। आपको यह त्रुटि दिखाई देगी:
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/eth-stealth-addresses-0.1.0/src/lib.rs:78:9:
+keys do not generate stealth address
+```
+
+फिर से, एक स्टैक ट्रेस के बाद।
+
+#### यूज़र इंटरफ़ेस {#ui}
+
+यूज़र इंटरफ़ेस [React](https://react.dev/) का उपयोग करके लिखा गया है और [Vite](https://vite.dev/) द्वारा परोसा जाता है। आप [इस ट्यूटोरियल](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) का उपयोग करके उनके बारे में जान सकते हैं। यहाँ [WAGMI](https://wagmi.sh/) की कोई आवश्यकता नहीं है क्योंकि हम सीधे ब्लॉकचेन या वॉलेट के साथ इंटरैक्ट नहीं करते हैं।
+
+यूज़र इंटरफ़ेस का एकमात्र गैर-स्पष्ट हिस्सा WASM कनेक्टिविटी है। यह कैसे काम करता है, यह यहाँ बताया गया है।
+
+**`vite.config.js`**
+
+इस फ़ाइल में [Vite कॉन्फ़िगरेशन](https://vite.dev/config/) है।
+
+```js
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import wasm from "vite-plugin-wasm";
+
+// https://vite.dev/config/
+export default defineConfig({
+ plugins: [react(), wasm()],
+})
+```
+
+हमें दो Vite प्लगइन्स की आवश्यकता है: [react](https://www.npmjs.com/package/@vitejs/plugin-react) और [wasm](https://github.com/Menci/vite-plugin-wasm#readme)।
+
+**`App.jsx`**
+
+यह फ़ाइल एप्लिकेशन का मुख्य घटक है। यह एक कंटेनर है जिसमें दो घटक शामिल हैं: `Alice` और `Bill`, जो उन यूज़र्स के लिए यूज़र इंटरफ़ेस हैं। WASM के लिए प्रासंगिक भाग इनिशियलाइज़ेशन कोड है।
+
+```jsx
+import init from './rust-wasm/pkg/rust_wasm.js'
+```
+
+जब हम [`wasm-pack`](https://rustwasm.github.io/docs/wasm-pack/) का उपयोग करते हैं, तो यह दो फाइलें बनाता है जिनका हम यहां उपयोग करते हैं: वास्तविक कोड वाली एक wasm फ़ाइल (यहाँ, `src/rust-wasm/pkg/rust_wasm_bg.wasm`) और इसका उपयोग करने के लिए परिभाषाओं वाली एक JavaScript फ़ाइल (यहाँ, `src/rust-wasm/pkg/rust_wasm.js`)। उस JavaScript फ़ाइल का डिफ़ॉल्ट एक्सपोर्ट वह कोड है जिसे WASM शुरू करने के लिए चलाने की आवश्यकता होती है।
+
+```jsx
+function App() {
+ .
+ .
+ .
+ useEffect(() => {
+ const loadWasm = async () => {
+ try {
+ await init();
+ setWasmReady(true)
+ } catch (err) {
+ console.error('Error loading wasm:', err)
+ alert("Wasm error: " + err)
+ }
+ }
+
+ loadWasm()
+ }, []
+ )
+```
+
+[`useEffect` हुक](https://react.dev/reference/react/useEffect) आपको एक फ़ंक्शन निर्दिष्ट करने देता है जो स्टेट वैरिएबल बदलने पर निष्पादित होता है। यहाँ, स्टेट वैरिएबल की सूची खाली (`[]`) है, इसलिए यह फ़ंक्शन केवल एक बार निष्पादित होता है जब पेज लोड होता है।
+
+इफेक्ट फ़ंक्शन को तुरंत लौटना होगा। असिंक्रोनस कोड का उपयोग करने के लिए, जैसे कि WASM `init` (जिसे `.wasm` फ़ाइल लोड करनी होती है और इसलिए समय लगता है) हम एक आंतरिक [`async`](https://en.wikipedia.org/wiki/Async/await) फ़ंक्शन को परिभाषित करते हैं और इसे `await` के बिना चलाते हैं।
+
+**`Bill.jsx`**
+
+यह बिल के लिए यूज़र इंटरफ़ेस है। इसमें एक ही क्रिया है, जो एलिस द्वारा प्रदान किए गए गोपनीय मेटा-पते के आधार पर एक पता बनाना है।
+
+```jsx
+import { wasm_generate_stealth_address } from './rust-wasm/pkg/rust_wasm.js'
+```
+
+डिफ़ॉल्ट एक्सपोर्ट के अलावा, `wasm-pack` द्वारा उत्पन्न JavaScript कोड WASM कोड में प्रत्येक फ़ंक्शन के लिए एक फ़ंक्शन एक्सपोर्ट करता है।
+
+```jsx
+