परिचय :

शून्य-ज्ञान प्रमाण निजी, सुरक्षित लेनदेन को सक्षम बनाते हैं। ZkSNARKs और zkSTARKs के साथ, एक कहावत वास्तविक डेटा का खुलासा किए बिना एक सत्यापनकर्ता को कुछ जानकारी का अधिकार साबित कर सकती है।

इसमें गुमनामी और गोपनीयता की बहुत बड़ी संभावना है। लेकिन zkSTARKs और zkSNARKs जटिल हैं। Risc0 उन्हें अधिक सुलभ बनाता है। आइए देखें कि यह बहुत ही बुनियादी कार्यान्वयन है:

यह ट्यूटोरियल कवर करेगा:

• Risc0 की स्थापना

• रस्ट का उपयोग करके अपना पहला शून्य-ज्ञान प्रमाण कार्यक्रम लिखना

  
  

पूर्वावश्यकताएँ:

• शॉर्टकट कॉपी पेस्ट करें

• आवश्यक स्थापनाएँ:

  • जंग लगी भाषा
  • कार्गो टोकरा

• जंग में कुछ बुनियादी कोडिंग ज्ञान

• कोड संपादक (यदि संभव हो तो VSCODE)

  
  

अंत तक, आपको Risc0 में शून्य-ज्ञान प्रमाणों के साथ व्यावहारिक अनुभव होगा। किसी उन्नत गणित या क्रिप्टोग्राफी पृष्ठभूमि की आवश्यकता नहीं है।

हम वास्तविक दुनिया के समाधानों का निर्माण शुरू करने के लिए कोडिंग अनिवार्यताओं पर ध्यान केंद्रित करेंगे। इस व्यावहारिक परिचय का उद्देश्य शक्तिशाली गोपनीयता तकनीक को किसी भी डेवलपर के लिए समझने योग्य बनाना है।

इंस्टालेशन :

• (MacOS के लिए) जंग और कार्गो को स्थापित करने के लिए, आप टर्मिनल में नीचे दिए गए कमांड को चला सकते हैं:

  curl [https://sh.rustup.rs](https://sh.rustup.rs/) -sSf | sh

• Risc0 को स्थापित करने के लिए, आप रस्ट की स्थापना के बाद नीचे दिए गए कमांड को चलाएँ और टर्मिनल को पुनरारंभ करें:

  cargo install cargo-risczero

• उपरोक्त आदेशों को सफलतापूर्वक बनाने के लिए, आपको आवश्यक निर्भरताएँ स्थापित करनी होंगी। brew install openssl brew install pkgconf

• इसके बाद, हमें risc0 टूलचेन को इनस्टॉल करना होगा: cargo risczero install

हमें बस यही चाहिए। तो, आइए कोड संपादक की ओर चलें।

कुछ जादुई पंक्तियाँ लिखना:

अब जब हमने इंस्टॉलेशन पूरा कर लिया है तो आप इन अबरा कदबरा 🪄 चरणों को पढ़ सकते हैं और उनका अनुसरण कर सकते हैं:

1. कोड संपादक खोलें और संपादक के टर्मिनल में उस स्थान पर जाएं जहां आप अपना प्रोजेक्ट बनाना चाहते हैं।

   
   

2. टर्मिनल में नीचे दिए गए कमांड का उपयोग करके प्रोजेक्ट का एक नया उदाहरण बनाएं: cargo risczero new multiply ।

   
   

   

3. आपको मल्टीप्ल नामक एक फ़ोल्डर बना हुआ दिखाई देना चाहिए। इसमें सीडी. cd multiply

   
   

4. फ़ोल्डर संरचना बहुत सरल है.

   
   

   1. हमारे पास एक होस्ट फ़ोल्डर और एक मेथड फ़ोल्डर है।

      
      

   2. होस्ट फ़ोल्डर में होस्ट प्रोग्राम होता है जिसे हम गेस्ट प्रोग्राम कहते हैं। यदि आप चाहें तो इसमें सत्यापित करने की क्षमता भी है।

      
      

   3. मेथड्स फ़ोल्डर में अतिथि प्रोग्राम होता है जिसमें zkvm एप्लिकेशन का वह भाग होता है जो सिद्ध हो जाता है। यह होस्ट से इनपुट पैरामीटर प्राप्त करता है, फिर तर्क के आधार पर, यह परिणाम उत्पन्न करता है, उन्हें जर्नल में भेजता है, और उन्हें रसीद के रूप में होस्ट को भेजता है।

      
      

   4. बाकी फाइलों को आवश्यकतानुसार चलते-फिरते समझाया जाएगा।

   

5. आइये अतिथि कार्यक्रम से शुरुआत करते हैं।

   
   

   1. आइए फ़ाइलों का नाम बदलें main.rs —> multiply.rs ।

      

      

   2. src फोल्डर में bin नाम का एक फोल्डर बनाएं और उसमें mutiply.rs ले जाएं। आपकी फ़ोल्डर संरचना कुछ इस तरह दिखनी चाहिए:

      

   3. Cargo.toml खोलें और अपडेट name = "method_name” —> name = "multiply” में बदलें।

      

   4. नीचे दिया गया कोड Cargo.toml में जोड़ें।

       [[bin]] name = "multiply" path = "src/bin/multiply.rs"

   5. तो आपका अंतिम Cargo.toml इस तरह दिखेगा:

      

   6. अब, multiply.rs खोलें। यहां हम मुख्य फ़ंक्शन को संपादित करेंगे। यह वह फ़ंक्शन है जिसे zkvm में निष्पादित किया जाएगा।

      
      

      1. नीचे दिए गए कोड में, हम होस्ट प्रोग्राम से इनपुट ले रहे हैं। फिर हम यह सुनिश्चित कर रहे हैं कि इनपुट तुच्छ कारक नहीं है जो कि 1 है। फिर हम उत्पाद की गणना करते हैं और अंत में इसे प्रोग्राम के होस्ट को वापस सौंप देते हैं।

          // We will get the values for these variables from host program let a:u64 = env::read(); let b:u64 = env::read(); // To avoid trivial factors like multiplication by 1 if a == 1 || b == 1 { panic!("Trivial factors !!") // The panic! macro in Rust is used to intentionally crash a program when an unrecoverable error occurs } // Caculate the product of the two numbers let product = a.checked_mul(b).expect("Integer Overflow"); // Commit back the output to the host to save it as receipt env::commit(&product);

      2. उपरोक्त परिवर्तनों के बाद, आपका multiply.rs इस तरह दिखना चाहिए।

         

   7. Cargo.toml ऑफ़ methods फ़ोल्डर में एक और अंतिम परिवर्तन है।

      

   8. name = "multiply-methods” का मान खोलें और अपडेट करें।

      
      

   9. आपका अंतिम Cargo.toml नीचे जैसा दिखेगा।

      

   10. यहां हमारा काम पूरा हो गया है.

   11. अब, होस्ट प्रोग्राम पर चलते हैं।

       1. आपका होस्ट फ़ोल्डर अब इस तरह दिख रहा होगा।

          

       2. हम main.rs दो फ़ाइलों में विभाजित करना चाहते हैं जो कि prover.rs और verify.rs हैं।

          
          

       3. src के अंतर्गत एक नया फ़ोल्डर बनाएं और इसे bin नाम दें।

          
          

       4. main.rs हटाएँ। फ़ाइलें बनाएं और उन्हें verify.rs & prove.rs नाम दें।

          
          

       5. अब आपकी फ़ोल्डर संरचना कुछ इस तरह दिखनी चाहिए।

          

       6. prove.rs खोलें, और कोडिंग शुरू करें:

          
          

       7. नीचे दिया गया कोड जोड़ें. ये वे आयात हैं जिनकी हमें आवश्यकता होगी।

           use multiply_methods::MULTIPLY_ELF; // It is a binary file of multiply_method use risc0_zkvm::{ default_prover, serde::{from_slice, to_vec}, ExecutorEnv, };

          
          

       8. आइए मुख्य फ़ंक्शन में परिवर्तन करें।

           fn main() { // Declaring our secret input params let a: u64 = 17; let b: u64 = 23; // First, we construct an executor environment let env = ExecutorEnv::builder() .add_input(&to_vec(&a).unwrap()) // Passing the input params to environment so it can be used by gues proggram .add_input(&to_vec(&b).unwrap()) .build() .unwrap(); // Obtain the default prover. let prover = default_prover(); // Produce a receipt by proving the specified ELF binary. let receipt = prover.prove_elf(env, MULTIPLY_ELF).unwrap(); // Extract journal of receipt (ie output c, where c = a * b) let c: u64 = from_slice(&receipt.journal).unwrap(); // Print an assertion println!("Hello, world! I know the factors of {}, and I can prove it!", c); // Let's serialize the receipt so we can save it to an file for verifier program to verify. let serialized = bincode::serialize(&receipt).unwrap(); // Writing the serialized contect to receipt.bin file let _saved_file = match std::fs::write("./receipt.bin", serialized){ Ok(()) => println!("Receipt saved and serialized as receipt.bin"), Err(_) => println!("Something went wrong !!"), }; }

          
          

       9. आपका अंतिम prove.rs इस तरह दिखना चाहिए।

          

       10. आइए खोलें और हमारे verify.rs में कोड जोड़ें।

           
           

       11. यहां, हम अतिथि कार्यक्रम छवि आईडी और कुछ बुनियादी आयात आयात करेंगे।

            use multiply_methods::MULTIPLY_ID; use risc0_zkvm::Receipt;

           
           

       12. आइए मुख्य फ़ंक्शन में परिवर्तन करें।

            fn main(){ // Let's impor the receipt that was generated by prove let receipt_path ="./receipt.bin".to_string(); let receipt_file = std::fs::read(receipt_path).unwrap(); // As we has serialized the receipt we need to desrialize it let receipt = bincode::deserialize::<Receipt>(&receipt_file).unwrap(); // Let's verify if the receipt that was generated was not created tampered with let _verification = match receipt.verify(MULTIPLY_ID){ Ok(()) => println!("Proof is Valid"), Err(_) => println!("Something went wrong !!"), }; }

           
           

       13. आपका अंतिम verify.rs कुछ इस तरह दिखना चाहिए।

           

       14. मैं वादा करता हूं कि ये अंतिम बदलाव हैं। अब, हम लगभग पूरा कर चुके हैं।

           
           

       15. host फ़ोल्डर में Cargo.toml खोलें, और निर्भरता के अंतर्गत नीचे दिए गए परिवर्तन करें।

           

            multiply-methods = { path = "../methods" }

       16. आपका Cargo.toml इस तरह दिखेगा।

           

   12. अंततः यह देखने का समय आ गया है कि हमारा कोड काम करता है या नहीं।

       
       

   13. प्रोजेक्ट की रूट डायरेक्टरी में अपने कंसोल को सक्रिय करें, और console cargo run --release --bin prove में नीचे दिए गए कमांड को चलाएँ

       
       

   14. यह आदेश सत्यापनकर्ता के लिए प्रमाण और रसीद उत्पन्न करेगा।

       
       

       पहली बार चलने पर इसमें काफी समय लगेगा। इसलिए चिंता न करें जब तक कि यह पूरा न हो जाए, एक कॉफी ले लें।

       
       

       

   15. एक बार यह हो जाने के बाद, यदि आप चाहें, तो अपने द्वारा जनरेट की गई रसीद को सत्यापित कर सकते हैं। उसके लिए, यह कमांड cargo run --release --bin verify चलाएँ

       
       

       पहली बार चलने पर इसमें काफी समय लगेगा। इसलिए चिंता न करें जब तक कि यह पूरा न हो जाए, एक कॉफी ले लें।

       
       

       

   बधाई हो !!! Risc0 का उपयोग करके अपना पहला ZK ऐप लिखने पर। यदि आपको किसी सहायता की आवश्यकता है, तो कृपया मुझे एक टिप्पणी छोड़ें, और मैं आपसे संपर्क करूंगा।