Adım Adım Kendi Blokchain’ini Oluşturma

Evrim Dönmezgel tarafından tarihinde yayınlandı

Blockchain oluşturma zannedildiği kadar zor değildir.

Blockchain ya da Türkçe ifadeyle Blok Zincir’in ne olduğunu öğrenmek için öncelikle aşağıdaki yazıya bir göz atın;

Blok Zincir nedir?

Yukarıdaki yazıyı okuduysanız devam edebiliriz. Bu yazıda blockchain’in ne olduğunu çok farklı bir yöntemle öğreneceğiz: kendi blockchain’imizi oluşturacağız! Blockchain oluşturma tabii çok kolay bir işlem değildir. Bunun için en azından bir takım temel teknik bilgi ve altyapıya sahip olmanız gerekiyor.

Şu an burada bu yazıyı okuyorsun, çünkü benim gibi, kripto paraların yükselişi konusunda kafayı yemişsin. Ve blockchain’in nasıl çalıştığını ve arkasındaki temel teknolojiyi bilmeyi arzuluyorsun. Bunun ötesinde Blockchain oluşturma yöntemlerini merak ediyorsun.

Ancak blockchain’i anlamak kolay değildir – ya da en azından benim için değildi. Bol bol videolar izledim, dersler aldım ve genelde hayal kırıklığı yaşadım.

Yaparak öğrenmeyi severim. Bazıları böyledir. Günlerce okur, çalışır fakat hiç birşey anlamaz. Bir kez yapar ve her şeyi kavrar. Ben öyleyim. Konuyu, kod düzeyinde ele almam lazım. Aynı şeyi siz de yaparsanız, bu rehberin sonunda, blokchain’in nasıl çalıştığına dair sağlam bir kavrayışa sahip olacaksınız artı işleyen bir Blockchain’iniz olacak. Blockchain oluşturma noktasında uzmanlık kazanmış olacaksınız.

Başlamadan önce…

Bir blockchain ya da blok zincirin, bloklar olarak adlandırılan değişmez, sıralı bir kayıt zinciri olduğunu unutmayın. İşlem (transaction), dosya veya istediğiniz herhangi bir veriyi içerebilirler. Ancak önemli olan, hash yöntemleriyle birbirine zincirlenmiş olmalarıdır.

Hash’in ne olduğundan emin değilseniz, buradaki kısa açıklamayı okuyabilirsiniz.

Bu rehber kimleri hedefliyor? HTTP üzerinden Blockchain ile konuşacağımız için temel Python bilgisine sahip olmanız gerek. Ayrıca HTTP isteklerinin (request) işleyişi hakkında biraz bilgi sahibi olmanız gerekir.

Neye ihtiyacınız olacak? Sisteminizde Python 3.6+ (pip ile birlikte) kurulu olduğundan emin olun. Ayrıca, Flask’ı ve Requests kitaplığını yüklemelisiniz:

pip install Flask==0.12.2 requests==2.18.4

Ayrıca Postman veya cURL gibi bir HTTP istemcisine de ihtiyacınız olacak.

Nihai kod nerede? Kaynak kodu burada mevcut.

Adım 1: Bir Blockchain Oluşturma

En sevdiğiniz metin editörünü veya IDE’yi açın, kişisel olarak ben PyCharm‘i seviyorum. Blockchain.py adlı yeni bir dosya oluşturun. Yalnızca tek bir dosya kullanacağız, ancak kaybolursanız, kaynak koda her zaman başvurabilirsiniz.

Temsili Blockchain Oluşturma

Constructor‘ı boş bir liste oluşturan (blok zincirimizi depolamak için) bir blok zinciri sınıfı oluşturuyoruz ve bir diğerini ise işlemleri depolamak için kullanacağız. Sınıfımız için hazırlanan tasarı aşağıda belirtilmiştir:

class Blockchain(object):
    def __init__(self):
        self.chain = []
        self.current_transactions = []
        
    def new_block(self):
        # Yeni bir blok oluşturur ve zincire ekler
        pass
    
    def new_transaction(self):
        # İşlem listesine yeni bir işlem ekler
        pass
    
    @staticmethod
    def hash(block):
        # Bloku hash'ler
        pass

    @property
    def last_block(self):
        # Zincirdeki son bloku döner
        pass

Blockchain sınıfımız zinciri yönetmekten sorumludur. İşlemleri depolar ve zincire yeni bloklar eklemek için bazı yardımcı yöntemlere (helper methods) sahiptir. Bazı yöntemleri bulmaya başlayalım.

Bir blok neye benzer?

Her blokta bir dizin (index), bir zaman damgası (Unix zamanında), işlemlerin bir listesi, bir ispat (daha sonra bunun üzerinde daha fazla bilgi edineceğiz fakat iş ispatı yazısına bakabilirsiniz) ve önceki blokun hash’i bulunur.

Tek bir blokun nasıl göründüğüne dair bir örnek:

block = {
    'index': 1,
    'timestamp': 1506057125.900785,
    'transactions': [
        {
            'sender': "8527147fe1f5426f9dd545de4b27ee00",
            'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
            'amount': 5,
        }
    ],
    'proof': 324984774000,
    'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}

Bu noktada, zincir fikrinin zihninizde belirginleşmiş olması lazım. Her yeni blok kendi içinde, önceki blokun hash’ini içerir. Bu çok önemlidir çünkü blok zincirlerin değiştirelemez olmasına neden olur: bir saldırgan zincirdeki bir önceki bloğu bozarsa, sonraki tüm bloklar hatalı hash’ler içerir. Blockchain oluşturma sürecindeki en önemli noktalardan biri budur.

Bütün bunlar size mantıklı geliyor mu? Gelmiyorsa, kendinize biraz daha zaman tanıyın. Eninde sonunda mantığını kavrayacaksınız.

Bir Bloğa İşlem Ekleme

Bloğa işlem (transaction) eklemenin bir yoluna ihtiyacımız olacak. Bunun için new_transaction () yöntemi sorumludur ve oldukça basittir:

class Blockchain(object):
    ...
    
    def new_transaction(self, sender, recipient, amount):
        """
        Kazılacak bir sonraki blok için yeni bir işlem oluşturur.
        :param sender:  Gönderenin adresi
        :param recipient:  Alıcının adresi
        :param amount:  Tutar
        :return:  Bu işlemi gerçekleştirecek blok dizini
        """

        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })

        return self.last_block['index'] + 1

New_transaction (), listeye bir işlem ekledikten sonra, işlemin ekleneceği -sonraki işlemin yapılacağı- sonraki bloğun dizinini döndürür. Bu daha sonra, işlemi gönderen kullanıcı için faydalı olacaktır.

Yeni Bloklar Oluşturma

Blockchain’imiz oluşturulduğunda onu bir genesis bloğu ile tohumlamak gerekir. Genesis bloğunun ne olduğunu öğrenmek için bu yazımızı okuyun. Genesis bloğu başlangıç bloğudur ve hiçbir öncülü olmayan bir bloktur. Madencilik sonucu üretilen genesis bloğumuza (veya iş ispatına) bir “kanıt” eklememiz gerekecek. Madencilik hakkında ilerleyen kısımlarda konuşacağız.

Constructor’ımızda genesis bloğunun oluşturulmasına ilaveten new_block (), new_transaction () ve hash () yöntemlerini de inceleyelim:

import hashlib
import json
from time import time


class Blockchain(object):
    def __init__(self):
        self.current_transactions = []
        self.chain = []

        # Genesis blokunu oluşturuyoruz
        self.new_block(previous_hash=1, proof=100)

    def new_block(self, proof, previous_hash=None):
        """
        Blockchain içinde bir blok oluşturuyoruz
        :param proof:  İspat "İş İspatı" algoritmasıyla verilir
        :param previous_hash: (Opsiyonel)  Önceki bloğun hash değeri
        :return:  Yeni blok
        """

        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }

        # Mevcut işlem listesini sıfırlıyoruz
        self.current_transactions = []

        self.chain.append(block)
        return block

    def new_transaction(self, sender, recipient, amount):
        """
        Kazılan sonraki bloğa eklenecek yeni işlemi oluşturuyoruz
        :param sender:  Gönderen adresi
        :param recipient:  Alıcı adresi
        :param amount:  Tutar
        :return:  Bu işlemi gerçekleştirecek blok dizini
        """
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })

        return self.last_block['index'] + 1

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

    @staticmethod
    def hash(block):
        """
        Blokun SHA-256 hash değerini oluşturuyoruz
        :param block:  Block
        :return: 
        """

        # Dictionary'nin Ordered olduğundan emin olmalıyız, aksi halde tutarsız hash'ler olur.
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

Yukarıdaki kod gayet açıklayıcı. Temsili blok zincirimizi neredeyse bitirdik. Ancak bu noktada, yeni blokların nasıl oluşturulduğunu ya da çıkarıldığını merak ediyor olmalısınız.

İş İspatını Anlamak

İş ispatı algoritması (PoW – Proof of Work) yeni blokların blok zincirde nasıl oluşturulduğu veya çıkarıldığıyla (madencilik) ilgilidir. Blockchain oluşturma sürecinin önemli adımlarından biridir. PoW’un amacı, matematiksel bir problemi çözen bir numarayı bulmaktır. Numaranın bulunması zor olmalı (Bakınız: Zorluk), ancak hesaplama açısından -ağdaki herkes tarafından- doğrulanması kolay olmalıdır. İş ispatının arkasında yatan temel fikir budur.

İş ispatını (PoW) anlamaya yardımcı olması için çok basit bir örneğe bakacağız.

X tamsayısının hash değerinin başka bir y ile çarpılmasının 0 ile bitmesi gerektiğine karar verelim.

Yani hash (x * y) = ac23dc … 0 gibi bir şey elde edeceğiz.

Bu basitleştirilmiş örnek için x = 5 olsun. Bunu Python’da uyguluyoruz:

from hashlib import sha256
x = 5
y = 0  # y'nin ne olması gerektiğini henüz bilmiyoruz...
while sha256(f'{x*y}'.encode()).hexdigest()[-1] != "0":
    y += 1
print(f'The solution is y = {y}')

Bu örnekte çözüm y=21’dir. Üretilen hash değeri 0 ile bitmiş olur;

hash(5 * 21) = 1253e9373e...5e3600155e860

Bitcoin’de, İş İspatı algoritmasına Hashcash denir. Ve yukarıdaki temel örneğimizden çok farklı değildir. Madencilerin yeni bir blok oluşturmak için çözmeye çalıştıkları algoritma budur. Genel olarak, zorluk bir dizedeki (string) aranan karakterlerin sayısına göre belirlenir. Madenciler daha sonra çözüm için bir koin ile ödüllendirilirler.

, madencilerin çözümlerini kolayca doğrulayabilir.

Temel İş İspatı Uygulaması

Blok zincirimiz için benzer bir algoritma uygulayalım. Kuralımız yukarıdaki örneğe benzer:

Bir önceki bloğun çözümü ile kıyaslandığında, 4 tane 0 ile başlayan bir hash üretilen bir p sayısı bulalım.

import hashlib
import json

from time import time
from uuid import uuid4

class Blockchain(object):
    ...
        
    def proof_of_work(self, last_proof):
        """
        Basit bir İş İspatı algoritması:
        :param last_proof: 
        :return: 
        """

        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1

        return proof

    @staticmethod
    def valid_proof(last_proof, proof):
        """
        İspatı doğrula: hash(last_proof, proof) 4 adet 0 ile başlıyor mu?
        :param last_proof:  Önceki İspat
        :param proof:  Mevcut İspat
        :return:  True if correct, False if not.
        """

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

Algoritmanın zorluğunu ayarlamak için önde gelen sıfırların sayısını değiştirebiliriz. Ama 4 yeterli. Tek bir sıfırın eklenmesinin, bir çözüm bulmak için gereken zamana büyük bir fark yarattığını öğreneceksiniz.

Sınıfımız (class) neredeyse tamamlandı ve onunla HTTP istekleri kullanarak etkileşime geçmeye hazırız.

Adım 2: Bir API olarak Blockchain’imiz

Python Flask Framework’ünü kullanacağız. Kendisi bir mikro-framework’tür ve uç noktaları Python fonksiyonlarına eşlemeyi kolaylaştırır. Bu, HTTP istekleri kullanarak web üzerindeki blok zincirimizle konuşmamıza olanak tanır.

Üç metot oluşturacağız:

  • /transactions/new, bir bloğa yeni bir işlem oluşturmak için kullanılır.
  • /mine, sunucumuza yeni bir blok çıkarmasını söyler.
  • /chain, tam bir Blockchain döner.

Flask Kurulumu

“Sunucumuz” blockchain ağımızda tek bir düğüm (node) oluşturacaktır. Kodu oluşturalım:

import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4

from flask import Flask

class Blockchain(object):
    ...

# Düğümümüzü (Node) somutlaştırıyoruz..
app = Flask(__name__)

# Bu düğüm için genel olarak benzersiz bir adres oluşturuyoruz.
node_identifier = str(uuid4()).replace('-', '')

# Blok zincirimizi somutlaştırıyoruz..
blockchain = Blockchain()

@app.route('/mine', methods=['GET'])
def mine():
    return "Yeni blok çıkaracağız"
  
@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    return "Yeni işlem ekleyeceğiz"

@app.route('/chain', methods=['GET'])
def full_chain():
    response = {
        'chain': blockchain.chain,
        'length': len(blockchain.chain),
    }
    return jsonify(response), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Yukarıda eklemiş olduğumuz şeylerin kısa bir açıklaması:

  • Düğümümüzü (node) başlattık. Flask hakkında daha fazla bilgi için buraya tıklayın.
  • Düğümümüz için rasgele bir isim oluşturduk.
  • Blockchain sınıfını hazırladık.
  • Bir GET isteği olan /mine endpoint’i oluşturduk.
  • Verileri ona gönderirken bir POST isteği olan /transactions/new endpoint’i oluşturduk.
  • Full blok zincirini döndüren /chain endpoint’i oluşturduk.
  • Sunucuyu 5000 port’undan çalıştırdık.

İşlem Endpoint’i

Bir işlem talebi aşağıdaki gibi görünecektir. Kullanıcının sunucuya gönderdiği şey budur:

{
"sender": "benim adresim",
"recipient": "başka birinin adresi",
"amount": 5
}

İşlemleri bir bloğa eklemek için kullanılan sınıf yöntemimiz zaten olduğundan, geri kalanı kolaydır. İşlem ekleme fonksiyonunu yazalım:

import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4

from flask import Flask, jsonify, request

...

@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    values = request.get_json()

    # Zorunlu alanların POST ile gönderilen verinin içinde olduğunu kontrol ediyoruz..
    required = ['sender', 'recipient', 'amount']
    if not all(k in values for k in required):
        return 'Missing values', 400

    # Yeni işlem oluşturuyoruz
    index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])

    response = {'message': f'İşlem {index} blokuna eklenecektir'}
    return jsonify(response), 201

Madencilik Endpoint’i

Madencilik endpoint’imiz büyünün gerçekleştiği yerdir. Üç şey yapmak zorundayız:

  • İş ispatını hesaplamalıyız
  • 1 adet koin veren bir işlem ekleyerek madenciyi ödüllendirmeliyiz
  • Yeni bloğu zincire ekleyerek çıkarmalı ya da kazımalıyız.
import hashlib
import json

from time import time
from uuid import uuid4

from flask import Flask, jsonify, request
...

@app.route('/mine', methods=['GET'])
def mine():
    # Sonraki kanıtı almak için iş kanıtı algoritmamızı çalıştırıyoruz...
    last_block = blockchain.last_block
    last_proof = last_block['proof']
    proof = blockchain.proof_of_work(last_proof)

    # Kanıtı bulduğumuz için ödül alıyoruz..
    blockchain.new_transaction(
        sender="0",
        recipient=node_identifier,
        amount=1,
    )

    # Yeni bloğu zincire ekleyerek çıkarıyoruz..
    block = blockchain.new_block(proof)

    response = {
        'message': "Yeni blok çıkarıldı",
        'index': block['index'],
        'transactions': block['transactions'],
        'proof': block['proof'],
        'previous_hash': block['previous_hash'],
    }
    return jsonify(response), 200

Çıkarılan bloğun alıcısının düğümümüzün adresi olduğunu unutmayın. Ve burada yaptığımız şeylerin çoğu Blockchain sınıfındaki yöntemlerle etkileşim kuruyor. Bu noktada işimiz bitti ve blok zincirimizle etkileşime geçmeye başlayabiliriz.

Adım 3: Blok zincirimizle etkileşim

Bir ağ üzerinden API’miz ile etkileşimde bulunmak için cURL veya Postman kullanabilirsiniz.

Sunucuyu çalıştırın:

$ python blockchain.py
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

http://localhost:5000/mine adresine GET talebi göndererek bir blok çıkarmaya çalışalım;

http://localhost:5000/transactions/new adresine POST talebi göndererek işlem (transaction) oluşturmaya çalışalım;

Blockchain Oluşturma

Postman kullanmıyorsanız, aynı talebi cURL kullanarak da yapabilirsiniz:

$ curl -X POST -H "Content-Type: application/json" -d '{
 "sender": "d4ee26eee15148ee92c6cd394edd974e",
 "recipient": "someone-other-address",
 "amount": 5
}' "http://localhost:5000/transactions/new"

Sunucumu restart ettim ve 2 tane daha blok çıkararak toplamda 3 blok elde ettim. Şimdi http://localhost:5000/chain adresine istek göndererek zincirin tamamını talep edelim;

{
  "chain": [
    {
      "index": 1,
      "previous_hash": 1,
      "proof": 100,
      "timestamp": 1506280650.770839,
      "transactions": []
    },
    {
      "index": 2,
      "previous_hash": "c099bc...bfb7",
      "proof": 35293,
      "timestamp": 1506280664.717925,
      "transactions": [
        {
          "amount": 1,
          "recipient": "8bbcb347e0634905b0cac7955bae152b",
          "sender": "0"
        }
      ]
    },
    {
      "index": 3,
      "previous_hash": "eff91a...10f2",
      "proof": 35089,
      "timestamp": 1506280666.1086972,
      "transactions": [
        {
          "amount": 1,
          "recipient": "8bbcb347e0634905b0cac7955bae152b",
          "sender": "0"
        }
      ]
    }
  ],
  "length": 3
}

Adım 4: Fikir birliği (Konsensüs)

Bu kısım çok güzel. İşlemleri kabul eden ve yeni blokları çıkarmamızı sağlayan temel bir Blockchain var. Fakat Blockchain’in bütün çıkış noktası merkezi olmamasıdır. Peki merkezi bir yapı olmadan, tüm düğümlerin aynı zinciri yansıtmalarını nasıl sağlayabiliriz? Buna Konsensüs adı verilir ve ağınızda birden fazla düğüm istiyorsanız Konsensüs Algoritması çalıştırmak zorundasınız.

Yeni Düğümlerin Kaydedilmesi

Bir Konsensüs Algoritması çalıştırmaya başlamadan önce, bir düğümün ağdaki komşu düğümleri bilmesine izin vermenin bir yoluna ihtiyacımız var. Ağımızdaki her düğüm ağdaki diğer düğümlerin kayıtlarını tutmalıdır. Dolayısıyla, daha fazla endpoint’e ihtiyacımız olacak:

  1. /nodes/register: URL biçimindeki yeni düğümlerin listesini kabul etmek için.
  2. /nodes/resolve: herhangi bir uyuşmazlığı çözen konsensüs algoritmasını uygulamak için.

Blockchain yapıcısını değiştirmeli ve düğümlerin kaydedilmesi için bir yöntem sağlamalıyız:

...
from urllib.parse import urlparse
...


class Blockchain(object):
    def __init__(self):
        ...
        self.nodes = set()
        ...

    def register_node(self, address):
        """
        Düğüm listesine yeni bir düğüm ekliyoruz..
        :param address:  Düğüm adresi. Örneğin. 'http://192.168.0.5:5000'
        :return: None
        """

        parsed_url = urlparse(address)
        self.nodes.add(parsed_url.netloc)

Düğümlerin listesini tutmak için bir set () kullandık. Bu, yeni düğümlerin eklenmesinin eş-kuvvette olmasını sağlamanın ucuz bir yoludur.

Konsensüs Algoritmasının Uygulanması

Belirtildiği gibi, bir çatışma, bir düğümün başka bir düğüme farklı bir zincire sahip olması demektir. Bunu çözmek için, en uzun geçerli zincirin yetkili olması kuralını uygularız. Başka bir deyişle, ağdaki en uzun zincir fiilen geçerlidir. Bu algoritmayı kullanarak, ağımızdaki düğümler arasında fikir birliğine varıyoruz.

...
import requests

class Blockchain(object)
    ...
    
    def valid_chain(self, chain):
        """
        Verilen bir blok zincirin geçerli olup olmadığını belirliyoruz..
        :param chain:  A blockchain
        :return:  True if valid, False if not
        """

        last_block = chain[0]
        current_index = 1

        while current_index < len(chain):
            block = chain[current_index]
            print(f'{last_block}')
            print(f'{block}')
            print("\n-----------\n")
            # Blok hash değerinin doğru olup olmadığını kontrol ediyoruz..
            if block['previous_hash'] != self.hash(last_block):
                return False

            # İş kanıtının doğru olup olmadığını kontrol ediyoruz..
            if not self.valid_proof(last_block['proof'], block['proof']):
                return False

            last_block = block
            current_index += 1

        return True

    def resolve_conflicts(self):
        """
        Bu konsensüs algoritmamızdır. Çatışmaları,
        zincirimizi ağdaki en uzun zincirle değiştirerek çözer.
        :return:  True if our chain was replaced, False if not
        """

        neighbours = self.nodes
        new_chain = None

        # Bizimkilerden daha uzun zincirleri arıyoruz...
        max_length = len(self.chain)

        # Ağımızdaki tüm düğümlerden gelen zincirleri alıp doğruluyoruz:
            response = requests.get(f'http://{node}/chain')

            if response.status_code == 200:
                length = response.json()['length']
                chain = response.json()['chain']

                # Zincirin uzunluğunu ve doğruluğunu kontrol ediyoruz..
                if length > max_length and self.valid_chain(chain):
                    max_length = length
                    new_chain = chain

        # Kendimizinkinden daha uzun ve geçerli zincir bulduğumuzda replace ediyoruz..
        if new_chain:
            self.chain = new_chain
            return True

        return False

İlk yöntem olan valid_chain (), bir zincirin her bir blok boyunca döngü yapılarak geçerli olup olmadığını kontrol etmekten ve hem hash değerinin hem de kanıtın doğrulamasından sorumludur.

resolve_conflicts () komşu düğümlerimiz arasında döngü oluşturan, zincirlerini indiren ve yukarıdaki yöntemi kullanarak doğrulayan bir yöntemdir. Uzunluğu bizimkinden daha büyük olan bir geçerli zincir bulunursa, bizimkinin yerini alır. Bu kısım çok önemlidir. Blockchain oluşturma sürecinin belki de en önemli adımlarından biridir.

İki endpoint’i API’mize kaydettirelim; bir tanesi komşu düğümler eklemek ve diğeri çatışmaları çözmek için:

@app.route('/nodes/register', methods=['POST'])
def register_nodes():
    values = request.get_json()

    nodes = values.get('nodes')
    if nodes is None:
        return "Hata: Lütfen geçerli düğüm listesi sunun", 400

    for node in nodes:
        blockchain.register_node(node)

    response = {
        'message': 'Yeni düğümler eklendi',
        'total_nodes': list(blockchain.nodes),
    }
    return jsonify(response), 201


@app.route('/nodes/resolve', methods=['GET'])
def consensus():
    replaced = blockchain.resolve_conflicts()

    if replaced:
        response = {
            'message': 'Zincirimiz değiştirildi',
            'new_chain': blockchain.chain
        }
    else:
        response = {
            'message': 'Zincirimiz yetkili',
            'chain': blockchain.chain
        }

    return jsonify(response), 200

Bu noktada isterseniz farklı bir makine kullanabilir ve ağınızda farklı düğümleri döndürebilirsiniz. Ya da aynı makinedeki farklı bağlantı noktalarını kullanarak işlemleri hızlandırabilirsiniz. Ben makinemde, farklı bir bağlantı noktasında başka bir düğüm oluşturdum ve mevcut düğümüme kaydettim. Böylece, iki düğümüm var:

http://localhost:5000 ve http://localhost:5001.

Sonrasında zincirin uzun olduğundan emin olmak için 2nci düğüm üzerinde yeni bloklar çıkardım. Konsensüs algoritmasının replace edildiği 1nci düğüm üzerinde GET /nodes/resolve komutunu çağırdım.

Ve işte tamamlandı! Blockchain oluşturma yöntemini öğrendiniz! Gidip birkaç arkadaşınızdan blok zincirinizi test etmesini isteyin.

Umarım bu rehber size yeni bir şeyler yaratmak için ilham kaynağı olmuştur. Kripto paralar konusunda çok mutlu ve umutluyum, çünkü Blockchain’in ekonomileri, hükümetleri ve kayıt tutma konusundaki düşüncelerimizi hızla değiştireceğine inanıyorum.

Yazıyı beğendiyseniz ya da eklemek istedikleriniz varsa lütfen yorum yazınız.

Blockchain oluşturma kodunun tamamını buradan indirebilirsiniz.

Kaynak

Facebook Yorumları

Evrim Dönmezgel

"Satoshi" adlı ilk Türkçe Bitcoin kitabının yazarı Evrim Dönmezgel, Bitcoinlerim.com sitesinin yazarıdır. Kripto para ve blockchain teknolojileri sevdalısıdır.

7 yorum

Tosba · 4 Ekim 2017 20:13 tarihinde

Hocam çok güzel olmuş teşekkürler.

Ahmet · 10 Ekim 2017 16:26 tarihinde

elinize sağlık başarılı bir makale olmuş

baris · 13 Ekim 2017 14:37 tarihinde

merhaba sitenizde iletişim kısmı göremedim bana survivalbaris@gmail.com mail adresinden ulaşırmısınız sizinle bir konuda görüşmem gerekli.

    bitcoin · 23 Kasım 2017 17:41 tarihinde

    Merhaba, bize hello @ bitcoinlerim.com adresinden e-mail gönderebilirsiniz.

burak aksu · 2 Kasım 2017 18:08 tarihinde

Bu konuyu videolu bir şekilde ele alsanız veya varsa videolu ele alan atsanız olur mu? Açıkcası kodlama bilmediğim için anlamadım hazır indirdiğim blockchain dosyasınıda postman’de çalıştıramadım. Yardımcı olur musunuz ?

Temmuz · 23 Kasım 2017 17:37 tarihinde

Merhaba,

Ben btcmatik Pazarlama Muduru Temmuz. Yakın zamanda Turkiye pazarında resmi olarak faaliyete gececek olan btcmatik.com markası olarak, bitcoin borsası uzerine bir proje baslatmıs bulunmaktayız. Bu surecte gerek mackolik gerekse diger firmalarla olan calismalarinizi yakindan takip ediyoruz.

btcmatik.com suan icin web sayfamiz tasarim asamasinda olup pazar arastirmasi yapmaktayiz. bu surec icerisinde sizlerden online borsa ve bitcoin uzerine olan tum platformlarda yerimizi almayi hedefledigimiz bir paket fiyat teklifi talep ediyorum. Eger reklam aginizda firmamizi tanitabilecegimiz uygun alanlar varsa trafigi satin almak istiyoruz. En kisa surede donus yapmanizi rica ederim.

Iyi Calismalar,

Temmuz Ozturk

mail : temmuz@btcmatik.com

Mustafa Ozsoy · 3 Şubat 2018 01:57 tarihinde

Coin Turkey Org olarak coin turk üretilecek projeye katılmak için sizi mutlaka bekliyorum.
Yazılarınızı okudum bize katılın sizin gibi biriyle ilk adımları başlatmak bana gurur verir.

Bir Cevap Yazın

This site uses Akismet to reduce spam. Learn how your comment data is processed.