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)]
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 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 create_testcases(self):
for i in xrange(20):
t = Testcase(i+1)
if i == 0:
t += Miner(0, 100, 20, 10)
t += Transporter(100)
t += Smelter(0, 100, 20)
elif i == 1:
t += Miner(0, 100, 20, 200)
t += Transporter(100)
t += Smelter(0, 100, 20)
elif i == 2:
t += Miner(1, 100, 20, 200)
t += Transporter(50)
t += Smelter(1, 100, 20)
elif i == 3:
t += Miner(0, 100, 20, 200)
t += Miner(2, 100, 20, 200)
t += Transporter(50)
t += Foundry(100, 20)
elif i == 4:
t += Miner(0, 100, 20, 200)
t += Miner(2, 100, 20, 200)
t += Transporter(50)
t += Foundry(50, 20)
elif i == 5:
t += Miner(0, 100, 20, 200)
t += Miner(1, 100, 20, 200)
t += Miner(2, 100, 20, 200)
t += Transporter(100)
t += Smelter(1, 100, 20)
t += Foundry(100, 20)
elif i == 6:
t += Miner(1, 100, 20, 400)
t += Transporter(100)
t += Transporter(100)
t += Smelter(1, 100, 20)
elif i == 7:
t += Miner(0, 100, 20, 400)
t += Miner(1, 100, 20, 400)
t += Transporter(100)
t += Transporter(100)
t += Smelter(0, 100, 20)
t += Smelter(1, 100, 20)
elif i == 8:
t += Miner(0, 100, 20, 200)
t += Miner(2, 100, 20, 200)
t += Transporter(100)
t += Transporter(100)
t += Foundry(100, 20)
elif i == 9:
t += Miner(0, 100, 20, 600)
t += Miner(2, 100, 20, 600)
t += Transporter(100)
t += Transporter(100)
t += Foundry(100, 20)
t += Foundry(100, 20)
elif i == 10:
t += Miner(0, 50, 20, 600)
t += Miner(2, 50, 20, 600)
t += Transporter(100)
t += Transporter(100)
t += Foundry(100, 20)
t += Foundry(100, 20)
elif i == 11:
t += Miner(1, 100, 40, 600)
t += Transporter(100)
t += Smelter(1, 100, 20)
t += Smelter(1, 100, 20)
elif i == 12:
t += Miner(1, 100, 40, 600)
t += Transporter(100)
t += Transporter(100)
t += Smelter(1, 100, 20)
t += Smelter(1, 100, 20)
elif i == 12:
t += Miner(0, 100, 40, 600)
t += Miner(1, 100, 40, 600)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Smelter(0, 100, 20)
t += Smelter(1, 100, 20)
t += Smelter(1, 100, 20)
elif i == 13:
t += Miner(1, 100, 20, 200)
t += Miner(1, 100, 20, 200)
t += Transporter(50)
t += Smelter(1, 100, 20)
elif i == 14:
t += Miner(0, 100, 20, 400)
t += Miner(2, 100, 20, 400)
t += Transporter(100)
t += Foundry(100, 20)
t += Foundry(100, 20)
elif i == 15:
t += Miner(0, 100, 20, 400)
t += Miner(1, 100, 20, 400)
t += Miner(2, 100, 20, 400)
t += Transporter(100)
t += Transporter(100)
t += Smelter(1, 100, 20)
t += Foundry(100, 20)
elif i == 16:
t += Miner(0, 100, 20, 400)
t += Miner(1, 100, 20, 400)
t += Miner(2, 100, 20, 400)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Smelter(1, 100, 20)
t += Foundry(100, 20)
elif i == 17:
t += Miner(0, 100, 20, 600)
t += Miner(1, 100, 20, 600)
t += Miner(2, 100, 20, 600)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Smelter(1, 100, 20)
t += Smelter(1, 100, 20)
t += Foundry(100, 20)
t += Foundry(100, 20)
elif i == 18:
t += Miner(0, 100, 10, 1200)
t += Miner(0, 100, 20, 1200)
t += Miner(0, 100, 30, 1200)
t += Miner(1, 100, 10, 600)
t += Miner(1, 100, 20, 600)
t += Miner(1, 100, 30, 600)
t += Miner(2, 100, 10, 600)
t += Miner(2, 100, 20, 600)
t += Miner(2, 100, 30, 600)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Transporter(100)
t += Smelter(0, 100, 20)
t += Smelter(0, 100, 20)
t += Smelter(1, 100, 20)
t += Smelter(1, 100, 20)
t += Foundry(100, 20)
t += Foundry(100, 20)
t += Foundry(100, 20)
t += Foundry(100, 20)
elif i == 19:
t += Miner(0, 200, 10, 3000)
t += Miner(0, 100, 20, 3000)
t += Miner(0, 50, 30, 3000)
t += Miner(1, 400, 10, 2000)
t += Miner(1, 200, 20, 2400)
t += Miner(1, 100, 30, 1200)
t += Miner(2, 200, 10, 1200)
t += Miner(2, 100, 20, 2000)
t += Miner(2, 50, 30, 1800)
t += Transporter(50)
t += Transporter(50)
t += Transporter(100)
t += Transporter(100)
t += Transporter(200)
t += Transporter(200)
t += Transporter(400)
t += Transporter(400)
t += Transporter(800)
t += Transporter(800)
t += Transporter(1000)
t += Smelter(0, 100, 30)
t += Smelter(0, 100, 10)
t += Smelter(0, 100, 20)
t += Smelter(0, 100, 70)
t += Smelter(1, 100, 40)
t += Smelter(1, 100, 60)
t += Smelter(1, 100, 50)
t += Smelter(1, 100, 30)
t += Foundry(100, 50)
t += Foundry(100, 20)
t += Foundry(100, 40)
t += Foundry(100, 30)
self.testcases.append(t)
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 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
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
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)
#! /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")
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
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"]
def push(self):
file = input('Enter file name or path: ')
print('Opening: ./' + file + '.txt ...')
self.miner = Miner('./' + file + '.txt')
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 = []
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()
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()
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 threading import Thread, Event
import time
import json
from Miner import Miner
blockchain = Blockchain()
peers = []
peerLimit = 5
myNode = 'http://987a51s0bea7.ngrok.io'
genesisURL = 'https://iitkbucks.pclub.in'
myPubKey = RSA.import_key(open('public.pem').read())
out_q = Queue()
mineWorker = None
peers = blockchain.initializeBlockchain(genesisURL, myNode)
mineWorker = Miner(blockchain, out_q)
mineWorker.start()
app = Flask(__name__)
@app.route('/')
def home():
return "<h3>\"Rabbit, Fire up the server!\"</h3>Thor,<br>The strongest avenger"
@app.route('/getBlock/<n>')
def getBlock(n):
with open('blockchain/blocks/{}.dat'.format(n), 'rb') as blockn:
data = blockn.read()
response = Response(response=data, mimetype='application/octet-stream')
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)
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)
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()
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)
@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)
def add_miner(self, privateKey):
miner = Miner(privateKey)
self.accts[miner.acct_id] = miner
self.miners.append(miner)
print(f"\nAdded miner {miner.acct_id}\n")
