R ile Kodlayarak Blokzincirleri Anlamak

Herkes şimdi kripto paraları konuşuyor – Bitcoin etrafındaki hype sayesinde. Bitcoin balonu olup olmadığı tartışmasından çok daha ilgi çekici olan, bu teknolojinin gerçekte nasıl çalıştığı ve neler yapabildiği sorusu. Bitcoin’in hikâyesi 2008’de "Bitcoin: Eşler Arası Elektronik Nakit Sistemi" başlıklı bir teknik makaleyle (whitepaper) başladı. Bu yazıda Satoshi Nakamoto isimli yazarın (Satoshi’nin gerçekte kim olduğu hâlâ yoğun biçimde tartışılıyor) tanıttığı yeni ve devrim niteliğinde bir teknoloji ve fikir vardı: blokzincir denilen bir şey üzerinde çalışan, merkezi olmayan elektronik para birimi. Fikir buradan yayıldı ve bugün birçok farklı alana uygulanabiliyor.

Blokzincirlerle ilk kez Oxford’daki BlockchainSociety’nin bir toplantısında tanıştım. Oradaki herkes bu yeni teknolojinin potansiyeli konusunda çok heyecanlı görünüyordu. Açık konuşmak gerekirse kulağa gerçekten çekici geliyor: Para transferleri, sözleşmeler veya aklınıza gelebilecek başka şeyler (örneğin, hack’lenemeyen oylama makineleri) için merkezi olmayan, bozulamaz bir veritabanı. Blokzincirin kripto topluluğuna vaadi, güveni devrimcileştirerek bankalar veya avukatlar gibi üçüncü taraflara artık ihtiyaç duymayacağımız, sadece kriptografinin gücüne güveneceğimiz yönünde ve bunun tüm sektörleri altüst edeceği.

Temel fikir oldukça sezgisel olsa da, blokzincirlerin teknik düzeyde aslında nasıl çalıştığı biraz daha zor anlaşılır. Geçen hafta R Bloggers’ta, BigData Doc’un tamamen R ile bir blokzincir kurduğu bir makaleye rastladım. R ile inşa edilen bir blokzincir dünyadaki en verimli veya pratik şey olmayabilir ama arkasındaki programlama ve kripto ilkelerini anlamak için harika bir yol. Ben de bunu anlamak istedim ve bu yüzden R’de daha küçük bir blokzincir sürümü uyguladım: "Kodlayabiliyorsanız, kesinlikle anlamışsınızdır".

Blokzincir Nedir?

Diyelim ki amacınız bazı verileri güvenli bir şekilde saklamak. Bunun için önce verileri bir kaba – yani bloğa – yerleştirirsiniz. Bitcoin örneğinde her blok, birden fazla finansal işlem içerir. Yeni işlemler (veya yeni veriler) olduğunda yeni bir blok oluşturulur ve önceki bloklarla birlikte bir zincir oluşturacak şekilde eklenir – yani blokzincir.

Şimdi, blokzincirlerin neredeyse hack’lenemez hâle gelmek için kriptografiden nasıl yararlandığına bakalım.

1. Bloklar

    block_example <- list(index = 1,
                     timestamp = "2018-01-05 17.00 MST",
                     data = "some data",
                     previous_hash = 0,
                     proof = 9,
                     new_hash = NULL)

Blokzinciri oluşturmaya – yani veri içeren farklı kapları birbirine zincirlemeye – başlamadan önce iki kavramı daha tanımanız gerekir: Hash’leme ve İş İspatı (Proof-of-Work) algoritmaları.

2. Hash

Bir hash, bir bloğu zincirdeki diğer bloklara bağlayarak bütünlüğünü sağlamaya yardımcı olur. Bir hash fonksiyonu, bir şeyi girdi olarak alır ve benzersiz, şifreli bir çıktı verir. Örneğin arkadaşınıza şu bulmacayı veriyorsunuz: "Hangisi daha iyi istatistik programıdır: Stata mı R mi?" ve doğru çözümün hash’ini de veriyorsunuz: "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86". Artık arkadaşınız, cevabını hash fonksiyonuna (bizim durumumuzda SHA256 algoritması) girerek doğru yanıta sahip olup olmadığını kendisi kontrol edebilir:

    library("digest")

    digest("Stata" ,"sha256") # first try

    ## [1] "3ac273f00d52dc9caf89cbd71e73e5915229a588117ca3441630089409ddb7bc"

    digest("R", "sha256") # second try

    ## [1] "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86"

Bu size nasıl yardımcı olur?

Bu durumda, hash fonksiyonuna sadece blokla ilgili bilgileri (index, zaman damgası, veri) değil, aynı zamanda önceki bloğun hash’ini de girersiniz. Bu, geçerli bir hash’i yalnızca önceki bloğun hash’ini biliyorsanız hesaplayabileceğiniz anlamına gelir; o da kendisinden önceki bloğun hash’iyle oluşturulmuştur ve bu böyle sürer gider. Bu, size değiştirilemez, sıralı bir blok zinciri sağlar. Sonradan bir bloğu değiştirirseniz, onu izleyen tüm blokların hash’lerini yeniden hesaplamanız gerekir.

    #Function that creates a hashed "block"
    hash_block <- function(block){
      block$new_hash <- digest(c(block$index,
                                 block$timestamp,
                                 block$data,
                                 block$previous_hash), "sha256")
      return(block)
    }

3. İş İspatı (Proof-of-Work)

Eğer blokzincirde saklanması gereken çok fazla bilgi varsa, çok sayıda yeni blok oluşturmanız gerekir. Çoğu durumda, kaç yeni blok oluşturulduğunu kontrol etmek istersiniz. Örneğin kripto paralarda, her saniye sonsuz sayıda coin üretilebilseydi coin’lerin değeri düşerdi.

Bu nedenle, yeni bir blok oluşturmanın zorluğunu kontrol eden "İş İspatı" (PoW) adlı bir algoritma ekleriz. "İspat", bilgisayarın belli bir miktarda iş yaptığını gösterir. Pratikte amaç, üretmesi zor ama doğrulaması kolay bir çıktı elde etmektir. PoW olarak şu "görevi" kullanacağım: 99’a ve son bloğun ispat numarasına tam bölünebilen bir sonraki sayıyı bulun.

    ### Simple Proof of Work Alogrithm
    proof_of_work <- function(last_proof){
      proof <- last_proof + 1

      # Increment the proof number until a number is found that is divisable by 99 and by the proof of the previous block
      while (!(proof %% 99 == 0 & proof %% last_proof == 0 )){
        proof <- proof + 1
      }

      return(proof)
    }

Bitcoin veya Ethereum gibi blokzincirlerde yeni bloklar, madenci denilen kişiler tarafından oluşturulur. Yeni bir blok gerektiğinde, hesaplama problemi ağa gönderilir. PoW problemini ilk çözen madenci yeni bloğu oluşturur ve Bitcoin ile ödüllendirilir (yeni Bitcoin’ler aslında bu şekilde yaratılır). Doğru ispatı bulma "piyangosu", yeni blok oluşturma gücünün merkeziyetsiz kalmasını sağlar. Yeni bir blok kazıldığında (mined) herkese gönderilir; böylece ağdaki her düğümün en güncel blokzincirin bir kopyası olur. Ağdaki en uzun blokzincirin ("en çok işin harcandığı" zincirin) geçerli sürüm olduğu fikrine "merkeziyetsiz mutabakat" denir.

Bitcoin örneğinde PoW problemi, belirli sayıda baştaki sıfıra sahip hash’ler üreten sayıları bulma problemidir (bulduğum en iyi açıklama Savjee’nin şu videosu). Ağdaki hesaplama hızındaki artışa ve madenci sayısındaki dalgalanmalara uyum sağlamak için PoW’un zorluğu ayarlanabilir; böylece yeni bir blok oluşturma süresi yaklaşık on dakika civarında sabit tutulur.

4. Yeni Bloklar Eklemek

Artık bir bloğun nasıl göründüğünü, blokların hash’ler kullanılarak nasıl zincirlendiğini ve yeni blokların oluşturulma hızının PoW ile nasıl düzenlendiğini biliyorsunuz. Şimdi hepsini bir fonksiyonda birleştirelim:

    #A function that takes the previous block and normally some data (in our case the data is a string indicating which block in the chain it is)
    gen_new_block <- function(previous_block){

      #Proof-of-Work
      new_proof <- proof_of_work(previous_block$proof)

      #Create new Block
      new_block <- list(index = previous_block$index + 1,
                        timestamp = Sys.time(),
                        data = paste0("this is block ", previous_block$index +1),
                        previous_hash = previous_block$new_hash,
                        proof = new_proof)

      #Hash the new Block
      new_block_hashed <- hash_block(new_block)

      return(new_block_hashed)
    }

Blokzincirinizi oluşturmaya başlamadan önce zinciri bir yerden başlatmanız gerekir. Bu, sözde Genesis Bloğu kullanılarak yapılır. Veri içermez ve ispat ile önceki hash için keyfî değerler taşır (çünkü önceki bir blok yoktur).

    # Define Genesis Block (index 1 and arbitrary previous hash)
    block_genesis <-  list(index = 1,
                           timestamp = Sys.time(),
                           data = "Genesis Block",
                           previous_hash = "0",
                           proof = 1)

5. Blokzinciri İnşa Etmek

Artık blokzinciri oluşturmaya başlayabilirsiniz. Genesis bloğuyla başlar ve ardından bir döngü kullanarak birkaç blok eklersiniz.

    blockchain <- list(block_genesis)
    previous_block <- blockchain[[1]]

      # How many blocks should we add to the chain after the genesis block
      num_of_blocks_to_add <- 5

      # Add blocks to the chain
      for (i in 1: num_of_blocks_to_add){
        block_to_add <- gen_new_block(previous_block) 
        blockchain[i+1] <- list(block_to_add)
        previous_block <- block_to_add

        print(cat(paste0("Block ", block_to_add$index, " has been added", "\n",
                   "\t", "Proof: ", block_to_add$proof, "\n",
                   "\t", "Hash: ", block_to_add$new_hash)))
      }

    ## Block 2 has been added
    ##  Proof: 99
    ##  Hash: 7d3dfbb58b410838769f6080dbc62a44a4c5d411a41048c4e597d26dccd1cd38NULL
    ## Block 3 has been added
    ##  Proof: 198
    ##  Hash: 4f8bdd79d751f9e9829c14c52a737f257285b61e54b29531dd59bf1a530f1097NULL
    ## Block 4 has been added
    ##  Proof: 396
    ##  Hash: 512b877c4ff92605d9fe10ac73ced20f748742964f306c211c4691f15425a26eNULL
    ## Block 5 has been added
    ##  Proof: 792
    ##  Hash: a3baaa025186c5bcb2238a888bc65e705ffe73c17dc5c8f26ee337fd62867993NULL
    ## Block 6 has been added
    ##  Proof: 1584
    ##  Hash: d12c3f54c14f3287a9f31ab542271197ba6a658cee561a9289819dd563fe4991NULL

Çok daha fazla blok eklemek isterseniz bunun giderek daha uzun sürdüğünü fark edersiniz. Bunun nedeni, ispat numarasının üstel olarak artmasıdır.

Bitcoin gibi kripto paralar için bu bir sorun olurdu; çünkü yeni bir blok oluşturma süresi aşağı yukarı sabit olmalıdır (Bitcoin’de yaklaşık 10 dakika). Bu nedenle, belirli bir anda ağdaki hesaplama hızındaki artış ve madenci sayısındaki değişimleri telafi etmek için PoW’un zorluğu sürekli ayarlanmalıdır.

Son olarak, zincirinizdeki bir blok şöyle görünüyor:

    blockchain[[5]]

    ## $index
    ## [1] 5
    ## 
    ## $timestamp
    ## [1] "2018-02-08 12:02:56 GMT"
    ## 
    ## $data
    ## [1] "this is block 5"
    ## 
    ## $previous_hash
    ## [1] "26cdc16a4560df5fa2fd521dbca22670e2475c35d3dd90781872bee98a164eef"
    ## 
    ## $proof
    ## [1] 792
    ## 
    ## $new_hash
    ## [1] "2eef25bf0bc4ee81e8c7cd1dfda65855b4ba32aba218d8c525a03a72b3454d74"

Özet

Bu kısa yazıda, en küçük blokzinciri uygulamasını yaptınız. Ana hedef, bir blokzincirin nasıl göründüğünü ve arkasındaki temel kavramlardan bazılarını tanıtmaktı. Kriptografinin dahiyane uygulamasını anlamak, insanların blokzincirin sunduğu imkânlar konusunda neden bu kadar heyecanlandığını gerçekten gösteriyor.

Bir blokzinciri üretim ortamına almak için çok daha fazla çalışma gerekir: bir API kurmak, cüzdanlar oluşturmak, açık-özel anahtar çiftleriyle dijital imzalar vb. Ayrıca, blokzincir ağının kalbinde yer alan merkeziyetsiz mutabakat kavramına da yalnızca yüzeysel olarak değindim.

Bu kısa giriş, "en küçük blokzinciri"ni Python’da uygulayan Gerald Nash’in blog yazısından yararlanır. Ben bunu R ile uyguladım ve Daniel van Flymen’in PoW uygulamasını ekledim.

Blokzincir konusuna daha derinlemesine dalmak için Satoshi Nakamoto’nun mükemmel, orijinal Bitcoin teknik makalesini ve BigData Doc’un blog yazısını öneririm.

Bu yazı hakkında herhangi bir düşünceniz veya yanıtınız varsa, Twitter’dan bana ulaşabilirsiniz: @jj_mllr adresindeyim; ayrıca veriye daha kapsayıcı, bütünleşik ve yenilikçi bir yaklaşımla dünyayı değiştirmek isteyen genç veri analistlerinden oluşan bir ağ olan @CorrelAid’e de göz atabilirsiniz.