actualiează nod

nod actualizat

Dockerfile

@@ -0,0 +1,12 @@
+FROM ubuntu:latest
+
+RUN apt update
+RUN apt upgrade -y
+RUN apt install -y python3-dev python3-pip 
+
+COPY . .
+
+RUN python3 -m pip install -r requirements.txt
+
+# CMD python3 -m Registru.bloc 2>&1 && python3 -m pytest Registru/testări 2>&1
+RUN python3 -m Registru.aplicație

Registru/ComunicareSocket.py

@@ -0,0 +1,20 @@
+from p2pnetwork.node import Node
+
+class ComunicareSocket(Node):
+
+    def __init__(self, ip, port):
+        super(ComunicareSocket, self).__init__(ip, port, None)
+
+    def startSocket(self):
+        self.start()
+
+    def inbound_node_connected(self, connected_node):
+        print('inbound connection')
+        self.send_to_node(connected_node, 'Hi, I am Straight !')
+
+    def outbound_node_connected(self, connected_node):
+        print('outbound connection')
+        self.send_to_node(connected_node, 'Hi, I am the node that initialized the connection !')
+
+    def node_message(self, connected_node, message):
+        print(message)

Registru/aplicație/__init__.py

@@ -0,0 +1,188 @@
+import json
+import random
+import requests
+import os
+import time
+
+from flask import Flask, jsonify, request
+
+from Registru.portofel.portofel import Portofel
+from Registru.portofel.tranzacție import Tranzacție
+from Registru.portofel.mină import Mină
+from Registru.sistem import Registrul
+from Registru.pubsub import PubSub
+
+from multiprocessing import Process
+
+import threading
+import time
+import queue
+
+aplicație = Flask(__name__)
+
+registru = Registrul()
+
+cheie_geneză_privată = Portofel.din_cheie(Portofel,f"C:\\Users\\jovre\\Documents\\GitHub\\sistem\\sistem\\Registru\\utile\\chei\\cheie_privată.pem")
+cheie_geneză_publică = cheie_geneză_privată.public_key()
+portofel = Portofel(registru)
+portofel.cheie_privată = cheie_geneză_privată
+portofel.cheie_publică = cheie_geneză_publică
+portofel.serializează_cheie_publică()
+
+mină = Mină()
+pubsub = PubSub(registru, mină)
+
+data_queue = queue.Queue()
+
+URL = 'https://fe60-82-77-240-24.ngrok-free.app'
+
+@aplicație.route('/')
+def default():
+    PORT_RĂDĂCINĂ=5000
+
+    rezultat = requests.get(f'https://fe60-82-77-240-24.ngrok-free.app/registru')
+
+    rezultat_registru = registru.din_json(rezultat.json())
+
+    try:
+        registru.înlocuiește_listă(rezultat_registru.listă)
+        print('\nRegistrul s-a sincronizat !')
+    except Exception as e:
+        print(f'\nRegistrul nu s-a sincronizat, eroare {e}')
+
+    return f"Welcome To Individual Freedom ! REGISTRUL ARE {len(str(rezultat_registru.to_json()).encode('utf-8'))/1000}"
+
+
+@aplicație.route('/registru')
+def route_registru():
+    return jsonify(registru.to_json())
+
+@aplicație.route('/registru/minează')
+def route_adăugare_bloc():
+
+    blue =  random.randint(0,10000000000) & 255
+    green = (random.randint(0,10000000000) >> 8) & 255
+    red =   (random.randint(0,10000000000) >> 16) & 255
+
+    informații = mină.informații_tranzacții()
+
+    informații.append(Tranzacție.răsplătește_tranzacție(portofel).to_json())
+
+    registru.adaugă_bloc(['#%02x%02x%02x' % (red, green, blue), informații])
+    pubsub.transmite_bloc(registru.listă[-1])
+
+    return jsonify(registru.listă[-1].to_json())
+
+@aplicație.route('/registru/minează/consensus', methods=['POST'])
+def route_adăugare_bloc_consensus():
+
+    start = time.time()
+
+    informații_tranzacție = request.get_json()
+
+    portofel = informații_tranzacție['plătitor']
+    portofel = Portofel.din_json(Portofel,portofel)
+    portofel.registru = Registrul.din_json(portofel.registru)
+
+    blue =  random.randint(0,10000000000) & 255
+    green = (random.randint(0,10000000000) >> 8) & 255
+    red =   (random.randint(0,10000000000) >> 16) & 255
+
+    informații = mină.informații_tranzacții()
+    informații.append(Tranzacție.răsplătește_tranzacție(portofel).to_json())
+    registru.adaugă_bloc(['#%02x%02x%02x' % (red, green, blue), informații])
+    print({f'durată_consensus: {time.time()-start}'})
+    return {'status': 200}
+
+
+@aplicație.route('/portofel/trimite', methods=['POST'])
+def route_portofel_transact():
+
+    informații_tranzacție = request.get_json()
+
+    portofel = informații_tranzacție['plătitor']
+    portofel = Portofel.din_json(Portofel,portofel)
+    portofel.registru = Registrul.din_json(portofel.registru)
+    tranzacția = mină.tranzacție_existentă(portofel.adresă)
+
+
+    if tranzacția:
+        tranzacția.actualizează(portofel, informații_tranzacție['beneficiar'], informații_tranzacție['sumă'])
+    elif 'plătitor' in informații_tranzacție.keys():
+        if informații_tranzacție['plătitor'] == informații_tranzacție['beneficiar']:
+            tranzacția = Tranzacție(informații_tranzacție['plătitor'],informații_tranzacție['beneficiar'],informații_tranzacție['sumă'] )
+        else:
+            tranzacția = Tranzacție(portofel, informații_tranzacție['beneficiar'], informații_tranzacție['sumă'])
+    else: 
+        tranzacția = Tranzacție(portofel, informații_tranzacție['beneficiar'], informații_tranzacție['sumă'])
+
+    pubsub.transmitere_trazacție(tranzacția)
+    e_necesar_îndeplinitor = mină.e_necesar_îndeplinitor()
+
+    if e_necesar_îndeplinitor:
+        îndeplinitor = registru.următor_îndeplinitor()
+        portofel = Portofel(registru)
+        portofel.registru = portofel.registru.to_json()
+        portofel.cheie_privată = []
+        portofel.cheie_publică = îndeplinitor
+        portofel.serializează_cheie_publică()
+
+        bloc = requests.post(f'{URL}/registru/minează/consensus', json={'plătitor': portofel.to_json()}).json()
+
+    return jsonify(tranzacția.to_json())
+
+
+def transmitere_date():
+
+    pubsub.transmitere_tranzacție(Tranzacție.din_json(data_queue.get()))
+
+def pornire_threads():
+
+    [threading.Thread(target=transmitere_date).start() for i in range(8)]
+
+@aplicație.route('/portofel/trimite/tranzacții', methods=['POST'])
+def route_portofel_tranzacții():
+
+    start = time.time()
+    informații_tranzacție = request.get_json()
+
+    [data_queue.put(trx) for trx in informații_tranzacție['tranzacții']]
+    print(f'date procesate {time.time()-start}')  
+    pornire_threads()
+
+    e_necesar_îndeplinitor = mină.e_necesar_îndeplinitor()
+
+    if e_necesar_îndeplinitor:
+        îndeplinitor = registru.următor_îndeplinitor()
+        portofel = Portofel(registru)
+        portofel.registru = portofel.registru.to_json()
+        portofel.cheie_privată = []
+        portofel.cheie_publică = îndeplinitor
+        portofel.serializează_cheie_publică()
+
+        bloc = requests.post(f'{URL}/registru/minează/consensus', json={'plătitor': portofel.to_json()}).json()
+
+    print({'durată_tranzacții': time.time() - start})
+    return {'status': 200}
+
+@aplicație.route('/portofel/info')
+def route_portofel_info():
+    return jsonify({'adresă': portofel.adresă, 'total': portofel.sumă})
+
+
+PORT_RĂDĂCINĂ = 5000
+PORT = PORT_RĂDĂCINĂ
+if 'True' in os.environ.get('PEER'):
+    PORT = random.randint(5001,35000)
+
+    rezultat = requests.get(f'https://fe60-82-77-240-24.ngrok-free.app/registru')
+
+    rezultat_registru = registru.din_json(rezultat.json())
+
+    try:
+        registru.înlocuiește_listă(rezultat_registru.listă)
+        print('\nRegistrul s-a sincronizat !')
+    except Exception as e:
+        print(f'\nRegistrul nu s-a sincronizat, eroare {e}')
+
+aplicație.run(port=PORT)

Registru/bloc.py

@@ -0,0 +1,136 @@
+import json
+import time
+
+
+from Registru.utile.algoritm_hash import creează_hash
+from Registru.utile.hex_binar import hex_binar
+from Registru.configurare import RATA
+
+INFORMAȚII_GENESIS = {
+    'dată': 1,
+    'ultimul_hash': 'ultimul_hash_geneză',
+    'hash': 'hash_geneză',
+    'informații':[],
+    'dificultate': 3,
+    'nonce': 'nonce-geneză'
+}
+class Bloc:
+    """
+    Bloc: o unitate de stocare.
+    Stochează tranzacții într-un registru care suportă o cryptomonedă.
+    """
+    def __init__(self,dată, ultimul_hash, hash, informații, dificultate, nonce):
+        self.dată = dată
+        self.ultimul_hash = ultimul_hash
+        self.hash = hash
+        self.informații = informații
+        self.dificultate = dificultate
+        self.nonce = nonce
+
+    def __repr__(self):
+        return ( 
+            'Bloc('
+            f'dată: {self.dată}, '
+            f'ultimul_hash: {self.ultimul_hash}, '
+            f'hash: {self.hash}, '
+            f'informații: {self.informații}, '
+            f'dificultate: {self.dificultate}, '
+            f'nonce: {self.nonce})'
+        )
+
+    def __eq__(self,other):
+        return self.__dict__ == other.__dict__
+
+    def to_json(self):
+        return self.__dict__
+
+    def din_json(bloc_json):
+        return Bloc(**bloc_json)
+
+    @staticmethod
+    def minează_bloc(ultimul_bloc, informații):
+
+        """
+        Minează un Bloc bazat pe ultimul bloc și data, pâmă când un hash este găsit conform cerințelor de 0-uri .
+        """
+        dată = time.time_ns()
+
+        ultimul_hash = ultimul_bloc.hash
+        dificultate = Bloc.adjustă_dificultatea(ultimul_bloc, dată)
+        nonce = 0
+        hash = creează_hash(dată,ultimul_hash,informații, dificultate, nonce)
+
+        while hex_binar(hash)[0:dificultate] != '0' * dificultate:
+            nonce += 1
+            dată = time.time_ns()
+            hash = creează_hash(dată,ultimul_hash,informații, dificultate, nonce)
+
+        #return  Bloc(dată,ultimul_hash,hash,informații, dificultate, nonce)
+        return  Bloc(dată,ultimul_hash,hash,informații, dificultate, nonce)
+
+    @staticmethod
+    def geneză():
+        """
+        Creaază Blocul Geneză.
+        """
+
+        # return  Bloc(INFORMAȚII_GENESIS['dată'],INFORMAȚII_GENESIS['ultimul_hash'], INFORMAȚII_GENESIS['hash'], INFORMAȚII_GENESIS['informații'])
+        return Bloc(**INFORMAȚII_GENESIS)
+
+    @staticmethod
+    def adjustă_dificultatea(ultimul_bloc, nouă_dată):
+        """
+        Calculează noua dificultate in funcție de RATĂ
+        """
+        if (nouă_dată - ultimul_bloc.dată) < RATA:
+            return ultimul_bloc.dificultate + 1
+
+        if (ultimul_bloc.dificultate -1) > 0:
+            return ultimul_bloc.dificultate - 1 
+
+        return 1
+
+    @staticmethod
+    def e_valid_blocul(ultimul_bloc,bloc):
+        """
+        Validează blocurile după următoarele reguli:
+        - Blocul trebuie să respecte ultimul hash cum trebuie
+        - Blocul trebuie să respecte validitatea algoritmului de muncă
+        - Blocul trebuie să se adjusteze doar cu câte o unitate
+        - Blocul trebuie să aibe informațiile utile corecte
+        """
+
+        if ( bloc.ultimul_hash != ultimul_bloc.hash ):
+            print(bloc.ultimul_hash, ultimul_bloc.hash)
+            raise Exception('Ultimul hash a blocului trebuie să fie corect !')
+
+        if hex_binar(bloc.hash)[0:bloc.dificultate] != '0' * bloc.dificultate:
+            raise Exception('Algoritmul de muncă nu a dat rezultatul corect !')
+
+        if abs(ultimul_bloc.dificultate - bloc.dificultate) > 1:
+            raise Exception('Dificultatea trebuie să se adjusteze doar cu 1 !')
+
+        hash_reconstruit = creează_hash(
+            bloc.dată,
+            bloc.ultimul_hash,
+            bloc.informații,
+            bloc.dificultate,
+            bloc.nonce
+        )
+
+        if bloc.hash != hash_reconstruit:
+            raise Exception('Hash-ul blocului trebuie să fie corect !')
+def main():
+
+    #geneză = Bloc.geneză()
+    #bloc_greșit = Bloc.minează_bloc(Bloc.geneză(), 'foo')
+    #bloc_greșit.ultimul_hash = 'greșit'
+    #bloc_greșit.dificultate = -2
+
+    ##try:
+    #    Bloc.e_valid_blocul(geneză,bloc_greșit)
+    #except Exception as e:
+    #    print(f'e_valid_blocul: {e}')
+    pass
+if __name__ == '__main__':
+    main()

Registru/configurare.py

@@ -0,0 +1,13 @@
+NANOSECUNDE = 1
+MICROSECUNDE = 1000 * NANOSECUNDE
+MILISECUNDE = 1000 * MICROSECUNDE
+SECUNDE = 1000 * MILISECUNDE
+
+RATA = 4 * SECUNDE
+
+TOTAL = 1000
+
+RĂSPLĂTIRE = 50
+RĂSPLĂTIRE_ = {'adresă': '*--oficială-răsplătire--*'}
+
+SECURIZEAZĂ_ = {'adresă': '*--oficială-securizare--*'}