def mine():
Log.log_message(
'blockchain.resolve_conflicts={}'.format(blockchain.resolve_conflicts),
port)
if blockchain.public_key is None:
load_keys_return = load_keys()
if load_keys_return[1] is not 201:
return load_keys_return
Log.log_message(
'blockchain.resolve_conflicts={}'.format(blockchain.resolve_conflicts),
port)
if blockchain.resolve_conflicts:
response = {'message': 'Resolve conflicts first, block not added!'}
Log.log_error(409, response, port)
return jsonify(response), 409
block = blockchain.mine_block()
if block != None:
dict_block = block.to_json()
response = {
'message': 'Block added succesfully',
'block': dict_block,
'funds': blockchain.get_balance()
}
Log.log_status(201, response, port)
return jsonify(response), 201
else:
response = {
'message': 'Adding a block failed.',
'wallet_set_up': wallet.public_key != None
}
Log.log_error(500, response, port)
return jsonify(response), 500
def mine_block(self):
if self.public_key == None:
return None
last_block = self.__chain[-1]
hashed_block = HashUtil.hash_block(last_block)
proof = self.proof_of_work()
reward_transaction = Transaction('MINING', self.public_key, '',
MINING_REWARD)
copied_transactions = self.__open_transactions[:]
for tx in copied_transactions:
if not Wallet.verify_transaction(tx):
return None
copied_transactions.append(reward_transaction)
block = Block(len(self.__chain), hashed_block, copied_transactions,
proof)
self.__chain.append(block)
self.__open_transactions = []
self.save_data()
for node in self.__peer_nodes:
url = '{}/broadcast-block'.format(node)
# Log.log_message(url, self.node_id)
try:
response = requests.post(url, json={'block': block.to_json()})
Log.log_message(response, self.node_id)
if response.status_code == 400 or response.status_code == 500:
print('Block declinde, needs resolving!')
if response.status_code == 409:
self.resolve_conflicts = True
except requests.exceptions.ConnectionError:
continue
return block
def add_new_transaction():
values = request.get_json()
if not values:
response = {'message': 'No data found.'}
return jsonify(response), 400
required_fields = ['sender', 'signature', 'recipient', 'amount']
if not all(field in values for field in required_fields):
response = {'message': 'Required data is missing.'}
Log.log_error(400, response, port)
return jsonify(response), 400
sender = values['sender']
signature = values['signature']
recipient = values['recipient']
amount = float(values['amount'])
Log.log_message(amount, port)
success = blockchain.add_transaction(recipient, sender, signature, amount)
Log.log_message(success, port)
if success:
response = {
'message': 'Succesfully added transaction',
'transaction': {
'sender': wallet.public_key,
'recipient': recipient,
'amount': amount,
'signature': signature
},
'funds': blockchain.get_balance()
}
return jsonify(response), 201
else:
response = {'message': 'Creating a transaction failed..!'}
Log.log_error(500, response, port)
return jsonify(response), 500
def add_node():
values = request.get_json()
if not values:
response = {'message': 'No data attached.'}
return jsonify(response), 400
Log.log_message(values, port)
if 'node' not in values:
response = {'message': 'No node data attached.'}
Log.log_error(401, response, port)
return jsonify(response), 401
node = values.get('node')
blockchain.add_peer_node(node)
response = {
'message': 'Node added succesfully.',
'all_nodes': blockchain.get_peer_nodes()
}
return jsonify(response), 201
def broadcast_transaction():
values = request.get_json()
Log.log_message(
'broadcast-transaction started with values{}'.format(values), port)
if not values:
response = {'message': 'No data found.'}
Log.log_error('400', response, port)
return jsonify(response), 400
required = ['sender', 'recipient', 'amount', 'signature']
if not all(key in values for key in required):
response = {'message': 'Some data are missing.'}
Log.log_error('400', response, port)
return jsonify(response), 400
Log.log_message('Broadcast-transaction', port)
success = blockchain.add_transaction(values['recipient'], values['sender'],
values['signature'], values['amount'],
True)
Log.log_message('Broadcast-transaction Ended', port)
if success:
response = {
'message': 'Succesfully added transaction',
'transaction': {
'sender': values['sender'],
'recipient': values['recipient'],
'amount': values['amount'],
'signature': values['signature']
}
}
return jsonify(response), 201
else:
response = {'message': 'Creating a transaction failed..!'}
return jsonify(response), 500
def add_peer_node(self, new_node):
# self.__peer_nodes.add(new_node)
# get all the peer nodes of the added node
url = '{}/node'.format(new_node)
try:
response = requests.get(url)
peer_nodes = response.json()
for peer_node in peer_nodes['all_nodes']:
self.__peer_nodes.add(peer_node)
except requests.exceptions.ConnectionError:
Log.log_error(requests.exceptions.ConnectionError,
'ConnectionError', self.node_id)
Log.log_message(Misc.get_Public_IP(self.node_id), self.node_id)
# if count == 0:
# try:
# local_http_addr = 'http://{}:{}'.format(Misc.get_Public_IP(self.node_id), self.node_id)
# response = requests.post(url, json={'node': local_http_addr, 'count': 1})
# Log.log_error(response.status_code, response, self.node_id)
# except requests.exceptions.ConnectionError:
# None
self.__peer_nodes.add(new_node)
self.save_data()
if __name__ == '__main__':
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('-p', '--port', type=int, default=80)
parser.add_argument('-n', '--nodeUrl', type=str, default='')
parser.add_argument('-np', '--nodePort', type=str, default='')
args = parser.parse_args()
port = args.port
IP_Address = Misc.get_Public_IP(port)
if args.nodeUrl is not '':
node_Url = args.nodeUrl
Log.log_message(
'A new node URL"{}" will be added at port:{}'.format(
node_Url, port), port)
elif args.nodePort is not '':
print('step 1')
node_Url = 'http://{}:{}'.format(IP_Address, args.nodePort)
print(node_Url)
else:
print('No parameters were passed!')
exit()
url = 'http://{}:{}/node'.format(IP_Address, port)
print('url:{}'.format(url))
try:
response = requests.post(url, json={'node': node_Url})
print(response)
if response.status_code == 400 or response.status_code == 500:
@app.route('/node/<node_url>', methods=['DELETE'])
def remove_node(node_url):
if node_url == '' or node_url == None:
response = {'message': 'No node attached.'}
return jsonify(response), 400
blockchain.remove_peer_node(node_url)
response = {
'message': 'Node removed succesfully.',
'all_nodes': blockchain.get_peer_nodes()
}
return jsonify(response), 201
@app.route('/node', methods=['GET'])
def get_node():
nodes = blockchain.get_peer_nodes()
response = {'all_nodes': nodes}
return jsonify(response), 201
if __name__ == '__main__':
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('-p', '--port', type=int, default=3200)
args = parser.parse_args()
port = args.port
Log.log_message('Server started at port:{}'.format(port), port)
wallet = Wallet(port)
blockchain = Blockchain(wallet.public_key, port)
app.run(host='0.0.0.0', port=port)
