Odată cu creșterea actuală a criptomonedelor, blockchain-ul creează un buzz în lumea tehnologiei. Această tehnologie a atras atât de multă atenție în principal datorită capacității sale de a garanta securitatea, de a aplica descentralizarea și de a accelera procesele către mai multe industrii – în special către industria financiară.

În esență, un blockchain este o bază de date publică care documentează și autentifică ireversibil posesia și transmiterea activelor digitale. Monedele digitale, precum Bitcoin și Ethereum, se bazează pe acest concept. Blockchain este o tehnologie interesantă pe care o puteți folosi pentru a transforma capacitățile aplicațiilor dvs.

În ultima vreme, am văzut guverne, organizații și persoane folosind tehnologia blockchain pentru a-și crea propriile criptomonede și pentru a evita să rămână în urmă. În special, atunci când Facebook și-a propus propria criptomonedă, numită Balanță, anunțul a agitat multe ape în întreaga lume.

Ce se întâmplă dacă ați putea urmări exemplul și puteți crea propria dvs. versiune a unei criptomonede?

M-am gândit la acest lucru și am decis să dezvolt un algoritm care creează o cripto.

Am decis să apelez la criptomonedă fccCoin.

În acest tutorial, voi ilustra procesul pas cu pas pe care l-am folosit pentru a construi moneda digitală (am folosit conceptele orientate obiect ale limbajului de programare Python).

Iată planul de bază al algoritmului blockchain pentru crearea fccCoin:

class Block:

    def __init__():

    #first block class

        pass
    
    def calculate_hash():
    
    #calculates the cryptographic hash of every block
        
    
class BlockChain:
    
    def __init__(self):
     # constructor method
    pass
    
    def construct_genesis(self):
        # constructs the initial block
        pass

    def construct_block(self, proof_no, prev_hash):
        # constructs a new block and adds it to the chain
        pass

    @staticmethod
    def check_validity():
        # checks whether the blockchain is valid
        pass

    def new_data(self, sender, recipient, quantity):
        # adds a new transaction to the data of the transactions
        pass

    @staticmethod
    def construct_proof_of_work(prev_proof):
        # protects the blockchain from attack
        pass
   
    @property
    def last_block(self):
        # returns the last block in the chain
        return self.chain[-1]

Acum, permiteți-mi să explic ce se întâmplă …

1. Construirea primei clase Block

Un blockchain cuprinde mai multe blocuri care sunt unite între ele (sună familiar, nu?).

Înlănțuirea blocurilor are loc astfel încât, dacă un bloc este modificat, restul lanțului devine invalid.

În aplicarea conceptului de mai sus, am creat următoarea clasă de blocuri inițiale:

import hashlib
import time

class Block:

    def __init__(self, index, proof_no, prev_hash, data, timestamp=None):
        self.index = index
        self.proof_no = proof_no
        self.prev_hash = prev_hash
        self.data = data
        self.timestamp = timestamp or time.time()

    @property
    def calculate_hash(self):
        block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no,
                                              self.prev_hash, self.data,
                                              self.timestamp)

        return hashlib.sha256(block_of_string.encode()).hexdigest()

    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_no,
                                               self.prev_hash, self.data,
                                               self.timestamp)

După cum puteți vedea din codul de mai sus, am definit fișierul __init __ () , care va fi executată când bloc clasa este inițiată, la fel ca în orice altă clasă Python.

Am furnizat următorii parametri funcției de inițiere:

  • de sine– aceasta se referă la instanța bloc clasă, făcând posibilă accesarea metodelor și atributelor asociate clasei;
  • index—Această ține evidența poziției blocului în cadrul blockchain-ului;
  • dovadă_nu— Acesta este numărul produs în timpul creării unui nou bloc (numit minerit);
  • prev_hash– aceasta se referă la hash-ul blocului anterior din lanț;
  • date—Acesta oferă o evidență a tuturor tranzacțiilor efectuate, cum ar fi cantitatea cumpărată;
  • timestamp-ul—Această plasează un timestamp pentru tranzacții.

A doua metodă din clasă, calculate_hash, va genera hashul blocurilor folosind valorile de mai sus. Modulul SHA-256 este importat în proiect pentru a ajuta la obținerea hashurilor blocurilor.

După ce valorile au fost introduse în algoritmul hash criptografic, funcția va returna un șir de 256 de biți reprezentând conținutul blocului.

Așa se realizează securitatea în blockchains – fiecare bloc va avea un hash și acel hash se va baza pe hash-ul blocului anterior.

Ca atare, dacă cineva încearcă să compromită orice bloc din lanț, celelalte blocuri vor avea hash-uri nevalide, ceea ce va duce la întreruperea întregii rețele blockchain.

În cele din urmă, un bloc va arăta astfel:

{
    "index": 2,
    "proof": 21,
    "prev_hash": "6e27587e8a27d6fe376d4fd9b4edc96c8890346579e5cbf558252b24a8257823",
    "transactions": [
        {'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1}
    ],
    "timestamp": 1521646442.4096143
}

2. Construirea clasei Blockchain

Ideea principală a unui blockchain, așa cum sugerează și numele, implică „înlănțuirea” mai multor blocuri între ele.

Prin urmare, voi construi un Blockchain clasă care va fi utilă în gestionarea funcționării întregului lanț. Aici va avea loc cea mai mare parte a acțiunii.

Blockchain clasa va avea diverse metode de asistență pentru îndeplinirea diverselor sarcini în blockchain.

Permiteți-mi să explic rolul fiecărei metode din clasă.

A. Metoda constructorului

Această metodă asigură instaurarea blockchain-ului.

class BlockChain:

    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.construct_genesis()

Iată rolurile atributelor sale:

  • sine.lant—Această variabilă păstrează toate blocurile;
  • self.date_current— Această variabilă păstrează toate tranzacțiile finalizate în bloc;
  • self.construct_genesis ()—Această metodă se va ocupa de construirea blocului inițial.

b. Construirea blocului genezei

Blockchain necesită un construct_genezie metoda de a construi blocul inițial în lanț. În convenția blockchain, acest bloc este special, deoarece simbolizează începutul blockchain-ului.

În acest caz, să-l construim pur și simplu trecând câteva valori implicite către construct_block metodă.

Le-am dat pe amândouă dovadă_nu și prev_hash o valoare zero, deși puteți furniza orice valoare doriți.

def construct_genesis(self):
    self.construct_block(proof_no=0, prev_hash=0)


def construct_block(self, proof_no, prev_hash):
    block = Block(
        index=len(self.chain),
        proof_no=proof_no,
        prev_hash=prev_hash,
        data=self.current_data)
    self.current_data = []

    self.chain.append(block)
    return block


c. Construirea de blocuri noi

construct_block metoda este utilizată pentru crearea de blocuri noi în blockchain.

Iată ce se întâmplă cu diferitele atribute ale acestei metode:

  • index—Această reprezintă lungimea blockchain-ului;
  • dovadă_nor & prev_hash—Metoda apelantului le trece;
  • date—Această conține o înregistrare a tuturor tranzacțiilor care nu sunt incluse în niciun bloc de pe nod;
  • self.date_current—Este folosit pentru a reseta lista tranzacțiilor de pe nod. Dacă a fost construit un bloc și tranzacțiile alocate acestuia, lista este resetată pentru a se asigura că viitoarele tranzacții sunt adăugate în această listă. Și acest proces va avea loc continuu;
  • self.chain.append () –această metodă îmbină blocurile nou construite la lanț;
  • întoarcere—În cele din urmă, se returnează un obiect bloc construit.

d. Verificarea validității

verificare_validitate metoda este importantă în evaluarea integrității blockchain-ului și în asigurarea absenței anomaliilor.

După cum sa menționat mai devreme, hashurile sunt esențiale pentru securitatea blockchain-ului, deoarece chiar și cea mai mică modificare a obiectului va duce la generarea unui hash complet nou.

Prin urmare, aceasta verificare_validitate utilizări ale metodei dacă declarații pentru a verifica dacă hash-ul fiecărui bloc este corect.

De asemenea, verifică dacă fiecare bloc indică blocul anterior din dreapta, prin compararea valorii hashurilor lor. Dacă totul este corect, se întoarce adevărat; în caz contrar, se întoarce fals.

@staticmethod
def check_validity(block, prev_block):
    if prev_block.index + 1 != block.index:
        return False

    elif prev_block.calculate_hash != block.prev_hash:
        return False

    elif not BlockChain.verifying_proof(block.proof_no, prev_block.proof_no):
        return False

    elif block.timestamp <= prev_block.timestamp:
        return False

    return True

e. Adăugarea datelor tranzacțiilor

date_nou metoda este utilizată pentru adăugarea datelor tranzacțiilor la un bloc. Este o metodă foarte simplă: acceptă trei parametri (detaliile expeditorului, detaliile destinatarului și cantitatea) și adaugă datele tranzacției la self.data_curent listă.

Ori de câte ori este creat un bloc nou, această listă este alocată blocului respectiv și se resetează încă o dată, așa cum se explică în construct_block metodă.

Odată ce datele de tranzacție au fost adăugate la listă, se returnează indexul următorului bloc care va fi creat.

Acest indice se calculează adăugând 1 la indexul blocului curent (care este ultimul din blockchain). Datele vor ajuta un utilizator să trimită tranzacția în viitor.

def new_data(self, sender, recipient, quantity):
    self.current_data.append({
        'sender': sender,
        'recipient': recipient,
        'quantity': quantity
    })
    return True


f. Adăugarea dovezii de muncă

Dovada muncii este un concept care previne abuzul de blockchain. Pur și simplu, obiectivul său este de a identifica un număr care rezolvă o problemă după ce se face o anumită cantitate de muncă de calcul.

Dacă nivelul de dificultate de identificare a numărului este ridicat, acesta descurajează spamul și manipularea blockchain-ului.

În acest caz, vom folosi un algoritm simplu care descurajează oamenii să extragă blocuri sau să creeze blocuri cu ușurință.

@staticmethod
def proof_of_work(last_proof):
    '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes
         f is the previous f'
         f' is the new proof
        '''
    proof_no = 0
    while BlockChain.verifying_proof(proof_no, last_proof) is False:
        proof_no += 1

    return proof_no


@staticmethod
def verifying_proof(last_proof, proof):
    #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes?

    guess = f'{last_proof}{proof}'.encode()
    guess_hash = hashlib.sha256(guess).hexdigest()
    return guess_hash[:4] == "0000"

g. Obținerea ultimului bloc

În cele din urmă, latest_block metoda este o metodă de ajutor care ajută la obținerea ultimului bloc din blockchain. Amintiți-vă că ultimul bloc este de fapt blocul actual din lanț.

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

Să însumăm totul împreună

Iată întregul cod pentru crearea fișierului fccCoin criptomonedă.

De asemenea, puteți obține codul acest depozit GitHub.

import hashlib
import time


class Block:

    def __init__(self, index, proof_no, prev_hash, data, timestamp=None):
        self.index = index
        self.proof_no = proof_no
        self.prev_hash = prev_hash
        self.data = data
        self.timestamp = timestamp or time.time()

    @property
    def calculate_hash(self):
        block_of_string = "{}{}{}{}{}".format(self.index, self.proof_no,
                                              self.prev_hash, self.data,
                                              self.timestamp)

        return hashlib.sha256(block_of_string.encode()).hexdigest()

    def __repr__(self):
        return "{} - {} - {} - {} - {}".format(self.index, self.proof_no,
                                               self.prev_hash, self.data,
                                               self.timestamp)


class BlockChain:

    def __init__(self):
        self.chain = []
        self.current_data = []
        self.nodes = set()
        self.construct_genesis()

    def construct_genesis(self):
        self.construct_block(proof_no=0, prev_hash=0)

    def construct_block(self, proof_no, prev_hash):
        block = Block(
            index=len(self.chain),
            proof_no=proof_no,
            prev_hash=prev_hash,
            data=self.current_data)
        self.current_data = []

        self.chain.append(block)
        return block

    @staticmethod
    def check_validity(block, prev_block):
        if prev_block.index + 1 != block.index:
            return False

        elif prev_block.calculate_hash != block.prev_hash:
            return False

        elif not BlockChain.verifying_proof(block.proof_no,
                                            prev_block.proof_no):
            return False

        elif block.timestamp <= prev_block.timestamp:
            return False

        return True

    def new_data(self, sender, recipient, quantity):
        self.current_data.append({
            'sender': sender,
            'recipient': recipient,
            'quantity': quantity
        })
        return True

    @staticmethod
    def proof_of_work(last_proof):
        '''this simple algorithm identifies a number f' such that hash(ff') contain 4 leading zeroes
         f is the previous f'
         f' is the new proof
        '''
        proof_no = 0
        while BlockChain.verifying_proof(proof_no, last_proof) is False:
            proof_no += 1

        return proof_no

    @staticmethod
    def verifying_proof(last_proof, proof):
        #verifying the proof: does hash(last_proof, proof) contain 4 leading zeroes?

        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

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

    def block_mining(self, details_miner):

        self.new_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_no = last_block.proof_no
        proof_no = self.proof_of_work(last_proof_no)

        last_hash = last_block.calculate_hash
        block = self.construct_block(proof_no, last_hash)

        return vars(block)

    def create_node(self, address):
        self.nodes.add(address)
        return True

    @staticmethod
    def obtain_block_object(block_data):
        #obtains block object from the block data

        return Block(
            block_data['index'],
            block_data['proof_no'],
            block_data['prev_hash'],
            block_data['data'],
            timestamp=block_data['timestamp'])

Acum, să testăm codul nostru pentru a vedea dacă funcționează.

blockchain = BlockChain()

print("***Mining fccCoin about to start***")
print(blockchain.chain)

last_block = blockchain.latest_block
last_proof_no = last_block.proof_no
proof_no = blockchain.proof_of_work(last_proof_no)

blockchain.new_data(
    sender="0",  #it implies that this node has created a new block
    recipient="Quincy Larson",  #let's send Quincy some coins!
    quantity=
    1,  #creating a new block (or identifying the proof number) is awarded with 1
)

last_hash = last_block.calculate_hash
block = blockchain.construct_block(proof_no, last_hash)

print("***Mining fccCoin has been successful***")
print(blockchain.chain)

A mers!

Iată rezultatul procesului minier:

***Mining fccCoin about to start***
[0 - 0 - 0 - [] - 1566930640.2707076]
***Mining fccCoin has been successful***
[0 - 0 - 0 - [] - 1566930640.2707076, 1 - 88914 - a8d45cb77cddeac750a9439d629f394da442672e56edfe05827b5e41f4ba0138 - [{'sender': '0', 'recipient': 'Quincy Larson', 'quantity': 1}] - 1566930640.5363243]


Concluzie

Iată-l!

Așa puteți crea propriul blockchain folosind Python.

Permiteți-mi să spun că acest tutorial demonstrează doar conceptele de bază pentru a vă uda picioarele în tehnologia inovatoare blockchain.

Dacă această monedă au fost implementate ca atare, nu a putut satisface cerințele actuale ale pieței pentru o criptomonedă stabilă, sigură și ușor de utilizat.

Prin urmare, poate fi în continuare îmbunătățit prin adăugarea de caracteristici suplimentare pentru a-și spori capacitățile de exploatare și expediere tranzactii financiare.

Cu toate acestea, este un bun punct de plecare dacă vă decideți să vă faceți cunoscut numele în lumea uimitoare a cryptos.

Dacă aveți orice comentarii sau întrebări, vă rugăm să le postați mai jos.

Codificare fericită (cripto)!