def test_uncle_block_inclusion_validity(vm_fn): # This test ensures that a forked block which is behind by # more than 6 layers cannot act as an ancestor to the current block OTHER_MINER_ADDRESS = 20 * b'\x01' chain = build( MiningChain, vm_fn(0), disable_pow_check(), genesis(), mine_block(), # 1 mine_block(), # 2 ) fork_chain = build( chain, at_block_number(1), mine_block(extra_data=b'fork-it!', coinbase=OTHER_MINER_ADDRESS), # fork 2 ) # we don't use canonical head here because the fork chain is non-canonical. uncle = fork_chain.get_block_header_by_hash(fork_chain.header.parent_hash) assert uncle.block_number == 2 with pytest.raises(ValidationError): chain = build( chain, # Mines blocks from 3 to 8 (both numbers inclusive) mine_blocks(6), # Mine block 9 with uncle mine_block(uncles=[uncle]), )
def test_chain_builder_build_uncle_fork(mining_chain): chain = build( mining_chain, mine_block(), # 1 mine_block(), # 2 ) fork_chain = build( chain, at_block_number(1), mine_block(extra_data=b'fork-it!'), # fork 2 ) # we don't use canonical head here because the fork chain is non-canonical. uncle = fork_chain.get_block_header_by_hash(fork_chain.header.parent_hash) assert uncle.block_number == 2 assert uncle != chain.get_canonical_head() chain = build( chain, mine_block(uncles=[uncle]), # 3 ) header = chain.get_canonical_head() block = chain.get_block_by_hash(header.hash) assert len(block.uncles) == 1 assert block.uncles[0] == uncle
def test_chain_builder_build_two_default_blocks(mining_chain): chain = build( mining_chain, mine_block(), mine_block(), ) header = chain.get_canonical_head() assert header.block_number == 2
def test_rewards_nephew_uncle_different_vm(vm_fn_uncle, vm_fn_nephew, miner_1_balance, miner_2_balance): OTHER_MINER_ADDRESS = 20 * b'\x01' TOTAL_BLOCKS_CANONICAL_CHAIN = 10 VM_CHANGE_BLOCK_NUMBER = 4 chain = build( MiningChain, vm_fn_uncle(0), vm_fn_nephew(VM_CHANGE_BLOCK_NUMBER), disable_pow_check(), genesis(), mine_blocks(TOTAL_BLOCKS_CANONICAL_CHAIN - 1), ) fork_chain = build( chain, at_block_number(3), mine_block(extra_data=b'fork-it!', coinbase=OTHER_MINER_ADDRESS), # fork 2 ) # we don't use canonical head here because the fork chain is non-canonical. uncle = fork_chain.get_block_header_by_hash(fork_chain.header.parent_hash) assert uncle.block_number == 4 chain = build( chain, mine_block(uncles=[uncle]), ) header = chain.get_canonical_head() block = chain.get_block_by_hash(header.hash) assert len(block.uncles) == 1 assert block.uncles[0] == uncle vm = chain.get_vm() coinbase_balance = vm.state.get_balance(block.header.coinbase) other_miner_balance = vm.state.get_balance(uncle.coinbase) uncle_vm = chain.get_vm_class_for_block_number(0) nephew_vm = chain.get_vm_class_for_block_number(VM_CHANGE_BLOCK_NUMBER) # We first test if the balance matches what we would determine # if we made all the API calls involved ourselves. assert coinbase_balance == (uncle_vm.get_block_reward() * 3 + nephew_vm.get_block_reward() * (TOTAL_BLOCKS_CANONICAL_CHAIN - 3) + vm.get_nephew_reward()) assert other_miner_balance == vm.get_uncle_reward(block.number, uncle) # But we also ensure the balance matches the numbers that we calculated on paper assert coinbase_balance == to_wei(miner_1_balance, 'ether') assert other_miner_balance == to_wei(miner_2_balance, 'ether')
async def test_eth_api_head_info_updates_with_announce(alice, bob, common_base_chain, LESAPI_class): # bob mines two blocks on his chain got_announce = asyncio.Event() async def _handle_announce(connection, msg): got_announce.set() alice.connection.add_command_handler(Announce, _handle_announce) bob_genesis = common_base_chain.headerdb.get_canonical_block_header_by_number( 0) assert alice.connection.has_logic(LESAPI_class.name) les_api = alice.connection.get_logic(LESAPI_class.name, LESAPI_class) assert les_api.head_info.head_hash == bob_genesis.hash assert les_api.head_info.head_td == bob_genesis.difficulty assert les_api.head_info.head_number == 0 bob_chain = build( common_base_chain, mine_block(), mine_block(), ) head = bob_chain.get_canonical_head() les_proto = bob.les_api.protocol assert isinstance(les_proto, BaseLESProtocol) assert head.block_number == 2 total_difficulty = bob_chain.headerdb.get_score(head.hash) les_proto.send( Announce( AnnouncePayload( head_hash=head.hash, head_number=head.block_number, head_td=total_difficulty, reorg_depth=0, params=(), ))) await asyncio.wait_for(got_announce.wait(), timeout=1) await asyncio.sleep(0.1) assert les_api.head_info.head_hash == head.hash assert les_api.head_info.head_td == total_difficulty assert les_api.head_info.head_number == 2
def test_rewards_uncle_created_at_different_generations( vm_fn, fork_at_block_number, miner_1_balance, miner_2_balance): OTHER_MINER_ADDRESS = 20 * b'\x01' TOTAL_BLOCKS_CANONICAL_CHAIN = 10 chain = build( MiningChain, vm_fn(0), disable_pow_check(), genesis(), mine_blocks(TOTAL_BLOCKS_CANONICAL_CHAIN - 1), ) fork_chain = build( chain, at_block_number(fork_at_block_number), mine_block(extra_data=b'fork-it!', coinbase=OTHER_MINER_ADDRESS), # fork 2 ) # we don't use canonical head here because the fork chain is non-canonical. uncle = fork_chain.get_block_header_by_hash(fork_chain.header.parent_hash) assert uncle.block_number == fork_at_block_number + 1 chain = build( chain, mine_block(uncles=[uncle]), ) header = chain.get_canonical_head() block = chain.get_block_by_hash(header.hash) vm = chain.get_vm() coinbase_balance = vm.state.account_db.get_balance(block.header.coinbase) other_miner_balance = vm.state.account_db.get_balance(uncle.coinbase) # We first test if the balance matches what we would determine # if we made all the API calls involved ourselves. assert coinbase_balance == ( vm.get_block_reward() * TOTAL_BLOCKS_CANONICAL_CHAIN + vm.get_nephew_reward()) assert other_miner_balance == vm.get_uncle_reward(block.number, uncle) # But we also ensure the balance matches the numbers that we calculated on paper assert coinbase_balance == to_wei(miner_1_balance, 'ether') assert other_miner_balance == to_wei(miner_2_balance, 'ether')
def test_chain_builder_mine_block_with_parameters(mining_chain): chain = build( mining_chain, mine_block(extra_data=b'test-setting-extra-data'), ) header = chain.get_canonical_head() assert header.extra_data == b'test-setting-extra-data'
async def test_handshake_with_incompatible_fork_id(alice_chain, bob_chain): alice_chain = build(alice_chain, mine_block()) pair_factory = ETHPeerPairFactory(alice_peer_context=ChainContextFactory( headerdb=AsyncHeaderDB(alice_chain.headerdb.db), vm_configuration=((1, PetersburgVM), (2, MuirGlacierVM))), ) with pytest.raises(WrongForkIDFailure): async with pair_factory as (alice, bob): pass
def test_chain_builder_chain_split(mining_chain): chain_a, chain_b = build( mining_chain, chain_split( (mine_block(extra_data=b'chain-a'), mine_block()), (mine_block(extra_data=b'chain-b'), mine_block(), mine_block()), ), ) first_a = chain_a.get_canonical_block_by_number(1).header first_b = chain_b.get_canonical_block_by_number(1).header assert first_a.extra_data == b'chain-a' assert first_b.extra_data == b'chain-b' head_a = chain_a.get_canonical_head() assert head_a.block_number == 2 head_b = chain_b.get_canonical_head() assert head_b.block_number == 3
async def test_eth_api_head_info_updates_with_newblock(alice, bob, bob_chain, ETHAPI_class): # mine two blocks on bob's chain bob_chain = build( bob_chain, mine_block(), mine_block(), ) got_new_block = asyncio.Event() async def _handle_new_block(connection, msg): got_new_block.set() alice.connection.add_command_handler(NewBlock, _handle_new_block) bob_genesis = bob_chain.headerdb.get_canonical_block_header_by_number(0) bob_eth_api = bob.connection.get_logic(ETHAPI_class.name, ETHAPI_class) alice_eth_api = alice.connection.get_logic(ETHAPI_class.name, ETHAPI_class) assert alice_eth_api.head_info.head_hash == bob_genesis.hash assert alice_eth_api.head_info.head_td == bob_genesis.difficulty assert not hasattr(alice_eth_api.head_info, 'head_number') head = bob_chain.get_canonical_head() assert head.block_number == 2 head_block = bob_chain.get_block_by_header(head) total_difficulty = bob_chain.headerdb.get_score(head.hash) bob_eth_api.send_new_block( head_block, total_difficulty, ) await asyncio.wait_for(got_new_block.wait(), timeout=1) assert alice_eth_api.head_info.head_hash == head.parent_hash assert alice_eth_api.head_info.head_td == bob_chain.headerdb.get_score( head.parent_hash) assert alice_eth_api.head_info.head_number == 1
def alice_chain_on_fork(bob_chain): bob_genesis = bob_chain.headerdb.get_canonical_block_header_by_number(0) chain = build( MiningChain, latest_mainnet_at(0), disable_pow_check(), genesis(params={"timestamp": bob_genesis.timestamp}), mine_block(), ) return chain
def test_chain_builder_at_block_number(mining_chain): pre_fork_chain = build( mining_chain, mine_block(), # 1 mine_block(), # 2 mine_block(), # 3 ) block_1 = pre_fork_chain.get_canonical_block_by_number(1) block_2 = pre_fork_chain.get_canonical_block_by_number(2) block_3 = pre_fork_chain.get_canonical_block_by_number(3) chain = build( pre_fork_chain, at_block_number(2), mine_block(extra_data=b'fork-it!'), # fork 3 mine_block(), # fork 4 mine_block(), # fork 5 ) # ensure that our chain is ahead of the pre_fork_chain head = chain.get_canonical_head() assert head.block_number == 5 pre_fork_head = pre_fork_chain.get_canonical_head() assert pre_fork_head.block_number == 3 f_block_1 = chain.get_canonical_block_by_number(1) f_block_2 = chain.get_canonical_block_by_number(2) f_block_3 = chain.get_canonical_block_by_number(3) # verify that the fork diverges from the pre_fork_chain assert f_block_1 == block_1 assert f_block_2 == block_2 assert f_block_3 != block_3
async def test_eth_api_head_info_updates_with_announce(alice, bob, common_base_chain): # bob mines two blocks on his chain bob_chain = build( common_base_chain, mine_block(), mine_block(), ) got_announce = asyncio.Event() async def _handle_announce(connection, msg): got_announce.set() alice.connection.add_command_handler(Announce, _handle_announce) bob_genesis = bob_chain.headerdb.get_canonical_block_header_by_number(0) les_api = alice.connection.get_logic(LESAPI.name, LESAPI) assert les_api.head_info.head_hash == bob_genesis.hash assert les_api.head_info.head_td == bob_genesis.difficulty assert les_api.head_info.head_number == 0 les_proto = bob.connection.get_protocol_by_type(LESProtocolV2) head = bob_chain.get_canonical_head() assert head.block_number == 2 total_difficulty = bob_chain.headerdb.get_score(head.hash) les_proto.send_announce( head, total_difficulty, ) await asyncio.wait_for(got_announce.wait(), timeout=1) assert alice.connection.has_logic(LESAPI.name) assert les_api.head_info.head_hash == head.hash assert les_api.head_info.head_td == total_difficulty assert les_api.head_info.head_number == 2
def test_chain_builder_mine_block_with_transactions( mining_chain, funded_address, funded_address_private_key): tx = new_transaction( mining_chain.get_vm(), from_=funded_address, to=ZERO_ADDRESS, private_key=funded_address_private_key, ) chain = build( mining_chain, mine_block(transactions=[tx]), ) block = chain.get_canonical_block_by_number(1) assert len(block.transactions) == 1 assert block.transactions[0] == tx
def test_chain_builder_mine_block_only_on_mining_chain(regular_chain): with pytest.raises(ValidationError, match="MiningChain"): mine_block()(regular_chain)