Cursus
Introductie tot R
4 uur
3.1M
Iedereen heeft het tegenwoordig over cryptovaluta – dankzij de hype rondom Bitcoin. Veel interessanter dan de vraag of er een Bitcoin-bubbel is, is hoe deze technologie eigenlijk werkt en waartoe ze in staat is. Het verhaal van Bitcoin begon in 2008 met een whitepaper genaamd "Bitcoin: A Peer-to-Peer Electronic Cash System". In dit document introduceert de auteur met de naam Satoshi Nakamoto (er is nog steeds veel discussie over wie Satoshi echt is) een nieuwe, revolutionaire technologie en idee: een gedecentraliseerde elektronische munt die draait op iets dat de blockchain heet. Het idee verspreidde zich vanaf dat moment en is nu toepasbaar op veel andere gebieden.
Ik maakte voor het eerst kennis met blockchains tijdens een bijeenkomst van de BlockchainSociety in Oxford. Iedereen daar leek erg enthousiast over het potentieel van deze nieuwe technologie. En eerlijk is eerlijk, het klinkt intrigerend: een gedecentraliseerde, onomkoopbare database van financiële transacties, contracten of wat je maar wilt (bijvoorbeeld niet te hacken stemmachines). De belofte van de blockchain aan de cryptogemeenschap is dat deze hele sectoren zal ontwrichten door vertrouwen te revolutioneren, zodat we geen derde partijen zoals banken of advocaten meer nodig hebben – alleen de kracht van cryptografie.
Hoewel het basisidee vrij intuïtief is, is het technisch werkingsprincipe van blockchains wat lastiger te doorgronden. Vorige week stuitte ik op dit artikel op R-bloggers, waarin BigData Doc een blockchain volledig in R bouwt. Een blockchain in R is misschien niet het meest efficiënte of praktische ter wereld, maar het is wel een geweldige manier om de programmeer- en cryptoprincipes erachter te begrijpen. Ik wilde het ook begrijpen en daarom heb ik een kleinere versie van de blockchain in R geïmplementeerd: "Als je het kunt coderen, begrijp je het zeker".
Wat is een blockchain?
Stel, je doel is om data veilig op te slaan. Daarvoor sla je de data eerst op in een container – die je een blok noemt. In het geval van Bitcoin bevat elk blok meerdere financiële transacties. Als er nieuwe transacties (of nieuwe data) zijn, wordt een nieuw blok gecreëerd en samen met eerdere blokken toegevoegd om een keten te vormen – de blockchain.
Laten we eens kijken hoe blockchains cryptografie gebruiken om in de praktijk vrijwel niet te hacken te zijn.
1. Blokken
block_example <- list(index = 1,
timestamp = "2018-01-05 17.00 MST",
data = "some data",
previous_hash = 0,
proof = 9,
new_hash = NULL)
Voordat je de blockchain kunt gaan bouwen – oftewel verschillende containers met data aan elkaar koppelen – moet je nog twee concepten leren kennen: hashing en Proof-of-Work-algoritmen.
2. Hash
Een hash helpt de integriteit van een blok te waarborgen door het te verbinden met de andere blokken in de keten. Een hashfunctie neemt iets als input en geeft je een unieke, versleutelde output. Een voorbeeld: je geeft je vriend(in) de puzzel "Wat is het betere statistiekprogramma: Stata of R?" en je geeft haar de hash van het juiste antwoord: "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86". Zij kan nu zelf controleren of ze het juiste antwoord heeft door haar antwoord in te voeren in de hashfunctie (in dit geval het SHA256-algoritme):
library("digest")
digest("Stata" ,"sha256") # first try
## [1] "3ac273f00d52dc9caf89cbd71e73e5915229a588117ca3441630089409ddb7bc"
digest("R", "sha256") # second try
## [1] "71ec0b920622cf4358bbc21d6a8b41f903584808db53ec07a8aa79119304ce86"
Hoe helpt dit jou?
In dit geval voer je niet alleen informatie over het blok (index, timestamp, data) in de hashfunctie in, maar ook de hash van het vorige blok. Dat betekent dat je de geldige hash alleen kunt berekenen als je de hash van het vorige blok kent, die weer is gemaakt met de hash van het blok daarvoor, enzovoort. Dit levert een onveranderlijke, sequentiële keten van blokken op. Als je achteraf één blok zou aanpassen, zou je alle hashes voor de opvolgende blokken opnieuw moeten berekenen.
#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. Proof-of-Work
Als er veel informatie in de blockchain moet worden opgeslagen, moet je veel nieuwe blokken aanmaken. In veel gevallen wil je controleren hoeveel nieuwe blokken er worden gemaakt. Bij cryptovaluta zouden munten bijvoorbeeld hun waarde verliezen als er elke seconde een oneindige hoeveelheid munten kan worden gecreëerd.
Daarom voegen we een zogenoemd "Proof-of-Work" (PoW)-algoritme toe dat de moeilijkheid van het maken van een nieuw blok regelt. "Proof" betekent dat de computer een bepaalde hoeveelheid werk heeft verricht. In de praktijk is het doel een item te creëren dat moeilijk te maken, maar gemakkelijk te verifiëren is. Ik gebruik de volgende "taak" als PoW: vind het eerstvolgende getal dat deelbaar is door 99 én deelbaar is door het proof-getal van het vorige blok.
### 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)
}
Bij blockchains zoals Bitcoin of Ethereum wordt het aanmaken van nieuwe blokken gedaan door zogeheten miners. Wanneer een nieuw blok moet worden gemaakt, wordt er een rekenprobleem naar het netwerk gestuurd. De miner die het PoW-probleem als eerste oplost, creëert het nieuwe blok en wordt beloond in bitcoins (zo worden nieuwe bitcoins daadwerkelijk gecreëerd). Deze "loterij" van het vinden van de juiste nieuwe proof zorgt ervoor dat de macht om nieuwe blokken te maken gedecentraliseerd is. Wanneer een nieuw blok is gemined, wordt het naar iedereen verzonden zodat elke node in het netwerk een kopie van de nieuwste blockchain heeft. Het idee dat de langste blockchain in het netwerk (degene waar "het meeste werk in is gestoken") de geldige versie van de blockchain is, wordt "gedecentraliseerd consensus" genoemd.
In het geval van Bitcoin houdt het PoW-probleem in dat je getallen moet vinden die hashes genereren met een bepaald aantal voorloopnullen (de beste uitleg die ik vond is deze video van Savjee). Om rekening te houden met toenemende rekenkracht en wisselende aantallen miners in het netwerk kan de moeilijkheid van de PoW worden aangepast, zodat de tijd om een nieuw blok te creëren constant blijft op ongeveer tien minuten.
4. Nieuwe blokken toevoegen
Je weet nu hoe een blok eruitziet, hoe blokken met hashes aan elkaar worden geketend en hoe het tempo van het aanmaken van nieuwe blokken wordt gereguleerd door PoW's. Laten we dit samenbrengen in een functie:
#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)
}
Voordat je je blockchain gaat bouwen, moet je de keten ergens starten. Dit gebeurt met een zogenoemd Genesis-blok. Het bevat geen data en arbitraire waarden voor proof en vorige hash (omdat er geen vorig blok is).
# 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. De blockchain bouwen
Nu kun je de blockchain gaan bouwen. Je begint met het Genesis-blok en voegt vervolgens een paar blokken toe met een lus.
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
Als je veel meer blokken wilt toevoegen, merk je dat het steeds meer tijd kost. De reden is dat het proof-getal exponentieel toeneemt.
Voor cryptovaluta zoals Bitcoin zou dit een probleem zijn, omdat de tijd om een nieuw blok te maken min of meer constant moet zijn (rond de 10 minuten in het geval van Bitcoin). Daarom moet de moeilijkheid van PoW continu worden aangepast om rekening te houden met toenemende rekenkracht en wisselende aantallen miners in het netwerk op een bepaald moment.
Tot slot, zo ziet één blok in je keten eruit:
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"
Afronding
In dit korte artikel heb je de allerkleinste blockchain gemaakt. Het hoofddoel was te laten zien hoe een blockchain eruitziet en enkele van de kernconcepten erachter te introduceren. Het begrijpen van de geniale toepassing van cryptografie laat goed zien waarom mensen zo enthousiast worden over de mogelijkheden van de blockchain.
Om een blockchain in productie te brengen is veel meer werk nodig: een API opzetten, wallets creëren, digitale handtekeningen met public-private-sleutelparen, enzovoort. Ik heb ook slechts aan de oppervlakte gekrast van het concept van gedecentraliseerde consensus, dat het hart vormt van het blockchainnetwerk.
Deze korte introductie leunt op de blogpost van Gerald Nash, die de "tiniest blockchain" in Python implementeerde. Ik heb hem in R geïmplementeerd en de PoW-implementatie toegevoegd van Daniel van Flymen.
Om dieper in het onderwerp blockchains te duiken, raad ik het briljante, originele whitepaper over Bitcoin van Satoshi Nakamoto aan en de blogpost van BigData Doc.
Als je ideeën of reacties op deze blogpost hebt, neem dan gerust contact met me op via Twitter: je vindt me op @jj_mllr of bekijk @CorrelAid, een netwerk van jonge data-analisten dat de wereld wil veranderen met een meer inclusieve, geïntegreerde en innovatieve aanpak van data-analyse.
Onderwerpen
