Building Search users in Github Created with Flask, PipEnv, Heroku

Search in Github

Here search for users in Github and other stuff!

This app is working with,

  • Data Github API
  • BackEnd Flask
  • Language Python
  • Package manager PipEnv
  • Hosted Heroku
  • Source on Github

Where to see

Open us-search.herokuapp.com.

Contribute

For small changes, open an issue or do it by yourself.

How to run

  • First clone it and go to the directory. Run pipenv shell.

This project is using PipEnv. Don't run pip3 install.

$ git clone https://github.com/BlackIQ/UG-Search
$ cd covid
$ pipenv shell
  • Export variables and run Flask app.
$ export FLASK_APP=wsgi.py
$ export FLASK_ENV=development
$ flask run
  • After go to 127.0.0.1:5000 in your broswer.

ScreenShot

Some screenshots

ScreenShot

ScreenShot

ScreenShot

Hacktoberfest

Now is October 12 and here is Hacktoberfest. Contribute on this project to get label.

License

This project is licensed under GPL-3 license

TODO

  •  Front-End design
  •  Deploy
  •  Search organization
  •  Search repository

Download Details:
Author: BlackIQ
Source Code: https://github.com/BlackIQ/UG-Search
License: GPL-3.0 License

#python #flask #github #heroku #PipEnv

What is GEEK

Buddha Community

Building Search users in Github Created with Flask, PipEnv, Heroku

Building Search users in Github Created with Flask, PipEnv, Heroku

Search in Github

Here search for users in Github and other stuff!

This app is working with,

  • Data Github API
  • BackEnd Flask
  • Language Python
  • Package manager PipEnv
  • Hosted Heroku
  • Source on Github

Where to see

Open us-search.herokuapp.com.

Contribute

For small changes, open an issue or do it by yourself.

How to run

  • First clone it and go to the directory. Run pipenv shell.

This project is using PipEnv. Don't run pip3 install.

$ git clone https://github.com/BlackIQ/UG-Search
$ cd covid
$ pipenv shell
  • Export variables and run Flask app.
$ export FLASK_APP=wsgi.py
$ export FLASK_ENV=development
$ flask run
  • After go to 127.0.0.1:5000 in your broswer.

ScreenShot

Some screenshots

ScreenShot

ScreenShot

ScreenShot

Hacktoberfest

Now is October 12 and here is Hacktoberfest. Contribute on this project to get label.

License

This project is licensed under GPL-3 license

TODO

  •  Front-End design
  •  Deploy
  •  Search organization
  •  Search repository

Download Details:
Author: BlackIQ
Source Code: https://github.com/BlackIQ/UG-Search
License: GPL-3.0 License

#python #flask #github #heroku #PipEnv

Riyad Amin

Riyad Amin

1571046022

Build Your Own Cryptocurrency Blockchain in Python

Cryptocurrency is a decentralized digital currency that uses encryption techniques to regulate the generation of currency units and to verify the transfer of funds. Anonymity, decentralization, and security are among its main features. Cryptocurrency is not regulated or tracked by any centralized authority, government, or bank.

Blockchain, a decentralized peer-to-peer (P2P) network, which is comprised of data blocks, is an integral part of cryptocurrency. These blocks chronologically store information about transactions and adhere to a protocol for inter-node communication and validating new blocks. The data recorded in blocks cannot be altered without the alteration of all subsequent blocks.

In this article, we are going to explain how you can create a simple blockchain using the Python programming language.

Here is the basic blueprint of the Python class we’ll use for creating the blockchain:

class Block(object):
    def __init__():
        pass
    #initial structure of the block class 
    def compute_hash():
        pass
    #producing the cryptographic hash of each block 
  class BlockChain(object):
    def __init__(self):
    #building the chain
    def build_genesis(self):
        pass
    #creating the initial block
    def build_block(self, proof_number, previous_hash):
        pass
    #builds new block and adds to the chain
   @staticmethod
    def confirm_validity(block, previous_block):
        pass
    #checks whether the blockchain is valid
    def get_data(self, sender, receiver, amount):
        pass
    # declares data of transactions
    @staticmethod
    def proof_of_work(last_proof):
        pass
    #adds to the security of the blockchain
    @property
    def latest_block(self):
        pass
    #returns the last block in the chain

Now, let’s explain how the blockchain class works.

Initial Structure of the Block Class

Here is the code for our initial block class:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()

As you can see above, the class constructor or initiation method ( init()) above takes the following parameters:

self — just like any other Python class, this parameter is used to refer to the class itself. Any variable associated with the class can be accessed using it.

index — it’s used to track the position of a block within the blockchain.

previous_hash — it used to reference the hash of the previous block within the blockchain.

data—it gives details of the transactions done, for example, the amount bought.

timestamp—it inserts a timestamp for all the transactions performed.

The second method in the class, compute_hash , is used to produce the cryptographic hash of each block based on the above values.

As you can see, we imported the SHA-256 algorithm into the cryptocurrency blockchain project to help in getting the hashes of the blocks.

Once the values have been placed inside the hashing module, the algorithm will return a 256-bit string denoting the contents of the block.

So, this is what gives the blockchain immutability. Since each block will be represented by a hash, which will be computed from the hash of the previous block, corrupting any block in the chain will make the other blocks have invalid hashes, resulting in breakage of the whole blockchain network.

Building the Chain

The whole concept of a blockchain is based on the fact that the blocks are “chained” to each other. Now, we’ll create a blockchain class that will play the critical role of managing the entire chain.

It will keep the transactions data and include other helper methods for completing various roles, such as adding new blocks.

Let’s talk about the helper methods.

Adding the Constructor Method

Here is the code:

class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()

The init() constructor method is what instantiates the blockchain.

Here are the roles of its attributes:

self.chain — this variable stores all the blocks.

self.current_data — this variable stores information about the transactions in the block.

self.build_genesis() — this method is used to create the initial block in the chain.

Building the Genesis Block

The build_genesis() method is used for creating the initial block in the chain, that is, a block without any predecessors. The genesis block is what represents the beginning of the blockchain.

To create it, we’ll call the build_block() method and give it some default values. The parameters proof_number and previous_hash are both given a value of zero, though you can give them any value you desire.

Here is the code:

def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
 def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block

Confirming Validity of the Blockchain

The confirm_validity method is critical in examining the integrity of the blockchain and making sure inconsistencies are lacking.

As explained earlier, hashes are pivotal for realizing the security of the cryptocurrency blockchain, because any slight alteration in an object will result in the creation of an entirely different hash.

Thus, the confirm_validity method utilizes a series of if statements to assess whether the hash of each block has been compromised.

Furthermore, it also compares the hash values of every two successive blocks to identify any anomalies. If the chain is working properly, it returns true; otherwise, it returns false.

Here is the code:

def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True

Declaring Data of Transactions

The get_data method is important in declaring the data of transactions on a block. This method takes three parameters (sender’s information, receiver’s information, and amount) and adds the transaction data to the self.current_data list.

Here is the code:

def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True

Effecting the Proof of Work

In blockchain technology, Proof of Work (PoW) refers to the complexity involved in mining or generating new blocks on the blockchain.

For example, the PoW can be implemented by identifying a number that solves a problem whenever a user completes some computing work. Anyone on the blockchain network should find the number complex to identify but easy to verify — this is the main concept of PoW.

This way, it discourages spamming and compromising the integrity of the network.

In this article, we’ll illustrate how to include a Proof of Work algorithm in a blockchain cryptocurrency project.

Finalizing With the Last Block

Finally, the latest_block() helper method is used for retrieving the last block on the network, which is actually the current block.

Here is the code:

def latest_block(self):
        return self.chain[-1]

Implementing Blockchain Mining

Now, this is the most exciting section!

Initially, the transactions are kept in a list of unverified transactions. Mining refers to the process of placing the unverified transactions in a block and solving the PoW problem. It can be referred to as the computing work involved in verifying the transactions.

If everything has been figured out correctly, a block is created or mined and joined together with the others in the blockchain. If users have successfully mined a block, they are often rewarded for using their computing resources to solve the PoW problem.

Here is the mining method in this simple cryptocurrency blockchain project:

def block_mining(self, details_miner):
            self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awarded with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)

Summary

Here is the whole code for our crypto blockchain class in Python:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()
    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()
    def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
    def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block
    @staticmethod
    def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True
    def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True        
    @staticmethod
    def proof_of_work(last_proof):
        pass
    @property
    def latest_block(self):
        return self.chain[-1]
    def chain_validity(self):
        pass        
    def block_mining(self, details_miner):       
        self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awared with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)  
    def create_node(self, address):
        self.nodes.add(address)
        return True
    @staticmethod
    def get_block_object(block_data):        
        return Block(
            block_data['index'],
            block_data['proof_number'],
            block_data['previous_hash'],
            block_data['data'],
            timestamp=block_data['timestamp']
        )
blockchain = BlockChain()
print("GET READY MINING ABOUT TO START")
print(blockchain.chain)
last_block = blockchain.latest_block
last_proof_number = last_block.proof_number
proof_number = blockchain.proof_of_work(last_proof_number)
blockchain.get_data(
    sender="0", #this means that this node has constructed another block
    receiver="LiveEdu.tv", 
    amount=1, #building a new block (or figuring out the proof number) is awarded with 1
)
last_hash = last_block.compute_hash
block = blockchain.build_block(proof_number, last_hash)
print("WOW, MINING HAS BEEN SUCCESSFUL!")
print(blockchain.chain)

Now, let’s try to run our code to see if we can generate some digital coins…

Wow, it worked!

Conclusion

That is it!

We hope that this article has assisted you to understand the underlying technology that powers cryptocurrencies such as Bitcoin and Ethereum.

We just illustrated the basic ideas for making your feet wet in the innovative blockchain technology. The project above can still be enhanced by incorporating other features to make it more useful and robust.

Learn More

Thanks for reading !

Do you have any comments or questions? Please share them below.

#python #cryptocurrency

Erstellen Sie Ihre eigene Kryptowährungs-Blockchain in Python

Kryptowährung ist eine dezentralisierte digitale Währung, die Verschlüsselungstechniken verwendet, um die Erzeugung von Währungseinheiten zu regulieren und den Geldtransfer zu überprüfen. Anonymität, Dezentralisierung und Sicherheit gehören zu seinen Hauptmerkmalen. Kryptowährung wird von keiner zentralisierten Behörde, Regierung oder Bank reguliert oder verfolgt.

Blockchain, ein dezentralisiertes Peer-to-Peer (P2P)-Netzwerk, das aus Datenblöcken besteht, ist ein wesentlicher Bestandteil der Kryptowährung. Diese Blöcke speichern chronologisch Informationen über Transaktionen und halten sich an ein Protokoll für die Kommunikation zwischen Knoten und die Validierung neuer Blöcke. Die in Blöcken aufgezeichneten Daten können nicht geändert werden, ohne dass alle nachfolgenden Blöcke geändert werden.

In diesem Artikel erklären wir, wie Sie mit der Programmiersprache Python eine einfache Blockchain erstellen können.

Hier ist die grundlegende Blaupause der Python-Klasse, die wir zum Erstellen der Blockchain verwenden:

class Block(object):
    def __init__():
        pass
    #initial structure of the block class 
    def compute_hash():
        pass
    #producing the cryptographic hash of each block 
  class BlockChain(object):
    def __init__(self):
    #building the chain
    def build_genesis(self):
        pass
    #creating the initial block
    def build_block(self, proof_number, previous_hash):
        pass
    #builds new block and adds to the chain
   @staticmethod
    def confirm_validity(block, previous_block):
        pass
    #checks whether the blockchain is valid
    def get_data(self, sender, receiver, amount):
        pass
    # declares data of transactions
    @staticmethod
    def proof_of_work(last_proof):
        pass
    #adds to the security of the blockchain
    @property
    def latest_block(self):
        pass
    #returns the last block in the chain

Lassen Sie uns nun erklären, wie die Blockchain-Klasse funktioniert.

Ausgangsstruktur der Blockklasse

Hier ist der Code für unsere anfängliche Blockklasse:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()

Wie Sie oben sehen können, nimmt der Klassenkonstruktor oder die Initiationsmethode ( init ()) die folgenden Parameter an:

self— Wie jede andere Python-Klasse wird dieser Parameter verwendet, um auf die Klasse selbst zu verweisen. Auf jede Variable, die der Klasse zugeordnet ist, kann über sie zugegriffen werden.

index — Es wird verwendet, um die Position eines Blocks innerhalb der Blockchain zu verfolgen.

previous_hash — Es wurde verwendet, um auf den Hash des vorherigen Blocks innerhalb der Blockchain zu verweisen.

data—it gibt Details zu den getätigten Transaktionen an, zum Beispiel den gekauften Betrag.

timestamp—it fügt einen Zeitstempel für alle durchgeführten Transaktionen ein.

Die zweite Methode in der Klasse, compute_hash , wird verwendet, um den kryptografischen Hash jedes Blocks basierend auf den obigen Werten zu erzeugen.

Wie Sie sehen können, haben wir den SHA-256-Algorithmus in das Kryptowährungs-Blockchain-Projekt importiert, um die Hashes der Blöcke zu erhalten.

Sobald die Werte im Hashing-Modul platziert wurden, gibt der Algorithmus einen 256-Bit-String zurück, der den Inhalt des Blocks angibt.

Das ist es, was der Blockchain Unveränderlichkeit verleiht. Da jeder Block durch einen Hash repräsentiert wird, der aus dem Hash des vorherigen Blocks berechnet wird, führt die Beschädigung eines Blocks in der Kette dazu, dass die anderen Blöcke ungültige Hashes haben, was zum Bruch des gesamten Blockchain-Netzwerks führt.

Aufbau der Kette

Das ganze Konzept einer Blockchain basiert darauf, dass die Blöcke aneinander „verkettet“ sind. Jetzt erstellen wir eine Blockchain-Klasse, die die entscheidende Rolle bei der Verwaltung der gesamten Kette spielt.

Es behält die Transaktionsdaten bei und enthält andere Hilfsmethoden zum Vervollständigen verschiedener Rollen, z. B. das Hinzufügen neuer Blöcke.

Sprechen wir über die Hilfsmethoden.

Hinzufügen der Konstruktormethode

Hier ist der Code:

class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()

Die Konstruktormethode init () instanziiert die Blockchain.

Hier sind die Rollen seiner Attribute:

self.chain — Diese Variable speichert alle Blöcke.

self.current_data — Diese Variable speichert Informationen über die Transaktionen im Block.

self.build_genesis() — Diese Methode wird verwendet, um den Anfangsblock in der Kette zu erstellen.

Aufbau des Genesis-Blocks

Die build_genesis()Methode wird verwendet, um den Anfangsblock in der Kette zu erstellen, dh einen Block ohne Vorgänger. Der Genesis-Block ist der Anfang der Blockchain.

Um es zu erstellen, rufen wir die build_block()Methode auf und geben ihr einige Standardwerte. Die Parameter proof_numberund previous_hasherhalten beide den Wert Null, Sie können ihnen jedoch jeden beliebigen Wert zuweisen.

Hier ist der Code:

def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
 def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block

Bestätigung der Gültigkeit der Blockchain

Die confirm_validityMethode ist entscheidend, um die Integrität der Blockchain zu überprüfen und sicherzustellen, dass Inkonsistenzen fehlen.

Wie bereits erwähnt, sind Hashes von entscheidender Bedeutung für die Realisierung der Sicherheit der Kryptowährungs-Blockchain, da jede geringfügige Änderung an einem Objekt zur Erstellung eines völlig anderen Hashs führt.

Somit verwendet das confirm_validityVerfahren eine Reihe von if-Anweisungen, um zu beurteilen, ob der Hash jedes Blocks kompromittiert wurde.

Darüber hinaus vergleicht es auch die Hash-Werte von jeweils zwei aufeinanderfolgenden Blöcken, um Anomalien zu identifizieren. Wenn die Kette richtig funktioniert, gibt sie true zurück; Andernfalls wird false zurückgegeben.

Hier ist der Code:

def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True

Deklarieren von Transaktionsdaten

Die get_dataMethode ist wichtig, um die Daten von Transaktionen in einem Block zu deklarieren. Diese Methode verwendet drei Parameter (Absenderinformationen, Empfängerinformationen und Betrag) und fügt die Transaktionsdaten zur Liste self.current_data hinzu.

Hier ist der Code:

def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True

Bewirken des Arbeitsnachweises

In der Blockchain-Technologie bezieht sich Proof of Work (PoW) auf die Komplexität, die mit dem Mining oder der Generierung neuer Blöcke auf der Blockchain verbunden ist.

Zum Beispiel kann das PoW implementiert werden, indem eine Zahl identifiziert wird, die ein Problem löst, wenn ein Benutzer eine Rechenarbeit abschließt. Jeder im Blockchain-Netzwerk sollte den Zahlenkomplex identifizieren, aber leicht zu überprüfen finden – dies ist das Hauptkonzept von PoW.

Auf diese Weise verhindert es Spam und gefährdet die Integrität des Netzwerks.

In diesem Artikel veranschaulichen wir, wie Sie einen Proof of Work-Algorithmus in ein Blockchain-Kryptowährungsprojekt einbinden.

Abschluss mit dem letzten Block

Schließlich wird die Hilfsmethode Latest_block() verwendet, um den letzten Block im Netzwerk abzurufen, der tatsächlich der aktuelle Block ist.

Hier ist der Code:

def latest_block(self):
        return self.chain[-1]

Implementieren von Blockchain-Mining

Das ist jetzt der spannendste Abschnitt!

Anfänglich werden die Transaktionen in einer Liste nicht verifizierter Transaktionen geführt. Mining bezieht sich auf den Prozess, die ungeprüften Transaktionen in einen Block zu legen und das PoW-Problem zu lösen. Es kann als die Rechenarbeit bezeichnet werden, die bei der Überprüfung der Transaktionen beteiligt ist.

Wenn alles richtig herausgefunden wurde, wird ein Block erstellt oder abgebaut und mit den anderen in der Blockchain zusammengefügt. Wenn Benutzer einen Block erfolgreich abgebaut haben, werden sie oft dafür belohnt, dass sie ihre Computerressourcen zur Lösung des PoW-Problems verwenden.

Hier ist die Mining-Methode in diesem einfachen Kryptowährungs-Blockchain-Projekt:

def block_mining(self, details_miner):
            self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awarded with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)

Zusammenfassung

Hier ist der gesamte Code für unsere Krypto-Blockchain-Klasse in Python:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()
    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()
    def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
    def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block
    @staticmethod
    def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True
    def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True        
    @staticmethod
    def proof_of_work(last_proof):
        pass
    @property
    def latest_block(self):
        return self.chain[-1]
    def chain_validity(self):
        pass        
    def block_mining(self, details_miner):       
        self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awared with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)  
    def create_node(self, address):
        self.nodes.add(address)
        return True
    @staticmethod
    def get_block_object(block_data):        
        return Block(
            block_data['index'],
            block_data['proof_number'],
            block_data['previous_hash'],
            block_data['data'],
            timestamp=block_data['timestamp']
        )
blockchain = BlockChain()
print("GET READY MINING ABOUT TO START")
print(blockchain.chain)
last_block = blockchain.latest_block
last_proof_number = last_block.proof_number
proof_number = blockchain.proof_of_work(last_proof_number)
blockchain.get_data(
    sender="0", #this means that this node has constructed another block
    receiver="LiveEdu.tv", 
    amount=1, #building a new block (or figuring out the proof number) is awarded with 1
)
last_hash = last_block.compute_hash
block = blockchain.build_block(proof_number, last_hash)
print("WOW, MINING HAS BEEN SUCCESSFUL!")
print(blockchain.chain)

Lassen Sie uns nun versuchen, unseren Code auszuführen, um zu sehen, ob wir einige digitale Münzen generieren können ...

Wow, es hat funktioniert!

Abschluss

Das ist es!

Wir hoffen, dass dieser Artikel Ihnen geholfen hat, die zugrunde liegende Technologie zu verstehen, die Kryptowährungen wie Bitcoin und Ethereum antreibt.

Wir haben gerade die Grundideen veranschaulicht, um Ihre Füße in der innovativen Blockchain-Technologie nass zu machen. Das obige Projekt kann noch verbessert werden, indem andere Funktionen integriert werden, um es nützlicher und robuster zu machen.

Crie seu próprio blockchain de criptomoeda em Python

A criptomoeda é uma moeda digital descentralizada que usa técnicas de criptografia para regular a geração de unidades monetárias e para verificar a transferência de fundos. Anonimato, descentralização e segurança estão entre suas principais características. A criptomoeda não é regulamentada ou rastreada por nenhuma autoridade centralizada, governo ou banco.

Blockchain, uma rede ponto a ponto descentralizada (P2P), que é composta por blocos de dados, é parte integrante da criptomoeda. Esses blocos armazenam cronologicamente informações sobre transações e aderem a um protocolo para comunicação entre nós e validação de novos blocos. Os dados gravados em blocos não podem ser alterados sem a alteração de todos os blocos subsequentes.

Neste artigo, vamos explicar como você pode criar um blockchain simples usando a linguagem de programação Python.

Aqui está o projeto básico da classe Python que usaremos para criar o blockchain:

class Block(object):
    def __init__():
        pass
    #initial structure of the block class 
    def compute_hash():
        pass
    #producing the cryptographic hash of each block 
  class BlockChain(object):
    def __init__(self):
    #building the chain
    def build_genesis(self):
        pass
    #creating the initial block
    def build_block(self, proof_number, previous_hash):
        pass
    #builds new block and adds to the chain
   @staticmethod
    def confirm_validity(block, previous_block):
        pass
    #checks whether the blockchain is valid
    def get_data(self, sender, receiver, amount):
        pass
    # declares data of transactions
    @staticmethod
    def proof_of_work(last_proof):
        pass
    #adds to the security of the blockchain
    @property
    def latest_block(self):
        pass
    #returns the last block in the chain

Agora, vamos explicar como a classe blockchain funciona.

Estrutura Inicial da Classe de Bloco

Aqui está o código para nossa classe de bloco inicial:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()

Como você pode ver acima, o construtor de classe ou método de iniciação ( init ()) acima usa os seguintes parâmetros:

self- assim como qualquer outra classe Python, este parâmetro é usado para se referir à própria classe. Qualquer variável associada à classe pode ser acessada usando-a.

index - é usado para rastrear a posição de um bloco dentro do blockchain.

previous_hash - usado para fazer referência ao hash do bloco anterior dentro do blockchain.

data—it dá detalhes das transações realizadas, por exemplo, a quantidade comprada.

timestamp—it insere um carimbo de data / hora para todas as transações realizadas.

O segundo método da classe, compute_hash, é usado para produzir o hash criptográfico de cada bloco com base nos valores acima.

Como você pode ver, importamos o algoritmo SHA-256 para o projeto blockchain de criptomoeda para ajudar a obter os hashes dos blocos.

Uma vez que os valores tenham sido colocados dentro do módulo de hashing, o algoritmo retornará uma string de 256 bits denotando o conteúdo do bloco.

Então, é isso que dá imutabilidade ao blockchain. Como cada bloco será representado por um hash, que será calculado a partir do hash do bloco anterior, corromper qualquer bloco da cadeia fará com que os outros blocos tenham hashes inválidos, resultando na quebra de toda a rede do blockchain.

Construindo a Rede

Todo o conceito de blockchain é baseado no fato de que os blocos são “encadeados” entre si. Agora, criaremos uma classe blockchain que desempenhará a função crítica de gerenciar toda a cadeia.

Ele manterá os dados das transações e incluirá outros métodos auxiliares para completar várias funções, como adicionar novos blocos.

Vamos falar sobre os métodos auxiliares.

Adicionando o Método do Construtor

Aqui está o código:

class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()

O método do construtor init () é o que instancia o blockchain.

Aqui estão as funções de seus atributos:

self.chain - esta variável armazena todos os blocos.

self.current_data - esta variável armazena informações sobre as transações no bloco.

self.build_genesis () - este método é usado para criar o bloco inicial na cadeia.

Construindo o Bloco Genesis

O build_genesis()método é usado para criar o bloco inicial da cadeia, ou seja, um bloco sem predecessores. O bloco de gênese é o que representa o início do blockchain.

Para criá-lo, chamaremos o build_block()método e forneceremos alguns valores padrão. Os parâmetros proof_numbere previous_hashrecebem o valor zero, embora você possa fornecer qualquer valor que desejar.

Aqui está o código:

def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
 def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block

Confirmando a Validade do Blockchain

O confirm_validitymétodo é fundamental para examinar a integridade do blockchain e garantir que haja inconsistências.

Conforme explicado anteriormente, os hashes são essenciais para realizar a segurança do blockchain da criptomoeda, porque qualquer pequena alteração em um objeto resultará na criação de um hash totalmente diferente.

Assim, o confirm_validitymétodo utiliza uma série de declarações if para avaliar se o hash de cada bloco foi comprometido.

Além disso, ele também compara os valores de hash de cada dois blocos sucessivos para identificar quaisquer anomalias. Se a cadeia estiver funcionando corretamente, ele retorna verdadeiro; caso contrário, retorna falso.

Aqui está o código:

def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True

Declaração de dados de transações

O get_datamétodo é importante para declarar os dados das transações em um bloco. Este método usa três parâmetros (informações do remetente, informações do receptor e quantidade) e adiciona os dados da transação à lista self.current_data.

Aqui está o código:

def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True

Efetuando a Prova de Trabalho

Na tecnologia blockchain, Prova de Trabalho (PoW) se refere à complexidade envolvida na mineração ou geração de novos blocos no blockchain.

Por exemplo, o PoW pode ser implementado identificando um número que resolve um problema sempre que um usuário conclui algum trabalho de computação. Qualquer pessoa na rede blockchain deve achar o número complexo de identificar, mas fácil de verificar - este é o conceito principal de PoW.

Dessa forma, desestimula o spamming e compromete a integridade da rede.

Neste artigo, ilustraremos como incluir um algoritmo de Prova de Trabalho em um projeto de criptomoeda blockchain.

Finalizando com o Último Bloco

Finalmente, o método auxiliar latest_block () é usado para recuperar o último bloco na rede, que é na verdade o bloco atual.

Aqui está o código:

def latest_block(self):
        return self.chain[-1]

Implementando Blockchain Mining

Agora, esta é a seção mais emocionante!

Inicialmente, as transações são mantidas em uma lista de transações não verificadas. Mineração se refere ao processo de colocar as transações não verificadas em um bloco e resolver o problema de PoW. Pode ser referido como o trabalho de computação envolvido na verificação das transações.

Se tudo foi descoberto corretamente, um bloco é criado ou extraído e unido com os outros no blockchain. Se os usuários extraíram um bloco com sucesso, eles geralmente são recompensados ​​por usar seus recursos de computação para resolver o problema de PoW.

Aqui está o método de mineração neste projeto simples de blockchain de criptomoeda:

def block_mining(self, details_miner):
            self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awarded with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)

Resumo

Aqui está todo o código para nossa classe crypto blockchain em Python:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()
    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()
    def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
    def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block
    @staticmethod
    def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True
    def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True        
    @staticmethod
    def proof_of_work(last_proof):
        pass
    @property
    def latest_block(self):
        return self.chain[-1]
    def chain_validity(self):
        pass        
    def block_mining(self, details_miner):       
        self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awared with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)  
    def create_node(self, address):
        self.nodes.add(address)
        return True
    @staticmethod
    def get_block_object(block_data):        
        return Block(
            block_data['index'],
            block_data['proof_number'],
            block_data['previous_hash'],
            block_data['data'],
            timestamp=block_data['timestamp']
        )
blockchain = BlockChain()
print("GET READY MINING ABOUT TO START")
print(blockchain.chain)
last_block = blockchain.latest_block
last_proof_number = last_block.proof_number
proof_number = blockchain.proof_of_work(last_proof_number)
blockchain.get_data(
    sender="0", #this means that this node has constructed another block
    receiver="LiveEdu.tv", 
    amount=1, #building a new block (or figuring out the proof number) is awarded with 1
)
last_hash = last_block.compute_hash
block = blockchain.build_block(proof_number, last_hash)
print("WOW, MINING HAS BEEN SUCCESSFUL!")
print(blockchain.chain)

Agora, vamos tentar executar nosso código para ver se podemos gerar algumas moedas digitais ...

Uau, funcionou!

Conclusão

É isso!

Esperamos que este artigo tenha ajudado você a entender a tecnologia subjacente que alimenta criptomoedas como Bitcoin e Ethereum.

Acabamos de ilustrar as idéias básicas para deixar seus pés molhados na tecnologia inovadora de blockchain. O projeto acima ainda pode ser aprimorado incorporando outros recursos para torná-lo mais útil e robusto.

Создайте свой собственный блокчейн криптовалюты на Python

Криптовалюта - это децентрализованная цифровая валюта, в которой используются методы шифрования для регулирования генерации денежных единиц и проверки перевода средств. Анонимность, децентрализация и безопасность - одни из его основных характеристик. Криптовалюта не регулируется и не отслеживается каким-либо централизованным органом, правительством или банком.

Блокчейн, децентрализованная одноранговая (P2P) сеть, состоящая из блоков данных, является неотъемлемой частью криптовалюты. Эти блоки хранят информацию о транзакциях в хронологическом порядке и придерживаются протокола для межузловой связи и проверки новых блоков. Данные, записанные в блоках, не могут быть изменены без изменения всех последующих блоков.

В этой статье мы собираемся объяснить, как создать простой блокчейн с помощью языка программирования Python.

Вот базовый план класса Python, который мы будем использовать для создания блокчейна:

class Block(object):
    def __init__():
        pass
    #initial structure of the block class 
    def compute_hash():
        pass
    #producing the cryptographic hash of each block 
  class BlockChain(object):
    def __init__(self):
    #building the chain
    def build_genesis(self):
        pass
    #creating the initial block
    def build_block(self, proof_number, previous_hash):
        pass
    #builds new block and adds to the chain
   @staticmethod
    def confirm_validity(block, previous_block):
        pass
    #checks whether the blockchain is valid
    def get_data(self, sender, receiver, amount):
        pass
    # declares data of transactions
    @staticmethod
    def proof_of_work(last_proof):
        pass
    #adds to the security of the blockchain
    @property
    def latest_block(self):
        pass
    #returns the last block in the chain

Теперь давайте объясним, как работает класс блокчейна.

Начальная структура класса блоков

Вот код нашего начального класса блока:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()

Как вы можете видеть выше, конструктор класса или метод инициации ( init ()) выше принимает следующие параметры:

self- как и любой другой класс Python, этот параметр используется для ссылки на сам класс. С его помощью можно получить доступ к любой переменной, связанной с классом.

index - он используется для отслеживания положения блока в цепочке блоков.

previous_hash - он использовался для ссылки на хэш предыдущего блока в цепочке блоков.

data—it предоставляет подробную информацию о проведенных транзакциях, например, купленную сумму.

timestamp—it вставляет отметку времени для всех выполненных транзакций.

Второй метод в классе, compute_hash, используется для создания криптографического хэша каждого блока на основе вышеуказанных значений.

Как видите, мы импортировали алгоритм SHA-256 в проект блокчейна криптовалюты, чтобы помочь в получении хэшей блоков.

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

Итак, это то, что дает неизменяемость блокчейна. Поскольку каждый блок будет представлен хешем, который будет вычисляться из хеша предыдущего блока, повреждение любого блока в цепочке приведет к тому, что другие блоки будут иметь недопустимые хеши, что приведет к поломке всей сети блокчейна.

Построение цепочки

Вся концепция блокчейна основана на том факте, что блоки «связаны» друг с другом. Теперь мы создадим класс цепочки блоков, который будет играть важную роль в управлении всей цепочкой.

Он будет хранить данные транзакций и включать другие вспомогательные методы для выполнения различных ролей, таких как добавление новых блоков.

Поговорим о вспомогательных методах.

Добавление метода конструктора

Вот код:

class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()

Метод конструктора init () - это то, что создает экземпляр блокчейна.

Вот роли его атрибутов:

self.chain - в этой переменной хранятся все блоки.

self.current_data - в этой переменной хранится информация о транзакциях в блоке.

self.build_genesis () - этот метод используется для создания начального блока в цепочке.

Создание блока генезиса

build_genesis()Метод используется для создания начального блока в цепочке, то есть, блок без каких - либо предшественников. Блок генезиса - это то, что представляет собой начало блокчейна.

Чтобы создать его, мы вызовем build_block()метод и дадим ему значения по умолчанию. Оба параметра proof_numberи previous_hashимеют нулевое значение, хотя вы можете присвоить им любое значение, которое пожелаете.

Вот код:

def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
 def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block

Подтверждение действительности блокчейна

Этот confirm_validityметод имеет решающее значение для проверки целостности цепочки блоков и проверки отсутствия несоответствий.

Как объяснялось ранее, хэши имеют решающее значение для обеспечения безопасности блокчейна криптовалюты, потому что любое небольшое изменение в объекте приведет к созданию совершенно другого хэша.

Таким образом, confirm_validityметод использует серию операторов if для оценки того, был ли скомпрометирован хэш каждого блока.

Кроме того, он также сравнивает хеш-значения каждых двух последовательных блоков для выявления любых аномалий. Если цепочка работает правильно, возвращается истина; в противном случае возвращается false.

Вот код:

def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True

Объявление данных транзакций

get_dataМетод имеет важное значение в объявлении данных об операциях на блоке. Этот метод принимает три параметра (информацию об отправителе, информацию о получателе и сумму) и добавляет данные транзакции в список self.current_data.

Вот код:

def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True

Выполнение доказательства работы

В технологии блокчейн Proof of Work (PoW) относится к сложности, связанной с майнингом или генерацией новых блоков в блокчейне.

Например, PoW может быть реализован путем определения числа, которое решает проблему всякий раз, когда пользователь выполняет некоторую вычислительную работу. Любой в сети блокчейн должен найти номер сложным для идентификации, но легким для проверки - это основная концепция PoW.

Таким образом, это препятствует распространению спама и нарушению целостности сети.

В этой статье мы покажем, как включить алгоритм Proof of Work в проект криптовалюты на блокчейне.

Завершение с последним блоком

Наконец, вспомогательный метод latest_block () используется для получения последнего блока в сети, который на самом деле является текущим блоком.

Вот код:

def latest_block(self):
        return self.chain[-1]

Внедрение Blockchain Mining

Теперь это самый интересный раздел!

Изначально транзакции хранятся в списке непроверенных транзакций. Майнинг относится к процессу размещения непроверенных транзакций в блоке и решения проблемы PoW. Это можно назвать вычислительной работой, связанной с проверкой транзакций.

Если все было правильно выяснено, блок создается или добывается и объединяется вместе с другими в цепочке блоков. Если пользователи успешно добыли блок, они часто получают вознаграждение за использование своих вычислительных ресурсов для решения проблемы PoW.

Вот метод майнинга в этом простом проекте блокчейна криптовалюты:

def block_mining(self, details_miner):
            self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awarded with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)

Резюме

Вот весь код нашего класса криптоблокчейна на Python:

import hashlib
import time
class Block(object):
    def __init__(self, index, proof_number, previous_hash, data, timestamp=None):
        self.index = index
        self.proof_number = proof_number
        self.previous_hash = previous_hash
        self.data = data
        self.timestamp = timestamp or time.time()
    @property
    def compute_hash(self):
        string_block = "{}{}{}{}{}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
        return hashlib.sha256(string_block.encode()).hexdigest()
    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_number, self.previous_hash, self.data, self.timestamp)
class BlockChain(object):
    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.build_genesis()
    def build_genesis(self):
        self.build_block(proof_number=0, previous_hash=0)
    def build_block(self, proof_number, previous_hash):
        block = Block(
            index=len(self.chain),
            proof_number=proof_number,
            previous_hash=previous_hash,
            data=self.current_data
        )
        self.current_data = []  
        self.chain.append(block)
        return block
    @staticmethod
    def confirm_validity(block, previous_block):
        if previous_block.index + 1 != block.index:
            return False
        elif previous_block.compute_hash != block.previous_hash:
            return False
        elif block.timestamp <= previous_block.timestamp:
            return False
        return True
    def get_data(self, sender, receiver, amount):
        self.current_data.append({
            'sender': sender,
            'receiver': receiver,
            'amount': amount
        })
        return True        
    @staticmethod
    def proof_of_work(last_proof):
        pass
    @property
    def latest_block(self):
        return self.chain[-1]
    def chain_validity(self):
        pass        
    def block_mining(self, details_miner):       
        self.get_data(
            sender="0", #it implies that this node has created a new block
            receiver=details_miner,
            quantity=1, #creating a new block (or identifying the proof number) is awared with 1
        )
        last_block = self.latest_block
        last_proof_number = last_block.proof_number
        proof_number = self.proof_of_work(last_proof_number)
        last_hash = last_block.compute_hash
        block = self.build_block(proof_number, last_hash)
        return vars(block)  
    def create_node(self, address):
        self.nodes.add(address)
        return True
    @staticmethod
    def get_block_object(block_data):        
        return Block(
            block_data['index'],
            block_data['proof_number'],
            block_data['previous_hash'],
            block_data['data'],
            timestamp=block_data['timestamp']
        )
blockchain = BlockChain()
print("GET READY MINING ABOUT TO START")
print(blockchain.chain)
last_block = blockchain.latest_block
last_proof_number = last_block.proof_number
proof_number = blockchain.proof_of_work(last_proof_number)
blockchain.get_data(
    sender="0", #this means that this node has constructed another block
    receiver="LiveEdu.tv", 
    amount=1, #building a new block (or figuring out the proof number) is awarded with 1
)
last_hash = last_block.compute_hash
block = blockchain.build_block(proof_number, last_hash)
print("WOW, MINING HAS BEEN SUCCESSFUL!")
print(blockchain.chain)

Теперь давайте попробуем запустить наш код, чтобы посмотреть, сможем ли мы сгенерировать несколько цифровых монет ...

Вау, сработало!

Заключение

Вот и все!

Мы надеемся, что эта статья помогла вам понять базовую технологию, на которой работают такие криптовалюты, как Биткойн и Эфириум.

Мы просто проиллюстрировали основные идеи, как сделать ваши ноги влажными в инновационной технологии блокчейн. Вышеупомянутый проект все еще можно улучшить, добавив другие функции, чтобы сделать его более полезным и надежным.