-
Notifications
You must be signed in to change notification settings - Fork 0
/
node_client.py
250 lines (196 loc) · 7.15 KB
/
node_client.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
import json
import time
import requests
from flask import Flask, request
from block import Block
from chain import Blockchain
# # from server_method import Server
# from client_method import Client
app = Flask(__name__)
# the node's copy of blockchain
blockchain = Blockchain()
<<<<<<< HEAD
# blockchain.create_genesis_block()
=======
blockchain.create_genesis_block()
>>>>>>> 9b704ea2c6a950308e04272dbdc4c57117066d33
# the address to other participating members of the network
peers = set()
# endpoint to submit a new transaction. This will be used by
# our application to add new data (posts) to the blockchain
@app.route("/new_transaction", methods=["POST"])
def new_transaction():
tx_data = request.get_json()
# print(tx_data)
# required_fields = ["author", "content"]
# for field in required_fields:
# if not tx_data.get(field):
# return "Invalid transaction data", 404
tx_data["timestamp"] = time.time()
blockchain.add_new_transaction(tx_data)
return "Success", 201
@app.route("/recent_block", methods=["GET"])
def get_block():
chain_data = []
# for block in blockchain.chain:
chain_data.extend(blockchain.chain[-1].transactions)
return json.dumps({"block": chain_data}), 200
<<<<<<< HEAD
@app.route("/last_self_added_block", methods=["GET"])
def get_last_self_added_block():
"""
for i in range(len(blockchain.chain), 0, -1):
if blockchain.chain[i]["author"] == "client":
return json.dumps({"block": blockchain.chain[i].transactions}), 200
"""
return json.dumps({"block": blockchain.chain[-2].transactions}), 200
=======
>>>>>>> 9b704ea2c6a950308e04272dbdc4c57117066d33
# endpoint to return the node's copy of the chain.
# Our application will be using this endpoint to query
# all the posts to display.
@app.route("/chain", methods=["GET"])
def get_chain():
chain_data = []
for block in blockchain.chain:
chain_data.append(block.__dict__)
return json.dumps(
{"length": len(chain_data), "chain": chain_data, "peers": list(peers)}
)
# endpoint to request the node to mine the unconfirmed
# transactions (if any). We'll be using it to initiate
# a command to mine from our application itself.
@app.route("/mine", methods=["GET"])
def mine_unconfirmed_transactions():
result = blockchain.mine()
if not result:
return "No transactions to mine"
else:
# Making sure we have the longest chain before announcing to the network
chain_length = len(blockchain.chain)
consensus()
if chain_length == len(blockchain.chain):
# announce the recently mined block to the network
announce_new_block(blockchain.last_block)
return "Block #{} is mined.".format(blockchain.last_block.index)
# endpoint to add new peers to the network.
@app.route("/register_node", methods=["POST"])
def register_new_peers():
node_address = request.get_json()["node_address"]
if not node_address:
return "Invalid data", 400
# Add the node to the peer list
peers.add(node_address)
# Return the consensus blockchain to the newly registered node
# so that he can sync
return get_chain()
@app.route("/register_with", methods=["POST"])
def register_with_existing_node():
"""
Internally calls the `register_node` endpoint to
register current node with the node specified in the
request, and sync the blockchain as well as peer data.
"""
node_address = request.get_json()["node_address"]
if not node_address:
return "Invalid data", 400
data = {"node_address": request.host_url}
headers = {"Content-Type": "application/json"}
# Make a request to register with remote node and obtain information
response = requests.post(
node_address + "/register_node", data=json.dumps(data), headers=headers
)
if response.status_code == 200:
global blockchain
global peers
# update chain and the peers
chain_dump = response.json()["chain"]
blockchain = create_chain_from_dump(chain_dump)
peers.update(response.json()["peers"])
peers.add(node_address + "/")
peers.remove("http://127.0.0.1:8001/")
return "Registration successful", 200
else:
# if something goes wrong, pass it on to the API response
return response.content, response.status_code
@app.route("/peers", methods=["GET"])
def return_peers():
return json.dumps(list(peers))
def create_chain_from_dump(chain_dump):
generated_blockchain = Blockchain()
generated_blockchain.create_genesis_block()
for idx, block_data in enumerate(chain_dump):
if idx == 0:
continue # skip genesis block
block = Block(
block_data["index"],
block_data["transactions"],
block_data["timestamp"],
block_data["previous_hash"],
block_data["nonce"],
)
proof = block_data["hash"]
added = generated_blockchain.add_block(block, proof)
if not added:
raise Exception("The chain dump is tampered!!")
return generated_blockchain
# endpoint to add a block mined by someone else to
# the node's chain. The block is first verified by the node
# and then added to the chain.
@app.route("/add_block", methods=["POST"])
def verify_and_add_block():
block_data = request.get_json()
block = Block(
block_data["index"],
block_data["transactions"],
block_data["timestamp"],
block_data["previous_hash"],
block_data["nonce"],
)
proof = block_data["hash"]
added = blockchain.add_block(block, proof)
if not added:
return "The block was discarded by the node", 400
return "Block added to the chain", 201
# endpoint to query unconfirmed transactions
@app.route("/pending_tx")
def get_pending_tx():
return json.dumps(blockchain.unconfirmed_transactions)
def consensus():
"""
Our naive consnsus algorithm. If a longer valid chain is
found, our chain is replaced with it.
"""
global blockchain
longest_chain = None
current_len = len(blockchain.chain)
for node in peers:
response = requests.get("{}chain".format(node))
length = response.json()["length"]
chain = response.json()["chain"]
if length > current_len and blockchain.check_chain_validity(chain):
current_len = length
longest_chain = chain
if longest_chain:
blockchain = longest_chain
return True
return False
def announce_new_block(block):
"""
A function to announce to the network once a block has been mined.
Other blocks can simply verify the proof of work and add it to their
respective chains.
"""
print()
for peer in peers:
url = "{}add_block".format(peer)
headers = {"Content-Type": "application/json"}
requests.post(
url, data=json.dumps(block.__dict__, sort_keys=True), headers=headers
)
# Uncomment this line if you want to specify the port number in the code
app.run(debug=True, port=8001)
# client = Client()
# model = client.model_build().get_weights()
# for i in range(10):
# models = client.Federated_model(i, model)