-
Notifications
You must be signed in to change notification settings - Fork 0
/
blockchain.py
283 lines (214 loc) · 7.63 KB
/
blockchain.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4
from flask import Flask, jsonify, request
from urllib.parse import urlparse
class Blockchain(object):
def __init__(self):
self.chain = []
self.current_transactions = []
self.new_block(previous_hash=1, proof=100)
self.nodes = set()
def register_node(self, address):
"""
Add a new node to list of nodes
:param address: <str> address of new node
:return None:
"""
parsed_url = urlparse(address)
self.nodes.add(parsed_url.netloc)
def valid_chain(self, chain):
"""
Determine if a chain is valid THE one
:param chain: <list> blockchain
:return: bool
"""
last_block = chain[0]
current_index = 1
while current_index < len(chain):
block = chain[current_index]
print(f'{last_block}')
print(f'{block}')
print('____________')
# checks that hash of a block is correct
if block['previous_hash'] != self.hash(last_block):
return False
# checks if proof of work is valid
if not self.valid_proof(last_block['proof'], block['proof']):
return False
last_block = block
current_index += 1
return True
def resolve_conflicts(self):
"""
This is our Consensus algorithm, it resolves conflicts
by replacing our chain with the longest one in the network.
:return: <bool> True if our chain was replaced, False if not
"""
neighbours = self.nodes
new_chain = None
# We are loogin for chain longer than our
max_lenght = len(self.chain)
# Grab all chains from our neighbours nodes
for node in neighbours:
response = request.get(f'http://{node}/chain')
if response.status_code == 200:
length = response.json()['length']
chain = response.json()['chain']
# Checks if lenght is longer and chain is valid
if length > max_lenght and self.valid_chain(chain):
max_lenght = length
new_chain = chain
if new_chain:
self.chain = new_chain
return True
return False
def proof_of_work(self, last_proof):
"""
Simple proof of work alghoritm:
- Find number X , such that hash X * Y containst last 4*0 char where Y is previous X
- X is new_proof, and Y is previous proof
:last_proof: <int>
: reutrn proof: <int>
"""
proof = 0
while self.valid_proof(last_proof, proof) is False:
print(proof)
proof += 1
return proof
def valid_proof(self, last_proof, proof):
"""
Validates the proof: Does hash sha256(last_proof, proof) contains 4 leading zeros?
:param: last_proof --> previous proof <int>
:param: proof --> Current proof <int>
: return: --> bool
"""
guess = f'{last_proof}{proof}'.encode()
guess_hash = hashlib.sha256(guess).hexdigest()
print(guess_hash[:4])
return guess_hash[:4] == "0000"
def new_block(self, proof, previous_hash=None):
"""
Create a new Block in the Blockchain
:param proof: <int> The proof given by the Proof of Work algorithm
:param previous_hash: (Optional) <str> Hash of the previous block
:return <dict> New Block
"""
block = {
'index': len(self.chain) + 1,
'timestamp': time(),
'transactions': self.current_transactions,
'proof': proof,
'previous_hash': previous_hash or self.hash(self.chain[-1])
}
self.chain.append(block)
self.current_transactions = []
return block
def new_transaction(self, sender, recipient, amount):
"""
Creates a new transaction to go into the next mined Block
:param sender: <str> Address of the Sender
:param recipient: <str> Address of the Recipient
:param amount: <int> Amount
:return: <int> The index of the Block that will hold this transaction
"""
self.current_transactions.append({
'sender': sender,
'recipient': recipient,
'amount': amount,
})
print(self.current_transactions)
return self.last_block['index'] + 1
@staticmethod
def hash(block):
"""
Creates a SHA-25 hash of a Block
:param block: <dict> Block
:return: <str>
"""
block_string = json.dumps(block, sort_keys=True).encode()
return hashlib.sha256(block_string).hexdigest()
@property
def last_block(self):
# Returns the last block in the chain
return self.chain[-1]
# Instatiate our node
app = Flask(__name__)
# Generate a globally unique address for this node
node_identifier = str(uuid4()).replace('-','')
# Instatiate the blockchain
blockchain = Blockchain()
@app.route('/mine', methods=['GET'])
def mine():
# First we run proof of work alghoritm
last_block = blockchain.last_block
last_proof = last_block['proof']
proof = blockchain.proof_of_work(last_proof)
# we must recieve reward for succesfull mining
# The sender is 0 to signifiy that this node has mined a new coin
blockchain.new_transaction(
sender="0",
recipient=node_identifier,
amount=1,
)
# Forge the new block by adding it to the chain
previous_hash = blockchain.hash(last_block)
block = blockchain.new_block(proof, previous_hash=previous_hash)
response = {
'message': 'New block Forged',
'index': block['index'],
'transactions': block['transactions'],
'proof': block['proof'],
'previous_hash': block['previous_hash'],
}
return jsonify(response), 200
@app.route('/transaction/new', methods=['POST'])
def new_transaction():
values = request.get_json()
# Checks if all required values for transaction are in POST
required = ['sender', 'recipient', 'amount']
print(values)
if not all(k in values for k in required):
return 'Missing values', 400
# Creates new transaction
index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
response = {'message': f'Your transaction will be added in block {index}'}
return jsonify(response), 201
@app.route('/chain', methods=['GET'])
def full_chain():
response = {
'chain': blockchain.chain,
'length': len(blockchain.chain),
}
return jsonify(response), 200
@app.route('/nodes/register', methods=['POST'])
def register_nodes():
values = request.get_json()
nodes = values.get('nodes')
if nodes is None:
return 'Please add valid nodes list', 400
for node in nodes:
blockchain.register_node(node)
response = {
'message': 'New nodes were added',
'total_nodes': list(blockchain.nodes)
}
return jsonify(response), 201
@app.route('/nodes/resolve', methods=['GET'])
def consensus():
replaced = blockchain.resolve_conflicts()
if replaced:
response = {
'message': 'Our chain was replaced',
'new_chain': blockchain.chain
}
else:
response = {
'message': 'Our chain is authorative',
'new_chain': blockchain.chain
}
return jsonify(response), 200
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=True)