def run_test(self): file_dir = os.path.dirname(os.path.realpath(__file__)) storage_contract = get_contract_instance( abi_file=os.path.join(file_dir, "contracts/simple_storage.abi"), bytecode_file=os.path.join(file_dir, "contracts/simple_storage.dat"), ) start_p2p_connection(self.nodes) self.log.info("Initializing contract") genesis_addr = self.genesis_addr self.log.info("genesis_addr={}".format(encode_hex_0x(genesis_addr))) block_gen_thread = BlockGenThread(self.nodes, self.log, interval_fixed=1) block_gen_thread.start() client = RpcClient(self.nodes[0]) tx = client.new_tx(value=int(0.625 * CFX) + GDrip, receiver=self.eth_hex_addr, nonce=self.get_nonce(genesis_addr)) client.send_tx(tx, True) assert_equal(client.get_balance(self.eth_hex_addr), int(0.625 * CFX) + GDrip) # deploy contract self.log.info("Deploying contract") tx = self.call_contract_function( contract=storage_contract, name="constructor", args=[], sender_key=self.eth_priv_key, eth_tx=True, ) wait_until(lambda: self.nodes[1].tx_inspect(tx.hash_hex())['exist'], timeout=10) block_gen_thread.stop() client.generate_blocks(40) block_hash = client.generate_custom_block(client.best_block_hash(), [], [tx]) wait_until(lambda: client.best_block_hash() == block_hash, timeout=10) client.generate_blocks(40) BlockGenThread(self.nodes, self.log, interval_fixed=1).start() receipt = self.wait_for_tx([tx])[0] assert_greater_than_or_equal(int(receipt['epochNumber'], 0), 80) self.log.info("All test done")
def run_test(self): block_number = 8000 client = RpcClient(self.nodes[0]) start = time.time() genesis = client.best_block_hash() parent = genesis # generate main chain for i in range(block_number): parent = client.generate_block_with_parent(parent, referee=[]) if i % 100 == 0: self.log.info("generate %d blocks", i) prev_end = parent now = time.time() self.log.info("Time to process main chain of %d blocks: %f", block_number, now - start) start = now # process fork parent = genesis for i in range(block_number + 1): parent = client.generate_block_with_parent(parent, referee=[]) self.log.debug("block hash: %s", parent) if i % 100 == 0: self.log.info("generate %d blocks", i) now = time.time() self.log.info("Time to process fork of %d blocks: %f", block_number + 1, now - start) # switch back to main chain parent = prev_end start = time.time() for i in range(2): parent = client.generate_block_with_parent(parent, referee=[]) now = time.time() self.log.info("Time to switch back %f", now - start)
def run_test(self): client0 = RpcClient(self.nodes[0]) genesis = client0.best_block_hash() # print(client0.block_by_hash(genesis)) a = self.nodes[0].generatefixedblock(genesis, [], 0, False, INITIAL_DIFFICULTY) block_a = client0.block_by_hash(a) assert (block_a['stable'] == True) b = self.nodes[0].generatefixedblock(a, [], 0, False, INITIAL_DIFFICULTY) c = self.nodes[0].generatefixedblock(genesis, [], 0, False, INITIAL_DIFFICULTY) d = self.nodes[0].generatefixedblock(c, [], 0, False, INITIAL_DIFFICULTY) if a > c: e = self.nodes[0].generatefixedblock(b, [d], 0, True, INITIAL_DIFFICULTY) else: e = self.nodes[0].generatefixedblock(d, [b], 0, True, INITIAL_DIFFICULTY) block_e = client0.block_by_hash(e) assert (block_e['stable'] == False)
def run_test(self): client0 = RpcClient(self.nodes[0]) client1 = RpcClient(self.nodes[1]) genesis = client0.best_block_hash() self.log.info("Generating two initial blocks") a1 = client0.generate_block() a2 = client0.generate_block() block_a2 = client0.block_by_hash(a2) assert(int(block_a2['height'], 16) == 2) self.log.info("Generating two invalid blocks") invalid = self.nodes[0].generatefixedblock(genesis, [a2], 0, False, INITIAL_DIFFICULTY) invalid2 = self.nodes[0].generatefixedblock(a2, [invalid], 0, False, INITIAL_DIFFICULTY) self.log.info("Sync two nodes") connect_nodes(self.nodes, 0, 1) wait_until(lambda: self.nodes[1].getblockcount() >= 3, timeout = 10) self.log.info("Node0 block count " + str(self.nodes[0].getblockcount())) self.log.info("Node1 block count " + str(self.nodes[1].getblockcount())) self.log.info("Generating a block without referencing partial invalid blocks") b1 = client1.generate_block() block_b1 = client1.block_by_hash(b1) assert(block_b1['parentHash'] == a2) assert(len(block_b1['refereeHashes']) == 0) self.log.info("Sync two nodes") connect_nodes(self.nodes, 1, 0) wait_until(lambda: self.nodes[0].getblockcount() >= 6, timeout = 40) wait_until(lambda: self.nodes[1].getblockcount() >= 4, timeout = 40) timer_cnt = 0 diff = int(block_b1['difficulty'], 16) pow_qual = int(block_b1['powQuality'], 16) if diff * TIMER_RATIO <= pow_qual: timer_cnt = 1 self.log.info("Start timer tick " + str(timer_cnt)) while timer_cnt < TIMER_BETA: a = client0.generate_block() self.log.info("Generated a block " + a) block_a = client0.block_by_hash(a) assert(len(block_a['refereeHashes']) == 0) diff = int(block_a['difficulty'], 16) pow_qual = int(block_a['powQuality'], 16) if diff * TIMER_RATIO <= pow_qual: timer_cnt += 1 self.log.info("Timer increased to " + str(timer_cnt)) self.log.info("Sync two nodes") connect_nodes(self.nodes, 0, 1) sync_blocks(self.nodes) self.log.info("Node1 generating a block to reference two partial invalid blocks") b2 = client1.generate_block() block_b2 = client1.block_by_hash(b2) assert(len(block_b2['refereeHashes']) > 0) assert(block_b2['refereeHashes'][0] == invalid2) self.log.info("Pass!")
def run_test(self): genesis_key = default_config["GENESIS_PRI_KEY"] receiver_sk, _ = ec_random_keys() receiver_addr = priv_to_addr(receiver_sk) client = RpcClient(self.nodes[0]) value = 100000000 tx = create_transaction(pri_key=genesis_key, receiver=receiver_addr, value=value, nonce=0, gas_price=1, epoch_height=0) client.send_tx(tx) block_gen_thread = BlockGenThread(self.nodes, self.log, interval_base=0.1) block_gen_thread.start() self.log.info( "Wait for the first transaction to go through with epoch_height = 0..." ) wait_until(lambda: parse_as_int(self.nodes[0].cfx_getBalance( eth_utils.encode_hex(receiver_addr))) == value) self.log.info("Wait for generating more than 50 epochs") wait_until(lambda: parse_as_int( client.block_by_hash(client.best_block_hash())['height']) > 50) block_gen_thread.stop() self.log.info("Now block count:%d", self.nodes[0].getblockcount()) tx = create_transaction(pri_key=genesis_key, receiver=receiver_addr, value=value, nonce=1, gas_price=1, epoch_height=0) try: client.send_tx(tx) self.log.info("Bad transaction not rejected!") assert (False) except ReceivedErrorResponseError: self.log.info("Bad transaction rejected.") except: self.log.info("Unexpected error!") assert (False) assert (parse_as_int(self.nodes[0].cfx_getBalance( eth_utils.encode_hex(receiver_addr))) == value) epoch_height = parse_as_int( client.block_by_hash(client.best_block_hash())['height']) tx = create_transaction(pri_key=genesis_key, receiver=receiver_addr, value=value, nonce=1, gas_price=1, epoch_height=epoch_height) client.send_tx(tx) block_gen_thread = BlockGenThread(self.nodes, self.log, interval_base=0.1) block_gen_thread.start() self.log.info( "Wait for the first transaction to go through with epoch_height = " + str(epoch_height) + "...") wait_until(lambda: parse_as_int(self.nodes[0].cfx_getBalance( eth_utils.encode_hex(receiver_addr))) == 2 * value) block_gen_thread.stop() self.log.info("Now block count:%d", self.nodes[0].getblockcount()) self.log.info("Pass!")
def _test_new_block(self): self.log.info("Test New Block") client = RpcClient(self.nodes[0]) best_block = client.best_block_hash() best_epoch = client.epoch_number() new_block = create_block(decode_hex(best_block), best_epoch + 1) self.send_msg(NewBlock(block=new_block)) wait_until( lambda: self.nodes[0].best_block_hash() == new_block.hash_hex()) # Wrong payload self.nodes[0].p2p.send_protocol_packet( rlp.encode([0]) + int_to_bytes(NEW_BLOCK)) time.sleep(1) assert_equal(self.nodes[0].best_block_hash(), new_block.hash_hex()) assert_equal(self.nodes[0].getblockcount(), 3) self.reconnect(self.nodes[0]) # Wrong-length parent hash invalid_block = create_block(parent_hash=b'', height=2) self.send_msg(NewBlock(block=invalid_block)) time.sleep(1) assert_equal(self.nodes[0].best_block_hash(), new_block.hash_hex()) assert_equal(self.nodes[0].getblockcount(), 3) self.reconnect(self.nodes[0]) # Wrong-length author invalid_block = create_block(author=b'', height=2) self.send_msg(NewBlock(block=invalid_block)) time.sleep(1) assert_equal(self.nodes[0].best_block_hash(), new_block.hash_hex()) assert_equal(self.nodes[0].getblockcount(), 3) self.reconnect(self.nodes[0]) # Wrong-length root invalid_block = create_block(deferred_state_root=b'', height=2, deferred_receipts_root=b'') self.send_msg(NewBlock(block=invalid_block)) time.sleep(1) assert_equal(self.nodes[0].best_block_hash(), new_block.hash_hex()) assert_equal(self.nodes[0].getblockcount(), 3) self.reconnect(self.nodes[0]) # Nonexistent parent invalid_block = create_block(parent_hash=b'\x00' * 32, height=2) self.send_msg(NewBlock(block=invalid_block)) time.sleep(1) assert_equal(self.nodes[0].best_block_hash(), new_block.hash_hex()) assert_equal(self.nodes[0].getblockcount(), 3) self.reconnect(self.nodes[0]) # Invalid height invalid_block = create_block(new_block.hash, 1) self.send_msg(NewBlock(block=invalid_block)) time.sleep(1) assert_equal(self.nodes[0].best_block_hash(), new_block.hash_hex()) assert_equal(self.nodes[0].getblockcount(), 3) self.reconnect(self.nodes[0]) sync_blocks(self.nodes) # TODO Generate some random blocks that have wrong ref edges pass