def newBlock():
block = Block()
block.blockFromByteArray(request.get_data())
if not blockchain.isBlockValid(block):
return "Invalid Block", 404
global mineWorker
mineWorker.join()
blockchain.processBlock(block)
blockchain.addBlock(block)
mineWorker = Miner(blockchain, out_q)
mineWorker.start()
propagateBlock(block)
return "Block added!", 200
def main():
db = DataBase()
db.connect()
m = Miner()
m.get_files()
m.get_tags()
m.insert()
def __init__(self, num_users, num_miners, difficulty):
"""
Initialization of controller for the FLOPchain network
Simulates the role of nodes in a Blockchain system. Should preserve all
decentralization logic, just makes simulation simpler.
:param num_users: Number of users in the network
:param num_miners: Number of miners in the network
:param difficulty: Mining difficulty
"""
# A default function that miners can use to fill the requirement
def nullFunc():
sleep(1)
return 2**100
nullJob = Computation("Null", nullFunc)
self.computations.add(nullJob)
self.difficulty = int(difficulty)
# initialize users
for _ in range(0, num_users):
self.users.append(User.User(self))
# set up the genesis block
t = Transaction("Ondaatje", "Jason", "0")
t.salt = '262'
genesis = Block([t], "", computation=Computation("", None))
self.blockchain.append(genesis)
# initialize miners
for i in range(0, num_miners):
u = self.users[i % len(self.users)]
m = Miner(self, [genesis], u)
self.miners.append(m)
thread.start_new_thread(m.mine, ())
def __init__(self, n):
self.num_of_miners = n
self.miners = []
# create new miners
for x in range(0,n):
# create each miner
self.miners += [Miner(Blockchain(), x)]
class Minecart():
miner = None
def menu(self):
print('1- Load file')
self.push()
print('2- Search in file')
self.beat()
def push(self):
file = input('Enter file name or path: ')
print('Opening: ./' + file + '.txt ...')
self.miner = Miner('./' + file + '.txt')
def beat(self):
listwords = []
listtags = []
try:
typedwords = input('Enter list of words: ')
listwords = typedwords.split()
except SyntaxError:
listwords = []
try:
typedtags = input('Enter list of tags: ')
listtags = typedtags.split()
except SyntaxError:
listtags = []
if (listtags == [] and listwords == []):
print('You\'ve typed an empty query')
return
if (listtags == []):
df = self.miner.search(tags=[], words=listwords)
print(df)
return
if (listwords == []):
df = self.miner.search(tags=listtags, words=[])
print(df)
return
df = self.miner.search(tags=listtags, words=listwords)
print(df)
return
def spawn(self, miner):
if miner in config.pools:
if miner in self.miner and self.miner[miner].isRunning:
print('Thread is already running!')
else:
self.miner[miner] = Miner(config.pools[miner])
self.miner[miner].start()
else:
print("%s not in config.pools" % miner)
def __project(self, projection):
nextBuy = self.__getNextBuy(projection)
while nextBuy.date < self.startDate + timedelta(self.days):
projection.miners.append(Miner(
hashRate=nextBuy.ghs,
startDate=nextBuy.date,
days=Reinvestment.__planDays,
))
projection.startDate = nextBuy.date
projection.project()
nextBuy = self.__getNextBuy(projection)
def __init__(self,
work_queue,
difficulty,
identity,
selfish=False,
trydospending=False):
self.wq = work_queue
self.miner = Miner.new(Blockchain(), 0, difficulty, selfish)
self.upcoming_transactions = []
self.received_blocks = []
self.identity = identity
self.spv_clients = [5007, 5008, 5009]
self.other_miners = [5000, 5001, 5002, 5003, 5004, 5005]
self.publist = []
self.other_miners.remove(self.identity)
self.addr = '127.0.0.1'
self.pubkeys = []
self.selfish = selfish
self.trydospending = trydospending
self.dospending = False
f = open(str(self.identity) + '.txt', 'w')
f.write(self.miner.get_pk())
f.close()
class Architect:
"""Top level class for stock program"""
def __init__(self):
# DB init goes here
self.miner = Miner()
# create DB calls
def mine_today(self):
# add all the companies from tblCompany
for dict in [{"Name":"Google", "Symbol":"GOOG"}]:
self.miner.add_company(Company(dict["Name"], dict["Symbol"]))
self.miner.mine()
self.miner.score_companies()
for company in self.miner.company_list:
print company.company_name, company.current_price, company.current_media
def main(self, msg_qs, outputq):
# print(self.id, len(self.msg_ct_list))
# self.msg_ct_list.append(self.id)
# print(self.id, self.msg_ct_list)
done = False
self.public_keys_of_nodes = [None] * self.N
self.public_keys_of_nodes[self.id] = self.public_key
self.node_id_of_public_key = {}
self.node_id_of_public_key[self.public_key] = self.id
self.last_transaction_verified = True
self.last_transaction_key = None
ct = 0
for i in range(0, self.N):
if i != self.id:
msg_qs[i].put(
Message("PUBLIC_KEY", self.public_key, self.id, i))
ct = 0
while ct < self.N - 1:
try:
msg = msg_qs[self.id].get(block=True, timeout=10)
if msg.type == "PUBLIC_KEY":
self.update_public_key_of_node(msg.src, msg.msg)
ct += 1
except Q.Empty:
print(" No message and wait for the public keys")
if self.debug:
print("Received public key total from ct {} from every node to {}".
format(str(ct), str(self.id)))
miner = Miner(self.id, self.N, self.narry, self.proof_of_work_zeros,
self.hash_type, self.confirmation_blocks,
self.private_key, self.public_keys_of_nodes,
self.node_id_of_public_key, self.debug)
debug_block_creation_time = True
if self.id == 0: ## create a genesis block
inputs = [Input('None', 'None')]
outputs = []
total_amount_generated = 0
print("Initial money")
for i in range(0, self.N):
amount = 1000
if i == 0:
amount += self.block_reward
total_amount_generated += amount
print(i, amount)
outputs.append(
Output(self.public_keys_of_nodes[i].hex(), amount,
self.hash_type))
coinbase_t = Transaction(self.public_keys_of_nodes[self.id],
inputs,
outputs,
self.private_key,
t_type='COINBASE',
hash_type=self.hash_type)
miner.blockchain = BlockChain(self.narry, self.proof_of_work_zeros,
self.hash_type)
if debug_block_creation_time:
start_time_block = time.time()
miner.blockchain.add_genesis_block([coinbase_t])
if debug_block_creation_time:
print("Time taken in genesis block creation,",
time.time() - start_time_block)
for i in range(1, self.N):
if self.debug:
print("Sending everyone else the genesis block ", self.id)
msg_qs[i].put(
Message("GENESIS_BLOCK", miner.blockchain, self.id, i))
self.update_unspent_btc_from_block(miner.blockchain.blockchain[0])
else: ### everyone else will receive the genesis block and use it further for transaction
received_genesis_block = False
while not received_genesis_block:
try:
msg = msg_qs[self.id].get(block=True, timeout=10)
if msg.type == "GENESIS_BLOCK":
miner.blockchain = msg.msg
received_genesis_block = True
except Q.Empty:
print(" Waiting for genesis block,", self.id)
if self.debug:
print(
"Received genesis block, now need to verify it and update its own money ",
self.id)
#msg.msg.blockchain[0].nounce = '223'
if miner.verify_genesis_block():
if self.debug:
print("verfied genesis block")
self.update_unspent_btc_from_block(
miner.blockchain.blockchain[0])
done = False
die_out_seconds = 120
timeout_seconds = 1
start_time = time.time()
last_block_cor = time.time()
last_transaction_time = time.time()
waited_time = 0
debug_size = False
debug_smt_contract = False
debug_multi_transaction = False
debug_smt_execute_once = False
debug_smt_repeat = False
smt_contract = False
debug_block_creation_time = False
debug_block_creation_time_num_of_nodes = False
if debug_smt_contract and self.id == 0:
debug_smt_execute_once = True
smt_contract = True
if debug_smt_contract and self.id == 1:
debug_smt_repeat = True
smt_contract = True
if debug_size and self.id == 0:
print(self.id, " size of block chain ", miner.blockchain.size())
while not done:
try:
#print(self.id , "main checking for message")
msg = msg_qs[self.id].get(block=True, timeout=timeout_seconds)
waited_time = 0
if msg.type == "Transaction":
#print(self.id,"Transaction has been received from ", msg.src )
if msg.msg.verify_sign_transaction():
miner.transactions_collected.append(
msg.msg) ###check if already exist in blockchain
last_transaction_time = time.time()
elif msg.type == "Block":
if self.debug:
print("Node ", self.id, "Block has been received from",
msg.src)
status = miner.add_block(msg.msg)
if status:
#print(self.id, " Received block has been added to blockchain ")
last_block_cor = time.time()
else:
print(self.id, " Received block was not added")
else:
print(
"Node ", self.id,
" Received message of type , I dont do what do i do with it",
msg.type, msg.src)
except Q.Empty:
waited_time += timeout_seconds
if waited_time > die_out_seconds:
print("waited for transactions for more than ",
die_out_seconds,
" seconds, seems none is using bitcoin, lets die")
#print("I {} had a amount of {} BTC".format(str(self.id),str(self.btc)))
self.print_self_balance()
return
else:
if time.time(
) - last_transaction_time > 15 and self.last_transaction_verified:
if coin_toss(1.0 /
self.N) and (not debug_smt_contract or
(debug_smt_contract and
(self.id in [0, 1, 3, 4]))):
#if True:
self.msg_ct_list.append(self.id)
if len(self.msg_ct_list) <= self.msg_ct_limit:
send_to = pick_receiver(self.id, self.N)
if debug_smt_contract and self.id == 0:
send_to = 8
if debug_smt_contract and self.id == 1:
send_to = 9
amount = random.randint(1, 4)
if debug_smt_execute_once and self.return_self_balance(
) >= 700:
amount = 100
debug_smt_execute_once = False
print(
"############\nNode ", self.id,
" : balance is ",
self.return_self_balance(),
" so as smart contract of execute once, sending ",
amount, "btc to ", send_to,
"\n############")
else:
if debug_smt_repeat and self.return_self_balance(
) >= 700:
amount = 100
print(
"############\nNode ", self.id,
" : balance is ",
self.return_self_balance(),
" so as smart contract of repeat, sending ",
amount, "btc to ", send_to,
"\n############")
else:
amount = random.randint(1, 4)
unspent_key = None
for key in self.unspent_btc.keys():
if amount + 3 <= self.unspent_btc[key][1]:
unspent_key = key
if unspent_key is None:
print("{} has no money left , so dying".
format(str(self.id)))
else:
#key = list(self.unspent_btc.keys())[0]
#print("{} has amount {} btc in selected key".format(str(self.id),str(self.unspent_btc[unspent_key][1])))
if debug_multi_transaction:
send_to_v = pick_receiver(
self.id, self.N)
inputs = [
Input(
self.unspent_btc[unspent_key]
[2],
self.unspent_btc[unspent_key]
[3])
]
outputs = [
Output(
self.public_keys_of_nodes[
send_to].hex(), amount,
self.hash_type),
Output(
self.public_keys_of_nodes[
send_to_v].hex(),
amount + 2, self.hash_type),
Output(
self.public_keys_of_nodes[
self.id].hex(),
self.unspent_btc[unspent_key]
[1] - amount - amount - 2 - 1,
self.hash_type)
]
print(
"Node {} Sending {} btc to node {} and {} btc to node {} "
.format(str(self.id), str(amount),
str(send_to),
str(amount + 2),
str(send_to_v)))
else:
inputs = [
Input(
self.unspent_btc[unspent_key]
[2],
self.unspent_btc[unspent_key]
[3])
]
outputs = [
Output(
self.public_keys_of_nodes[
send_to].hex(), amount,
self.hash_type),
Output(
self.public_keys_of_nodes[
self.id].hex(),
self.unspent_btc[unspent_key]
[1] - amount - 1,
self.hash_type)
]
transaction = Transaction(
self.public_keys_of_nodes[self.id],
inputs,
outputs,
self.private_key,
t_type='Regular',
hash_type=self.hash_type)
for i in range(0, self.N):
if i != self.id:
msg_qs[i].put(
Message(
"Transaction", transaction,
self.id, i))
miner.transactions_collected.append(
transaction)
self.last_transaction_verified = False
self.last_transaction_key = unspent_key
#del self.unspent_btc[key] #### check for this and
self.last_transaction_time = time.time()
print("Node {} Sending {} btc to node {} ".
format(str(self.id), str(amount),
str(send_to)))
waited_time = 0
if time.time() - last_block_cor > self.block_creation_time:
#last_block_cor= time.time()
if coin_toss(1 * 1.0 / self.N):
#if True and self.id == 0:
print(self.id, " Creating a block ",
len(miner.transactions_collected))
if debug_block_creation_time:
print("starting debug block time creatioin")
times = []
for i in range(0, 100):
block_start_time = time.time()
miner.create_block()
block_end_time = time.time()
times.append(block_end_time -
block_start_time)
print(self.id, " block chain creation times",
times)
new_block = miner.create_block()
if new_block is not None:
#
if self.debug:
print(
self.id,
" block has been created but first check if someone computed first"
)
send_block_to_ee = False
empty_queue = False
temp_msgs = []
while not empty_queue:
try:
msg = msg_qs[self.id].get(
block=True,
timeout=timeout_seconds)
if msg.type == "Block":
if self.debug:
print(
self.id,
" Ohh Received a block from ",
msg.src)
miner.add_block(msg.msg)
empty_queue = True
else:
temp_msgs.append(msg)
except Q.Empty:
send_block_to_ee = True
empty_queue = True
for msg in temp_msgs:
msg_qs[self.id].put(
Message(
msg.type, msg.msg, msg.src,
msg.dst)
) ## putting it back so can be fetched again in main loop
if send_block_to_ee:
#if self.debug:
waited_time = 0
print(
self.id,
" No block has been recieved, so send it everyone"
)
print(self.id,
" size of blockchain containing ",
len(new_block.transactions),
" and size of ",
new_block.size_merkle())
for i in range(0, self.N):
if i != self.id:
if self.debug:
print(
self.id,
" sending created block to ",
i)
msg_qs[i].put(
Message(
"Block", new_block,
self.id, i))
miner.add_block(new_block)
#last_block_cor = time.time()
res = miner.increase_verified_block()
#print(self.id, "after adding status",res)
last_block_cor = time.time()
if res:
if debug_size and self.id == 0:
print(self.id,
" size of block chain after adding ",
miner.blockchain.size())
self.update_unspent_btc_from_block(
miner.blockchain.blockchain[
miner.blockchain.confirmed_block_index]
) ## it will
## also need to check if last payment by this node is verified
self.print_self_balance()
from argparse import ArgumentParser
from flask import Flask, jsonify, request
from Miner import Miner
import requests
from GeneralSettings import host_address, blockchain_port
# Instantiate our Node
app = Flask(__name__)
# Instantiate the Miner
miner = Miner()
@app.route('/mine', methods=['GET'])
def mine():
result = miner.mine()
if type(result) is str:
return jsonify({'message': result}), 200
response = {
'message': "New Block Forged",
'index': result['index'],
'transactions': result['transactions'],
'proof': result['proof'],
'previous_hash': result['previous_hash'],
'timestamp': result['timestamp']
}
return jsonify(response), 200
from argparse import ArgumentParser
from flask import Flask, jsonify, request
from Miner import Miner
import requests
from GeneralSettings import host_address, blockchain_port
# Instantiate our Node
app = Flask(__name__)
# Instantiate the Miner
miner = Miner()
@app.route('/mine', methods=['GET'])
def mine():
result = miner.mine()
if type(result) is str:
return jsonify({
'message': result
}), 200
response = {
'message': "New Block Forged",
'index': result['index'],
'transactions': result['transactions'],
'proof': result['proof'],
'previous_hash': result['previous_hash'],
'timestamp': result['timestamp']
}
def __init__(self,
pow,
miner_count,
neighbour_count,
delay,
upload_bandwidth,
download_bandwidth,
hash_power=1,
selfish_miner_hash_power_in_percent=0.3,
propagator_count=100,
propagator_delay=0,
propagator_upload_bandwidth=100,
propagator_download_bandwidth=100,
racing_test=False,
race_count=0):
self.hash_power = hash_power
self.selfish_miner_hash_power_in_percent = selfish_miner_hash_power_in_percent
self.racing_test = racing_test
self.race_count = race_count
if not racing_test:
# init <miner_count> miners
self.pow = pow
self.miner_count = miner_count
self.propagater_count = propagator_count
self.selfish_miner = None
# if configuration == "selfish1":
selfish_miner_hr = math.ceil(
hash_power * miner_count /
(1 - selfish_miner_hash_power_in_percent) -
miner_count * hash_power)
self.selfish_miner = SelfishMiner(0, pow, delay, upload_bandwidth,
download_bandwidth,
selfish_miner_hr)
selfish_propagaters = [
SelfishPropagator(self.selfish_miner, i, pow, propagator_delay,
propagator_upload_bandwidth,
propagator_download_bandwidth)
for i in range(1 + self.miner_count, 1 + self.miner_count +
self.propagater_count)
]
self.miners = [Miner(i, pow, delay, upload_bandwidth, download_bandwidth, hash_power) for i in range(1, miner_count+1)] \
+ [self.selfish_miner] + selfish_propagaters
# else:
# self.miners = [Miner(i, pow, delay, bandwidth, hash_power) for i in range(miner_count)]
NetworkGraphGen.random_graph(self.miners, neighbour_count)
self.clock = 0
self.propagation_rates = []
else:
# init <miner_count> miners
self.pow = POW(1, 1)
self.miner_count = miner_count
self.propagater_count = propagator_count
self.selfish_miner = None
# if configuration == "selfish1":
self.selfish_miner = SelfishMiner(0, self.pow, delay,
upload_bandwidth,
download_bandwidth, 1)
self.selfish_miner.racing_test = True
racer_miner = Miner(1, self.pow, delay, upload_bandwidth,
download_bandwidth, 1)
selfish_propagaters = [
SelfishPropagator(self.selfish_miner, i, self.pow,
propagator_delay,
propagator_upload_bandwidth,
propagator_download_bandwidth)
for i in range(1 + self.miner_count, 1 + self.miner_count +
self.propagater_count)
]
self.miners = [Miner(i, self.pow, delay, upload_bandwidth, download_bandwidth, 0) for i in range(2, miner_count+1)] \
+ [self.selfish_miner] + [racer_miner] + selfish_propagaters
# else:
# self.miners = [Miner(i, pow, delay, bandwidth, hash_power) for i in range(miner_count)]
NetworkGraphGen.random_graph(self.miners, neighbour_count)
self.clock = 0
self.propagation_rates = []
#! /usr/bin/env python3
#! /usr/bin/python3.6
# Form implementation generated from reading ui file 'untitled.ui'
# Created by: PyQt5 UI code generator 5.10.1
import vlc, sqlite3, _thread, time
from PyQt5 import QtCore, QtGui, QtWidgets
from DB import Database
from Miner import Miner
from create_person_dialog import Ui_create_pers
from create_group_dialog import Ui_create_group_dialog
from link_dialog import Ui_Dialog
global miner, db
miner = Miner(None)
db = Database()
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
self.playing = False
self.player = None
MainWindow.setObjectName("MainWindow")
MainWindow.resize(726, 570)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.gridLayout = QtWidgets.QGridLayout(self.centralwidget)
self.gridLayout.setObjectName("gridLayout")
self.verticalLayout = QtWidgets.QVBoxLayout()
self.verticalLayout.setObjectName("verticalLayout")
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
from Miner import Miner
from MinersWife import MinersWife
from EntityNames import EntityNames
from EntityManager import EntityManager
import time
# create a miner
Bob = Miner(EntityNames.ent_Miner_Bob)
# create his wife
Elsa = MinersWife(EntityNames.ent_Elsa)
#register them with the entity manager
#EntityMgr = EntityManager()
EntityManager.getInstance().RegisterEntity(Bob)
EntityManager.getInstance().RegisterEntity(Elsa)
for x in range(0, 20):
Bob.Update()
Elsa.Update()
time.sleep(1)
def start_miner(self):
prev_hash = hash_string(str(self.blockchain.get_last()))
self.miner = Miner(self, prev_hash, self.blockchain.get_size(),
self.transaction_pool)
self.miner.start()
while not Connected():
Connect()
Wait(10000)
if __name__ == "__main__":
AddToSystemJournal("stealth-pyMiner script starting...")
AddToSystemJournal("Target your storage container...")
ClientRequestObjectTarget()
while not ClientTargetResponsePresent():
Wait(250)
_storage = ClientTargetResponse()
# Miner(homerunebook name, [mining book names], storage container)
_m = Miner("Home", ["Mining1", "Mining2"], _storage)
while _m.Mounted:
UseObject(Self())
Wait(750)
_m.DropoffOre()
while not Dead():
if len(_m.DiggingTools) < 10:
_m.MakeTools()
for _miningBook in _m.RunebooksMining:
for _rune in range(0, 15):
# _miningBook.Recall(_rune)
_m.Mine(10)
import sys, os
sys.path.insert(0, os.path.abspath('..'))
from flask import Flask, request, jsonify
from Miner import Miner
from Utils.Navtime import NavTime
from Utils.Hash import CalculateFileHash
app = Flask(__name__)
miner = Miner(CalculateFileHash("/home/gaurav/NAV-Chain/demo/id_rsa.pub"), "",
"", "")
time = NavTime()
@app.route("/getNewsFromClient", methods=["POST"])
def getNewsFromClient():
ip = request.remote_addr
# print(request.)
user_id = request.json["id"]
text = request.json["text"]
genre = request.json["genre"]
miner.ReceiveContent(miner.id, user_id, text, genre)
miner.clientIp.append(ip)
return jsonify({"bid": "QmdDyNf1oKqH44cRisLE9a298cBcry3ifrpGrweXGEjZt8"})
@app.route("/getNewsfromPeer", methods=["POST"])
def getNewsfromPeer():
ip = request.remote_addr
user_id = request["id"]
text = request["text"]
class MyManager(BaseManager):
pass
MyManager.register('QEL', Queue_Event_Lock)
main_node_pool = []
seed_nodes = dict({})
manager = MyManager()
manager.start()
# create genesis block
for i in range(num_seed_nodes):
# seed_nodes[i] = new_seed.get_QEL()
seed_nodes[i] = manager.QEL()
new_seed = Miner(miner_id=i,
blockchain=None,
manager_qel=seed_nodes[i],
node_type="SEED")
main_node_pool.append(new_seed)
# create genesis blockchain with cionbase for each seed node
block = Block(node_pool=main_node_pool, genesis_block=True)
block.construct_merkle_tree()
print('Node 0 ki compute power', main_node_pool[0].compute_power)
# block = calc_proof_of_work(block, main_node_pool[0].compute_power)
block = calc_proof_of_work(block, 2)
print('Done computing')
gen_blockchain = Blockchain(genesis_block=block)
for i in range(num_seed_nodes):
main_node_pool[i].blockchain = gen_blockchain
def __init__(self):
# DB init goes here
self.miner = Miner()
def push(self):
file = input('Enter file name or path: ')
print('Opening: ./' + file + '.txt ...')
self.miner = Miner('./' + file + '.txt')
q3.put(blk)
if js[0] == '1':
print("=================Transaction received===================")
t = js[1]
q4.put(t)
if js[0] == '2':
print("=================Coin request received================")
receiver, amt = js[1],js[2]
q5.put({receiver:amt})
print(receiver, amt)
if __name__ == "__main__":
miner = Miner('5ff904f38a0b1c1de04193668f7442c5146bd0c868eb2e31','b7e9e8c717bbfab299e6a4dbaacef166957aab1865a5762d4e22cc7de31057c99682651642e1bd6ad138c03e4f37f495')
print('pubkey:', miner.pubkey)
miner.port = ("localhost", 2346)
q3 = Queue()
q4 = Queue()
q5 = Queue()
p1 = Process(target=miner.mine_block, args=(q3,q4,q5))
p2 = Process(target=server, args=(q3,q4,q5))
p1.start()
p2.start()
class Node:
def __init__(self, address, own_port):
self.address = address # wallet address
self.own_port = own_port # porta na qual receberá requests
self.peers = None
self.blockchain = Blockchain(Genesis())
self.difficulty = 4
self.current_state = None
self.miner = None
self.transaction_pool = []
self.lock = RLock()
def start_node(self):
initial_socket = socket(AF_INET, SOCK_STREAM)
initial_socket.connect((SERVER, SERVER_PORT))
initial_socket.send(write_message('connect', self.own_port))
initial_socket.shutdown(SHUT_WR)
try:
response = ''
while True:
data = initial_socket.recv(1024).decode('ascii')
if not data:
break
response += data
print(response)
code, data = read_message(response)
if code == 'ok':
self.peers = eval(str(data))
writePeers("cpeers.txt", self.peers)
finally:
initial_socket.close()
for peer in self.peers:
peer = eval(str(peer))
self.request_top_block(peer_ip=peer[0], peer_port=peer[1])
self.listen_requests()
def request_top_block(self, peer_ip, peer_port):
s = socket(AF_INET, SOCK_STREAM)
try:
s.connect((peer_ip, peer_port))
s.send(write_message('get_top', None))
s.shutdown(SHUT_WR)
response = ''
while True:
data = s.recv(BUFFER).decode('ascii')
if not data:
break
response += data
code, data = read_message(response)
if code == 'top_block':
block = rebuild_block(data)
self.receive_block(block, peer_ip, peer_port)
except ConnectionRefusedError:
# self.peers.remove((peer_ip, peer_port))
print(peer_ip, ':', peer_port, ' is unreachable')
def receive_block(self, new_block, sender_ip, sender_port):
last_block = self.blockchain.get_last()
if new_block.index <= last_block.index:
return False # stale block
else:
# verifica o novo bloco e a chain a qual pertence, se diferente da atual
self.validate_chain(new_block, sender_ip, sender_port)
def request_block(self, block_hash, sender_ip, sender_port):
s = socket(AF_INET, SOCK_STREAM)
s.connect((sender_ip, sender_port))
s.send(write_message('get_block', block_hash))
s.shutdown(SHUT_WR)
response = ''
while True:
data = s.recv(BUFFER).decode('ascii')
if not data:
break
response += data
code, data = read_message(response)
if code == 'block':
block = rebuild_block(data)
return block
return None
def listen_requests(self):
s = socket(AF_INET, SOCK_STREAM)
s.bind(('', self.own_port))
s.listen()
while 1:
conn, addr = s.accept()
_thread.start_new_thread(self.route_request, (conn, addr))
def send_transactions(self, receiving_address, ammount):
for peer in self.peers:
peer = eval(str(peer))
_thread.start_new_thread(
self.send_transaction,
(peer[0], peer[1], receiving_address, ammount))
def send_transaction(self, peer_ip, peer_port, receiving_address, amount):
data = {self.address: -amount, receiving_address: amount}
try:
s = socket(AF_INET, SOCK_STREAM)
s.connect((peer_ip, peer_port))
s.send(write_message('transaction', data))
s.shutdown(SHUT_WR)
response = ''
while True:
data = s.recv(BUFFER).decode('ascii')
if not data:
break
response += data
code, data = read_message(response)
print(peer_ip, ':', peer_port, ' - ', code)
except ConnectionRefusedError:
print(peer_ip, ':', peer_port, ' is unreachable')
def receive_transaction(self, peer_socket, transaction):
if not self.miner:
peer_socket.send(write_message('not_mining', None))
elif len(self.transaction_pool) >= 9:
peer_socket.send(write_message('full_block', None))
elif self.accept_transaction(transaction):
peer_socket.send(write_message('tr_accepted', None))
peer_socket.close()
def route_request(self, conn, addr):
msg = ''
while 1:
data = conn.recv(BUFFER).decode('ascii')
if not data:
break
msg += data
code, data = read_message(msg)
if code == 'get_block':
block_hash = data
data = self.blockchain.get_block(block_hash)
conn.send(write_message('block', data))
elif code == 'get_top':
data = self.blockchain.get_last()
conn.send(write_message('top_block', data))
elif code == 'new_block':
block = rebuild_block(data)
self.receive_block(block, sender_ip=addr[0], sender_port=addr[1])
elif code == 'transaction':
self.receive_transaction(conn, data)
conn.close()
def accept_transaction(self, transaction):
candidate_state = self.get_current_state().copy()
if sum(transaction.values()) != 0:
return False
for address in transaction.keys():
if address in candidate_state.keys(): # o endereço existe
if candidate_state[address] - transaction[
address] >= 0: # o endereço possue fundos suficientes
candidate_state[address] += transaction[address]
else:
return False
# se o endereço não existe mas a quantia é positiva
elif transaction[address] > 0:
# cria o endereço
candidate_state[address] = transaction[address]
else: # a quantia é negativa
return False
self.transaction_pool.append(transaction)
self.restart_miner()
return True
def start_miner(self):
prev_hash = hash_string(str(self.blockchain.get_last()))
self.miner = Miner(self, prev_hash, self.blockchain.get_size(),
self.transaction_pool)
self.miner.start()
def restart_miner(self):
if self.miner:
self.stop_miner()
self.start_miner()
def stop_miner(self):
self.miner.stop()
def get_current_state(self):
if not self.current_state:
return self.rebuild_current_state()
return self.current_state
# retorna um dict com todos os addresses existentes e seus fundos
def rebuild_current_state(self):
state = {}
for transaction in self.blockchain.get_all_transactions():
for address in transaction.keys():
if address in state.keys():
state[address] += transaction[address]
else:
state[address] = transaction[address]
self.current_state = state
return state
def validate_chain(self, top_block, sender_ip, sender_port):
self.lock.acquire(
) # locka a blockchain para que ela não seja alterada durante a verificação
try:
different_blocks = [top_block]
top_index = top_block.index
current_block = top_block
# itera para encontrar blocos diferentes dos quais a blockchain atual armazena
while self.blockchain.get_block(current_block.prev_hash) is None:
# pede o bloco diferente
current_block = self.request_block(current_block.prev_hash,
sender_ip, sender_port)
top_index = current_block.index
different_blocks.append(current_block)
# itera sobre os blocos diferentes
for block in different_blocks:
if not self.validate_block(block): # se o bloco não é valido
if top_index <= self.blockchain.get_size(
): # e o tamanho da chain recebida é menor que a atual
return # não faz nada
else: # a chain nova é maior e correta até certo ponto
break # adiciona
else: # o bloco é válido
top_index = block.index
self.add_new_blocks(
different_blocks, top_index
) # adiciona os novos blocos até o maior índice válido
finally:
self.lock.release()
def validate_block(self, block):
block_hash = hash_string(str(block))
if not verify_size(block):
return False
if not self.verify_difficulty(block_hash):
return False
if not self.verify_transactions(block):
return False
print(block_hash, " accepted as valid")
return True
def add_new_blocks(self, blocks, top_index):
self.current_state = None # inutiliza a referencia atual do estado
self.transaction_pool = []
self.restart_miner()
for block in blocks:
if block.index <= top_index:
self.blockchain.add_block(block, block.index)
def verify_difficulty(self, block_hash):
first_chars = block_hash[:self.difficulty]
first_chars = first_chars.replace('0', '') # remove os zeros
if first_chars:
return False # first_chars não está vazia
return True
def verify_transactions(self, block):
current_state = self.get_current_state()
candidate_state = current_state.copy()
print(block.transactions)
# valida a primeira transação
if len(block.transactions[0].keys()) > 1 or sum(
block.transactions[0].values()) > 10:
return False
# itera sobre as transações restantes
for transaction in block.transactions[1:]:
if sum(transaction.values()) != 0:
return False
for address in transaction.keys():
if address in candidate_state.keys(): # o endereço existe
if candidate_state[address] - transaction[
address] >= 0: # o endereço possue fundos suficientes
candidate_state[address] += transaction[address]
else:
return False
# se o endereço não existe mas a quantia é positiva
elif transaction[address] > 0:
# cria o endereço
candidate_state[address] = transaction[address]
else: # a quantia é negativa
return False
return True
from Blockchain import Blockchain
from Miner import Miner
from Transaction import Transaction
from blockchain_utils import *
import jsonpickle
from utils import log, generate_malicious_chain
app = Flask(__name__)
blockchain = Blockchain()
test_names = ["special miner", "a miner"]
test_ips = ["http://192.168.1.108:5000", "http://192.168.1.108:5001"]
test_ports = [5000, 5001]
test = 0
miner = Miner(test_names[test], 0)
my_node_address = test_ips[
test] #"http://192.168.1.108:5001"#"http://197.55.175.10:5000"
# Address format : http://IP:port
peers = set()
if miner.name != "special miner":
node_address = "http://192.168.1.108:5000" #"http://197.160.27.226:5000"#"http://102.40.55.128:5000" # Special miner
peers.add(node_address)
if not node_address:
log("main_miner", "Special miner address is not specified!", "error")
raise Exception("Node address is not specified!")
data = {"node_address": my_node_address}
headers = {'Content-Type': "application/json"}
response = requests.post(node_address + "/register_node",
data=json.dumps(data),
def new_miners(self, amount, power):
for i in range(amount):
self.add_node(Miner(self, power))
from Miner import Miner
import time
# Press the green button in the gutter to run the script.
if __name__ == '__main__':
miner = Miner()
for x in range(1, 20):
miner.update()
time.sleep(1)
# See PyCharm help at https://www.jetbrains.com/help/pycharm/
import hashlib
import random
import time
import math
import json
import KeyGen
from Miner import Miner
from Users import user_db
from Blockchain import BlockChain
from Transaction import Transaction
if __name__ == "__main__":
sutdcoin = BlockChain()
users = list(user_db.keys())
t1 = Transaction(users[0], users[2], 80, "user0 -(80)-> user2")
t2 = Transaction(users[0], users[1], 30, "user0 -(30)-> user1")
sutdcoin.add_transaction_to_pool([t1, t2])
user3 = Miner(users[3], sutdcoin)
user3.mine()
print("\nsutdcoin blockchain graph:", sutdcoin.graph)
print("\nsutdcoin user_db:", user_db)
includeReferralBonus = True
investments = [
Investment(1800, '5/30/2018'),
Investment(300, '5/30/2018'),
Investment(300, '5/30/2018'),
Investment(10, '6/4/2018'),
Investment(10, '6/8/2018')
]
totalInvested = 0
for investiment in investments:
totalInvested = totalInvested + investiment.amount
miners = [
Miner(hashRate=40600, startDate='5/31/2018', days=90),
Miner(hashRate=3450, startDate='6/4/2018', days=90),
Miner(hashRate=1000, startDate='6/5/2018', days=90),
Miner(hashRate=1270, startDate='6/7/2018', days=90),
Miner(hashRate=1900, startDate='6/9/2018', days=90),
Miner(hashRate=1540, startDate='6/11/2018', days=90),
Miner(hashRate=1300, startDate='6/13/2018', days=90),
Miner(hashRate=1070, startDate='6/14/2018', days=90),
Miner(hashRate=3000, startDate='6/17/2018', days=90),
Miner(hashRate=4800, startDate='6/27/2018', days=90),
Miner(hashRate=6500, startDate='7/3/2018', days=90),
Miner(hashRate=3700, startDate='7/7/2018', days=90),
Miner(hashRate=11950, startDate='7/9/2018', days=90)
]
print "End Date Main Referral Total Profit % Min Buy (GHS)"
from Miner import Miner import sys import time m = Miner(int(sys.argv[1]), ["127.0.0.1"], [8000]) time.sleep(60) m.blockchain.printBlockchainAndAll()
from Crypto import Random # From Pycryptodome
import time # For Runtime Analysis
from Difficulty import System # Import basic System Class for checking proof-of-work
from Miner import Miner
Example_System = System(
) # Object to check Proof-Of-Work 256 Bits , intitial Difficulty = 1
miner_count = 500 # Total Number of Miner Threads
RUNTIME = (120) # For Burnout, Specify time
start_time = time.time()
miners = []
# Start all miners
for i in range(miner_count):
x = Miner(Example_System, i)
x.start()
time.sleep(RUNTIME)
stop_time = time.time()
hashes_count = Example_System.get_total_hashes()
block_count = Example_System.get_block_count()
for miner in miners:
miner.halt_thread()
# Stats and Math
time_elapsed = stop_time - start_time
hash_rate = (hashes_count / time_elapsed) / 1000
@app.route('/get_transactions', methods=['POST'])
def listening_to_my_transactions():
user_pub_key = request.get_json()['pub']
print(user_pub_key)
# need to serialize transaction and then make on other side
transactions_list = []
data = {}
# print(sutdcoin.blockchain_graph)
last_block = sutdcoin.blockchain_graph[sutdcoin.longest_header]["block"]
longest_chain = sutdcoin.createChainToParentBlock(last_block)
longest_chain.insert(0, last_block)
#blockchain_graph_items = sutdcoin.blockchain_graph.items()
for block in longest_chain:
for trans in block.merkle_tree.past_transactions:
if trans.sender == user_pub_key or trans.receiver == user_pub_key:
nodes, neighbour, index = block.merkle_tree.get_min_nodes(
trans)
transactions_list.append(
[trans.serialize(), nodes, neighbour, index])
data['transaction_list'] = transactions_list
print("THE TRANSACTION LIST IS:", data)
data = json.dumps(data)
return data, 200
if __name__ == '__main__':
myMiner = Miner(pub_key, sutdcoin)
app.run(host="0.0.0.0", port=args.port, debug=True)
import hashing
from Wallet import Wallet
from Blockchain import get_blockchain
from Miner import Miner
if __name__ == "__main__":
print(hashing.hash("Jetzt liken und abonnieren!!! The Morpheus Tutorials :)"))
w = Wallet()
print(w.public_key)
print(w.private_key)
print(w.password)
print(w.send_money([w.public_key], [50]))
print(get_blockchain().get_json())
miner = Miner(own_public_key=w.public_key)
