Example #1
0
def start(thread_name, ip_address, port):
    import json

    addr = (ip_address, port)
    buf_size = 10240

    # 소켓 생성 및 바인딩
    tcp_socket = socket(AF_INET, SOCK_STREAM)
    tcp_socket.bind(addr)
    tcp_socket.listen(5)

    while is_running:

        # 요청이 있을경우 소켓과 송신자의 ip 주소 저장
        receive_socket, sender_ip = tcp_socket.accept()

        while is_running:
            print("Receiving")

            # 소켓으로부터 버퍼 사이즈씩 데이터 수신
            data = receive_socket.recv(buf_size)
            try:
                # 수신된 데이터가 없는 경우
                if (len(data) == 0):
                    break

                print("data received...")

                # json 형태의 데이터를 dict 타입으로 변경
                data_json_obj = json.loads(data)

                # Transaction을 받은 경우
                if data_json_obj['type'] == 'T':
                    print("Received transaction")
                    print(data_json_obj)

                    # dict 데이터로부터 transaction 객체 생성
                    tx = Transaction().from_json(data_json_obj)

                    # transaction 추가
                    transaction.add_transaction(tx)

                elif data_json_obj['type'] == 'B':
                    print("block received...")
                    # 기존 transacion 삭제
                    transaction.remove_all()

                    #블록 추가
                    received_block = Block().from_json(data_json_obj)

                    append_block(received_block)

            except:
                print("recv error...")
                traceback.print_exc()
                break

    tcp_socket.close()
    receive_socket.close()
Example #2
0
def create_block():

    diff_bits = 5
    transactions = transaction.get_transactions()

    # transaction이 없을 경우 block을 생성하지 않음
    if (len(transactions) == 0):
        print("No transactions...")
        return

    # 내 node가 가지고 있는 마지막 블럭
    last_block = block.get_last_block()

    #transaction JSON 문자열로 변환
    transactions_str = []
    for tx in transactions:
        transactions_str.append(tx.to_json())

    # transaction 으로부터 merkle root 생성
    merkle_root = merkle_tree(transactions_str)

    # block 새로 생성
    _block = Block()

    # 마지막 블록이 있는 경우
    if last_block:

        # last bock 에 대한 정보 저장
        _block.prev_block_id = last_block.block_id
        _block.prev_block_hash = last_block.block_hash

        # 작업 증명을 위해 nonce값과 결과 생성
        _block.block_id = last_block.block_id + 1
        _block.merkle_root = merkle_root
        _block.difficulty = diff_bits

        block_header = _block.getheader_json()
        hash_result, nonce = proof_of_work(block_header, diff_bits)

        # block 정보
        _block.block_hash = hash_result
        _block.nonce = nonce
        _block.tx_list = transactions_str

        # 내 node에 block 저장
        block.append_block(_block)

        # 내 node가 가지고 있는 transaction 삭제
        transaction.remove_all()

        # 나머지 node에게 block 전송
        sender.send_to_all_node((_block.to_json()), except_my_node=True)
Example #3
0
def create_block():
	transactions = transaction.get_transactions()

	# transaction이 없을 경우 block을 생성하지 않음
	if len(transactions) == 0:
		return

	# 내 node 가 가지고 있는 마지막 블럭
	last_block = block.get_last_block()

	# transaction JSON 문자열로 변환
	transactions_str = list(map(lambda x: x.to_json(), transactions))

	# transaction으로부터 merkle root 생성
	merkle_root = merkle_tree(transactions_str)

	# block 정보에 merkle root 할당
	block_info = merkle_root

	# block 새로 생성
	_block = Block()

	# 마지막 block이 있는 경우
	if last_block:
		# block 정보에 마지막 블럭의 해쉬를 더함
		block_info += last_block.block_hash

		# 새로 생성한 block에 이전 block 정보 저장
		_block.prev_block_hash = last_block.block_hash
		_block.prev_block_id = last_block.block_id

	# 작업 증명을 통해 nonce값과 hash 결과 생성
	hash_result, nonce = proof_of_work(block_info, diff_bits=5)

	# block 정보
	_block.block_hash = hash_result
	_block.nonce = nonce
	_block.block_info = block_info
	_block.time_stamp = datetime.datetime.now()

	# 내 node 에 block 저장
	block.create_block(_block)

	# 내 node가 가지고 있는 transaction 삭제
	transaction.remove_all()

	# 나머지 node에게 block 전송
	sender.send_to_all_node((_block.to_json()), except_my_node=True)
Example #4
0
def create_block():
    transactions = transaction.get_transactions()

    # transaction이 없을 경우 block을 생성하지 않음
    if len(transactions) == 0:
        return

    _block = block.create_block(transactions)

    block.store_block(_block)

    # 내 node가 가지고 있는 transaction 삭제
    transaction.remove_all()

    # 나머지 node에게 block 전송
    sender.send_to_all_node((_block.to_json()), except_my_node=True)
Example #5
0
def start(thread_name, ip_address, port):
    import json

    addr = (ip_address, port)
    buf_size = 1024

    # 소켓 생성 및 바인딩
    tcp_socket = socket(AF_INET, SOCK_STREAM)
    tcp_socket.bind(addr)
    tcp_socket.listen(5)

    while is_running:

        # 요청이 있을 경우 소켓과 송신자의 ip 주소 저장
        receive_socket, sender_ip = tcp_socket.accept()

        while is_running:
            log.write("Receiving")

            # 소켓으로부터 버퍼 사이즈씩 데이터 수신
            data = receive_socket.recv(buf_size)
            try:

                # 수신된 데이터가 없는 경우
                if len(data) == 0:
                    break

                # json 형태의 데이터를 dict 타입으로 변경
                data_json_obj = json.loads(data)

                # Transaction을 받은 경우
                if data_json_obj['type'] == 'T':
                    log.write("Receiving a transaction")

                    verify_msg = data_json_obj['time_stamp'] + data_json_obj[
                        'message']

                    if key.verify_signature(data_json_obj['pub_key'],
                                            data_json_obj['signature'],
                                            verify_msg) is True:
                        log.write("Transaction is valid")
                        tx = Transaction().from_json(data_json_obj)
                        transaction.add_transaction(tx)
                    else:
                        log.write("Transaction is invalid")

                # 블록을 수신한 경우
                elif data_json_obj['type'] == 'B':
                    # 기존의 트랜잭션 삭제
                    transaction.remove_all()

                    # 블록 생성
                    received_block = Block().from_json(data_json_obj)

                    # 블록 저장
                    create_block(received_block)

            except:
                traceback.print_exc()
                break

    tcp_socket.close()
    receive_socket.close()