Update app.py

app.py

@@ -399,45 +399,131 @@ for i,ea in enumerate(f_ist):
 
 ##############################   BLOCKCHAIN END  ###############################
 ##############################   MYCHAIN START   ###############################
- 
+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 get_my_chain(sender_name=None):
+def get_my_chain_send(sender_name=None):
     try:
-        r = requests.get(f'{main_balance}{chain_name}.json') 
-        global mychain
-        mychain = MyChain(chain_load=main_balance,load=r.text)
-        response = {'chain': mychain.chain,
-                    'length': len(mychain.chain)}
-        message = f"Blockchain loaded from: {main_balance}{chain_name}.json"
+        r = requests.get(f'{main_balance}{sender_name}.json') 
+        global mychain_send
+        mychain_send = MyChain(chain_load=main_balance,load=r.text)
+        response = {'chain': mychain_send.chain,
+                    'length': len(mychain_send.chain)}
+        message = f"Blockchain loaded from: {main_balance}{sender_name}.json"
         return response,message
     except:
         message = f"Error loading from: {sender_name}"
         return ["Error Loading Chain"],message
+        
+def get_my_chain_rec(recipient_name=None):
+    try:
+        r = requests.get(f'{main_balance}{recipient_name}.json') 
+        global mychain_rec
+        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:
+        try:
+            global mychain_rec
+            mychain_rec = MyChain(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:
+            message = f"Error loading from: {recipient_name}"
+            return ["Error Loading Chain"],message
+        
+def mychain_transaction_send(sender,recipient,amount):
+    mes, out, balance_send, balance_rec = issue_tokens(sender,recipient,amount)
+    if out == True:
+        mychain_send.new_transaction(f"{sender}",f"{recipient}",f"{amount}",f"{balance_send}")
+        message = "Transaction Added to Pool"
+        data = pd.DataFrame(mychain_send.pending_transactions)
+    if out == False:
+        message = mes
+        data = None
+    return data,message,None,None,None
 
-def mychain_transaction(sender,recipient,amount):
-    mes, out = issue_tokens(sender,recipient,amount)
+def mychain_transaction_rec(sender,recipient,amount):
+    mes, out, balance_send, balance_rec = issue_tokens(sender,recipient,amount)
     if out == True:
-        mychain.new_transaction(f"{sender}",f"{recipient}",f"{amount}",f"{balance}")
+        mychain_rec.new_transaction(f"{sender}",f"{recipient}",f"{amount}",f"{balance_rec}")
         message = "Transaction Added to Pool"
-        data = pd.DataFrame(mychain.pending_transactions)
+        data = pd.DataFrame(mychain_rec.pending_transactions)
     if out == False:
         message = mes
         data = None
     return data,message,None,None,None
+    
+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 issue_tokens(send,rec,amount):
-    print(f"CURRENT USER:: {api.whoami(['name'])}")
+    #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)
+                response,message = get_my_chain_send(send)
                 #r = requests.get(f'{main_balance}{send}.json') 
                 lod = json.loads(response)
                 p=True
@@ -449,74 +535,18 @@ def issue_tokens(send,rec,amount):
             if p==True:
                 balance = lod["chain"][-1]["balance"]
                 print (balance)
-                balance =int(balance)-int(amount)
+                balance_send =int(balance)-int(amount)
                 if balance >=0:
                     p==True
-                    '''
-                    #mychain.new_transaction(sender=send, recipient=rec, amount=amount, balance=balance)
-                    block = {'index': len(lod) + 1,
-                            'timestamp': str(datetime.datetime.now()),
-                            'sender': f'{send}',
-                            'recipient':f'{rec}',
-                            'amount': f'{amount}',
-                            'balance': f'{balance}'
-                            }
-                    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=f'{main_balance.split("main/",1)[1]}/{send}.json',
-                        repo_id=main_balance.split('datasets/',1)[1].split('/raw',1)[0],
-                        token=token_self,
-                        repo_type="dataset",
-                        )
-                        os.remove("tmp1.json")
-                    except Exception as e:
-                        mes=e
-                        pass 
-            
-                    try:
-                        r = requests.get(f'{main_balance}{rec}.json') 
-                        lod = json.loads(r.text)
-                        balance = lod[-1]["balance"]
-        
-                    except:
-                        lod=[]
-                        balance=0
-                        pass
-                    print (balance)
-                    balance =int(balance)+int(amount)                
-                    block = {'index': len(lod) + 1,
-                            'timestamp': str(datetime.datetime.now()),
-                            'sender': f'{send}',
-                            'recipient':f'{rec}',
-                            'amount': f'{amount}',
-                            'balance': f'{balance}'}
-                    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=f'{main_balance.split("main/",1)[1]}/{rec}.json',
-                        repo_id=main_balance.split('datasets/',1)[1].split('/raw',1)[0],
-                        token=token_self,
-                        repo_type="dataset",
-                        )
-                        os.remove("tmp1.json")
-                
-                    except Exception as e:
-                        mes = e
-                        pass   
-                    if mes == None:
-                        mes = f'{amount} sent from {send} to {rec}'
-                    '''
+                    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
@@ -526,7 +556,17 @@ def issue_tokens(send,rec,amount):
     except Exception:
         mes = "Blockchain not loaded?"
         p=False
-    return mes,p
+    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 (response_send, response_rec, show_chain_send, show_chain_rec, data_send, data_rec, message_send, message_rec)
 
 
 ##############################   MYCHAIN END   ###############################
@@ -575,10 +615,21 @@ with gr.Blocks() as bc:
                 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()
-
-    issue_btn.click(issue_tokens,[send,rec,am],[block_text,out_box_bool])
+            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],[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])