-
Notifications
You must be signed in to change notification settings - Fork 0
/
blockchain.py
236 lines (177 loc) · 6.44 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
import requests
from dataclasses import dataclass
from time import time
from urllib.parse import urlparse
from flask import Flask, jsonify, request
from uuid import uuid4
class Blockchain:
@dataclass
class Block:
index: str
timestamp: float
transactions: list
proof: int
previousHash: int
class GenesisBlock(Block):
def __post_init__(self) -> None:
self.index = 0
def __init__(self):
self.chain = []
self.transactions = []
self.nodes = set()
def __len__(self) -> int:
return len(self.chain)
def register_node(self, add:str) -> None:
parsed_url = urlparse(add)
self.nodes.add(parsed_url.netloc)
def valid_chain(self, chain:list) -> bool:
last_block = chain[0]
current_index = 1
while current_index < len(chain):
block = self.Block
print(f'{last_block}')
print(f'{block}')
print("\n-----------\n")
if block["previousHash"] != hash(last_block):
return False
if not self.valid_proof(last_block["proof"], block["proof"]):
return False
last_block = block
current_index += 1
return True
def resolve_conflicts(self) -> bool:
"""
This is the Consensus Algorithm, it resolves conflicts
by replacing our chain with the longest one in the network.
"""
neighbours = self.nodes
self.chain = None
max_length = len(self)
for node in neighbours:
response = requests.get(f"https://{node}/chain")
if response.status_code == 200:
length = response.json()["length"]
chain = response.json()["chain"]
if length > max_length and self.valid_chain(chain):
max_length = length
new_chain = chain
if new_chain:
self.chain = new_chain
return True
return False
def add_block(self, proof:int, previousHash:str=None):
if len(self) == 0:
cls = self.GenesisBlock
def gph():
return None
else:
cls = self.Block
def gph():
return hash(self.chain[-1])
self.chain.append(cls(index=len(self), timestamp=time(), transactions=self.transactions, proof=proof, previousHash=previousHash or gph()))
self.transactions = []
return cls
def new_transaction(self, sender:str, recipient:str, amount:int):
self.transactions.append({"sender":sender, "recipient":recipient, "amount": amount})
return self.last_block["index"] + 1
@property
def last_block(self):
return self.chain[-1] if len(self) > 0 else 0
def proof_of_work(self, last_proof:int) -> int:
"""
Simple Proof of Work Algorithm:
- Find a number p' such that hash(pp') contains 4 leading zeroes, where p is the previous p'
- p is the previous proof, and p' is the new proof
"""
proof = 0
while self.valid_proof(last_proof, proof) is False:
proof += 1
return proof
@staticmethod
def valid_proof(last_proof:int, proof:int) -> bool:
"""
Validates the Proof: Does hash(last_proof, proof) contain 4 leading zeroes?
"""
guess = f'{last_proof}{proof}'.encode()
guess_hash = hash(guess)
return guess_hash[:4] == "0000"
app = Flask(__name__)
# Generate a globally unique address for this node
node_identifier = str(uuid4()).replace('-', '')
# Instantiate the Blockchain
blockchain = Blockchain()
# /mine to tell the server to mine a new block
# GET request endpoint
@app.route('/mine', methods=['GET']) #
def mine():
last_block = blockchain.last_block
last_proof = last_block['proof']
proof = blockchain.proof_of_work(last_proof)
# receive a reward for finding the proof
# The sender is "0" to signify 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 = hash(last_block)
block = blockchain.add_block(proof, 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
# /transactions/new to create a new transaction to a block
# POST request endpoint, since we’ll be posting data to it
@app.route('/transactions/new', methods=['POST'])
def new_transaction():
values = request.get_json() # extracts the JSON data from the POST request
# Check that the required fields are in the POST data
required = ['sender', 'recipient', 'amount']
if not all(k in values for k in required):
return 'Missing values', 400
# Create a new Transaction
index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
response = {'message': f'Transaction will be added to Block {index}'}
return jsonify(response), 201
# /chain to return the full Blockchain
@app.route('/chain', methods=['GET'])
def full_chain():
response = {
'chain': blockchain.chain,
'length': len(blockchain),
}
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 "Error: Please supply a valid list of nodes", 400
for node in nodes:
blockchain.register_node(node)
response = {
'message': 'New nodes have been 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 authoritative',
'chain': blockchain.chain
}
return jsonify(response), 200
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)