Create mychain.py

mychain.py

@@ -0,0 +1,639 @@
+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)
+chain_d="chain1.json"
+chain_t="trans1.json"
+
+
+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=f"{main_chain.split('main/',1)[1]}{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.trans_data_out =[]
+
+            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)
+            outfile.close()
+            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")
+                #MyChainTrans.reset(self,create=chain_n)
+            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
+
+class MyChainSend:
+
+    def __init__(self,chain_load,load=None,create=None):
+        global main_chain_send
+        main_chain_send=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,prev_block=None,chain_r=None,chain_n=None):
+        if chain_r=="" or chain_r==None:
+            chain_r=f"{main_chain_send.split('datasets/',1)[1].split('/raw',1)[0]}"
+        if chain_n !="" and chain_n !=None:
+            chain_n = f"{main_chain_send.split('main/',1)[1]}{chain_n}.json"
+        if chain_n=="" or chain_n==None:
+            chain_n="error_send.json"
+        #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_send.json", "w") as outfile:
+                outfile.write(json_object)
+            outfile.close()
+            try: 
+                api.upload_file(
+                path_or_fileobj="tmp_send.json",
+                path_in_repo=chain_n,
+                repo_id=chain_r,
+                token=token_self,
+                repo_type="dataset",
+                )
+                os.remove("tmp_send.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
+
+    def deep_valid_send(self, chain1,chain2):
+       
+        block_index = 1 
+        out=True
+        ind=None
+        mes=None
+        while block_index < len(chain1):
+            block = chain1[block_index]
+            block_ind = block['block']
+            block2 = chain2[block_ind]
+
+            check1 = {
+                'timestamp':block['timestamp'],
+                'recipient':block['transactions']['recipient'],
+                'amount':block['transactions']['amount'],
+                'balance':block['transactions']['balance'],
+                'balance2':block['balance'],
+                'proof':block['proof'],
+                'previous_hash':block['previous_hash']
+            }
+            zz=1
+            while zz < len(block2[transactions]):
+                
+                check2 = {
+                    'timestamp':block2['timestamp'],
+                    'sender':block2['transactions'][zz][0]['name'],
+                    'recipient':block2['transactions'][zz][0]['recipient'],
+                    'amount':block2['transactions'][zz][0]['amount'],
+                    'balance':block2['transactions'][zz][0]['balance'],
+                    'balance2':block2['transactions'][zz][0]['balance'],
+                    'proof':block2['proof'],
+                    'previous_hash':block2['previous_hash']
+                }
+                zz+=1
+                
+            
+                if self.hash(check1) != self.hash(check2):
+                    out=False
+                    ind=block_index
+                    mes='Hash'
+                    break
+            
+            if out == False:
+                break
+            block_index += 1
+        
+        return out, ind, mes
+
+        
+
+class MyChainRec:
+
+    def __init__(self,chain_load, 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',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=None,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="error_rec.json"
+        #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_rec.json", "w") as outfile:
+                outfile.write(json_object)
+            outfile.close()
+            try: 
+                api.upload_file(
+                path_or_fileobj="tmp_rec.json",
+                path_in_repo=chain_n,
+                repo_id=chain_r,
+                token=token_self,
+                repo_type="dataset",
+                )
+                os.remove("tmp_rec.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,load=None,create=None):
+        global main_chain_trans
+        main_chain_trans=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(balance=0, proof=1, previous_hash='0',chain_n=create)
+    def create_block(self,balance, proof, previous_hash,prev_block=None,chain_r=None,chain_n=None):
+        if chain_r=="" or chain_r==None:
+            chain_r=f"{main_chain_trans.split('datasets/',1)[1].split('/raw',1)[0]}"
+        if chain_n !="" and chain_n !=None:
+            chain_n = f"{main_chain_trans.split('main/',1)[1]}{chain_t}"
+        if chain_n=="" or chain_n==None:
+            chain_n="error_send.json"
+        #prev_block = len(blockchain.chain)-1
+        #previous_block = blockchain.chain[prev_block]            
+        block = {'index': len(self.chain) + 1,
+                'timestamp': str(datetime.datetime.now()),
+                #'block': len(Blockchain.chain)+1,
+                '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_trans.json", "w") as outfile:
+                outfile.write(json_object)
+            outfile.close()
+            try: 
+                api.upload_file(
+                path_or_fileobj="tmp_trans.json",
+                path_in_repo=chain_n,
+                repo_id=chain_r,
+                token=token_self,
+                repo_type="dataset",
+                )
+                os.remove("tmp_trans.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