app.py

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 MyChainSend 
from mychain import MyChainRec 

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)



########################  BLOCKCHAIN START  ###############################

def bc_transactions(block):
    #mes, out = issue_tokens(sender,recipient,amount)
    
    try:
        blockchain.new_transaction(block)
        message = "Transaction Added to Pool"
        data = pd.DataFrame(blockchain.trans_data_out)
    except Exception as e:
        message = e
        data = None
    return data,message

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):
    if chain_n=="":
        chain_n = chain_d
    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
    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)
        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]




##############################   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 = MyChainSend(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 = MyChainRec(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 = MyChainRec(chain_load=main_balance,create=recipient_name)
            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:
            message = f"Error loading from: {recipient_name}"
            return ["Error Loading Chain"],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 valid_send():
    valid,ind,mes = mychain_send.chain_valid(mychain_send.chain)
    if valid:
        response = 'The Blockchain is valid.'
        z=True
    else:
        response = f'Sender Blockchain is not valid. {mes} at Index {ind}'
        z=False
    return response,z,mes,ind
    
def valid_rec():
    valid,ind,mes = mychain_rec.chain_valid(mychain_rec.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, mes, ind



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,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, message

def merge_trans():
    trans_bx = []
    previous_post_send = mychain_send.print_previous_block()
    previous_post_rec = mychain_rec.print_previous_block()
    
    send_block = {
            'role': 'Sender',
            'name': previous_post_send['transactions'][0]['sender'],
            'index': previous_post_send['index'],
            'timestamp': previous_post_send['timestamp'],
            'recipient': previous_post_send['transactions'][0]['recipient'],
            'amount': previous_post_send['transactions'][0]['amount'],
            'balance': previous_post_send['balance'], 
            'proof': previous_post_send['proof'],
            'previous_hash': previous_post_send['previous_hash']}
    rec_block = {
            'role': 'Recipient',
            'name': previous_post_rec['transactions'][0]['recipient'],
            'index': previous_post_rec['index'],
            'timestamp': previous_post_rec['timestamp'],
            'sender': previous_post_rec['transactions'][0]['sender'],
            'amount': previous_post_rec['transactions'][0]['amount'],
            'balance': previous_post_rec['balance'], 
            'proof': previous_post_rec['proof'],
            'previous_hash': previous_post_rec['previous_hash']}
    trans_bx.append(send_block)
    trans_bx.append(rec_block)
    return trans_bx



    
def issue_tokens(send,rec,amount):
    response_send={}
    response_rec={}
    show_chain_send={}
    show_chain_rec={}
    data_send=None
    data_rec=None
    rec_send=None
    rec_drop=None
    message_send=None
    message_rec=None    
    trans_data=None
    trans_mes=None
    balance_send = 0
    balance_rec = 0
    mes = "blank message"
    try:
        b_mes,z=valid()
        if z == True:
            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
            mes1,val,mes2,ind = valid_send()
            print (f'val:: {val}')
            if val == False:
                p=False 
                mes = f"Sender: {send} Blockchain is not valid. {mes2} at Index {ind}"
                #mes = "Blockchain is not valid."
            
            #if val == True:
            if p==True:
                try:
                    balance = lod["chain"][-1]["balance"]
                except Exception:
                    balance = 0
                    p=False
                #print (balance)
                balance_send =int(balance)-int(amount)
                if balance_send >=0:
                    p=True
                    response,message = get_my_chain_rec(rec)
                    lod_rec = response
                    mes1,val,mes2,ind = valid_rec()
                    print (f'val:: {val}')
                    if val == False:
                        p=False 
                        mes = f"Recipient: {rec} Blockchain is not valid. {mes2} at Index {ind}"
                        #mes = "Blockchain is not valid."
                    #print (lod_rec)
                    if val == True:
                        try:
                            balance = lod_rec["chain"][-1]["balance"]
                            #print (balance)
                        except Exception:
                            p=False
                            balance = 0
                        balance_rec =int(balance)+int(amount)

                if balance_send < 0:
                    mes ="Not enough tokens"
                    p = False
             
            print(mes)

        if z==False:
            mes = b_mes
            p=False
    except Exception as e:
        mes = f"Blockchain not loaded? {e}" 
        p=False
    print (mes)
    
    if p==False:
        return (mes, p,None,None,None,None,None,None,None,None,None,None,None)
        
        #return (mes, p,{},{},{},{},{},{},None,None,None,None,{})
        #json, json, json, json, dataframe, dataframe, textbox, textbox, dropdown, dropdown, dataframe
    if p==True:
        

        mychain_send.new_transaction(f"{send}",f"{rec}",f"{amount}",f"{balance_send}")
        message_send = "Transaction Added to Pool"
        data_send = pd.DataFrame(mychain_send.pending_transactions)
        mychain_rec.new_transaction(f"{send}",f"{rec}",f"{amount}",f"{balance_rec}")
        message_rec = "Transaction Added to Pool"
        data_rec = pd.DataFrame(mychain_rec.pending_transactions)
        response_send, show_chain_send, message_send = mychain_mine_block_send(balance_send, chain_r=None,chain_n=send)
        response_rec, show_chain_rec, message_rec = mychain_mine_block_rec(balance_rec, chain_r=None,chain_n=rec)
        mes = (f'Send: {message_send} :: Recieve: {message_rec}')
        _,rec_send=update_send_list()
        _,rec_drop=update_rec_list()
        trans_bx = merge_trans()
        trans_data, mes = bc_transactions(trans_bx)
        return (mes, p, response_send, response_rec, show_chain_send, show_chain_rec, data_send,  data_rec,  message_send, message_rec, rec_send, rec_drop,trans_data)


        
        
##############################   MYCHAIN END   ###############################

def res_source():
    block = {'index': 1,
                'timestamp': str(datetime.datetime.now()),
                'transactions': [],
                'balance': 10000000000000000000,
                'proof': 1,
                'previous_hash': 0}
    
    pending_transactions_x = []
    pending_transactions_x.append(block)
    json_object = json.dumps(pending_transactions_x, indent=4)
    with open("tmp_send.json", "w") as outfile:
        outfile.write(json_object)
    try: 
        api.upload_file(
        path_or_fileobj="tmp_send.json",
        path_in_repo="balance/__Source__.json",
        repo_id=main_balance.split('datasets/',1)[1].split('/raw',1)[0],
        token=token_self,
        repo_type="dataset",
        )
        os.remove("tmp_send.json")
        return "__Source__ Reset"
    except Exception as e:
        return e


def update_send_list():
    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
    return send_list, gr.Dropdown.update(label="Sender", choices=[f for f in send_list])
send_list,send_drop = update_send_list()

def update_rec_list():
    f_ist = (api.list_repo_files(repo_id=f'{repo}/{name}', repo_type="dataset"))
    rec_list =[]
    for i,ea in enumerate(f_ist):
        if "balance/" in ea:
            try:
                if not "__Source__" in ea:
                    rec_list.append(ea.split("/",1)[1].split(".",1)[0])
            except Exception:
                pass
    return rec_list, gr.Dropdown.update(label="Recipient", choices=[f for f in rec_list])
rec_list, rec_drop = update_rec_list()

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.Dropdown(label="Recipient", choices=[f for f in rec_list], allow_custom_value=True)
                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):
            with gr.Row():
                with gr.Column():
                    issue_btn=gr.Button()
                with gr.Column():
                    with gr.Row():
                        reset_blockchain=gr.Button("Reset Main Blockchain")
                        reset_source=gr.Button("Reset __Source__")
                    with gr.Row():
                        reset_sender=gr.Button("Reset Sender")
                        reset_recieve=gr.Button("Reset Recipient")
            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()     

    def res_bc():
        blockchain.reset(create="chain1.json")
        return ("Main Blockchain Reset")
    def res_send(send):
        mychain_send = MyChainSend(chain_load=main_balance,create=send)
        return ("Sender Blockchain Reset")
        
    reset_sender.click(res_send,send,block_text)
    reset_blockchain.click(res_bc,None,block_text)
    reset_source.click(res_source,None,block_text)

    send_trans.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,send,rec,trans_data])
    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,send,rec,trans_data])
    #issue_btn.click(issue_tokens,[send,rec,am],[block_text,out_box_bool,json_out_send])
    
    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)