def modification(frame, hack_block_index, hack_block_content):
window = tk.Toplevel(frame)
label = tk.Label(window,
text="modification Successful",
height=2,
width=30,
font=('Chinyen', 12))
label.pack(side="top", fill="x", pady=10)
hacker_block = bc.Block(
hack_block_index, date.datetime.now(), hack_block_content,
public_ledger_A[len(public_ledger_A) - 1].gethash())
hack_block_index = int(hack_block_index)
print(type(hack_block_index))
print(hack_block_content)
for index in range(len(public_ledger_A)):
print(public_ledger_A[index].getIndex())
if public_ledger_A[index].getIndex() == hack_block_index:
public_ledger_A[index] = hacker_block
break
def mine(self):
"""
Mines new blocks
"""
self.add_genesis_block()
while self._mining:
coinbase_transaction = self.create_coinbase_transaction()
transactions = [coinbase_transaction]
for _ in range(constants.BLOCK_MAX_TRANSACTIONS - 1):
# transaction = self._transaction_generator.generate()
transaction = self._transaction_queue.get()
transactions.append(transaction)
block = blockchain.Block(
hash_prev=self._hash_prev,
difficulty=self._config.difficulty,
transactions=transactions,
)
console.info("Mining a new block:" + " " * 32 +
"\n{:}\n".format(block.summary))
found = False
while not found:
found = self.mine_one_iteration(block)
# Throttle mining to reduce CPU load (for the demo)
time.sleep(self._config.mining_throttle_ms / 1000)
def create_new_block_and_header():
'''Creates a new block and header with the coinbase transaction included and returns them.'''
block = blockchain.Block()
header = blockchain.Header()
# Create the coinbase Transaction
coinbase_tx = blockchain.Transaction()
coinbase_tx.setVersionNumber(
len(Blockchain)) # Becomes a unique identifier for the transaction
coinbase_tx.setInCounter(1)
coinbase_tx.setOutCounter(1)
coinbase_tx.setListOfInputs([blockchain.compute_double_hash('coinbase')])
coinbase_tx.setListOfOutputs([blockchain.compute_double_hash('minerpay')])
coinbase_tx.setTransactionHash(
blockchain.computeTransactionHash(coinbase_tx))
# Add to block and update header
block.addTransaction(coinbase_tx)
block.setTransactionCounter(block.getTransactionCounter() + 1)
Tree = Merkel_Tree(list(block.getTransactions()[0].getTransactionHash()))
Tree.construct_tree()
header.sethashMerkleRoot(Tree.merkelroot) # Set Merkel Root
header.setTimestamp(int(time.time()))
header.sethashPrevBlock(
Blockchain[-1].getBlockhash()) # Set Previous Block
header.setBits(0x1e200000) # Set the difficulty bits
block.setBlocksize(179)
block.setBlockHeader(header)
block.setBlockhash(blockchain.computeHeaderHash(block.getBlockHeader()))
return block, header
def mindTransactionBlock():
chain.syncNode(host, port)
req = request.get_json()
sender = req["sender"]
to = req["to"]
amount = req["amount"]
trx = tx.Transaction(sender, {to: int(amount)})
balance = trx.updateInputs(chain)
byteTx = pickle.dumps(trx)
newBlock = blockchain.Block(chain.getLastID_Hash()[0] + 1, byteTx,
chain.getLastID_Hash()[1])
newBlock.mineBlock()
chain.addBlock(newBlock)
chain.syncNode(host, port)
response = {
"sender": sender,
"amount": amount,
"newBlock": {
"id": newBlock.index,
"hash": newBlock.hash,
"previous hash": newBlock.prevHash
},
"transaction": {
"balance": balance,
"txid": trx.id
}
}
return jsonify(req)
def NewBlockReceived(self, request, context):
global Blockchain
global mine_lock
global current_block
global current_header
print("New Block Received")
block = blockchain.Block()
header = blockchain.Header()
for transaction in request.transaction:
block.addTransaction(transaction_from_serial(transaction))
block.setTransactionCounter(request.transaction_counter)
for header in request.Blockheader:
header.sethashMerkleRoot(header.hash_merkel_root)
header.setTimestamp(header.timestamp)
header.sethashPrevBlock(header.hash_prev_block)
header.setBits(header.bits)
block.setBlocksize(request.BlockSize)
block.setBlockHeader(header)
block.setBlockhash(request.blockhash)
Blockchain.append(block) # Add the new block
mine_lock = False
time.sleep(random.randint(0, 3)) # Sleep for random time
mine_lock = True
current_block, current_header = create_new_block_and_header(
) # Reset the current block and header
return response
def generate_genesis_block():
'''Generates the genesis block'''
# Genesis Transaction
genesis_transaction = blockchain.Transaction()
genesis_transaction.setVersionNumber(0)
genesis_transaction.setOutCounter(1)
genesis_transaction.setInCounter(1)
genesis_transaction.setListOfInputs(['genin'])
genesis_transaction.setListOfOutputs(['genesis07'])
genesis_transaction.setTransactionHash(
blockchain.computeTransactionHash(genesis_transaction))
# Genesis Header
genesis_header = blockchain.Header()
genesis_header.sethashPrevBlock('0' * 64) # Previous Hash of all 0's
Tree = Merkel_Tree([genesis_transaction.getTransactionHash()])
Tree.construct_tree()
genesis_header.sethashMerkleRoot(Tree.merkelroot)
# Genesis Block
genesis_block = blockchain.Block()
genesis_block.setBlockHeader(genesis_header)
genesis_block.setTransactionCounter(1)
genesis_block.addTransaction(genesis_transaction)
genesis_block.setBlocksize(179)
genesis_block.setBlockhash(
blockchain.computeHeaderHash(genesis_block.getBlockHeader()))
return genesis_block
def test_getSerialiedData(self): b = blockchain.Block( index = 0, timestamp = date.datetime.now(), data = b'Some test data', lastHash="0", proofOfWork=0 ) self.assertTrue(b.getSerializedData())
def test_add_block(self):
block = blockchain.Block(1558649054, "Genesis Block", None, 0)
bc = blockchain.Blockchain()
bc.add(block)
block2 = blockchain.Block(int(time.time()), "First block", block.hash,
1)
bc.add(block2)
block3 = blockchain.Block(int(time.time()), "2nd block", block2.hash,
2)
bc.add(block3)
self.assertEqual(
bc.getblock(0).hash,
"61977ea186232850707dd0c2f14d74f5981ba9cff82c07966608c56d0d101542")
self.assertEqual(bc.getblock(1).data, "First block")
self.assertEqual(bc.getblock(2).data, "2nd block")
self.assertEqual(bc.getblock(3), None)
def manager():
chain = blockchain.Chain()
spam_chain = blockchain.Chain()
block = blockchain.Block()
flag = True
#mining text data
#filter by naive bayes
'''
input feature_result.csv
'''
df = pd.read_csv('feature_result.csv', header=None)
train_matrix = df.values
model, dictionary = spam_filter.train(train_matrix)
while flag:
print("\n####Email tracking demon by blockchain####")
option = """
Action set:
(1) send email by smtp
(2) recieve&record in blockchain email by pop3
(3) show the email content(block)
(4) show the whole email chain
(5) judge the spam & store in spam chain
(6) show the spam chain
(7) exit
"""
print(option)
decide = input('-->Enter: ')
if decide == '1':
send_block()
elif decide == '2':
recieve_block(chain)
elif decide == '3':
index = int(input('input the index of the block: '))
print_info(chain, index)
elif decide == '4':
if len(chain.chain) > 0:
print_chain(chain)
else:
print('no block in the chain')
elif decide == '5':
if len(chain.chain) > 0:
index = int(input('input the index of the block: '))
judge_spam(chain, index, spam_chain, model, dictionary)
else:
print('No block')
elif decide == '6':
if len(spam_chain.chain) > 0:
print_chain(spam_chain)
else:
print('No spam eamil in the chain')
elif decide == '7':
print('\nexit')
flag = False
def invest_submit(investor_name, amount, invest_type):
invest_detail = [[100000000000, "Government Debt", 0.03, 12],
[30000000000, "Corporate Investment", 0.02, 24]]
detail = invest_detail[invest_type]
block_detail = str(detail) + "-" + str((investor_name, amount))
print((investor_name, amount, invest_type, detail, block_detail))
public_ledger_A.append(
bc.Block(len(public_ledger_A), date.datetime.now(), block_detail,
public_ledger_A[len(public_ledger_A) - 1].gethash()))
public_ledger_B.append(
bc.Block(len(public_ledger_B), date.datetime.now(), block_detail,
public_ledger_A[len(public_ledger_B) - 1].gethash()))
public_ledger_C.append(
bc.Block(len(public_ledger_C), date.datetime.now(), block_detail,
public_ledger_A[len(public_ledger_C) - 1].gethash()))
public_ledger_D.append(
bc.Block(len(public_ledger_D), date.datetime.now(), block_detail,
public_ledger_A[len(public_ledger_D) - 1].gethash()))
public_ledger_E.append(
bc.Block(len(public_ledger_E), date.datetime.now(), block_detail,
public_ledger_A[len(public_ledger_E) - 1].gethash()))
def judge_spam(chain, index, spam_chain, model, dictionary):
message_block = chain.chain[index]
for message in message_block.messages:
content = message.content
result_matrix = spam_filter.judge(content, model,
dictionary) #retunr confusion matrix
if result_matrix[0][0]:
print('The mail is Ham')
else:
print('The mail is Spam, store the spam in spam_chain')
block = blockchain.Block()
block.add_message(message)
spam_chain.add_block(block)
def verify_and_add_block():
block_data = request.get_json()
block = blockchain.Block(block_data["index"],
block_data["transactions"],
block_data["timestamp"],
block_data["previous_hash"],
)
block.hash = block_data['hash']
added = bchain.add_block_on_shard(block,"")
if not added:
return "The block was discarded by the node", 400
worldstate.update_with_block(block)
return "Block added to the chain", 201
async def consumer(message, websocket, queue):
"""Consumer implementation for when a web socket message is received."""
print("consumer message:", message)
global NODES
payload = Payload(message)
if payload.msgtype == "all_nodes":
return_data = json.dumps(list(NODES.keys()))
print(return_data)
await queue.put(return_data)
elif payload.msgtype == "new_node":
NODES[payload.msgpayload] = None #reserve
blockchain_json = json.dumps(
[b.__dict__ for b in blockchain.blockchain])
full_message = Payload(msgtype="full_blockchain",
msgpayload=blockchain_json).to_json()
await websocket.send(full_message)
elif payload.msgtype == "full_blockchain":
try:
json_obj = json.loads(payload.msgpayload)
for block in json_obj:
block = blockchain.Block(block['data'], block['previous_hash'],
block['index'], block['timestamp'],
block['hash'], block['nonce'])
blockchain.blockchain.append(block)
except:
blockchain.blockchain = []
print("Unexpected error:", sys.exc_info()[0], sys.exc_info()[1])
print('received full blockchain')
elif payload.msgtype == "new_block":
json_obj = payload.msgpayload
block = blockchain.Block(json_obj['data'], json_obj['previous_hash'],
json_obj['index'], json_obj['timestamp'],
json_obj['hash'], json_obj['nonce'])
blockchain.blockchain.append(block)
else:
print("Unknown msgtype received: ", payload.msgtype)
def func2():
choice = request.form['candidate']
v1 = b1.vote(int(choice))
with open('votefile.csv', 'a', newline="") as votefile:
writer = csv.writer(votefile)
for key, value in v1.voteobject.items():
writer.writerow([key, value])
if b1.vote.count % 4 == 0:
block1 = b1.Block()
blockx = block1.mineblock()
with open('blockchain.abc', 'ab') as blockfile:
pickle._dump(blockx, blockfile)
print("block added")
return redirect('/thanks')
def load_seed():
invest_detail = [[100000000000, "Government Debt", 0.03, 12],
[30000000000, "Corporate Investment", 0.02, 24]]
names = [
"Juliane Hutt", "Millard Rakow", "Maryam Borders",
"Michaele Walton", "Willis Edsall", "Barb Lamar", "Maira Bryd",
"Senaida Paris"
"Hanna Womack", "Irvin Holen", "Layne Richmond", "Hedwig Brunette",
"Anastacia Derrow", "Ivan Smitherman", "Evia Vice",
"Mercedez Rader", "Loriann Tesch"
]
for i in range(10):
seed_1 = []
seed_1 = invest_detail[int(2 * random.random())]
block_detail = str(seed_1) + "-" + str((names[int(
16 * random.random())], int(1000 * random.random())))
public_ledger_A.append(
bc.Block(len(public_ledger_A), date.datetime.now(),
block_detail,
public_ledger_A[len(public_ledger_A) - 1].gethash()))
public_ledger_B.append(
bc.Block(len(public_ledger_B), date.datetime.now(),
block_detail,
public_ledger_A[len(public_ledger_B) - 1].gethash()))
public_ledger_C.append(
bc.Block(len(public_ledger_C), date.datetime.now(),
block_detail,
public_ledger_A[len(public_ledger_C) - 1].gethash()))
public_ledger_D.append(
bc.Block(len(public_ledger_D), date.datetime.now(),
block_detail,
public_ledger_A[len(public_ledger_D) - 1].gethash()))
public_ledger_E.append(
bc.Block(len(public_ledger_E), date.datetime.now(),
block_detail,
public_ledger_A[len(public_ledger_E) - 1].gethash()))
def new_block():
data = json.loads(request.get_json())
block = blockchain.Block(index=data['index'],
timestamp=data['timestamp'],
transactions=data['transactions'],
previous_hash=data['previous_hash'],
nonce=data['nonce'])
added = my_blockchain.add_block(block)
if not added:
return 'Block was discarded by the node', 400
return 'Block added to chain', 201
def recieve_block(chain):
block = blockchain.Block()
block_message = None
user = input('Email user: '******'User password: '******'POP3 server: ')
#pop3_server = poplib.POP3_SSL('pop.googlemail.com', '995')
#pop3_server = poplib.POP3_SSL(pop3_server, '995')
temp_server = email_track.fetch_email(user, password, pop3_server)
temp_server.connect()
temp_server.decode_email()
block_message = temp_server.block_message
block.add_message(blockchain.Email_Content(block_message))
chain.add_block(block)
print('add successfully, block: ', block)
print('\r\n')
def test_create_block(self): ts = date.datetime.now() b = blockchain.Block( index = 0, timestamp = ts, data = b'Some test data', lastHash="0", proofOfWork=0 ) self.assertEqual(b.index, 0) self.assertEqual(b.timestamp, ts) self.assertEqual(b.data, b'Some test data') self.assertEqual(b.lastHash, "0") self.assertEqual(b.proofOfWork, 0) # test that hash of this block was generated self.assertTrue(b.hash)
async def add_transaction(broadcast_outbox, transaction):
"""Adds a transaction to a block in the blockchain."""
TRANSACTIONS_QUEUE.append(transaction.__dict__)
print("transactions len:", len(TRANSACTIONS_QUEUE))
if len(TRANSACTIONS_QUEUE) >= 5:
previous_hash: str = None
if len(blockchain.blockchain) > 0:
previous_hash = blockchain.blockchain[len(blockchain.blockchain) -
1].hash
block = blockchain.Block(json.dumps(TRANSACTIONS_QUEUE), previous_hash)
hash_value, nonce = blockchain.proof_of_work(block, 1)
print(f"proof of work completed. Hash: {hash_value} Nonce:{nonce}")
block.hash_value = hash_value
block.nonce = nonce
block.timestamp = datetime.utcnow().strftime("%y/%m/%d %H:%M")
blockchain.blockchain.append(block)
await alert_all_nodes(broadcast_outbox, "new_block", block.__dict__)
TRANSACTIONS_QUEUE.clear()
def test(num_blocks):
blckchain = blockchain.Blockchain()
rand2 = random.randint(1, 10)
for i in range(0, num_blocks):
block = blockchain.Block()
for j in range(rand2):
rand3 = random.randint(1, 100)
block.add_transaction(rand3)
blckchain.add_block(block)
blckchain.blocks[1].add_transaction(57)
start_time = time.time()
blckchain.rehash()
time_taken = time.time() - start_time
return time_taken
def consensus():
# Replace chain with longest valid chain in network
replaced = False
longest_chain = my_blockchain.chain
chain_len = len(my_blockchain.chain)
for node in my_blockchain.nodes:
chain = []
# Create blockchain instance from json string returned by node
url = 'http://127.0.0.1:' + str(node) + '/chain'
response = requests.get(url)
data = response.json()
for i in range(0, len(data)):
block = blockchain.Block(
index = data[i]['index'],
timestamp = data[i]['timestamp'],
transactions = data[i]['transactions'],
previous_hash = data[i]['previous_hash'],
nonce = data[i]['nonce']
)
chain.append(block)
if my_blockchain.validate_chain(longest_chain):
if my_blockchain.validate_chain(chain) and len(chain) > chain_len:
replaced = True
chain_len = len(chain)
longest_chain = chain
else:
replaced = True
chain_len = len(chain)
longest_chain = chain
if replaced:
my_blockchain.chain = longest_chain
return 'Our chain was replaced'
return 'Our chain is authoritative'
def add_block(chain):
train_dir = 'ling-spam\\train-mails'
emails = [os.path.join(train_dir, f) for f in os.listdir(train_dir)]
print(emails[0])
block_msg = None
for mail in emails[601:]:
context = None
with open(mail) as file:
context = file.read()
#print(context)
block_msg = context
block = blockchain.Block()
block.add_message(blockchain.Email_Content(block_msg))
#print(len(chain.chain))
chain.add_block(block)
print(len(emails[601:]))
# print(chain.chain[0])
# print(chain.chain[1])
return emails[601:]
def add_genesis_block(self):
"""
Assembles genesis block, the first block in the blockchain.
It is hardcoded and the same for every mining node.
"""
coinbase_transaction = self.create_coinbase_transaction(
dest_key=constants.GENESIS_BLOCK_DEST_KEY)
transactions = [coinbase_transaction]
genesis_block = blockchain.Block(
hash_prev=constants.GENESIS_BLOCK_HASH_PREV,
difficulty=constants.GENESIS_BLOCK_DIFFICULTY,
hash=constants.GENESIS_BLOCK_HASH,
merkle_root=constants.GENESIS_BLOCK_MERKLE_ROOT,
nonce=constants.GENESIS_BLOCK_NONCE,
extra_nonce=constants.GENESIS_BLOCK_EXTRA_NONCE,
transactions=transactions)
self._hash_prev = genesis_block.hash
self.maybe_add_block(genesis_block)
def create_chain_from_dump(chain_dump):
generated_blockchain = blockchain.Blockchain()
# generated_blockchain.create_genesis_block()
for idx, block_data in enumerate(chain_dump):
if idx == 0 and not IS_SHARDED:
continue # skip genesis block
block = blockchain.Block(block_data["index"],
block_data["transactions"],
block_data["timestamp"],
block_data["previous_hash"])
block.hash = block_data['hash']
if IS_SHARDED:
#integraty check is not performed
added= generated_blockchain.add_block_on_shard(block,'')
else:
added = generated_blockchain.add_block(block)
if not added:
raise Exception("The chain dump is tampered!!")
return generated_blockchain
def mindCoinBaseBlock(name, amount, chain=chain):
chain.syncNode(host, port)
coin = tx.Transaction("coinbase", {name: int(amount)})
byteCoin = pickle.dumps(coin)
newBlock = blockchain.Block(chain.getLastID_Hash()[0] + 1, byteCoin,
chain.getLastID_Hash()[1])
newBlock.mineBlock()
chain.addBlock(newBlock)
chain.syncNode(host, port)
response = {
"sender": name,
"amount": amount,
"newBlock": {
"id": newBlock.index,
"hash": newBlock.hash,
"previous hash": newBlock.prevHash
}
}
jsonify(response)
return jsonify(response)
def new_transaction():
global LAST_INDEX
global PREV_HASH
values = request.get_json()
# Check that the required fields are in the POST'ed data
required = ['ts', 'sender', 'recipient', 'amount']
if not all(k in values for k in required):
return 'Missing values', 400
# Create a new Transaction
index = bchain.new_transaction(values['ts'], values['sender'], values['recipient'], values['amount'])
if len(bchain.current_transactions) == TX_PER_BLOCK:
#
block = blockchain.Block(LAST_INDEX, bchain.current_transactions, time.time(), PREV_HASH)
block.hash = block.compute_hash()
PREV_HASH = block.hash
peer_broadcast("add_block", block.__dict__, [])
LAST_INDEX += 1
bchain.current_transactions=[]
print('block has been broadcasted')
return 'block has been broadcasted', 201
def new_block(self, proof, phash):
block = bl.Block(proof, phash, *self.unconfirmed_transactions)
self.unconfirmed_transactions = []
self.chain.add(block)
return block
from flask import *
import blockchain
FILE = "test.txt"
chain = blockchain.Chain(FILE+".chain.json",blockchain.Block(0,"",""))
app = Flask(__name__)
@app.route("/")
def base():
chain.load()
return render_template("file.html",hashes=[block.hash[:8] for block in chain.blocks if block.data != ""],filename=FILE)
@app.route("/<string:hash>")
def byhash(hash):
chain.load()
if len(hash)>8: return abort(400)
for i in range(chain.blocks[-1].index,-1,-1):
if chain.blocks[i].hash[:8]==hash:
return Response(chain.blocks[i].data,mimetype="text/plain")
return abort(404)
if __name__=="__main__":
app.run(port=8000)
def incoming_command_handler(connection, ip_address, port_number, command,
incoming_message):
global registered_peers
#------------------------------------------------------------#
#-- used for populating the peer and registered peer lists --#
machineID = ""
key = ""
ipAddress = ""
port = ""
#------------------------------------------------------------#
outgoing_message = ""
#------------------------------------------------------------------------------------------------------------------#
# --------------------------------------- Peer receives list of peers info ----------------------------------------#
if command == "PEER":
message_length = len(incoming_message)
index = 0
while index < message_length:
# ----------- MachineID ---------------#
while incoming_message[index] != " ":
machineID += incoming_message[index]
index += 1
#---------------------------------------#
index += 1
# --------------- Key ------------------#
while incoming_message[index] != " ":
key += incoming_message[index]
index += 1
#---------------------------------------#
index += 1
#------------- ipAddress ---------------#
while incoming_message[index] != " ":
ipAddress += incoming_message[index]
index += 1
#---------------------------------------#
index += 1
#------------ portNumber ---------------#
while incoming_message[index] != " ":
port += incoming_message[index]
index += 1
#---------------------------------------#
index += 1
# -- Add peer info to list of peers --#
peers.append(Peer_Info(machineID, key, ipAddress, port))
# -- clear each variable so it can be reused --#
machineID = ""
key = ""
ipAddress = ""
port = ""
#------------------------------------------------------------------------------------------------------------------#
# ------------------- Peer receives command to send copy of registered peer list ---------------------------------#
elif command == "REGP":
print("sending list of registered peers to %s " % (connection))
outgoing_message = MESSAGE_HEADER + "|" + "REPL" + "|" + ""
for x in registered_peers:
outgoing_message += (str(x.machineID) + " " + str(x.privateKey) +
" " + str(x.ipAddress) + " " +
str(x.portNumber) + " ")
print(outgoing_message)
connection.send(outgoing_message.encode("utf-8"))
#------------------------------------------------------------------------------------------------------------------#
# ----------------------------------- Peer receive list of registered peers -------------------------------------#
elif command == "REPL":
message_length = len(incoming_message)
index = 0
while index < message_length:
# -------------- MachineID ----------------#
while incoming_message[index] != " ":
machineID += incoming_message[index]
index += 1
#------------------------------------------#
index += 1
#------------------ Key -------------------#
while incoming_message[index] != " ":
key += incoming_message[index]
index += 1
#------------------------------------------#
index += 1
#--------------- ipAddress ----------------#
while incoming_message[index] != " ":
ipAddress += incoming_message[index]
index += 1
#------------------------------------------#
index += 1
#--------------- portNumber ---------------#
while incoming_message[index] != " ":
port += incoming_message[index]
index += 1
#------------------------------------------#
index += 1
#---- Add peer to list of registered peers if not already there ---#
found = False
for p in registered_peers:
if (p.machineID == machineID) and (p.privateKey == key):
p.ipAddress = ipAddress
p.portNumber = port
found = True
break
#------------------------------------------------------------------#
if (found == False) and (machineID != MACHINE_ID):
registered_peers.append(
Peer_Info(machineID, key, ipAddress, port))
# -- clear variables to reuse --#
machineID = ""
key = ""
ipAddress = ""
port = ""
#---------------------------------------------------------------------------------------------------------------#
#------------ Peer receive request from another node to join it's list of registered peers ---------------------#
elif command == "JOIN":
outgoing_message = MESSAGE_HEADER + "|" + "WELC" + "|" + incoming_message
print(outgoing_message)
connection.send(outgoing_message.encode("utf-8"))
#---------------------------------------------------------------------------------------------------------------#
#------------ Peer receives confirmation that it has joined list of registered peers for node ------------------#
elif command == "WELC":
print(
"Succesfully joined list of registered peers for node at ip address: %s port number: %s"
% (ip_address, port_number))
#---------------------------------------------------------------------------------------------------------------#
#----------------------------- Peer receives command to update it's blockchain ---------------------------------#
elif command == "ADDB":
print("Adding block to blockchain, sent from peer: %s " % (connection))
#parse the incoming_message to repackage into identical block
parsedMessage = incoming_message.split("%")
incomingId = parsedMessage[0]
from datetime import datetime
incomingTime = datetime.strptime(parsedMessage[1],
'%Y-%m-%d %H:%M:%S.%f')
incomingBallot = ast.literal_eval(parsedMessage[2])
incomingPrevHash = parsedMessage[4]
blockToAdd = blockchain.Block(incomingId, incomingTime, incomingBallot,
incomingPrevHash)
index = len(blockchain.chain)
if (blockToAdd.previous_hash == blockchain.chain[index - 1].hash):
blockchain.append_block(blockToAdd)
saveBlockchain(blockchain.chain, 'localBlockchain.pk1')
else:
print("invalid block")
outgoing_message = MESSAGE_HEADER + "|" + "CONF" + "|" + incoming_message
print(outgoing_message)
connection.send(outgoing_message.encode("utf-8"))
#---------------------------------------------------------------------------------------------------------------#
#-------- Peer reveives confirmation that other peer has received new block and added it to blockchain ---------#
elif command == "CONF":
print("Confirmation to add block to blockchain")
block_chain.append(incoming_message)
print("Block added: " + incoming_message)
# --------------------------------------------------------------------------------------------------------------#
#------------ Peer receives error message indicating something went wrong durring communication ----------------#
elif command == "ERRO":
print("error performing operation %s" % (ip_address))
#---------------------------------------------------------------------------------------------------------------#
# ------------------------------------------ Peer quits network -------------------------------------------------#
elif command == "QUIT":
outgoing_message = MESSAGE_HEADER + "|" + "DONE" + "|" + incoming_message
connection.send(outgoing_message.encode("utf-8"))
for i, p in enumerate(registered_peers):
if (p.ipAddress == ipAddress) and (p.portNumber == port_number):
print("Peer: %s signed off from network." % (p.machineID))
del registered_peers[i]
# -----------------------------------------------------------------------------------------------------------------#
#------------------ Peer receives confirmation that it has disconnected from other peer ---------------------------#
elif command == "DONE":
print("Confirmed disconnection from peer")
#------------------------------------------------------------------------------------------------------------------#
elif command == "LEAD":
global LEADER
LEADER = True
print("%s is now the leader" % (MACHINE_ID))
time.sleep(10.0)
LEADER = False
#----------------------------- Peer receives unrecognized command to close socket ------------------------------#
else:
outgoing_message = MESSAGE_HEADER + "|" + "ERRO" + "|" + incoming_message
print(outgoing_message)
connection.send(outgoing_message.encode("utf-8"))
# Unit tests for Blockchain class of blockchain.py import blockchain difficulty=16 block0 = blockchain.Block(0, '0', 'Genesis Block') block0.search_hash(difficulty) block1 = blockchain.Block(1, block0.hash, 'data1') block1.search_hash(difficulty) block2 = blockchain.Block(2, block1.hash, 'data2') block2.search_hash(difficulty) bchain = blockchain.Blockchain(difficulty) assert bchain.validate(block2, block1) assert bchain.validate(block1, block0) assert bchain.validate(block0, "No_parent") assert bchain.validate(block2, block0) == False assert bchain.validate_chain() assert bchain.add_block(block0) assert bchain.validate_chain() assert bchain.add_block(block1) assert bchain.validate_chain() assert bchain.add_block(block2) assert bchain.validate_chain()
