def __init__(self, is_bootstrap, N, ip="192.168.1.1", port=5000): #print("Initializing Node") self.id = 0 self.chain = blockchain.Blockchain() self.wallet = wallet.wallet() self.ip = ip self.port = port self.utxo = [] self.ring = [] self.current_block = None self.current_lock = threading.Lock() self.utxo_lock = threading.Lock() self.list_lock = threading.Lock() self.lengths_lock = threading.Lock() self.lengths = [] self.tx_list = [] self.conflict = False self.num_of_minings = 0 self.total_mining_time = 0 self.added_lock = threading.Lock() self.N = N if is_bootstrap: boot_info = {} boot_info["address"] = ip + ":" + str(port) boot_info["id"] = self.id boot_info["key"] = self.wallet.public_key.decode() self.ring.append(boot_info)
def batch(): #Check variables MANDATORY_ENV_VARS = ["hv_mongo_url", "hv_mongo_db", "hv_daemon_url"] for var in MANDATORY_ENV_VARS: if var not in os.environ: raise EnvironmentError("Failed because {} is not set.".format(var)) bc = blockchain.Blockchain() cg = coingecko.Coingecko() if 'hv_debug' in os.environ: cg.importCurrencies() if 'hv_resetrates' in os.environ: cg.importExchangePrice(365 * 3) cg.importExchangePrice(90) cg.importExchangePrice(1) bc.scanBlockchain() else: try: with pid.PidFile('havenBatch' + os.environ['hv_mongo_db']) as p: print("Starting process on " + os.environ['hv_mongo_db']) cg.importCurrencies() if 'hv_resetrates' in os.environ: cg.importExchangePrice(365 * 3) cg.importExchangePrice(90) cg.importExchangePrice(1) bc.scanBlockchain() except pid.PidFileError: print("Process already running") except Exception as e: print(e)
def test_recv_new_block(self): bchain = blockchain.Blockchain() old_bchain_len = len(bchain.blockchain) #unit testing is really testing an outer layer of the application and hence in order #to make process of testing faster and also to ensure that testing does not seep into #a great depth but stays only in the outer layer, MOCKING helps, for example if there #is an API call in a function(say some HTTPS request), instead of dealing with actual #request we can just assume that the server is there to serve the application and #start testing the functionality, hence inn unittesting such API calls and onjects should #be mocked and tested. I don't want to instansiate the actual blocks to check the blockchian #functionality hence I can use MagicMock to mock the blocks and check functionality #this actually allows me to not bother making explicitly the blocks with valid/invalid values #I can just simulate if blocks are valid in valid by magicmock objects and #return value of check functions prev_block = MagicMock() new_block = MagicMock() with self.subTest('newly recieved block is valid and hence should be added'): new_block.has_valid_index = MagicMock(return_value=True) new_block.has_valid_prev_hash = MagicMock(return_value=True) new_block.has_valid_hash = MagicMock(return_value=True) bchain.blockchain = [prev_block] bchain.recv_new_block(new_block) self.assertEqual(len(bchain.blockchain)-old_bchain_len,1) with self.subTest('newly received block is invalid and hence should not be added'): #any one of them being false is enough to make new_block invalid new_block.has_valid_index = MagicMock(return_value=False) new_block.has_valid_prev_hash = MagicMock(return_value=False) new_block.has_valid_hash = MagicMock(return_value=False) bchain.blockchain = [prev_block] bchain.recv_new_block(new_block) self.assertEqual(len(bchain.blockchain)-old_bchain_len,0)
def __init__(self, bootstrap, number, port, ipbootstrap, ip_dikia_mou): self.port = port self.chain = blockchain.Blockchain() self.current_id_count = 0 #register_node_to_ring() self.wallet = wallet.wallet() #self.NBCs = self.wallet.balance() temp = "http://" + ipbootstrap + ":5000" self.ring = [ temp ] #here we store information for every node, as its id, its address (ip:port) its public key and its balance self.nei = number self.public_key_list = [] self.myip = ip_dikia_mou if (bootstrap == "0"): self.public_key_list = [self.wallet.public_key] self.id = 0 self.chain.create_genesis(number, self.public_key_list[0]) #print("my chain list " , self.chain.list[0].output()) self.wallet.add_genesis(self.chain.list[0].output()) self.e = threading.Event() self.e.clear() t2 = threading.Thread(target=self.init) t2.start() else: self.my_reg()
def __init__(self): # Networking stuff self.HEADER = 4069 # Expected file receive size, 4 kilobytes self.PORT = 5050 # The port in which we will be 'listening and talking' through self.IP = socket.gethostbyname( socket.gethostname()) # find my local ip self.ADDR_SERVER = (self.IP, self.PORT) self.server = socket.socket( socket.AF_INET, socket.SOCK_STREAM) # Create a socket obj for allowing connections self.server.bind( self.ADDR_SERVER) # 'Bind' it on this machine on port 5050 self.clients = [] # Store all current and imcoming connections self.run = True # If the network should be active # Blockchain Stuff self.ledger = blockchain.Blockchain() self.ledger.printChainInfo() ''' For one client the code below works, but to handle multiple clients we only connect to a node when we need to and disconnect right after ''' # self.ADDR_CLIENT = ("10.0.0.113", self.PORT) # self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # self.client.connect(self.ADDR_CLIENT) # self.servers = [] '''
def updateChain(self, ret = True): chainChoice = {} self.updateNeighbours(ret = False) self._neighboursMutex.acquire() for k, v in self.getNeighbours().items(): if v.ping: id = v.id() chain_hash = self.getChainHashOfId(id) if chain_hash: if chain_hash not in chainChoice: chainChoice[chain_hash] = [id, 0] else: chainChoice[chain_hash][1] += 1 node.mutexReleaser(self._neighboursMutex) max_vote = 1 my_id = self.id() max_voted_chain_id = my_id for k, v in chainChoice.items(): if v[1] > max_vote: max_vote = v[1] max_voted_chain_id = v[0] if max_voted_chain_id != my_id: chain = self.getChainOfId(max_voted_chain_id) if chain: self._chainMutex.acquire() pendTransactions = self._chain.pendingTransactions self._chain = blockchain.Blockchain(chain) for k, v in pendTransactions.items(): self._chain.addTransaction(k, v) node.mutexReleaser(self._chainMutex) return ret
def premine(): global PITCOIN print(color.OKGREEN + "Premine mode is active now.\nGenerating 3 private keys...") keys_adds = {} keys = [] addresses = [] for i in range(3): keys.append(str(wallet.GenerateNewPrivateKey())) open("key" + str(i), 'w').write(str(wallet.privateKeyToWif(keys[i]))[2:-1]) addresses.append(str(wallet.GetNewPublicAdress(keys[i]))[2:-1]) keys_adds[keys[i]] = addresses[i] open("minerkey", 'w').write(str(wallet.privateKeyToWif(keys[0]))[2:-1]) open("address", 'w').write(addresses[0]) print( "Keys was saved in files key[0-2].\nAlso minerkey from the first key and miner address files were created." + color.BOLD) PITCOIN = blockchain.Blockchain() PITCOIN.genesis_block() addRandomTxsToPool(keys_adds, 30) for x in range(10): new_block = block.InitNewBlock(PITCOIN.chain[-1].hash) print("New block has been mined and added to a chain.\nBlock hash =", new_block.hash) PITCOIN.AddNewBlock(new_block) saveBlockchainToFile(PITCOIN) print(color.ENDC)
def test_save(self): bc4 = blockchain.Blockchain() firstBlockData = b'This is the first block. Should have index 1' secondBlockData = b'This is the second block. Should have index 2' bc4.addBlock(firstBlockData) bc4.addBlock(secondBlockData) bc4.save('testSave.bc') self.assertTrue(os.path.isfile('./testSave.bc'))
def __init__(self, port): self.peers = [] self.chain = blockchain.Blockchain() self.chain.genesis() self.staging = [] # staging data to add to block # socket stuff self.port = port
def __init__(self, port = 8080): self.testargs = " ".join(sys.argv[1:]) self.publickey, self.privatekey = rsa.newkeys(512) self.host = '' # <-- works on all available network interfaces self.port = port self.chain = blockchain.Blockchain() self.phonebook = Phonebook() self.uid = uuid.uuid1()
def __init__(self, port=NODE_PORT): self.gblockchain = None try: self.gblockchain = blockchain.Blockchain(URL, port) except Exception as msg: print(str(msg)) sys.exit() super(MinerCli, self).__init__()
def test_add_transaction(): my_blockchain = blockchain.Blockchain( ) # first, initiate a blockchain object # add it to the mempool my_blockchain.add_new_transaction(my_transaction) # loop through all the transactions and check to see if that transaction is in the pool for transaction in my_blockchain.unconfirmed_transactions: # check whether our transaction is in the list of uncofirmed transaction assert transaction == my_transaction
def __init__(self, address, port): self.connectedUsernames = ["Smart Grid"] self.connectedIDs = [str(uuid4())] self.connectedAddresses = ["127.0.0.1"] self.connectedPorts = ["6789"] self.numPeers = 0 self.tracker = self.startTracker(address, port) self.bc = blockchain.Blockchain() self.cont = True
def __init__(self, node_identifier): """ Initialize a blockchain object BUFFER_MAX_LEN is the number of entries per block """ self.blockchain = bc.Blockchain(node_identifier) self.BUFFER_MAX_LEN = 20 self.MINE_REWARD = 10 self.node_identifier = node_identifier
def __init__(self, db_file): self._db_file = db_file try: with open(self._db_file, 'rb') as f: self.kv = pickle.load(f) except: with open(self._db_file, 'wb') as f: newblockchain = blockchain.Blockchain() pickle.dump(newblockchain, f) self.kv = newblockchain
def test_generate_new_block(self): bchain = blockchain.Blockchain() #this is really a class object which actually contains the blockchain old_bchain_len = len(bchain.blockchain) data = "this is a new block's data" with self.subTest('add new block to blockchain'): bchain.generate_next_block(data) self.assertEqual(len(bchain.blockchain)-old_bchain_len,1) self.assertEqual(bchain.get_latest_block().data, data)
def do_add_node(self, arg): """adds a node to a blockchain""" if (PITCOIN is None): inp = input( "There is no chain in memory\nType 'new' if you want to create a new chain otherwise type a file name to import from\n(new/'filename')\n" ) if inp == "new": PITCOIN = blockchain.Blockchain() PITCOIN.genesis_block() PITCOIN.add_node(arg) saveBlockchainToFile(PITCOIN)
def __init__(self, address): ##set self.chain = blockchain.Blockchain() self.current_id_count = 1 self.address = address self.wallet = wallet.wallet(address) # here we store information for every node, as its id, its address (ip:port) its public key and its balance self.peers = ({str(self.wallet.publickey.decode('utf-8')): address}) self.id_ip = {"id0": address} self.wallets = {} self.lock = threading.Lock() self.commitLock = threading.Lock()
def __init__(self, address, chain, current_block=None, node_id=0, NBC=0, ring=[]): ##set self.chain = blockchain.Blockchain() self.id = node_id self.NBC = NBC self.address = address # Address is a string self.wallet = self.create_wallet() self.ring = ring #here we store information for every node, as its id, its address (ip:port) its public key and its balance self.current_block = current_block self.block_ids = 1 self.difficulty = 5
def test_save_extraMetadata(self): bc4 = blockchain.Blockchain() firstBlockData = b'This is the first block. Should have index 1' secondBlockData = b'This is the second block. Should have index 2' bc4.addBlock(firstBlockData) bc4.addBlock(secondBlockData) bc4.save('testSave2.bc', {'finances':{ 'Alice':0.001, 'Bob':0.072 } }) self.assertTrue(os.path.isfile('./testSave2.bc'))
def sample_blockchain_setup(): blockchain_app = blockchain.Blockchain() blockchain_app.new_transaction("Rajiv", "Tanush", '5 BTC') blockchain_app.new_transaction("Tanush", "Pradyumna", '1 BTC') blockchain_app.new_transaction("Pradyumna", "Rajiv", '7 BTC') blockchain_app.new_block() blockchain_app.new_transaction("Elon Musk", "Bill Gates", '100 BTC') blockchain_app.new_transaction("Bill Gates", "Jeff Bezos", '250 BTC') blockchain_app.new_transaction("Jeff Bezos", "Mark Zuckerberg", '720 BTC') blockchain_app.new_block() return blockchain_app.return_blockchain()
def __init__(self, name, password): self.name = name self.password = password self.private_key = None self.public_key = None self.balance = 0 self.pending_updates = Queue.Queue() self.ledger = blockchain.Blockchain() self.id = None self.root = None self.createKeys()
def test_getBlockData_ValidIndex(self): bc2 = blockchain.Blockchain() firstBlockData = b'This is the first block. Should have index 1' secondBlockData = b'This is the second block. Should have index 2' bc2.addBlock(firstBlockData) bc2.addBlock(secondBlockData) genesisBlock = bc2.getBlockData(0) firstBlock = bc2.getBlockData(1) secondBlock = bc2.getBlockData(2) self.assertNotEqual(genesisBlock, False) self.assertEqual(firstBlock, firstBlockData) self.assertEqual(secondBlock, secondBlockData)
def work_flow(): chain = blockchain.Blockchain() while (True): print("Menu") print("---> process new transaction") print("---> view blockchain") choice = int(input()) if (choice == 1): chain.add_block(process_request()) else: chain.print_chain()
def dbCheck(): db = sqlite3.connect(databaseLocation) cursor = db.cursor() cursor.execute('SELECT * FROM blocks WHERE id = (SELECT MAX(id) FROM blocks)') # Last block from own database lastBlock_db = cursor.fetchone() bc = blockchain.Blockchain(lastBlock_db) # Empty database if not lastBlock_db: genesis = bc.getLastBlock() writeBlock(genesis) db.commit() db.close() return bc
def __init__(self, is_premine=0): cmd.Cmd.__init__(self) self.prompt = "฿ " self.intro = "\t\tWelcome to the miner cli\nHow to use? 'help'!!" self.doc_header = "For detail information use 'help _command_')" self.blockchain = pp.get_data("blockchain.pickle") if (self.blockchain == False or is_premine == True): os.remove("utxo.pickle") self.blockchain = blockchain.Blockchain() if is_premine == True: print("PREMINE IS ON") pubkeys = premine.createKeysAndAddresses() self.blockchain.genesis_block() if is_premine == True: premine.premine_mode(pubkeys, self)
class TestBlockChainMethods(unittest.TestCase): chain = blockchain.Blockchain() def test_newBlock(self): block = self.chain.new_block(100, 123) self.assertEqual(block["proof"], 100) self.assertEqual(block["previous_hash"], 123) def test_validate_prof(self): self.assertTrue(self.chain.valid_proof(1, 72608)) self.assertFalse(self.chain.valid_proof(1, 2)) def test_proof_of_work(self): self.assertEqual(self.chain.proof_of_work(1), 72608) self.assertEqual(self.chain.proof_of_work(2), 69926) self.assertNotEqual(self.chain.proof_of_work(2), 3)
def test(): LEVELS = { 'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'critical': logging.CRITICAL } # if len(sys.argv) > 1: # level_name = sys.argv[1] level_name = 'operations' level = LEVELS.get(level_name, logging.NOTSET) logging.basicConfig(level=level) print 'Start operations log file' print(logging.getLoggerClass().root.handlers[0].baseFilename) LOG_FILENAME = 'example.log' logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) logging.debug('This message should go to the log file') logging.debug('This is a debug message') logging.info('This is an info message') logging.warning('This is a warning message') logging.error('This is an error message') logging.critical('This is a critical error message') chain = blockchain.Blockchain() logging.info('Blockchain initialized') white = Actor('White') logging.info('White Actor Created') red = Actor('Red') logging.info('Red Actor Created') blue = [] blue_strategic = Actor('Blue/Strategic') blue.append(blue_strategic) blue_operational = Actor('Blue/Operational') blue.append(blue_operational) blue_tactical = Actor('Blue/Tactical') blue.append(blue_tactical) logging.info('Blue Strategic, Operational and Tactical Actors Created') return 1
def create_chain_from_dump(chain_dump): newblockchain = blockchainModule.Blockchain() for idx, block_data in enumerate(chain_dump): newblock = block.Block(block_data["index"], block_data["previous_hash"], block_data["transactions"]) newblock.timestamp = block_data["timestamp"] proof = block_data['hash'] if idx > 0: newblock.nonce = block_data["nonce"] added = newblockchain.add_block(newblock, proof) if not added: raise Exception("The chain dump is tampered!!") else: # else the block is a genesis block, no verification needed newblock.hash = proof newblockchain.chain.append(newblock) return newblockchain
def __init__(self, node): self.node = node self.rating = rating.RatingBase() self.work_time = time.time() self.blockchain = blockchain.Blockchain() self.amount_of_valid = 0 self.percent = 0 self.voted = set() self.virus_people = 0 self.validators = dict() self.threads = [] self.time_for_vote = None self.time_of_voting_end = None self.graph = nx.Graph() self.figure = plt.figure() self.show_plot() self.start_listen()