created blockchain demo

Author: Juraj Veverka

block-chain/.gitignore

@@ -0,0 +1,11 @@
+.gradle
+.settings
+bin
+build
+build_gradle
+out
+.classpath
+.project
+java-logging.log
+*.iml
+.idea

block-chain/README.md

@@ -0,0 +1,29 @@
+# Simple BlockChain demo
+
+This is simple block-chain demo for java, using sha256 hashing algorithm.
+
+There are two block-chain implementations. 
+1. simple one in ```itx.examples.blockchain.simple``` which does not require proof-of-work (mining) for next block to be 
+added into ledger. This implementation is much faster.
+2. advanced one in ```itx.examples.blockchain.advanced``` which requires proof-of-work (mining) for next block to be added into ledger. 
+When new block is added into ledger, it's hash and nonce is setup to meed certain criteria. This procedure takes computing time.
+This implementation is inspired by [this](https://www.youtube.com/watch?v=_160oMzblY8&t=204s) video tutorial.
+
+
+### Example of use 
+```
+LedgerBuilder ledgerBuilder = new LedgerBuilder();
+ledgerBuilder.setId("ledger 1");
+ledgerBuilder.setHashPrefix("00"); //<- this is only for advanced ledger
+ledgerBuilder.addData("data 1");
+ledgerBuilder.addData("data 2");
+ledgerBuilder.addData("data 3");
+ledgerBuilder.addData("data 4");
+
+Ledger ledger = ledgerBuilder.build();
+
+boolean ledgerOk = BlockChainUtils.verifyLedger(ledger);
+```
+
+#### Build 
+```gradle clean build```

block-chain/build.gradle

@@ -0,0 +1,25 @@
+
+apply plugin: 'java'
+apply plugin: 'maven'
+
+sourceCompatibility = 10
+targetCompatibility = 10
+        
+repositories {
+   mavenCentral()
+}
+
+dependencies {
+   compile 'org.slf4j:slf4j-api:1.8.0-beta2'
+   compile 'org.slf4j:slf4j-simple:1.8.0-beta2'
+   testCompile 'org.testng:testng:6.14.3'
+}
+
+test {
+   // enable TestNG support (default is JUnit)
+   useTestNG()
+   testLogging {
+      events "passed", "skipped", "failed"
+   }
+}
+

block-chain/src/main/java/itx/examples/blockchain/CommonUtils.java

@@ -0,0 +1,41 @@
+package itx.examples.blockchain;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+public final class CommonUtils {
+
+    private CommonUtils() {
+    }
+
+    private static MessageDigest digest;
+
+    static {
+        try {
+            digest = MessageDigest.getInstance("SHA-256");
+        } catch (NoSuchAlgorithmException e) {
+            digest = null;
+        }
+    }
+
+    public static final String GENESIS_BLOCK_ID = "0";
+    public static final String GENESIS_BLOCK_PREVIOUS_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
+
+    public static String getNextBlockId(String lastBlockId) {
+        Long id = Long.parseLong(lastBlockId) + 1;
+        return id.toString();
+    }
+
+    public static String createSHA256Hash(String data) {
+        byte[] encodedHash = digest.digest(data.getBytes(StandardCharsets.UTF_8));
+        return bytesToHex(encodedHash);
+    }
+
+    public static String bytesToHex(byte[] bytes) {
+        StringBuffer result = new StringBuffer();
+        for (byte byt : bytes) result.append(Integer.toString((byt & 0xff) + 0x100, 16).substring(1));
+        return result.toString();
+    }
+
+}

block-chain/src/main/java/itx/examples/blockchain/advanced/Block.java

@@ -0,0 +1,39 @@
+package itx.examples.blockchain.advanced;
+
+public class Block {
+
+    private String id;
+    private String nonce;
+    private String data;
+    private String previousHash;
+    private String hash;
+
+    public Block(String id, String nonce, String data, String previousHash, String hash) {
+        this.id = id;
+        this.nonce = nonce;
+        this.data = data;
+        this.previousHash = previousHash;
+        this.hash = hash;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getNonce() {
+        return nonce;
+    }
+
+    public String getData() {
+        return data;
+    }
+
+    public String getHash() {
+        return hash;
+    }
+
+    public String getPreviousHash() {
+        return previousHash;
+    }
+
+}

block-chain/src/main/java/itx/examples/blockchain/advanced/BlockBuilder.java

@@ -0,0 +1,42 @@
+package itx.examples.blockchain.advanced;
+
+public class BlockBuilder {
+
+    private String id;
+    private String nonce;
+    private String data;
+    private String previousHash;
+
+    public BlockBuilder setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public BlockBuilder setNonce(String nonce) {
+        this.nonce = nonce;
+        return this;
+    }
+
+    public BlockBuilder setData(String data) {
+        this.data = data;
+        return this;
+    }
+
+    public BlockBuilder setPreviousHash(String previousHash) {
+        this.previousHash = previousHash;
+        return this;
+    }
+
+    public BlockBuilder from (Block block) {
+        this.id = block.getId();
+        this.nonce = block.getNonce();
+        this.data = block.getData();
+        this.previousHash = block.getPreviousHash();
+        return this;
+    }
+
+    public Block build() {
+        return new Block(id, nonce, data, previousHash, BlockChainUtils.createSHA256Hash(id, nonce, data, previousHash));
+    }
+
+}

block-chain/src/main/java/itx/examples/blockchain/advanced/BlockChainUtils.java

@@ -0,0 +1,98 @@
+package itx.examples.blockchain.advanced;
+
+import itx.examples.blockchain.CommonUtils;
+
+public final class BlockChainUtils {
+
+    private BlockChainUtils() {
+    }
+
+    private static final String ALPHABET = "0123456789abcdefghijklmnopqrstuvxywz";
+
+    public static String getNextNonce(String lastNonce) {
+        if (lastNonce == null) return String.valueOf(ALPHABET.charAt(0));
+        int maxIndex = ALPHABET.length() - 1;
+        StringBuilder nextNonce = new StringBuilder(lastNonce);
+        int remainder = 0;
+        for (int i=(lastNonce.length()-1); i>=0; i--) {
+            int nextIndex = ALPHABET.indexOf(lastNonce.charAt(i)) + 1;
+            if (nextIndex <= maxIndex) {
+                nextNonce.setCharAt(i, ALPHABET.charAt(nextIndex));
+                remainder = 0;
+                break;
+            } else {
+                nextNonce.setCharAt(i, ALPHABET.charAt(0));
+                remainder = 1;
+            }
+        }
+        if (remainder != 0) {
+            return ALPHABET.charAt(0) + nextNonce.toString();
+        } else {
+            return nextNonce.toString();
+        }
+    }
+
+    public static String createSHA256Hash(Block block) {
+        String blockData = block.getId() + block.getNonce() + block.getData() + block.getPreviousHash();
+        return CommonUtils.createSHA256Hash(blockData);
+    }
+
+    public static String createSHA256Hash(String id, String nonce, String data, String previousHash) {
+        String blockData = id + nonce + data + previousHash;
+        return CommonUtils.createSHA256Hash(blockData);
+    }
+
+    public static boolean isValid(Block block, String hashPrefix) {
+        return block.getHash().startsWith(hashPrefix);
+    }
+
+    public static Block mineGenesisBlock(String data, String hashPrefix) {
+        String nextId = CommonUtils.GENESIS_BLOCK_ID;
+        return mineForValidBlock(nextId, data, CommonUtils.GENESIS_BLOCK_PREVIOUS_HASH, hashPrefix);
+    }
+
+    public static Block mineNextBlock(Block lastBlock, String data, String hashPrefix) {
+        String nextId = CommonUtils.getNextBlockId(lastBlock.getId());
+        return mineForValidBlock(nextId, data, lastBlock.getHash(), hashPrefix);
+    }
+
+    private static Block mineForValidBlock(String id, String data, String previousHash, String hashPrefix) {
+        String nonce = getNextNonce(null);
+        Block nextBlock = new BlockBuilder()
+                .setId(id)
+                .setNonce(nonce)
+                .setData(data)
+                .setPreviousHash(previousHash)
+                .build();
+        while (true) {
+            if (isValid(nextBlock, hashPrefix)) break;
+            nonce = getNextNonce(nonce);
+            nextBlock = new BlockBuilder()
+                    .from(nextBlock)
+                    .setNonce(nonce)
+                    .build();
+        }
+        return nextBlock;
+    }
+
+    public static boolean verifyBlock(Block block, Block previousBlock, String hashPrefix) {
+        return (verifyBlock(block, hashPrefix) && verifyBlock(previousBlock, hashPrefix) && block.getPreviousHash().equals(previousBlock.getHash()));
+    }
+
+    public static boolean verifyBlock(Block block, String hashPrefix) {
+        String hash = createSHA256Hash(block);
+        return (hash.equals(block.getHash()) && isValid(block, hashPrefix));
+    }
+
+    public static boolean verifyLedger(Ledger ledger) {
+        for (int i=(ledger.size()-1); i>0; i--) {
+            Block previousBlock = ledger.getBlockAt(i - 1);
+            Block block = ledger.getBlockAt(i);
+            if (!verifyBlock(block, previousBlock, ledger.getHashPrefix())) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+}

block-chain/src/main/java/itx/examples/blockchain/advanced/Ledger.java

@@ -0,0 +1,38 @@
+package itx.examples.blockchain.advanced;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Ledger {
+
+    private String id;
+    private String hashPrefix;
+    private List<Block> blocks;
+
+    public Ledger(String id, String hashPrefix, List<Block> blocks) {
+        this.id = id;
+        this.hashPrefix = hashPrefix;
+        this.blocks = blocks;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getHashPrefix() {
+        return hashPrefix;
+    }
+
+    public List<Block> getBlocks() {
+        return Collections.unmodifiableList(blocks);
+    }
+
+    public int size() {
+        return blocks.size();
+    }
+
+    public Block getBlockAt(int index) {
+        return blocks.get(index);
+    }
+
+}

block-chain/src/main/java/itx/examples/blockchain/advanced/LedgerBuilder.java

@@ -0,0 +1,49 @@
+package itx.examples.blockchain.advanced;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LedgerBuilder {
+
+    private String id;
+    private String hashPrefix;
+    private List<Block> blocks;
+
+    public LedgerBuilder() {
+        blocks = new ArrayList<>();
+    }
+
+    public LedgerBuilder setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public LedgerBuilder setHashPrefix(String hashPrefix) {
+        this.hashPrefix = hashPrefix;
+        return this;
+    }
+
+    public LedgerBuilder from(Ledger ledger) {
+        this.id = ledger.getId();
+        this.hashPrefix = ledger.getHashPrefix();
+        this.blocks = new ArrayList<>(ledger.getBlocks());
+        return this;
+    }
+
+    public LedgerBuilder addData(String data) {
+        if (blocks.size() == 0) {
+            Block nextBlock = BlockChainUtils.mineGenesisBlock(data, hashPrefix);
+            this.blocks.add(nextBlock);
+        } else {
+            Block lastBlock = blocks.get(blocks.size() - 1);
+            Block nextBlock = BlockChainUtils.mineNextBlock(lastBlock, data, hashPrefix);
+            this.blocks.add(nextBlock);
+        }
+        return this;
+    }
+
+    public Ledger build() {
+        return new Ledger(id, hashPrefix, blocks);
+    }
+
+}