Spaces:
Runtime error
Runtime error
| import gradio as gr | |
| import pandas as pd | |
| import datetime | |
| import hashlib | |
| import json | |
| import os | |
| import requests | |
| from blockchain import Blockchain | |
| from mychain import MyChain | |
| from huggingface_hub import (create_repo,get_full_repo_name,upload_file,CommitOperationAdd,HfApi) | |
| main_chain='https://huggingface.co/datasets/Omnibus/blockchain-sim/raw/main/chains/' | |
| main_balance='https://huggingface.co/datasets/Omnibus/blockchain-sim/raw/main/balance/' | |
| main_nodes='https://huggingface.co/datasets/Omnibus/blockchain-sim/raw/main/node_file1.json' | |
| main_pending='https://huggingface.co/datasets/Omnibus/blockchain-sim/raw/main/pending1.json' | |
| token_self = os.environ['HF_TOKEN'] | |
| pa=os.environ['PASS'] | |
| repo_d='Omnibus/static-bin' | |
| chain_d='chain1.json' | |
| node_file='node_file.json' | |
| space='blockchain-simulator-dev1' | |
| api = HfApi(token=token_self) | |
| class Balance_sheet: | |
| def create_block(self, proof, previous_hash,chain_r=None,chain_n=None,balance=None): | |
| if chain_r=="" or chain_r==None: | |
| chain_r=f"{main_chain.split('datasets/',1)[1].split('/raw',1)[0]}" | |
| if chain_n=="" or chain_n==None: | |
| chain_n=chain_d | |
| block = {'index': len(self.chain) + 1, | |
| 'timestamp': str(datetime.datetime.now()), | |
| 'transactions': self.pending_transactions, | |
| #'balance':self.balance | |
| 'proof': proof, | |
| 'previous_hash': previous_hash} | |
| if self.block_valid(block) == True: | |
| self.pending_transactions = [] | |
| self.chain.append(block) | |
| json_object = json.dumps(self.chain, indent=4) | |
| with open("tmp.json", "w") as outfile: | |
| outfile.write(json_object) | |
| try: | |
| api.upload_file( | |
| path_or_fileobj="tmp.json", | |
| path_in_repo=chain_n, | |
| repo_id=chain_r, | |
| token=token_self, | |
| repo_type="dataset", | |
| ) | |
| os.remove("tmp.json") | |
| except Exception as e: | |
| print(e) | |
| pass | |
| return block | |
| else: | |
| block = {"Not Valid"} | |
| print("not Valid") | |
| return block | |
| def print_previous_block(self): | |
| return self.chain[-1] | |
| def new_transaction(self, sender, recipient, amount): | |
| transaction = { | |
| 'sender': sender, | |
| 'recipient': recipient, | |
| 'amount': amount | |
| } | |
| self.pending_transactions.append(transaction) | |
| class Blockchain1: | |
| def __init__(self,load=None,create=None): | |
| self.pending_transactions = [] | |
| if load == None or load=="": | |
| self.chain = [] | |
| self.create_block(proof=1, previous_hash='0',chain_n=create) | |
| elif load != None and load !="": | |
| #r = requests.get(load) | |
| lod = json.loads(load) | |
| self.chain = lod | |
| def reset(self,create=None): | |
| self.chain = [] | |
| self.pending_transactions = [] | |
| self.create_block(proof=1, previous_hash='0',chain_n=create) | |
| def create_block(self, proof, previous_hash,chain_r=None,chain_n=None): | |
| if chain_r=="" or chain_r==None: | |
| chain_r=f"{main_chain.split('datasets/',1)[1].split('/raw',1)[0]}" | |
| if chain_n=="" or chain_n==None: | |
| chain_n=chain_d | |
| block = {'index': len(self.chain) + 1, | |
| 'timestamp': str(datetime.datetime.now()), | |
| 'transactions': self.pending_transactions, | |
| 'proof': proof, | |
| 'previous_hash': previous_hash} | |
| if self.block_valid(block) == True: | |
| self.pending_transactions = [] | |
| self.chain.append(block) | |
| json_object = json.dumps(self.chain, indent=4) | |
| with open("tmp.json", "w") as outfile: | |
| outfile.write(json_object) | |
| try: | |
| api.upload_file( | |
| path_or_fileobj="tmp.json", | |
| path_in_repo=chain_n, | |
| repo_id=chain_r, | |
| token=token_self, | |
| repo_type="dataset", | |
| ) | |
| os.remove("tmp.json") | |
| except Exception as e: | |
| print(e) | |
| pass | |
| return block | |
| else: | |
| block = {"Not Valid"} | |
| print("not Valid") | |
| return block | |
| def print_previous_block(self): | |
| return self.chain[-1] | |
| def new_transaction(self, sender, recipient, amount): | |
| transaction = { | |
| 'sender': sender, | |
| 'recipient': recipient, | |
| 'amount': amount | |
| } | |
| self.pending_transactions.append(transaction) | |
| def proof_of_work(self, previous_proof): | |
| new_proof = 1 | |
| check_proof = False | |
| while check_proof is False: | |
| hash_operation = hashlib.sha256( | |
| str(new_proof**2 - previous_proof**2).encode()).hexdigest() | |
| if hash_operation[:5] == '00000': | |
| check_proof = True | |
| else: | |
| new_proof += 1 | |
| return new_proof | |
| def hash(self, block): | |
| encoded_block = json.dumps(block, sort_keys=True).encode() | |
| return hashlib.sha256(encoded_block).hexdigest() | |
| def block_valid(self, block): | |
| print (block) | |
| #prev_block=len(self.chain) | |
| if len(self.chain) > 0: | |
| prev_block = len(self.chain)-1 | |
| previous_block = self.chain[prev_block] | |
| print (previous_block) | |
| out=True | |
| ind=None | |
| mes=None | |
| if block['previous_hash'] != self.hash(previous_block): | |
| out=False | |
| #ind=block_index | |
| mes='Hash' | |
| previous_proof = previous_block['proof'] | |
| proof = block['proof'] | |
| hash_operation = hashlib.sha256( | |
| str(proof**2 - previous_proof**2).encode()).hexdigest() | |
| if hash_operation[:5] != '00000': | |
| out=False | |
| #ind=block_index+1 | |
| mes='Proof' | |
| previous_block = block | |
| else: | |
| out = True | |
| return out | |
| def chain_valid(self, chain): | |
| previous_block = chain[0] | |
| block_index = 1 | |
| out=True | |
| ind=None | |
| mes=None | |
| while block_index < len(chain): | |
| block = chain[block_index] | |
| if block['previous_hash'] != self.hash(previous_block): | |
| out=False | |
| ind=block_index | |
| mes='Hash' | |
| break | |
| previous_proof = previous_block['proof'] | |
| proof = block['proof'] | |
| hash_operation = hashlib.sha256( | |
| str(proof**2 - previous_proof**2).encode()).hexdigest() | |
| if hash_operation[:5] != '00000': | |
| out=False | |
| ind=block_index+1 | |
| mes='Proof' | |
| break | |
| previous_block = block | |
| block_index += 1 | |
| return out, ind, mes | |
| #def check_balance(sender,amount): | |
| ######################## BLOCKCHAIN START ############################### | |
| def bc_transactions(sender,recipient,amount): | |
| mes, out = issue_tokens(sender,recipient,amount) | |
| if out == True: | |
| blockchain.new_transaction(f"{sender}",f"{recipient}",f"{amount}") | |
| message = "Transaction Added to Pool" | |
| data = pd.DataFrame(blockchain.pending_transactions) | |
| if out == False: | |
| message = mes | |
| data = None | |
| return data,message,None,None,None | |
| def create_chain(create=None): | |
| global blockchain | |
| blockchain = Blockchain(chain_load=main_chain,create=create) | |
| #blockchain.reset(create=create) | |
| return "New Chain Created",None,display_chain() | |
| def display_chain(): | |
| response = {'chain': blockchain.chain, | |
| 'length': len(blockchain.chain)} | |
| return response | |
| def mine_block(chain_r=None,chain_n=None): | |
| previous_block = blockchain.print_previous_block() | |
| previous_proof = previous_block['proof'] | |
| proof = blockchain.proof_of_work(previous_proof) | |
| previous_hash = blockchain.hash(previous_block) | |
| block = blockchain.create_block(proof, previous_hash,chain_r,chain_n) | |
| response = {'message': 'A block is MINED', | |
| 'index': block['index'], | |
| 'timestamp': block['timestamp'], | |
| 'proof': block['proof'], | |
| 'previous_hash': block['previous_hash']} | |
| message = "A block is MINED" | |
| show_chain = display_chain() | |
| if len(blockchain.chain) > 1000: | |
| blockchain.reset() | |
| response = None | |
| show_chain=display_chain() | |
| message = "New Chain Created at Max 20 Blocks" | |
| return response, show_chain,pd.DataFrame(blockchain.pending_transactions), message | |
| def sort_valid(): | |
| #nodes=main_nodes.replace("'","") | |
| f = requests.get(f'{main_nodes}') | |
| t = open('tmp.json','w') | |
| t.write(f.text) | |
| t.close() | |
| f = open('tmp.json','r') | |
| f = f.read() | |
| j = json.loads(f) | |
| #j=f.json() | |
| print (len(j)) | |
| cnt=0 | |
| valid_chains=[] | |
| not_valid=[] | |
| response='' | |
| while cnt < len(j): | |
| try: | |
| r = requests.get(f'{j[cnt]["url"]}') | |
| g = open('tmp1.json','w') | |
| g.write(r.text) | |
| g.close() | |
| gg = open('tmp1.json','r') | |
| ggg=gg.read() | |
| print (ggg) | |
| leng=len(json.loads(ggg)) | |
| print(f'Blockchain {cnt}: Length {leng} ') | |
| valid,ind,mes = blockchain.chain_valid(json.loads(ggg)) | |
| except Exception: | |
| valid=False | |
| leng="No Data" | |
| if valid: | |
| valid_chains.append({"Chain": cnt, "Length": leng}) | |
| response = f'{response} Valid: {cnt}' | |
| else: | |
| not_valid.append({"Chain": cnt, "Length": leng}) | |
| response = f'{response} Invalid:{cnt}' | |
| per = ((len(valid_chains)+1)/(len(j)+1))*100 | |
| cnt+=1 | |
| response=f'{int(per)}%-{response}' | |
| print (f'Valid: {valid_chains}') | |
| print (f'Not Valid: {not_valid}') | |
| #p = json.loads(str(valid_chains)) | |
| p = valid_chains | |
| cnt2=0 | |
| bot=0 | |
| out=[] | |
| while cnt2 < len(p): | |
| if p[cnt2]['Length'] > bot: | |
| bot = p[cnt2]['Length'] | |
| out = [cnt2,bot] | |
| else: | |
| pass | |
| cnt2+=1 | |
| print (out) | |
| return response | |
| def valid(): | |
| valid,ind,mes = blockchain.chain_valid(blockchain.chain) | |
| if valid: | |
| response = 'The Blockchain is valid.' | |
| z=True | |
| else: | |
| response = f'Blockchain is not valid. {mes} at Index {ind}' | |
| z=False | |
| return response,z | |
| def get_chain(repo_name=None,chain_name=None,token=None): | |
| if repo_name == "": | |
| repo_name = repo_d | |
| if chain_name=="": | |
| chain_name = chain_d | |
| #src = f"https://huggingface.co/spaces/{repo_name}/raw/main/{chain_name}" | |
| #ff = open('chain1.json','r') | |
| #src = ff.read() | |
| #src = json.loads(ff) | |
| try: | |
| r = requests.get(f'{main_chain}{chain_name}') | |
| #create_chain(load=r.text) | |
| global blockchain | |
| blockchain = Blockchain(chain_load=main_chain,load=r.text) | |
| #return "New Chain Created",display_chain() | |
| #create_chain(src) | |
| response = {'chain': blockchain.chain, | |
| 'length': len(blockchain.chain)} | |
| message = f"Blockchain loaded from: {main_chain}{chain_name}" | |
| return response,message | |
| except: | |
| message = f"Error loading from: {src}" | |
| return ["Error Loading Chain"],message | |
| def checkp(inp): | |
| if inp == pa: | |
| return gr.update(visible=False), gr.update(visible=True) | |
| elif inp != pa: | |
| return gr.update(visible=True), gr.update(visible=False) | |
| def add_node(this_space,repo,space,chain_file): | |
| #print(f"{api.whoami(['name'])}") | |
| #repo = f'omnibus/{space}' | |
| is_valid='True' | |
| r = requests.get(f'{main_nodes}') | |
| try: | |
| lod = json.loads(r.text) | |
| except: | |
| lod=[] | |
| pass | |
| block = {'index': len(lod) + 1, | |
| 'timestamp': str(datetime.datetime.now()), | |
| 'url': f'https://huggingface.co/datasets/{repo}/{space}/raw/main/{chain_file}', | |
| 'valid': f'{is_valid}'} | |
| lod.append(block) | |
| json_object = json.dumps(lod, indent=4) | |
| with open("tmp1.json", "w") as outfile: | |
| outfile.write(json_object) | |
| try: | |
| api.upload_file( | |
| path_or_fileobj="tmp1.json", | |
| path_in_repo=main_nodes.split('main/',1)[1], | |
| repo_id=main_nodes.split('datasets/',1)[1].split('/raw',1)[0], | |
| token=token_self, | |
| repo_type="dataset", | |
| ) | |
| os.remove("tmp1.json") | |
| except Exception as e: | |
| pass | |
| #api = HfApi(token=token) | |
| repo = main_balance.split('datasets/',1)[1].split('/raw',1)[0].split('/',1)[0] | |
| name = main_balance.split('datasets/',1)[1].split('/raw',1)[0].split('/',1)[1] | |
| f_ist = (api.list_repo_files(repo_id=f'{repo}/{name}', repo_type="dataset")) | |
| send_list =[] | |
| for i,ea in enumerate(f_ist): | |
| if "balance/" in ea: | |
| try: | |
| send_list.append(ea.split("/",1)[1].split(".",1)[0]) | |
| except Exception: | |
| pass | |
| ############################## BLOCKCHAIN END ############################### | |
| ############################## MYCHAIN START ############################### | |
| def get_my_chain_send(sender_name=None): | |
| global mychain_send | |
| try: | |
| r = requests.get(f'{main_balance}{sender_name}.json') | |
| print (f'r={r.text}') | |
| mychain_send = MyChain(chain_load=main_balance,load=r.text) | |
| response = {'chain': mychain_send.chain, | |
| 'length': len(mychain_send.chain)} | |
| print (f'response={response}') | |
| message = f"Blockchain loaded from: {main_balance}{sender_name}.json" | |
| return response,message | |
| except Exception: | |
| message = f"Error loading from: {sender_name}" | |
| return ["Error Loading Chain"],message | |
| def get_my_chain_rec(recipient_name=None): | |
| global mychain_rec | |
| try: | |
| r = requests.get(f'{main_balance}{recipient_name}.json') | |
| mychain_rec = MyChain(chain_load=main_balance,load=r.text) | |
| response = {'chain': mychain_rec.chain, | |
| 'length': len(mychain_rec.chain)} | |
| message = f"Blockchain loaded from: {main_balance}{recipient_name}.json" | |
| return response,message | |
| except Exception: | |
| try: | |
| mychain_rec = MyChain(chain_load=main_balance,create=recipient_name) | |
| response = mychain_rec.chain | |
| message = f"Blockchain loaded from: {main_balance}{recipient_name}.json" | |
| return response,message | |
| except Exception: | |
| message = f"Error loading from: {recipient_name}" | |
| return ["Error Loading Chain"],message | |
| def mychain_mine_block_send(balance, chain_r=None,chain_n=None): | |
| previous_block = mychain_send.print_previous_block() | |
| previous_proof = previous_block['proof'] | |
| proof = mychain_send.proof_of_work(previous_proof) | |
| previous_hash = mychain_send.hash(previous_block) | |
| block = mychain_send.create_block(balance, proof, previous_hash,chain_r,chain_n) | |
| response = {'message': 'A block is MINED', | |
| 'index': block['index'], | |
| 'timestamp': block['timestamp'], | |
| 'balance': block['balance'], | |
| 'proof': block['proof'], | |
| 'previous_hash': block['previous_hash']} | |
| message = "A block is MINED" | |
| show_chain = display_chain_send() | |
| if len(mychain_send.chain) > 1000: | |
| mychain_send.reset() | |
| response = None | |
| show_chain=display_chain_send() | |
| message = "New Chain Created at Max 20 Blocks" | |
| return response, show_chain,pd.DataFrame(mychain_send.pending_transactions), message | |
| def mychain_mine_block_rec(balance, chain_r=None,chain_n=None): | |
| previous_block = mychain_rec.print_previous_block() | |
| previous_proof = previous_block['proof'] | |
| proof = mychain_rec.proof_of_work(previous_proof) | |
| previous_hash = mychain_rec.hash(previous_block) | |
| block = mychain_rec.create_block(balance, proof, previous_hash,chain_r,chain_n) | |
| response = {'message': 'A block is MINED', | |
| 'index': block['index'], | |
| 'timestamp': block['timestamp'], | |
| 'balance': block['balance'], | |
| 'proof': block['proof'], | |
| 'previous_hash': block['previous_hash']} | |
| message = "A block is MINED" | |
| show_chain = display_chain_rec() | |
| if len(mychain_rec.chain) > 1000: | |
| mychain_rec.reset() | |
| response = None | |
| show_chain=display_chain_rec() | |
| message = "New Chain Created at Max 20 Blocks" | |
| return response, show_chain,pd.DataFrame(mychain_rec.pending_transactions), message | |
| def display_chain_send(): | |
| response = {'chain': mychain_send.chain, | |
| 'length': len(mychain_send.chain)} | |
| return response | |
| def display_chain_rec(): | |
| response = {'chain': mychain_rec.chain, | |
| 'length': len(mychain_rec.chain)} | |
| return response | |
| def issue_tokens(send,rec,amount): | |
| response_send=None | |
| response_rec=None | |
| show_chain_send=None | |
| show_chain_rec=None | |
| data_send=None | |
| data_rec=None | |
| message_send=None | |
| message_rec=None | |
| #print(f"CURRENT USER:: {api.whoami(['name'])}") | |
| #repo = f'omnibus/{space}' | |
| #is_valid='True' | |
| balance_send = 0 | |
| balance_rec = 0 | |
| try: | |
| _,z=valid() | |
| if z == True: | |
| mes = None | |
| try: | |
| response,message = get_my_chain_send(send) | |
| print (f'response:{response}::message{message}') | |
| #r = requests.get(f'{main_balance}{send}.json') | |
| lod=response | |
| #lod = json.loads(response) | |
| print (lod) | |
| p=True | |
| except Exception as e: | |
| lod=[] | |
| p=False | |
| mes = f"Sender has no wallet {e}" | |
| pass | |
| if p==True: | |
| balance = lod["chain"][-1]["balance"] | |
| print (balance) | |
| balance_send =int(balance)-int(amount) | |
| if balance >=0: | |
| p==True | |
| response,message = get_my_chain_rec(rec) | |
| lod_rec = json.loads(response) | |
| #try: | |
| if lod_rec["chain"][-1]["index"] > 1: | |
| balance = lod_rec["chain"][-1]["balance"] | |
| if lod_rec["chain"][-1]["index"] == 1: | |
| balance = 0 | |
| balance_rec =int(balance)+int(amount) | |
| if balance < 0: | |
| mes ="Not enough tokens" | |
| p = False | |
| if z==False: | |
| mes = "Invalid Blockchain" | |
| p=False | |
| except Exception: | |
| mes = "Blockchain not loaded?" | |
| p=False | |
| if p==True: | |
| mychain_send.new_transaction(f"{sender}",f"{recipient}",f"{amount}",f"{balance_send}") | |
| message_send = "Transaction Added to Pool" | |
| data_send = pd.DataFrame(mychain_send.pending_transactions) | |
| mychain_rec.new_transaction(f"{sender}",f"{recipient}",f"{amount}",f"{balance_rec}") | |
| message_rec = "Transaction Added to Pool" | |
| data_rec = pd.DataFrame(mychain_rec.pending_transactions) | |
| response_send, show_chain_send,data_send, message_send = mychain_mine_block_send(balance_send, chain_r=None,chain_n=send) | |
| response_rec, show_chain_rec,data_rec, message_rec = mychain_mine_block_send(balance_rec, chain_r=None,chain_n=rec) | |
| mes = (f'Send: {message_send} :: Recieve: {message_rec}') | |
| return (mes, p, response_send, response_rec, show_chain_send, show_chain_rec, data_send, data_rec, message_send, message_rec) | |
| ############################## MYCHAIN END ############################### | |
| with gr.Blocks() as bc: | |
| with gr.Row(visible=True) as invalid: | |
| pass_box = gr.Textbox() | |
| pass_btn = gr.Button() | |
| with gr.Box(visible=False) as valida: | |
| gr.Markdown("""<h1><center>Blockchain Simulator<br><h3>(Transactions have no value)<br><h4>Chain will reset at 20 blocks""") | |
| blockchain = gr.State() | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Accordion(label="Load",open=False): | |
| with gr.Row(): | |
| chain_repo=gr.Textbox(label="repo/name") | |
| chain_n=gr.Textbox(label="Chain file") | |
| with gr.Row(): | |
| in_chain_btn=gr.Button("Load Chain") | |
| create_bc = gr.Button("Create New Blockchain") | |
| #send=gr.Textbox(label="Sender") | |
| send = gr.Dropdown(label="Sender", choices=[f for f in send_list], value = "Bank") | |
| rec=gr.Textbox(label="Recipient") | |
| am=gr.Textbox(label="Amount") | |
| send_trans=gr.Button("Post Transaction") | |
| mine_b = gr.Button("Mine Block") | |
| check = gr.Button("Check Chain") | |
| check_all = gr.Button("Check All") | |
| with gr.Column(): | |
| block_text = gr.Textbox() | |
| trans_data = gr.Dataframe() | |
| json_out = gr.JSON() | |
| chain_json = gr.JSON() | |
| with gr.Accordion("Nodes", open=False): | |
| with gr.Row(): | |
| this_space=gr.Textbox(label="This Repo/Space") | |
| with gr.Row(): | |
| node_repo=gr.Textbox(label="Node Repo") | |
| node_space=gr.Textbox(label="Node Space") | |
| node_file=gr.Textbox(label="Node File") | |
| node_add=gr.Button("Add Node") | |
| with gr.Accordion("Tokens", open=False): | |
| issue_btn=gr.Button() | |
| out_box_bool=gr.Textbox() | |
| with gr.Row(): | |
| with gr.Column(): | |
| block_text_send = gr.Textbox() | |
| trans_data_send = gr.Dataframe() | |
| json_out_send = gr.JSON() | |
| chain_json_send = gr.JSON() | |
| with gr.Column(): | |
| block_text_rec = gr.Textbox() | |
| trans_data_rec = gr.Dataframe() | |
| json_out_rec = gr.JSON() | |
| chain_json_rec = gr.JSON() | |
| issue_btn.click(issue_tokens,[send,rec,am],[block_text,out_box_bool,json_out_send,json_out_rec,chain_json_send,chain_json_rec,trans_data_send,trans_data_rec,block_text_send,block_text_rec]) | |
| node_add.click(add_node,[this_space,node_repo,node_space,node_file],block_text) | |
| pass_btn.click(checkp,pass_box,[invalid,valida]) | |
| in_chain_btn.click(get_chain,[chain_repo,chain_n],[chain_json,block_text]) | |
| create_bc.click(create_chain,[chain_n],[block_text,json_out,chain_json]) | |
| check.click(valid,None,[block_text,out_box_bool]) | |
| check_all.click(sort_valid,None,block_text) | |
| send_trans.click(bc_transactions,[send,rec,am],[trans_data,block_text,send,rec,am]) | |
| mine_b.click(mine_block,[chain_repo,chain_n],[json_out,chain_json,trans_data,block_text]) | |
| bc.launch(enable_queue=False) | |