Complete proof of work section

Author: 15Dkatz

.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+*__pycache__*
+*node_modules*

README.md

@@ -0,0 +1,17 @@
+**Activate the virtual environment**
+```
+source blockchain-env/bin/activate
+```
+
+**Install all packages**
+```
+pip3 install -r requirements.txt
+```
+
+**Run the tests**
+
+Make sure to activate the virtual environment.
+
+```
+python3 -m pytest backend/tests
+```

backend/__init__.py

@@ -0,0 +1,88 @@
+import time
+
+from backend.util.crypto_hash import crypto_hash
+from backend.util.hex_to_binary import hex_to_binary
+from backend.config import MINE_RATE
+
+GENESIS_DATA = {
+    'timestamp': 1,
+    'last_hash': 'genesis_last_hash',
+    'hash': 'genesis_hash',
+    'data': [],
+    'difficulty': 3,
+    'nonce': 'genesis_nonce'
+}
+
+class Block:
+    """
+    Block: a unit of storage.
+    Store transactions in a blockchain that supports a cryptocurrency.
+    """
+    def __init__(self, timestamp, last_hash, hash, data, difficulty, nonce):
+        self.timestamp = timestamp
+        self.last_hash = last_hash
+        self.hash = hash
+        self.data = data
+        self.difficulty = difficulty
+        self.nonce = nonce
+
+    def __repr__(self):
+        return (
+            'Block('
+            f'timestamp: {self.timestamp}, '
+            f'last_hash: {self.last_hash}, '
+            f'hash: {self.hash}, '
+            f'data: {self.data}, '
+            f'difficulty: {self.difficulty}, '
+            f'nonce: {self.nonce})'
+        )
+
+    @staticmethod
+    def mine_block(last_block, data):
+        """
+        Mine a block based on the given last_block and data, until a block hash
+        is found that meets the leading 0's proof of work requirement.
+        """
+        timestamp = time.time_ns()
+        last_hash = last_block.hash
+        difficulty = Block.adjust_difficulty(last_block, timestamp)
+        nonce = 0
+        hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)
+
+        while hex_to_binary(hash)[0:difficulty] != '0' * difficulty:
+            nonce += 1
+            timestamp = time.time_ns()
+            difficulty = Block.adjust_difficulty(last_block, timestamp)
+            hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)
+
+        return Block(timestamp, last_hash, hash, data, difficulty, nonce)
+
+    @staticmethod
+    def genesis():
+        """
+        Generate the genesis block.
+        """
+        return Block(**GENESIS_DATA)
+
+    @staticmethod
+    def adjust_difficulty(last_block, new_timestamp):
+        """
+        Calculate the adjusted difficulty according to the MINE_RATE.
+        Increase the difficulty for slowly mined blocks.
+        Decrease the difficulty for quickly mined blocks.
+        """
+        if (new_timestamp - last_block.timestamp) < MINE_RATE:
+            return last_block.difficulty + 1
+
+        if (last_block.difficulty - 1) > 0:
+            return last_block.difficulty - 1
+
+        return 1
+
+def main():
+    genesis_block = Block.genesis()
+    block = Block.mine_block(genesis_block, 'foo')
+    print(block)
+
+if __name__ == '__main__':
+    main()

backend/blockchain/__init__.py

@@ -0,0 +1,26 @@
+from backend.blockchain.block import Block
+
+class Blockchain:
+    """
+    Blockchain: a public ledger of transactions.
+    Implemented as a list of blocks - data sets of transactions
+    """
+    def __init__(self):
+        self.chain = [Block.genesis()]
+
+    def add_block(self, data):
+        self.chain.append(Block.mine_block(self.chain[-1], data))
+
+    def __repr__(self):
+        return f'Blockchain: {self.chain}'
+
+def main():
+    blockchain = Blockchain()
+    blockchain.add_block('one')
+    blockchain.add_block('two')
+
+    print(blockchain)
+    print(f'blockchain.py ___name__: {__name__}')
+
+if __name__ == '__main__':
+    main()

backend/blockchain/block.py

@@ -0,0 +1,6 @@
+NANOSECONDS = 1
+MICROSECONDS = 1000 * NANOSECONDS
+MILLISECONDS = 1000 * MICROSECONDS
+SECONDS = 1000 * MILLISECONDS
+
+MINE_RATE = 4 * SECONDS

backend/blockchain/blockchain.py

@@ -0,0 +1,22 @@
+import time
+
+from backend.blockchain.blockchain import Blockchain
+from backend.config import SECONDS
+
+blockchain = Blockchain()
+
+times = []
+
+for i in range(1000):
+    start_time = time.time_ns()
+    blockchain.add_block(i)
+    end_time = time.time_ns()
+
+    time_to_mine = (end_time - start_time) / SECONDS
+    times.append(time_to_mine)
+
+    average_time = sum(times) / len(times)
+
+    print(f'New block difficulty: {blockchain.chain[-1].difficulty}')
+    print(f'Time to mine new block: {time_to_mine}s')
+    print(f'Average time to add blocks: {average_time}s\n')

backend/config.py

@@ -0,0 +1,50 @@
+import time
+
+from backend.blockchain.block import Block, GENESIS_DATA
+from backend.config import MINE_RATE, SECONDS
+from backend.util.hex_to_binary import hex_to_binary
+
+def test_mine_block():
+    last_block = Block.genesis()
+    data = 'test-data'
+    block = Block.mine_block(last_block, data)
+
+    assert isinstance(block, Block)
+    assert block.data == data
+    assert block.last_hash == last_block.hash
+    assert hex_to_binary(block.hash)[0:block.difficulty] == '0' * block.difficulty
+
+def test_genesis():
+    genesis = Block.genesis()
+
+    assert isinstance(genesis, Block)
+    for key, value in GENESIS_DATA.items():
+        getattr(genesis, key) == value
+
+def test_quickly_mined_block():
+    last_block = Block.mine_block(Block.genesis(), 'foo')
+    mined_block = Block.mine_block(last_block, 'bar')
+
+    assert mined_block.difficulty == last_block.difficulty + 1
+
+def test_slowly_mined_block():
+    last_block = Block.mine_block(Block.genesis(), 'foo')
+    time.sleep(MINE_RATE / SECONDS)
+    mined_block = Block.mine_block(last_block, 'bar')
+
+    assert mined_block.difficulty == last_block.difficulty - 1
+
+def test_mined_block_difficulty_limits_at_1():
+    last_block = Block(
+        time.time_ns(),
+        'test_last_hash',
+        'test_hash',
+        'test_data',
+        1,
+        0
+    )
+
+    time.sleep(MINE_RATE / SECONDS)
+    mined_block = Block.mine_block(last_block, 'bar')
+
+    assert mined_block.difficulty == 1

backend/scripts/average_block_rate.py

@@ -0,0 +1,14 @@
+from backend.blockchain.blockchain import Blockchain
+from backend.blockchain.block import GENESIS_DATA
+
+def test_blockchain_instance():
+    blockchain = Blockchain()
+
+    assert blockchain.chain[0].hash == GENESIS_DATA['hash']
+
+def test_add_block():
+    blockchain = Blockchain()
+    data = 'test-data'
+    blockchain.add_block(data)
+
+    assert blockchain.chain[-1].data == data