if random.uniform(0,1) <= prob:

return True

else:

receiver= id

while receiver == id:

receiver = random.randint(0,N-1)

def __init__(self,id,N,narry,prowk,hash_type,confirmation_blocks,num_msg_limit,msg_ct_list,debug=False):

self.id = id

self.N = N

self.debug = debug

self.narry = narry

self.proof_of_work_zeros = prowk

self.hash_type = hash_type

self.block_reward = 10

self.confirmation_blocks = confirmation_blocks

self.transaction_fee = 1

self.block_creation_time = 30

self.public_key,self.private_key = generate_public_private_keys()

self.public_key_hash = generate_hash(self.public_key.hex(),type = hash_type)

self.btc = 0

self.unspent_btc = {}

self.msg_ct_limit = num_msg_limit

self.msg_ct_list = msg_ct_list

self.start_time = time.time()

def time_spent(self):

return int(time.time() - self.start_time)

def update_public_key_of_node(self,nodeid,public_key):

self.public_keys_of_nodes[nodeid] = public_key

self.node_id_of_public_key[public_key] = nodeid

def update_unspent_btc_from_block(self,block): ### only called when block is confirmed

for tx in block.transactions:

txid = tx.txid

sender_address = bytes.fromhex(tx.sender_address)

for index,output in enumerate(tx.tx_out):

if output.to_address == self.public_key_hash:

key = txid+"-"+str(index)

if key not in self.unspent_btc:

if tx.t_type == "COINBASE":

print("{} Received {} BTC as block creation reward".format(str(self.id),str(output.amount)))

else:

if self.id != self.node_id_of_public_key[sender_address]:

print("{} Received {} BTC from {}".format(str(self.id),str(output.amount),self.node_id_of_public_key[sender_address]))

self.unspent_btc[key] = [sender_address,output.amount,txid,index]

self.btc += output.amount

else:

print("RED ALERT:already received money from this transaction,", self.id)

if sender_address == self.public_key and tx.t_type !='COINBASE':

for index,input in enumerate(tx.tx_in):

key = input.prev_output_tid +"-"+str(input.prev_output_index)

self.btc -= self.unspent_btc[key][1]

if self.last_transaction_key is not None:

if key == self.last_transaction_key:

self.last_transaction_verified = True

print(self.id, "Time taken for transaction verification ",time.time()-self.last_transaction_time)

print("{} verified last transaction".format(str(self.id)))

self.last_transaction_key = None

#print("{} have received {} awards BTC".format(str(self.id),str(self.btc)))

del self.unspent_btc[key]

def print_self_balance(self):

total_balance = 0

for key in self.unspent_btc.keys():

total_balance += self.unspent_btc[key][1]

print("{} has balance of {} BTC".format(str(self.id),str(total_balance)))

def return_self_balance(self):

total_balance = 0

for key in self.unspent_btc.keys():

total_balance += self.unspent_btc[key][1]

return total_balance

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()