def run_test(self): client = RpcClient(self.nodes[0]) genesis_address = "0x" + encode_hex( priv_to_addr(default_config['GENESIS_PRI_KEY'])) genesis_balance = default_config["TOTAL_COIN"] client.generate_empty_blocks(ERA_EPOCH_COUNT * 10) print(client.epoch_number("latest_checkpoint")) assert client.epoch_number("latest_checkpoint") > 0 # Just assert we can still get the balance assert_equal(client.get_balance(genesis_address, client.EPOCH_NUM(1)), genesis_balance)
def run_test(self): num_blocks = 200 checkpoint_epoch = 100 # Generate checkpoint on node[0] client = RpcClient(self.nodes[0]) genesis_nonce = client.get_nonce(client.GENESIS_ADDR) for _ in range(num_blocks): tx = client.new_tx(nonce=genesis_nonce) tx_hash = client.send_tx(tx) assert tx_hash == tx.hash_hex() genesis_nonce += 1 client.generate_block(100) # Start node[1] as full node to sync checkpoint # Change phase from CatchUpSyncBlockHeader to CatchUpCheckpoint # only when there is at least one connected peer. self.start_node(1, ["--full"], phase_to_wait=None) connect_nodes(self.nodes, 1, 0) # FIXME full node issue that hang at phase CatchUpRecoverBlockFromDbPhase self.nodes[1].wait_for_phase(["NormalSyncPhase"], wait_time=30) sync_blocks(self.nodes, sync_count=False) client = RpcClient(self.nodes[1]) # At epoch 1, block header exists while body not synchronized try: print(client.block_by_epoch(client.EPOCH_NUM(1))) except ReceivedErrorResponseError as e: assert 'Internal error' == e.response.message # There is no state from epoch 1 to checkpoint_epoch # Note, state of genesis epoch always exists assert client.epoch_number() >= checkpoint_epoch for i in range(1, checkpoint_epoch): try: client.get_balance(client.GENESIS_ADDR, client.EPOCH_NUM(i)) raise AssertionError( "should be not state for epoch {}".format(i)) except ReceivedErrorResponseError as e: assert "State for epoch" in e.response.message assert "does not exist" in e.response.message # State should exist at checkpoint client.get_balance(client.GENESIS_ADDR, client.EPOCH_NUM(checkpoint_epoch)) # There should be states after checkpoint for i in range(checkpoint_epoch + 1, client.epoch_number() - 3): client.get_balance(client.GENESIS_ADDR, client.EPOCH_NUM(i))
def run_test(self): num_blocks = 200 checkpoint_epoch = 100 # Generate checkpoint on node[0] client = RpcClient(self.nodes[0]) self.genesis_nonce = client.get_nonce(client.GENESIS_ADDR) for _ in range(num_blocks): txs = self._generate_txs(0, random.randint(5, 10)) client.generate_block_with_fake_txs(txs) # Start node[1] as full node to sync checkpoint # Change phase from CatchUpSyncBlockHeader to CatchUpCheckpoint # only when there is at least one connected peer. self.start_node(1, ["--full"], phase_to_wait=None) connect_nodes(self.nodes, 1, 0) # FIXME full node issue that hang at phase CatchUpRecoverBlockFromDbPhase self.nodes[1].wait_for_phase(["NormalSyncPhase"], wait_time=30) sync_blocks(self.nodes, sync_count=False) client = RpcClient(self.nodes[1]) # At epoch 1, block header exists while body not synchronized try: print(client.block_by_epoch(client.EPOCH_NUM(1))) except ReceivedErrorResponseError as e: assert 'Internal error' == e.response.message # There is no state from epoch 1 to checkpoint_epoch # Note, state of genesis epoch always exists assert client.epoch_number() >= checkpoint_epoch # FIXME: we minus REWARD_EPOCH_COUNT here as a workaround. # FIXME: after the state boundary is implemented in consensus, # FIXME: this workaround should be removed. for i in range(1, checkpoint_epoch - 11): try: client.get_balance(client.GENESIS_ADDR, client.EPOCH_NUM(i)) raise AssertionError( "should not have state for epoch {}".format(i)) except ReceivedErrorResponseError as e: assert "State for epoch" in e.response.message assert "does not exist" in e.response.message # State should exist at checkpoint client.get_balance(client.GENESIS_ADDR, client.EPOCH_NUM(checkpoint_epoch)) # There should be states after checkpoint for i in range(checkpoint_epoch, client.epoch_number() - 3): client.get_balance(client.GENESIS_ADDR, client.EPOCH_NUM(i))
def run_test(self): time.sleep(7) client = RpcClient(self.nodes[0]) genesis = self.nodes[0].best_block_hash() self.log.info(genesis) genesis_epoch = client.epoch_number(client.EPOCH_LATEST_CONFIRMED) assert_equal(genesis_epoch, 0) # generate blocks in 0.5 sec interval like default for i in range(0, 160): self.nodes[0].generate_empty_blocks(1) time.sleep(0.5) last_mined = client.epoch_number(client.EPOCH_LATEST_MINED) confirmed = client.epoch_number(client.EPOCH_LATEST_CONFIRMED) self.log.info("Mined epoch: " + str(last_mined) + " Confirmed epoch: " + str(confirmed)) # This is a very loose bound given the default parameter for Conflux. # If we change consensus/confirmation related parameters, this needs to be # changed as well. assert (last_mined <= 70 or last_mined - confirmed > 70) assert (last_mined - confirmed < 100)
def run_test(self): num_blocks = 200 snapshot_epoch = 150 # Generate checkpoint on node[0] archive_node_client = RpcClient(self.nodes[0]) self.genesis_nonce = archive_node_client.get_nonce( archive_node_client.GENESIS_ADDR) blocks_in_era = [] for i in range(num_blocks): txs = self._generate_txs(0, random.randint(50, 100)) block_hash = archive_node_client.generate_block_with_fake_txs(txs) if i >= snapshot_epoch: blocks_in_era.append(block_hash) sync_blocks(self.nodes[:-1]) self.log.info("All archive nodes synced") # Start node[full_node_index] as full node to sync checkpoint # Change phase from CatchUpSyncBlockHeader to CatchUpCheckpoint # only when there is at least one connected peer. full_node_index = self.num_nodes - 1 self.start_node(full_node_index, ["--full"], phase_to_wait=None) for i in range(self.num_nodes - 1): connect_nodes(self.nodes, full_node_index, i) self.log.info("Wait for full node to sync, index=%d", full_node_index) self.nodes[full_node_index].wait_for_phase(["NormalSyncPhase"], wait_time=240) sync_blocks(self.nodes, sync_count=False) full_node_client = RpcClient(self.nodes[full_node_index]) # At epoch 1, block header exists while body not synchronized try: print( full_node_client.block_by_epoch(full_node_client.EPOCH_NUM(1))) except ReceivedErrorResponseError as e: assert 'Internal error' == e.response.message # There is no state from epoch 1 to snapshot_epoch # Note, state of genesis epoch always exists assert full_node_client.epoch_number() >= snapshot_epoch wait_until( lambda: full_node_client.epoch_number() == archive_node_client. epoch_number() and full_node_client.epoch_number("latest_state") == archive_node_client.epoch_number("latest_state")) # We have snapshot_epoch for state execution but # don't offer snapshot_epoch for Rpc clients. for i in range(1, snapshot_epoch + 1): try: full_node_client.get_balance(full_node_client.GENESIS_ADDR, full_node_client.EPOCH_NUM(i)) raise AssertionError( "should not have state for epoch {}".format(i)) except ReceivedErrorResponseError as e: assert "State for epoch" in e.response.message assert "does not exist" in e.response.message # Wait for execution to complete. time.sleep(1) # There should be states after checkpoint for i in range(snapshot_epoch + 1, full_node_client.epoch_number() - 3): full_balance = full_node_client.get_balance( full_node_client.GENESIS_ADDR, full_node_client.EPOCH_NUM(i)) archive_balance = archive_node_client.get_balance( archive_node_client.GENESIS_ADDR, archive_node_client.EPOCH_NUM(i)) assert_equal(full_balance, archive_balance) # Blocks within execution defer (5 epochs) and reward_defer (12 epochs) do not have state_valid available_blocks = blocks_in_era[:-17] assert_blocks_valid(self.nodes[:-1], available_blocks) assert_blocks_valid(self.nodes[-1:], available_blocks)
def run_test(self): # Pos contract enabled, stake and register in the first hard-fork phase. client = RpcClient(self.nodes[self.num_nodes - 1]) client.generate_empty_blocks(300) sync_blocks(self.nodes) for node in self.nodes[:-1]: client = RpcClient(node) pos_identifier, _ = client.wait_for_pos_register() sync_blocks(self.nodes) client = RpcClient(self.nodes[self.num_nodes - 1]) # generate blocks until we are after pos initialization and before pos start. best_epoch = client.epoch_number() client.generate_empty_blocks(600 - best_epoch) sync_blocks(self.nodes) voting_power_map = {} pub_keys_map = {} logs = client.get_logs(filter=Filter(from_epoch="earliest", to_epoch="latest_state", address=["0x0888000000000000000000000000000000000005"])) for log in logs: pos_identifier = log["topics"][1] if log["topics"][0] == REGISTER_TOPIC: bls_pub_key, vrf_pub_key = eth_abi.decode_abi(["bytes", "bytes"], decode_hex(log["data"])) pub_keys_map[pos_identifier] = (encode_hex_0x(bls_pub_key), encode_hex_0x(vrf_pub_key)) elif log["topics"][0] == INCREASE_STAKE_TOPIC: assert pos_identifier in pub_keys_map voting_power_map[pos_identifier] = parse_as_int(log["data"]) with open(os.path.join(self.options.tmpdir, "public_keys"), "w") as f: for pos_identifier in pub_keys_map.keys(): f.write(",".join([pub_keys_map[pos_identifier][0][2:], pub_keys_map[pos_identifier][1][2:], str(voting_power_map[pos_identifier])]) + "\n") initialize_tg_config(self.options.tmpdir, len(self.nodes), len(self.nodes), DEFAULT_PY_TEST_CHAIN_ID, pkfile="public_keys") # generate blocks until pos start self.nodes[0].generate_empty_blocks(500) sync_blocks(self.nodes) pos_identifier, _ = client.wait_for_pos_register() client.generate_empty_blocks(400) sync_blocks(self.nodes) time.sleep(2) latest_pos_ref = self.latest_pos_ref() for i in range(55): print(i) if i == 10: self.stop_node(5, clean=True) self.start_node(5, phase_to_wait=None) self.nodes[5].wait_for_recovery(["NormalSyncPhase"], 30) if i == 12: self.maybe_restart_node(5, 1, 0) if i == 15: assert_equal(int(client.pos_get_account(pos_identifier)["status"]["availableVotes"], 0), 2000) client.pos_retire_self() if i == 30: self.maybe_restart_node(5, 1, 1) # Retire node 3 after 5 min. # Generate enough PoW block for PoS to progress self.nodes[0].generate_empty_blocks(60) # Leave some time for PoS to reach consensus time.sleep(3) self.nodes[0].generate_empty_blocks(1) new_pos_ref = self.latest_pos_ref() if i >= 10: assert_ne(latest_pos_ref, new_pos_ref) client.wait_for_unstake(client.node.pow_sk) assert client.get_balance(eth_utils.encode_hex(priv_to_addr(client.node.pow_sk))) > 10000 * 10**18 assert_equal(int(client.pos_get_account(pos_identifier)["status"]["availableVotes"], 0), 0)
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