def processor_macro_block_body_write(self, content): try: macro_block_body = MacroBlockBody.unpack(content) except Exception: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'macro_block_body unpack error') else: result = self.server.macro_chain.add_macro_block_body( macro_block_body) if result: if macro_block_body in self.server.cached_macro_block_body: self.server.cached_macro_block_body.remove( macro_block_body) _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') else: print('failed1', macro_block_body.hash) if self.server.macro_chain.accepted_macro_block_bodies[ macro_block_body.hash] >= 1: print('pass') else: self.server.cached_macro_block_body.append( macro_block_body) _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') finally: self.request.sendall(_)
def processor_macro_block_header_write(self, content): try: macro_block_header = MacroBlockHeader.unpack(content) print('add macro block', macro_block_header.hash, macro_block_header.public_key_hash) except Exception: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'macro_block_header unpack error') else: result = self.server.macro_chain.add_macro_block_header(macro_block_header) if self.server.macro_chain.accepted_macro_block_headers[macro_block_header.hash] == 1: for i in self.server.cached_macro_block_body: if i.hash == macro_block_header.hash: self.parentless_macro_block_body_process(i) if result: for i in self.server.cached_macro_block_header: if macro_block_header.hash in i.parent_hash: self.parentless_macro_block_header_process() _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') else: print('failed1', macro_block_header.hash) if self.server.macro_chain.accepted_macro_block_headers[macro_block_header.hash] > 1: print('pass') else: if macro_block_header not in self.server.cached_macro_block_header: self.server.cached_macro_block_header.append(macro_block_header) _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') finally: self.request.sendall(_)
def processor_trans_make(self, content): i_ = 0 # add_from = random.randint(0, 1) add_from = 0 if add_from > 2: add_from = 0 add_to = 0 add_to_two = random.randint(0, 1) _address = [add_from, add_to, add_to_two] result = dict() # print(_address) fd = open('ad1.txt', 'r') line = fd.readlines() for i in _address: line_ = line[i].rstrip() pr, pu = line_.split('ENDDING') temp = bytes(pu[2:-1], encoding='utf-8') temp = temp.replace(b'\r\n', b'\n') public_key = temp.replace(b'\\n', b'\n') temp = bytes(pr[2:-1], encoding='utf-8') temp = temp.replace(b'\r\n', b'\n') private_key = temp.replace(b'\\n', b'\n') sha = hashlib.sha256() sha.update(public_key) public_key_hash = sha.digest() result[i] = [public_key, private_key, public_key_hash] fd.close() for utxo in self.server.blockchain.utxo.utxo.items(): if utxo[1]['to'] == result[_address[0]][2] and utxo[0] not in self.server.Used: self.server.Used.append(utxo[0]) # print('1') i_ = 1 private_key = serialization.load_pem_private_key(result[_address[0]][1], None, backend=default_backend()) ipt = TransInput([utxo[0]], result[_address[0]][2]) opt = TransOutput([(utxo[1]['amount']/2, result[_address[1]][2]), (utxo[1]['amount']/2, result[_address[2]][2])]) tran = Transaction(ipt, opt) tran.ready(private_key) content = trans_to_json(tran) requests.post('http://127.0.0.1:23390/transaction_post', data=content) requests.post('http://127.0.0.1:23391/transaction_post', data=content) if result[_address[0]][2] in self.server.Address.keys(): self.server.Address[result[_address[0]][2]][0] -= len(tran.b) \ * self.server.throughput / (1000 * 2 * 4) self.server.Address[result[_address[0]][2]][1] = time.time() else: self.server.Address[result[_address[0]][2]] = [100, time.time()] _ = send_handler(MsgType.TYPE_RESPONSE_OK, tran.b) self.request.sendall(_) break if i_ == 0: # print('0') _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') self.request.sendall(_) else: pass
def processor_micro_block_write(self, content): try: micro_block = MicroBlock.unpack(content) except Exception: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'micro_block unpack error') else: result = self.server.macro_chain.add_micro_block(micro_block) if result: # c = 0 # for i in self.server.macro_chain.micro_block_pool: # c += sys.getsizeof(i.b) for i_ in self.server.cached_macro_block_body: if micro_block.hash in i_.ref_hash: self.parentless_macro_block_body_process(i_) for i in micro_block.data.trans: if i.txid not in self.server.transpool.used: self.server.transpool.used.append(i.txid) _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') else: # print('failed1', micro_block.hash) if self.server.macro_chain.accepted_micro_blocks[ micro_block.hash] >= 1: # print('pass') pass else: pass _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') finally: self.request.sendall(_)
def processor_micro_block_write(self, content): try: micro_block = MicroBlock.unpack(content) except Exception: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'micro_block unpack error') else: result = self.server.macro_chain.add_micro_block(micro_block) if result: c = 0 for i in self.server.macro_chain.micro_block_pool: c += sys.getsizeof(i.b) for i_ in self.server.cached_macro_block_body: if micro_block.hash in i_.ref_hash: self.parentless_macro_block_body_process(i_) print("chain length1 = ", self.server.macro_chain.micro_block_num + 1) print('real length = ', len(self.server.macro_chain.micro_block_pool)) _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') else: print('failed1', micro_block.hash) if self.server.macro_chain.accepted_micro_blocks[ micro_block.hash] >= 1: print('pass') else: pass _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') finally: self.request.sendall(_)
def processor_block_write(self, content): with self.server.mutex: a = time.time() try: block = Block.unpack(content) except Exception: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'block unpack error') else: print('receive block', block.hash, block.data.attachment.content, a) result = self.server.blockchain.add_block(block) # self.server.Trans_num += len(block.data.trans) # for trans in block.data.trans: # self.server.Trans_size += sys.getsizeof(trans.txid) # print('trans_num = ', self.server.Trans_num) # print('trans_size = ', self.server.Trans_size) # c = 0 # for block in self.server.blockchain.chain.queue: # c += sys.getsizeof(block.b) # print(c) # print(self.server.blockchain.size_) # print('nnn') print(result) if result: print("chain length1 = ", self.server.blockchain.length + 1) print('real length = ', len(self.server.blockchain.chain.queue)) self.server.transpool.remove(block) self.parentless_block_process() _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') else: print('failed1', block.hash) if block.hash in self.server.blockchain.accepted_blocks_hash or \ self.server.blockchain.accepted_blocks[block.hash] > 1: print('pass') print(block.hash) print(self.server.blockchain.accepted_blocks[block.hash]) else: print('\nin\n') for i in self.server.ass_chain: if block.previous_hash == i.hash: flag = 1 self.server.ass_chain[block] = (flag, i) self.longest_chain(block) break for i in self.server.blockchain.chain.queue: if block.previous_hash == i.hash: flag = 0 self.server.ass_chain[block] = (flag, i) break if block not in self.server.cache and block not in self.server.ass_chain.keys(): self.server.cache.append(block) _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') finally: self.request.sendall(_) print('all end', a)
def processor_trans_read(self, content): result = self.server.transpool.read_serialized() if len(result) > 0: _ = send_handler(MsgType.TYPE_RESPONSE_OK, batch_handler(result)) else: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') self.request.sendall(_)
def processor_trans_search_txid(self, content): try: trans = self.server.blockchain.search_transaction(content) except TransNotInChain: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') else: _ = send_handler(MsgType.TYPE_RESPONSE_OK, trans.b) finally: self.request.sendall(_)
def processor_trans_make(self, content): i_ = 0 add_from = 0 add_to = 2 add_to_two = random.randint(0, 1) _address = [add_from, add_to, add_to_two] result = dict() # print(_address) fd = open('ad1.txt', 'r') line = fd.readlines() for i in _address: line_ = line[i].rstrip() pr, pu = line_.split('ENDDING') temp = bytes(pu[2:-1], encoding='utf-8') temp = temp.replace(b'\r\n', b'\n') public_key = temp.replace(b'\\n', b'\n') temp = bytes(pr[2:-1], encoding='utf-8') temp = temp.replace(b'\r\n', b'\n') private_key = temp.replace(b'\\n', b'\n') sha = hashlib.sha256() sha.update(public_key) public_key_hash = sha.digest() result[i] = [public_key, private_key, public_key_hash] fd.close() for utxo in self.server.macro_chain.utxo.utxo.items(): if utxo[1]['to'] == result[_address[0]][2] and utxo[0] not in self.server.Used: self.server.Used.append(utxo[0]) # print('utxo', utxo) i_ = 1 private_key = serialization.load_pem_private_key(result[_address[0]][1], None, backend=default_backend()) ipt = TransInput([utxo[0]], result[_address[0]][2]) opt = TransOutput([(utxo[1]['amount']/2, result[_address[1]][2]), (utxo[1]['amount']/2, result[_address[2]][2])]) tran = Transaction(ipt, opt) tran.ready(private_key) content = trans_to_json(tran) requests.post('http://129.211.110.239:8000/transaction_post', data=content) requests.post('http://129.211.112.165:8000/transaction_post', data=content) requests.post('http://129.211.108.22:8000/transaction_post', data=content) requests.post('http://129.211.107.98:8000/transaction_post', data=content) requests.post('http://129.211.112.210:8000/transaction_post', data=content) requests.post('http://212.129.128.25:8000/transaction_post', data=content) requests.post('http://129.211.112.110:8000/transaction_post', data=content) requests.post('http://129.211.108.179:8000/transaction_post', data=content) requests.post('http://129.211.112.247:8000/transaction_post', data=content) requests.post('http://212.64.102.86:8000/transaction_post', data=content) _ = send_handler(MsgType.TYPE_RESPONSE_OK, tran.b) self.request.sendall(_) break if i_ == 0: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') self.request.sendall(_) else: pass
def processor_trans_write(self, content): result = self.server.transpool.add(content) if result: _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') else: print('false') _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') self.request.sendall(_)
def processor_macro_block_header_write(self, content) -> bool: flag_ = False try: macro_block_header = MacroBlockHeader.unpack(content) except Exception: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'macro_block_header unpack error') else: result = self.server.macro_chain.add_macro_block_header( macro_block_header) if self.server.macro_chain.accepted_macro_block_headers[ macro_block_header.hash] == 1: for i in self.server.cached_macro_block_body: if i.hash == macro_block_header.hash: self.parentless_macro_block_body_process(i) if result: for i in self.server.cached_macro_block_header: if macro_block_header.hash in i.parent_hash: self.parentless_macro_block_header_process() _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') flag_ = True else: print('failed1', macro_block_header.hash) if macro_block_header.hash in self.server.macro_chain.accepted_macro_block_header_hash or \ self.server.macro_chain.accepted_macro_block_headers[macro_block_header.hash] > 1: print('pass') else: for i in self.server.ass_chain: if macro_block_header.parent_hash[0] == i.hash: flag = 1 self.server.ass_chain[macro_block_header] = (flag, i) self.longest_chain(macro_block_header) flag_ = True break for i in self.server.macro_chain.chain_.queue: if macro_block_header.parent_hash[0] == i.hash: flag = 0 self.server.ass_chain[macro_block_header] = (flag, i) flag_ = True break if macro_block_header not in self.server.cached_macro_block_header and macro_block_header not in \ self.server.ass_chain.keys(): self.server.cached_macro_block_header.append( macro_block_header) _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') finally: self.request.sendall(_) return flag_
def processor_trans_write(self, content): result = self.server.transpool.add(content) print(len(self.server.transpool.chain.chain.queue)) # tran = Transaction.unpack(content) # print(tran.show_trans()) # print('ok3') if result: _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') else: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') self.request.sendall(_)
def create(self): print('ok') while True: try: # sleep for the remaining seconds of interval print('ok') with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall(send_handler(MsgType.TYPE_TRANS_MAKE, b'')) *_, msgtype, content = recv_parser(s) print('content') print(content) if content == b'': time.sleep(0.1) else: sha = hashlib.sha256() sha.update(content[BLENGTH_TXID:]) print(content[:BLENGTH_TXID]) print('sha') print(sha.digest()) time.sleep(0.01) except Exception as e: print('error') time.sleep(0.1) finally: pass
def processor_trans_write(self, content): result = self.server.transpool.add(content) tran = Transaction.unpack(content) # print(tran.show_trans()) # print('ok3') if result: a = Transaction.unpack(content) _ = send_handler(MsgType.TYPE_RESPONSE_OK, b'') # print('trans_received') # print(a.timestamp) # print(time.time()) # print(len(self.server.transpool.trans.queue)) else: _ = send_handler(MsgType.TYPE_RESPONSE_ERROR, b'') self.request.sendall(_)
def processor_get_parent_hash(self, content): content = self.server.macro_chain.pivot_chain.queue[-1] for i in self.server.macro_chain.tips: if i != self.server.macro_chain.pivot_chain.queue[-1]: content += i self.request.sendall(send_handler(MsgType.TYPE_RESPONSE_OK, content))
def create(self): print('ok') while True: try: # sleep for the remaining seconds of interval print('ok') with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall(send_handler(MsgType.TYPE_TRANS_MAKE, b'')) *_, msgtype, content = recv_parser(s) print('content') print(content) if content == b'': time.sleep(0.001) pass else: sha = hashlib.sha256() sha.update(content[BLENGTH_TXID:]) print(content[:BLENGTH_TXID]) print('sha') print(sha.digest()) # content = Transaction.unpack(content) # content = trans_to_json(content) # r = requests.post('http://127.0.0.1:23390/transaction_post', data=content) # q = requests.post('http://127.0.0.1:23391/transaction_post', data=content) # print(r.text) # print(q.text) time.sleep(0.01) except Exception as e: print('error') time.sleep(0.01) finally: pass
def transaction(): if request.method == 'GET': return r'<!DOCTYPE html><html><body><form action="/transaction" method=POST>' \ r'To:<br><input type="text" name="to" value=""><br>Amount:<br><input ' \ r'type="text" name="amount" value="" pattern="+[0-9]"><br>Private Key:<br><textarea rows="4" ' \ r'cols="20" name="prikey" value=""></textarea><br>Input(TxID,index;):<br><textarea rows="4" cols="20" ' \ r'name="input" value=""></textarea><br><input type="submit" value="Submit"></form> </body></html>' else: receiver = request.form['to'] amount = int(request.form['amount']) prikey = request.form['prikey'].encode() ipt = request.form['input'] ipt, index = ipt.split(',') ipt = unhexlify(ipt) index = int(index) prikey = prikey.replace(b'\r\n', b'\n') prikey = prikey.replace(b'\\n', b'\n') private_key = load_pem_private_key(prikey, None, default_backend()) public_key = private_key.public_key() serialized_public = public_key.public_bytes( encoding=Encoding.PEM, format=PublicFormat.SubjectPublicKeyInfo) sha = hashlib.sha256() sha.update(serialized_public) public_key_hash = sha.digest() t_input = TransInput([(TXID(ipt), OUTPUT_INDEX(index))], public_key_hash) t_output = TransOutput([(ASSET(amount), PUBLIC_KEY_HASH(unhexlify(receiver)))]) trans = Transaction(t_input, t_output) trans.ready(private_key) result = trans_to_json(trans) fd = open('peer.txt', 'r') for line in fd.readlines(): if line != '\n': print('http://' + line.rstrip() + '/transaction_post') r = requests.post('http://' + line.rstrip() + '/transaction_post', data=result) print(r.text) fd.close() with socket.socket( socket.AF_UNIX, socket.SOCK_STREAM) as s: # submit the valid transaction s.connect(chainbase_address) s.sendall(send_handler(MsgType.TYPE_TRANS_WRITE, trans.b)) *_, msgtype, content = recv_parser(s) if msgtype == MsgType.TYPE_RESPONSE_OK: return 'ok' else: print(trans.show_trans()) return 'error'
def test_004_previous_hash(self): with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.address) s.sendall(send_handler(MsgType.TYPE_BLOCK_PREVIOUS_HASH, b'')) header, length, msgtype, content = recv_parser(s) self.assertEqual(msgtype, MsgType.TYPE_RESPONSE_OK) self.assertEqual(len(content), 32) print(content)
def init_prev_hash(self): """get previous hash from chainbase when initializing""" with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall(send_handler(MsgType.TYPE_BLOCK_PREVIOUS_HASH, b'')) *_, msgtype, content = recv_parser(s) self.prev_hash = content print('prev_hash = ', content)
def processor_block_read(self, content): start = bin2int(content[:4]) end = bin2int(content[4:8]) # do the search result = [] for i in range(start, end): # if start <= server.blockchain.chain.queue[i].index <= end: result.append(self.server.blockchain.chain.queue[i].b) # send back result self.request.sendall(send_handler(MsgType.TYPE_RESPONSE_OK, batch_handler(result)))
def test_002_trans_read(self): with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.address) s.sendall(send_handler(MsgType.TYPE_TRANS_READ, b'')) header, length, msgtype, content = recv_parser(s) content = batch_parser(content) for i in content: Transaction.unpack(i) self.assertEqual(msgtype, MsgType.TYPE_RESPONSE_OK) self.assertEqual(len(content), 2)
def put_miner_use(self, usage, useful) -> List: with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall( send_handler( MsgType.TYPE_MINER_USE, batch_handler( [struct.pack('=d', usage), struct.pack('=d', useful)]))) *_, msgtype, content = recv_parser(s) result = batch_parser(content) return result
def add_block(self, block: Block) -> bool: """ add the block to the chainbase :param block: binary block :return: True | False """ with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall(send_handler(MsgType.TYPE_BLOCK_WRITE, block.b)) *_, msgtype, content = recv_parser(s) return msgtype == MsgType.TYPE_RESPONSE_OK
def __get_trans(self) -> List[Transaction]: # self.chainbase_address with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall(send_handler(MsgType.TYPE_TRANS_READ, b'')) *_, msgtype, content = recv_parser(s) trans = [] # todo: the first transaction should reward the miner, # todo: the server may have a property named owner_address if msgtype == MsgType.TYPE_RESPONSE_OK: trans += batch_parser(content) return [Transaction.unpack(t) for t in trans]
def block(): start = request.args.get('start', type=int) end = request.args.get('end', type=int) with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(chainbase_address) s.sendall( send_handler(MsgType.TYPE_BLOCK_READ, struct.pack('=i', start) + struct.pack('=i', end))) *_, msgtype, content = recv_parser(s) content = batch_parser(content) block = [Block.unpack(i).show_block() for i in content] return jsonify(block)
def add_macro_block_body(self, macro_block_body: MacroBlockBody) -> bool: """ add the macro_block_body to the chainbase :param macro_block_body: binary macro_block_body :return: True | False """ with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall( send_handler(MsgType.TYPE_MACRO_BLOCK_BODY_WRITE, macro_block_body.b)) *_, msgtype, content = recv_parser(s) return msgtype == MsgType.TYPE_RESPONSE_OK
def get_parent_hash(self) -> list: """ get pivot chain macro_block_header and tips in local DAG :return: a list of hash (the first hash refers to voting edge, others refer to reference edges) """ with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall(send_handler(MsgType.TYPE_GET_PARENT_HASH, None)) *_, msgtype, content = recv_parser(s) result = list() len_ = int(len(content) / 32) for i in range(len_): result.append(content[i * 32:(i + 1) * 32]) return result
def get_miner_credit(self, public_key_hash, num) -> List: with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) p = time.time() * 100000000 print(struct.pack('=d', p)) s.sendall( send_handler( MsgType.TYPE_MINER_CREDIT, batch_handler([ public_key_hash, struct.pack('=d', num), struct.pack('=d', p) ]))) *_, msgtype, content = recv_parser(s) result = batch_parser(content) return result
def add_macro_block_header(self, macro_block_header: MacroBlockHeader) -> bool: """ add the macro_block_header to the chainbase :param macro_block_header: binary macro_block_header :return: True | False """ print('in add macro') with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s: s.connect(self.chainbase_address) s.sendall( send_handler(MsgType.TYPE_MACRO_BLOCK_HEADER_WRITE, macro_block_header.b)) *_, msgtype, content = recv_parser(s) return msgtype == MsgType.TYPE_RESPONSE_OK
def transaction_post(): temp = str(request.get_data(), encoding='utf-8') trans = json_to_trans(temp) with socket.socket( socket.AF_UNIX, socket.SOCK_STREAM) as s: # submit the valid transaction s.connect(chainbase_address) s.sendall(send_handler(MsgType.TYPE_TRANS_WRITE, trans.b)) *_, msgtype, content = recv_parser(s) # print('end.....') # print(content) if msgtype == MsgType.TYPE_RESPONSE_OK: return 'ok' else: return 'error'