Complete section: Proof of Work

Author: 15Dkatz

README.md

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

backend/blockchain/block.py

@@ -1,6 +1,10 @@
 import time
 
 from backend.util.crypto_hash import crypto_hash
+<<<<<<< HEAD
+=======
+from backend.util.hex_to_binary import hex_to_binary
+>>>>>>> a77fccd... Complete proof of work section
 from backend.config import MINE_RATE
 
 GENESIS_DATA = {
@@ -25,9 +29,12 @@ def __init__(self, timestamp, last_hash, hash, data, difficulty, nonce):
         self.difficulty = difficulty
         self.nonce = nonce
 
+<<<<<<< HEAD
     def add_block(self, data):
         self.chain.append(Block(data))
 
+=======
+>>>>>>> a77fccd... Complete proof of work section
     def __repr__(self):
         return (
             'Block('
@@ -51,7 +58,7 @@ def mine_block(last_block, data):
         nonce = 0
         hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)
 
-        while hash[0:difficulty] != '0' * difficulty:
+        while hex_to_binary(hash)[0:difficulty] != '0' * difficulty:
             nonce += 1
             timestamp = time.time_ns()
             difficulty = Block.adjust_difficulty(last_block, timestamp)
@@ -70,8 +77,8 @@ def genesis():
     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 slowly mined blocks.
+        Increase the difficulty for quickly mined blocks.
         """
         if (new_timestamp - last_block.timestamp) < MINE_RATE:
             return last_block.difficulty + 1
@@ -84,7 +91,14 @@ def adjust_difficulty(last_block, new_timestamp):
 def main():
     genesis_block = Block.genesis()
     block = Block.mine_block(genesis_block, 'foo')
+<<<<<<< HEAD
     print(f'block: {block}')
 
 if __name__ == '__main__':
     main()
+=======
+    print(block)
+
+if __name__ == '__main__':
+    main()
+>>>>>>> a77fccd... Complete proof of work section

backend/blockchain/blockchain.py

@@ -20,7 +20,7 @@ def main():
     blockchain.add_block('two')
 
     print(blockchain)
-    print(f'blockchain.py __name__: {__name__}')
+    print(f'blockchain.py ___name__: {__name__}')
 
 if __name__ == '__main__':
     main()

backend/config.py

@@ -3,4 +3,4 @@
 MILLISECONDS = 1000 * MICROSECONDS
 SECONDS = 1000 * MILLISECONDS
 
-MINE_RATE = 4 * SECONDS
+MINE_RATE = 4 * SECONDS

backend/scripts/average_block_rate.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/tests/blockchain/test_block.py

@@ -1,4 +1,8 @@
+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()
@@ -8,10 +12,39 @@ def test_mine_block():
     assert isinstance(block, Block)
     assert block.data == data
     assert block.last_hash == last_block.hash
-    assert block.hash[0:block.difficulty] == '0' * block.difficulty
+    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():
-        assert getattr(genesis, key) == value
+        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/tests/util/test_crypto_hash.py

@@ -1,7 +1,7 @@
 from backend.util.crypto_hash import crypto_hash
 
 def test_crypto_hash():
-    # It should create the same hash with arguments of different data types in
-    # any order
+    # It should create the same hash with arguments of different data types
+    # in any order
     assert crypto_hash(1, [2], 'three') == crypto_hash('three', 1, [2])
     assert crypto_hash('foo') == 'b2213295d564916f89a6a42455567c87c3f480fcd7a1c15e220f17d7169a790b'

backend/tests/util/test_hex_to_binary.py

@@ -0,0 +1,8 @@
+from backend.util.hex_to_binary import hex_to_binary
+
+def test_hex_to_binary():
+    original_number = 789
+    hex_number = hex(original_number)[2:]
+    binary_number = hex_to_binary(hex_number)
+
+    assert int(binary_number, 2) == original_number

backend/util/crypto_hash.py

@@ -15,4 +15,4 @@ def main():
     print(f"crypto_hash(2, 'one', [3]): {crypto_hash(2, 'one', [3])}")
 
 if __name__ == '__main__':
-    main()
+    main()

backend/util/hex_to_binary.py

@@ -0,0 +1,45 @@
+from backend.util.crypto_hash import crypto_hash
+
+HEX_TO_BINARY_CONVERSION_TABLE = {
+    '0': '0000',
+    '1': '0001',
+    '2': '0010',
+    '3': '0011',
+    '4': '0100',
+    '5': '0101',
+    '6': '0110',
+    '7': '0111',
+    '8': '1000',
+    '9': '1001',
+    'a': '1010',
+    'b': '1011',
+    'c': '1100',
+    'd': '1101',
+    'e': '1110',
+    'f': '1111'
+}
+
+def hex_to_binary(hex_string):
+    binary_string = ''
+
+    for character in hex_string:
+        binary_string += HEX_TO_BINARY_CONVERSION_TABLE[character]
+
+    return binary_string
+
+def main():
+    number = 451
+    hex_number = hex(number)[2:]
+    print(f'hex_number: {hex_number}')
+
+    binary_number = hex_to_binary(hex_number)
+    print(f'binary_number: {binary_number}')
+
+    original_number = int(binary_number, 2)
+    print(f'original_number: {original_number}')
+
+    hex_to_binary_crypto_hash = hex_to_binary(crypto_hash('test-data'))
+    print(f'hex_to_binary_crypto_hash: {hex_to_binary_crypto_hash}')
+
+if __name__ == '__main__':
+    main()