👎🏿 📽️ 🍎 खनन और यह कैसे काम करता है: मैटरियल 🧙🏿 🎴 👩🏾‍💻

हाय% उपयोगकर्ता नाम%!
मैं बताऊंगा और दिखाऊंगा कि क्रिप्टोकरेंसी में पैसा पैदा करने का आधार कैसे काम करता है - खनन। पहला ब्लॉक कैसे बनाया जाता है, नए ब्लॉक और कैसे पैसा कहीं से भी बाहर आता है।
इसे समझना आसान बनाने के लिए, हम अपने इम्प्रोवाइज्ड माइनर को इंप्रोमेटु क्रिप्टोक्यूरेंसी हब्राकॉन के लिए लिखेंगे।

पहला, एक सरलीकृत शैक्षिक कार्यक्रम, जहां इसके बिना।

पर्स

प्रत्येक बटुआ एक बेतरतीब ढंग से उत्पन्न कुंजी जोड़ी है। दरअसल, वॉलेट एड्रेस पब्लिक की से एक हैश है। तो यह विशिष्ट रूप से पहचाना जा सकता है।

लेन-देन

यह एक रिकॉर्ड है कि किस वॉलेट में किस राशि को स्थानांतरित किया जाता है। और यह भी, ऑपरेशन का समय और तारीख। यह रिकॉर्ड (इसका हैश) प्रेषक की निजी कुंजी द्वारा हस्ताक्षरित है और पुष्टि की प्रत्याशा में जिले में सभी को भेजा गया है।

पुष्टीकरण

लेनदेन के बारे में जानने के लिए और सभी को इसे स्वयं रिकॉर्ड करने के लिए, आपको इसकी पुष्टि करने की आवश्यकता है, जिसे एक नया ब्लॉक बनाकर प्राप्त किया जाता है।

खंड

यह सर्विस डेटा + ट्रांजेक्शन लिस्ट + माइनर का वॉलेट नंबर + मैजिक नंबर है ।

ब्लॉक श्रृंखला

अनुक्रम जिसमें प्रत्येक बाद के ब्लॉक में पिछले एक की आईडी शामिल है।

शुरुआत

तो, एक निश्चित संख्या में लोग हैं, एक हो सकता है। चलो उसे हब्रोश कहते हैं। वह अपने हब्राकॉइन क्रिप्टोक्यूरेंसी सिस्टम को लॉन्च करने का फैसला करता है।

चूंकि इस मुद्रा में समर्पित सर्वर नहीं हैं, इसलिए इसके सभी प्रतिभागी समान हैं और किसी न किसी तरह से लेनदेन की वैधता पर सहमत होना चाहिए। यही है, हमें एक तंत्र की आवश्यकता होगी जो प्रदान करेगा:

लेन-देन की अनिवार्यता।
किसी को भी उनकी वैधता को सत्यापित करने की क्षमता।

ऐसा करने के लिए, वह वर्तमान में मौजूद अपुष्ट लेनदेन, पिछले ब्लॉक की संख्या, उसके बटुए की संख्या आदि से एक ब्लॉक बनाता है। हमारे पास पहले ब्लॉक के लिए कोई लेनदेन नहीं है, हमारे पास पिछले ब्लॉक की संख्या नहीं है, वास्तव में कुछ भी नहीं है। समय के साथ केवल हब्रोशी वॉलेट का पता और तारीख।

साथ ही, हाब्रॉन्ग एल्गोरिथम में निम्न बातों का संकेत दिया गया है।

यह सलाह दी जाती है कि हर 10 मिनट में एक बार नए ब्लॉक बनाए जाएं। यदि थोड़ी देर बाद हम देखते हैं, और यह पता चला है कि आवश्यकता से अधिक हैं, तो हर 100 ब्लॉकों में उनकी पीढ़ी की नई जटिलता की गणना करें
वैध ब्लॉक बनाने वाले किसी व्यक्ति के लिए, वे 50 हब्रासो + कमीशन के इनाम के हकदार हैं
"विजेता" वह ब्लॉक है जिसमें सबसे अधिक लेनदेन होता है

गति सीमा

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

क्रिप्टोकरेंसी में, जटिलता को सीमित करने की एक विधि का उपयोग किया जाता है, जिसमें किसी दिए गए मूल्य के हैश की गणना करने की समस्या होती है । अधिक सटीक होने के लिए, यह एक निश्चित मूल्य से कम है ।
अगर किसी को पता नहीं है, तो एक हैश, उदाहरण के लिए f7c9f52d1ebf8c6aef8986fb127ba1bdeec58521f7eb46f026b708df26940912, यह क्या है, लेकिन एक संख्या है। दशमलव प्रणाली में, यह 112078102004378042284884826242480806284022042488488848628408208468422468268028 जैसा दिखता है। यानी हैश की तुलना, जोड़ा, घटाया और सब किया जा सकता है।
तो यहाँ है। ब्लॉक को मान्य मानने के लिए सभी के लिए, इसका हैश अधिकतम संभावित शून्य से कम होना चाहिए, जिसे सभी द्वारा परिभाषित मूल्य कहा जाता है, जिसे जटिलता कहा जाता है ।
उदाहरण के लिए, हमारे पास 4 बाइट्स का हैश है, इसके FFFFFFFF का अधिकतम संभव मूल्य _{16 है} । और जटिलता, उदाहरण के लिए, 100 _{10 है} । एक को दूसरे से घटाते हुए, यह पता चलता है कि हमारा हैश FFFFFF9B ₁₆ से कम होना चाहिए

इसे कैसे प्राप्त किया जाए?

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

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

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

ब्लॉक 1-> ब्लॉक 2-> ब्लॉक 3 ए
ब्लॉक 1-> ब्लॉक 2-> ब्लॉक 3 बी

फिर जिस समय के लिए 4 ब्लॉक पाया जाएगा, वह आगे जीत जाएगा। एक छोटी श्रृंखला बाहर फेंक दी जाती है और इसके लेनदेन को फिर से पुष्टि के लिए कतारबद्ध किया जाता है।

आयोग

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

आइए स्थिति का अनुकरण करें और हब्रोश शिल्प को किसी प्रकार के ब्लॉक में मदद करें।

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

प्रोग्राम कोड

package com.paranoim.money;

import java.math.BigInteger;
import java.util.Arrays;

import junit.framework.TestCase;

import org.bouncycastle.crypto.params.ECPublicKeyParameters;
import org.bouncycastle.crypto.util.Pack;
import org.bouncycastle.math.ec.ECPoint;

import com.paranoim.TestsAll;
import com.paranoim.crypto.assymetric.ECDSA;
import com.paranoim.crypto.digest.SHA3_512;
import com.paranoim.crypto.utils.ByteUtils;

public class MiningTest extends TestCase
{

    
    private byte[] counter = new byte[4];

    private byte[] getAddressFromPublicKey(ECPublicKeyParameters publicKey)
    {
        ECPoint q = publicKey.getQ();
        byte[] encoded = q.getEncoded(true);
        return SHA3_512.process(encoded); // reciever's address is it's pubkic key hash
    }
    
    public void testMining()
    {
        ECPublicKeyParameters fromKey = (ECPublicKeyParameters) TestsAll.ALICE.getPublic();
        ECPublicKeyParameters toKey = (ECPublicKeyParameters) TestsAll.BOB.getPublic();
        
        
        byte[] from = getAddressFromPublicKey(fromKey);
        byte[] to = getAddressFromPublicKey(toKey);
        
        int amount = 100; //100 HabraCoin
        long now = System.currentTimeMillis();
        
        //compose the message for signing
        
        byte[] fromTo = ByteUtils.concat(from, to);
        
        byte[] bAmount = Pack.intToBigEndian(amount);
        byte[] bTime = Pack.longToBigEndian(now);
        
        byte[] amountAndTime = ByteUtils.concat(bAmount, bTime);
        
        byte[] msg = ByteUtils.concat(fromTo, amountAndTime);
        
        BigInteger[] sigCoords = ECDSA.signDigest(TestsAll.ALICE.getPrivate(), SHA3_512.process(msg));
        byte[] signature = ByteUtils.concat(sigCoords[0].toByteArray(), sigCoords[1].toByteArray());
        
        // MSG contains from, to, amount, time and signature
        msg = ByteUtils.concat(msg, signature); 
        
        
        ECPublicKeyParameters minersKey = (ECPublicKeyParameters) TestsAll.ALICE1.getPublic();
        byte[] bminersKey = getAddressFromPublicKey(minersKey);
        
        //msg = msg + miner's address
        msg = ByteUtils.concat(msg, bminersKey);
        
        byte[] hash = doTheMining(msg);
        
        msg = ByteUtils.concat(msg, counter);
        
        assertTrue(Arrays.equals(hash, SHA3_512.process(msg)));
                
    }

    private byte[] doTheMining(byte[] msg)
    {
        byte[] hash = SHA3_512.process(ByteUtils.concat(msg, counter));
        
        while(hash[0] != 0 || hash[1] != 0 )
        {
            incrementCounter();
            hash = SHA3_512.process(ByteUtils.concat(msg, counter));
        }
        
        return hash;
    }
    
    private  void incrementCounter()
    {
        for (int i = 0; i < counter .length; i++)
        {
            counter[i]++;
            if (counter[i] != 0)
                break;
        }
    }
}

:

1824B9ADF09908222CF65069FDE226D32F165B3CF71B7AA0039FDFEF75EAA61610909EBFFBAC023480FC87FCF640C4A
009B82C4A6D25A0F4B8A732AE54EF733E792681137BA378577DFDC2732D192DAF323966EAD4ADC9635D7A12EDD50E34
9F660622D186AF3C03BF7D265F2AA7EB125056F4BF45BE519E8B22B845B28065110000006400000142E5D667CB01CEE
EDD0AC15EC4C491819A99030BD5FEF7CD2B469F2B90BA13D7981EDCD0708353D13390B8564F496C44FAC2777B0AF79D
C94CBF36D0CC0F047E807889F34C4DC5FEB724699C257391F84F3DDD70B84F841D115F4EFEAF4E58779042F35257E5C
035046037DE740718D199A8F06AD7A58E37CCCD4CC5E95295DCC2C5F3C70847BD59FA57BCC5FF4B208F93948FCFD763
EC1E5C85B61C43EB64B77A9F53B28785D7DE2335333003260A0839D53927976751A8D8967B2BB325909D86E82BC4125
2A28ECF6F0E7476BB99B29585EB0E75410000

:

000008ACF935A8E3E453AC538706F560155943C6B0A77E5F5FCA7939D5FFE589676A6B3CD7AC78845786C50449D1A6F
91003EDCA7B5D8B12AC36CCA36A00844A

. , .

खनन और यह कैसे काम करता है: मैटरियल