Duplicate from Omnibus/Blockchain-Simulator-dev3

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,12 @@
+---
+title: Blockchain Simulator
+emoji: 🔗
+colorFrom: purple
+colorTo: yellow
+sdk: gradio
+sdk_version: 3.40.1
+app_file: app.py
+duplicated_from: Omnibus/Blockchain-Simulator-dev3
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,614 @@
+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)

blockchain.py

@@ -0,0 +1,153 @@
+import os
+import json
+import hashlib
+import datetime
+from huggingface_hub import (upload_file,HfApi)
+
+token_self = os.environ['HF_TOKEN']
+api = HfApi(token=token_self)
+
+class Blockchain:
+
+    def __init__(self,chain_load,load=None,create=None):
+        global main_chain
+        main_chain=chain_load
+        
+        self.pending_transactions = []
+        self.trans_data_out = []
+        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 !="" and chain_n !=None:
+            chain_n = f"{main_chain.split('main/',1)[1]}{chain_n}"
+        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, block):
+        print (f'block::{block}')
+        trans_data = {
+            'name': block[0]['name'],
+            'recipient': block[0]['recipient'],
+            'amount': block[0]['amount'],
+            'balance': block[0]['balance'], 
+            'index': block[0]['index'],
+            'timestamp': block[0]['timestamp'],
+            'proof': block[0]['proof'],
+            'previous_hash': block[0]['previous_hash']
+        }
+        self.trans_data_out.append(trans_data)
+        self.pending_transactions.append(block)
+    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

chain1.json

@@ -0,0 +1,16 @@
+[
+    {
+        "index": 1,
+        "timestamp": "2023-03-19 20:02:31.090095",
+        "transactions": [],
+        "proof": 1,
+        "previous_hash": "0"
+    },
+    {
+        "index": 2,
+        "timestamp": "2023-03-19 20:02:35.707703",
+        "transactions": [],
+        "proof": 632238,
+        "previous_hash": "384ef5450d6f22e593e1edf3ee051c0fff6c55e92563ebbc149c30e37b3be7ea"
+    }
+]

mychain.py

@@ -0,0 +1,432 @@
+import os
+import json
+import hashlib
+import datetime
+from huggingface_hub import (upload_file,HfApi)
+from blockchain import Blockchain as blockchain
+
+token_self = os.environ['HF_TOKEN']
+api = HfApi(token=token_self)
+chain_d="chain1.json"
+class MyChainSend:
+
+    def __init__(self,chain_load,prev_block=None,load=None,create=None):
+        global main_chain
+        main_chain=chain_load
+        
+        self.pending_transactions = []
+        if load == None or load=="":
+            self.chain = []
+            self.create_block(balance=0,proof=1, previous_hash='0',prev_block=prev_block,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, balance, proof, previous_hash,prev_block,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 !="" and chain_n !=None:
+            chain_n = f"{main_chain.split('main/',1)[1]}{chain_n}.json"
+        if chain_n=="" or chain_n==None:
+            chain_n=chain_d
+        #prev_block = len(blockchain.chain)-1
+        #previous_block = blockchain.chain[prev_block]            
+        block = {'index': len(self.chain) + 1,
+                'timestamp': str(datetime.datetime.now()),
+                'block': prev_block,
+                'transactions': self.pending_transactions,
+                'balance': 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, balance):
+        transaction = {
+            'sender': sender,
+            'recipient': recipient,
+            'amount': amount,
+            'balance': balance            
+        }
+        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
+
+class MyChainRec:
+
+    def __init__(self,chain_load,prev_block=None, load=None,create=None):
+        global main_chain_rec
+        main_chain_rec=chain_load
+        
+        self.pending_transactions = []
+        if load == None or load=="":
+            self.chain = []
+            self.create_block(balance=0, proof=1, previous_hash='0',prev_block=None,chain_n=create)
+        if 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, balance, proof, previous_hash, prev_block,chain_r=None,chain_n=None):
+        if chain_r=="" or chain_r==None:
+            chain_r=f"{main_chain_rec.split('datasets/',1)[1].split('/raw',1)[0]}"
+        if chain_n !="" and chain_n !=None:
+            chain_n = f"{main_chain_rec.split('main/',1)[1]}{chain_n}.json"
+        if chain_n=="" or chain_n==None:
+            chain_n=chain_d
+        #prev_block = len(blockchain.chain)-1
+        #previous_block = blockchain.chain[prev_block]             
+        block = {'index': len(self.chain) + 1,
+                'timestamp': str(datetime.datetime.now()),
+                'block': prev_block,
+                'transactions': self.pending_transactions,
+                'balance': 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("tmp1.json", "w") as outfile:
+                outfile.write(json_object)
+            try: 
+                api.upload_file(
+                path_or_fileobj="tmp1.json",
+                path_in_repo=chain_n,
+                repo_id=chain_r,
+                token=token_self,
+                repo_type="dataset",
+                )
+                os.remove("tmp1.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, balance):
+        transaction = {
+            'sender': sender,
+            'recipient': recipient,
+            'amount': amount,
+            'balance': balance            
+        }
+        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
+
+
+class MyChainTrans:
+
+    def __init__(self,chain_load,block_trans,load=None,create=None):
+        global main_chain
+        main_chain=chain_load
+        
+        self.pending_transactions = []
+        if load == None or load=="":
+            self.chain = []
+            self.create_block(balance=0,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, balance, 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 !="" and chain_n !=None:
+            chain_n = f"{main_chain.split('main/',1)[1]}{chain_n}.json"
+        if chain_n=="" or chain_n==None:
+            chain_n=chain_d
+        block = {'block':blockchain.print_previous_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, balance):
+        transaction = {
+            'sender': sender,
+            'recipient': recipient,
+            'amount': amount,
+            'balance': balance            
+        }
+        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

node_file.json

@@ -0,0 +1,12 @@
+[
+    {
+        "index": 1,
+        "timestamp": "2023-03-20 03:43:39.828736",
+        "url": "https://huggingface.co/spaces/Omnibus/static-bin/raw/main/chain2.json"
+    },
+    {
+        "index": 2,
+        "timestamp": "2023-03-20 03:44:35.183872",
+        "url": "https://huggingface.co/spaces/Omnibus/static-bin/raw/main/chain1.json"
+    }
+]