CryptoSphere

Kode Blockchain Sederhana dalam Python

Posted by Brody on 22/02/2025 at 20:24

import hashlib
import json
import time
from uuid import uuid4
from urllib.parse import urlparse
class Blockchain:
    def __init__(self):
        self.chain = []
        self.current_transactions = []
        self.nodes = set()
        # Membuat blok genesis (blok pertama di blockchain)
        self.new_block(previous_hash='1', proof=100)
    def register_node(self, address):
        """
        Mendaftarkan node baru ke dalam jaringan blockchain
        """
        parsed_url = urlparse(address)
        self.nodes.add(parsed_url.netloc)
    def valid_chain(self, chain):
        """
        Memeriksa apakah blockchain valid dengan memeriksa hash dan proof of work
        """
        last_block = chain[0]
        current_index = 1
        while current_index < len(chain):
            block = chain[current_index]
            # Verifikasi hash blok sebelumnya
            if block['previous_hash'] != self.hash(last_block):
                return False
            # Verifikasi proof of work
            if not self.valid_proof(last_block['proof'], block['proof']):
                return False
            last_block = block
            current_index += 1
        return True
    def resolve_conflicts(self):
        """
        Konsensus untuk mengganti rantai saat terdapat konflik
        """
        neighbours = self.nodes
        new_chain = None
        max_length = len(self.chain)
        for node in neighbours:
            response = requests.get(f'http://{node}/chain')
            if response.status_code == 200:
                length = response.json()['length']
                chain = response.json()['chain']
                if length > max_length and self.valid_chain(chain):
                    max_length = length
                    new_chain = chain
        if new_chain:
            self.chain = new_chain
            return True
        return False
    def new_block(self, proof, previous_hash=None):
        """
        Membuat blok baru dalam blockchain
        """
        block = {
            'index': len(self.chain) + 1,
            'timestamp': time.time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }
        self.current_transactions = []
        self.chain.append(block)
        return block
    def new_transaction(self, sender, recipient, amount):
        """
        Membuat transaksi baru yang akan dimasukkan ke dalam blok berikutnya
        """
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })
        return self.last_block['index'] + 1
    @staticmethod
    def hash(block):
        """
        Membuat hash SHA-256 dari blok
        """
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()
    @property
    def last_block(self):
        """
        Mengembalikan blok terakhir dalam blockchain
        """
        return self.chain[-1]
    def proof_of_work(self, last_proof):
        """
        Algoritma Proof of Work yang sederhana:
        - Temukan angka p' sehingga hash(pp') memiliki empat angka nol di depan
        - p adalah proof sebelumnya, dan p' adalah proof baru
        """
        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1
        return proof
    @staticmethod
    def valid_proof(last_proof, proof):
        """
        Memverifikasi Proof of Work:
        - Menggabungkan dua angka dan membuat hash
        - Memeriksa apakah hash dimulai dengan empat angka nol
        """
        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

Penjelasan Fitur dan Fungsinya

1. Blok Genesis:

self.new_block(previous_hash=’1′, proof=100)

Blok pertama yang disebut “blok genesis” dibuat secara manual untuk memulai blockchain.

2. Register Node:

register_node(self, address)

Memungkinkan penambahan node baru ke dalam jaringan blockchain.

3. Validasi Rantai (Chain Validation):

valid_chain(self, chain)

Memeriksa integritas blockchain dengan membandingkan hash blok sebelumnya dan memverifikasi Proof of Work.

4. Resolusi Konflik (Consensus Mechanism):

resolve_conflicts(self)

Mengganti rantai blockchain saat terdapat konflik dengan memilih rantai terpanjang yang valid.

5. Pembuatan Blok Baru:

new_block(self, proof, previous_hash=None)

Menambahkan blok baru ke dalam blockchain setelah memvalidasi Proof of Work.

6. Pembuatan Transaksi Baru:

new_transaction(self, sender, recipient, amount)

Menambahkan transaksi baru yang akan dimasukkan ke dalam blok berikutnya.

7. Hashing Blok:

hash(block)

Menggunakan algoritma SHA-256 untuk menghasilkan hash unik dari setiap blok.

8. Proof of Work (PoW):

proof_of_work(self, last_proof) dan valid_proof(last_proof, proof)

Memastikan penambahan blok baru memerlukan perhitungan matematis yang sulit untuk memvalidasi keamanan blockchain.

Kegunaan Kode Ini

1. Keamanan Data:

Setiap blok terhubung dengan hash blok sebelumnya, sehingga memodifikasi satu blok akan merusak seluruh rantai.

2. Transparansi dan Akuntabilitas:

Semua transaksi dicatat dalam blockchain, memungkinkan transparansi penuh tanpa memerlukan pihak ketiga.

3. Desentralisasi:

Blockchain tidak memerlukan otoritas pusat, karena setiap node dalam jaringan memiliki salinan dari rantai.

4. Integritas Transaksi:

Algoritma Proof of Work memastikan bahwa hanya transaksi yang valid yang dapat ditambahkan ke blockchain.

5. Penerapan Praktis:

Kode ini dapat diimplementasikan untuk berbagai kasus penggunaan seperti cryptocurrency, pelacakan rantai pasokan, kontrak pintar (smart contracts), dan banyak lagi.

Brody replied 1 month ago 1 Member · 0 Replies

0 Replies

Sorry, there were no replies found.