{

"python.pythonPath": "blockchain-env/bin/python3"

}

**Activate the virtual environment**

<br>

This is a requirement because any change in the python module in the system can affect the whole code. A virtual environment will not cause any such problem to the system modules.

**Installing all the requirements**

<br>

All the requirements will be updated in the requirements.txt file hence there will not be any requirement of typing numbers of code.

**Running tests**

<br>

Make sure to activate the virtual environment first. Then later perform these tests.

**Running the app and API**

<br>

Make sure to activate the virtual environment first. Then perform these tests.

**Running a peer instance**

<br>

Make sure to activate the virtual environment.

*This will be updated accordingly*

My idea is to create a cryptocurrency system which I can utilise for payments inside the college. The idea is to create a full fledged cryptocurrency system with certain nodes and verification. I hope to make teacher's desktops as miners and students as the wallet holders. Teacher's desktop will verify and add the transaction details to the blockchain and on spending some computational power the teacher may recieve some incentive which will be decided during a later period. The value of the currency system will also be decided later on.

The notes provided are in chronological order. Even the words written are in chronological order.

<br>

- **Day 1(10/10/2020)**: Created the blockchain module and block module, also we have created the hashing function in the python-blockchain folder. The files are commented for anyone to understand the code.[END OF DAY 1]

- **Day 2(11/10/2020)**: We have updated our modules into packages, and we have put __init__.py function each of the folders. We have split the modules into two categories blockchain and util. Blockchain contains the block and blockchain module. Util contains the other utilities required in the function. We have also set up a virtual environment using the venv command and to activate the virtual environment we have used the shell/terminal command mentioned above in this file.

So to activate the package format we use

- I have also created some tests using Pytest. Pytest checks all the test cases at once rather than us have to type test cases inside the python file and then later we have to check cases for each of the files. Later I have also included time.asctime() to display the timestamp in form of string.[END OF DAY 2]

- **Day 3(18/10/2020)**: I have created the proof of work system in the Block.py module in the mine_block() method. I also have included certain tests in the test folder. Now I also have created a config.py file which will give the mention of the MINE_RATE. Now I have set the mine rate to 10 seconds. So we have to get the rate to around 10 seconds (4 seconds just for program purposes). Now we have added certain tests which support the proof of work system. Till now there was a hex based proof of work system but we need a binary form of proof of work system.

Now we have implemented a system for conversion of hex to binary and hence the difficulty determination is binary based work now. There is no new shell script other than testing the application.

Extra information is given in the required files.

- PART 2: Now I have implemented conditions required for validation of the block and test condtions in the test_block.py file. These tests will check the conditions necessary to validate a block. Also with the help of the pytest's 'with' keyword, we have been able to validate the require exception without the program crashing. Later we have provided test cases to validate a chain, which is basically validating multiple blocks. One important condition is that we have to validate the genesis block which we didn't do in block validation. Hence this was the extra thing we did in the blockchain validation. More stuff is given in programs as documentation string and as well as in commented blocks. Later we have included some chain texts which will help us setup nodes in the blockchain network. Later I will try to explain the use of REST api's and pubsub layers the best I can because I'm using it for the first time myself.[END OF DAY 3]

- **Day 4(25/10/2020)**: I have now setup Flask which is a python module used to create web applications as well as API. The installation of this module is updated in the requirements.txt file. This will install the required modules in the virtual environment. Then later I have been able to run the application which have helped to run this application as localhost. I have also imported the jsonify class to convert objects into JSON format which can be utilised by any application to read data. But then Blockchain class is not JSON serializable hence we need to provide a method in the blockchain class which does so. I have added a method which will return the string to it's JSON format which is either a dictionary, string, tuple, response instance or a valid callable. This ensures that the text in the blockchain gets jsonified and we will get the proper blockchain output in the JSON format which can be utilised by the application to access it's data. Later I also have setup the mine block route in the app directory's __init__.py file which does the mining method in the server. Later in the day I have installed requests module in python which will help get any peer node the already present blockchain data. This will ensure all the nodes remain upto date in the network.

- **Day 5(14/11/2020)**: Today I began my work with developing a cryptocurrency system in this project. I have started by making a folder for the wallet which has different parameters. A wallet should contain a public key, a private key, transactions and wallet balance. So by python I have created a wallet module (by adding an init file along with the main file.), this features wallet data mentioned above, method for signing transactions as well as verify them. Initially I have imported a UUID module which serves us as a Unique digital identifier, this will help us prevent repeating transactions over the same address. Our method for cryptography is EC(Elliptic cryptography), but soon our team will try to migrate to RSA cryptography. This method is highly complex mathematics and will not be easy to crack the original data once created. I have also updated the requirements.txt file in this folder so that future developers can collaborate into this project by downloading the required files. There are many inbuilt functions in the modules. I have also included a test to verify the wallet data in the tests folder in the backend module.

- Later I have also created a transaction module which facilates the transactions in this cryptocurrency network. This includes the wallet module created and uuid module which provides a unique identifier to the new module. The transactions module contains input structure and output structure which will record and calculate the balance necessities in a wallet. This includes exceeding balance which should result in a failure of transactions. We have also included tests for the transactions which will help us in correcting any error which comes into the code without having to run any programs again and again.

- **Day 6 (15/11/2020)**: Today I have installed another application which will bring us POST requests necessary for carrying out transactions, for that we have refactored some code which has helped in running the application smoothly (serialised public key and signature), I have imported a few encoding and decoding functions which will help convert byte strings to required format (either lists, tuples, dictionaries, strings, or booleans). We have also been able to get the signature values in the form of a tuple using elliptic key Cryptography decoding and encoding functions. The application we are using is POSTMAN (i guess which will not be required in later stages).

- Next I have created a transaction pool which will store the transaction data which will be available for the node to read. Later I am also trying to broadcast transactions by deserialising them back to it's instance which will help read the transaction data and it's output. Later this design will also help in implementation of the frontend mechanics.

- **Day 7(16/11/2020)**: Today our goal was to complete the backend part of our project. This involved linking our cryptocurrency system to our blockchain system. We already have built our blockchain module in it's entirity by taking the data as some test string. This test string is now replaced with the actual transaction data which we require during any transaction activity. We have jsonified this data hence this can be readable accross any websites. We have also performed some test app scripts which will send data in realtime to check whether the application works properly or not. During this process we also encountered that there are multiple outputs adding into the same recepient, we dealt with this by deleting the output from the list which has the same address. I guess we cannot send the same amount transactions to the same recipient, but I am sure we will be able to tackle that as well.

*This will also be updated on a later basis*

This project wouldn't have been possible without the help of certain people who although unknowingly helped me to understand concepts of Blockchain and Cryptocurrency systems. The course link which I took is given below.

[Udemy course on Cryptocurrency systems](https://www.udemy.com/share/102sB6AEAec15UQ3wJ/)

import os

import requests #Sends GET and POST requests in the application

import random

from flask import Flask , jsonify, request #This imports the Flask and jsonify class from the flask module.

from backend.blockchain.blockchain import Blockchain #Required to GET the blockchain data.

from backend.wallet.wallet import Wallet

from backend.wallet.transactions import Transactions

from backend.wallet.transaction_pool import TransactionPool

from backend.pubsub import PubSub

app = Flask(__name__) #Flask class takes one parameter which is name.

blockchain = Blockchain()

wallet = Wallet(blockchain)

transaction_pool = TransactionPool()

pubsub = PubSub(blockchain,transaction_pool)

#blockchain.addBlock(i)

def route_default():

return 'Welcome to the blockchian'

def route_blockchain():

return jsonify(blockchain.to_json())

def route_blockchain_mine():

transaction_data = transaction_pool.transaction_data()

transaction_data.append(Transactions.reward_transaction(wallet).to_json())

blockchain.addBlock(transaction_data)

block = blockchain.chain[-1]

pubsub.broadcast_block(block)

transaction_pool.clear_blockchain_transactions(blockchain)

return jsonify(block.to_json())

def route_wallet_transact():

transaction_data = request.get_json()

transaction = transaction_pool.existing_transaction(wallet.address)

if transaction:

transaction.update(

wallet,

transaction_data['recepient'],

transaction_data['amount']

)

else:

transaction = Transactions(

wallet,

transaction_data['recepient'],

transaction_data['amount']

)

pubsub.broadcast_transaction(transaction)

return jsonify(transaction.to_json())

def route_wallet_info():

return jsonify({'address':wallet.address, 'balance': wallet.balance })

ROOT_PORT = 5000

PORT = ROOT_PORT

if os.environ.get('PEER') == 'True':

PORT = random.randint(5001,6000)

result = requests.get(f"http://localhost:{ROOT_PORT}/blockchain")

result_blockchain = Blockchain.from_json(result.json())

try:

blockchain.replace_chain(result_blockchain.chain)

print("\n --Successfully synchronised the local chain")

except Exception as e:

print(f"\n--Error in synchronising: {e}")

app.run(port=PORT)

import time

from backend.util.crypto_hash import crypto_hash

from backend.util.hex_to_bin import hex_to_bin

from backend.config import MINE_RATE

GENESIS_DATA = {

'number' : 0,

'timestamp' : 1,

'timerec' : '0',

'last_hash' : 'genesis_last_hash',

'hash' : 'genesis_hash',

'data' : [],

'difficulty': 3,

'nonce':'genesis_nonce'

}

class Block:

"""

def __init__(self,number,timestamp,timerec,last_hash, hash, data, difficulty, nonce):

self.number = number

self.timestamp = timestamp

self.timerec = timerec

self.hash = hash

self.last_hash = last_hash

self.data = data

self.difficulty= difficulty # Number of leading zeros in the block hash.

self.nonce= nonce # Number of iterations required to reach the valid hash.

def __repr__(self): #This method is required to print out the class value of the block.

return(

f'Block-number: {self.number}\n'

f'Block-time recorded: {self.timerec}\n' #Prints the date and time of the block entry.

f'Block-timestamp: {self.timestamp}\n'

f'Block-hash: {self.hash}\n'

f'Block-last_hash: {self.last_hash}\n'

f'Block-data: {self.data}\n'

f'Difficulty: {self.difficulty}\n'

f'Nonce: {self.nonce}\n\n'

)

def __eq__(self,other): #It is another hidden class which will equate the

#given instances in the form of a dictionary.

return self.__dict__ == other.__dict__

def to_json(self):

"""

return self.__dict__

@staticmethod

def mine_block(last_block, data):

"""

number = last_block.number + 1

timestamp = time.time_ns() # Returns time in nanoseconds .

last_hash = last_block.hash

difficulty = Block.adjust_diff(last_block,timestamp)

nonce = 0

hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)

while hex_to_bin(hash)[0:difficulty] != '0' * difficulty: # We need to add leading zeroes according to difficulty

#This process converts the code into binary format of hexadecimal hash value and then enters the loop

nonce += 1 #Nonce value is incremented to one everytime this loop is executed

timestamp = time.time_ns() #This is necessary.

difficulty = Block.adjust_diff(last_block,timestamp) #Difficulty will get itself adjusted according to current block timestamp.

hash = crypto_hash(timestamp, last_hash, data, difficulty, nonce)

timerec = time.asctime() # Returns time in form of string.

return Block(number,timestamp,timerec,last_hash, hash, data, difficulty, nonce)

@staticmethod

def genesis():

"""

return Block(**GENESIS_DATA) #Double asterisks are used to unpack the data

#present in the GENESIS_DATA dictionary. This is one convenient method.

@staticmethod

def from_json(block_json):

"""

return Block(**block_json)

@staticmethod

def adjust_diff(last_block,new_timestamp):

"""

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

@staticmethod

def isblockvalid(last_block,block):

"""