def test_transaction_fixtures(fixture):
header = BlockHeader(1, fixture['blocknumber'], 100)
chain = MainnetChain(BaseChainDB(get_db_backend()), header=header)
vm = chain.get_vm()
TransactionClass = vm.get_transaction_class()
if 'sender' in fixture:
transaction = rlp.decode(fixture['rlp'], sedes=TransactionClass)
expected = normalize_signed_transaction(fixture['transaction'])
assert transaction.nonce == expected['nonce']
assert transaction.gas_price == expected['gasPrice']
assert transaction.gas == expected['gasLimit']
assert transaction.to == expected['to']
assert transaction.value == expected['value']
assert transaction.data == expected['data']
assert transaction.v == expected['v']
assert transaction.r == expected['r']
assert transaction.s == expected['s']
sender = to_canonical_address(fixture['sender'])
try:
assert transaction.sender == sender
except BadSignature:
assert not (27 <= transaction.v <= 34)
else:
# check RLP correctness
try:
transaction = rlp.decode(fixture['rlp'], sedes=TransactionClass)
# fixture normalization changes the fixture key from rlp to rlpHex
except KeyError:
assert fixture['rlpHex']
return
# rlp is a list of bytes when it shouldn't be
except TypeError as err:
assert err.args == ("'bytes' object cannot be interpreted as an integer",)
return
# rlp is invalid or not in the correct form
except (rlp.exceptions.ObjectDeserializationError, rlp.exceptions.DecodingError):
return
# check parameter correctness
try:
transaction.validate()
except ValidationError:
return
def test_transaction_fixtures(fixture):
header = BlockHeader(1, fixture['blocknumber'], 100)
chain = MainnetChain(ChainDB(get_db_backend()), header=header)
vm = chain.get_vm()
TransactionClass = vm.get_transaction_class()
if 'sender' in fixture:
transaction = rlp.decode(fixture['rlp'], sedes=TransactionClass)
expected = normalize_signed_transaction(fixture['transaction'])
assert transaction.nonce == expected['nonce']
assert transaction.gas_price == expected['gasPrice']
assert transaction.gas == expected['gasLimit']
assert transaction.to == expected['to']
assert transaction.value == expected['value']
assert transaction.data == expected['data']
assert transaction.v == expected['v']
assert transaction.r == expected['r']
assert transaction.s == expected['s']
sender = to_canonical_address(fixture['sender'])
try:
assert transaction.sender == sender
except BadSignature:
assert not (27 <= transaction.v <= 34)
else:
# check RLP correctness
try:
transaction = rlp.decode(fixture['rlp'], sedes=TransactionClass)
# fixture normalization changes the fixture key from rlp to rlpHex
except KeyError:
assert fixture['rlpHex']
return
# rlp is a list of bytes when it shouldn't be
except TypeError as err:
assert err.args == ("'bytes' object cannot be interpreted as an integer",)
return
# rlp is invalid or not in the correct form
except (rlp.exceptions.ObjectDeserializationError, rlp.exceptions.DecodingError):
return
# check parameter correctness
try:
transaction.validate()
except ValidationError:
return
def new_chain_from_fixture(fixture):
db = BaseChainDB(get_db_backend())
vm_config = chain_vm_configuration(fixture)
ChainFromFixture = MainnetChain.configure(
'ChainFromFixture',
vm_configuration=vm_config,
)
return ChainFromFixture.from_genesis(
db,
genesis_params=genesis_params_from_fixture(fixture),
genesis_state=fixture['pre'],
)
def new_chain_from_fixture(fixture):
base_db = MemoryDB()
vm_config = chain_vm_configuration(fixture)
ChainFromFixture = MainnetChain.configure(
'ChainFromFixture',
vm_configuration=vm_config,
)
return ChainFromFixture.from_genesis(
base_db,
genesis_params=genesis_params_from_fixture(fixture),
genesis_state=fixture['pre'],
)
def new_chain_from_fixture(fixture):
db = ChainDB(get_db_backend())
vm_config = chain_vm_configuration(fixture)
ChainFromFixture = MainnetChain.configure(
'ChainFromFixture',
vm_configuration=vm_config,
)
return ChainFromFixture.from_genesis(
db,
genesis_params=genesis_params_from_fixture(fixture),
genesis_state=fixture['pre'],
)
def test_blockchain_fixtures(fixture, chain_vm_configuration):
genesis_params = {
'parent_hash': fixture['genesisBlockHeader']['parentHash'],
'uncles_hash': fixture['genesisBlockHeader']['uncleHash'],
'coinbase': fixture['genesisBlockHeader']['coinbase'],
'state_root': fixture['genesisBlockHeader']['stateRoot'],
'transaction_root': fixture['genesisBlockHeader']['transactionsTrie'],
'receipt_root': fixture['genesisBlockHeader']['receiptTrie'],
'bloom': fixture['genesisBlockHeader']['bloom'],
'difficulty': fixture['genesisBlockHeader']['difficulty'],
'block_number': fixture['genesisBlockHeader']['number'],
'gas_limit': fixture['genesisBlockHeader']['gasLimit'],
'gas_used': fixture['genesisBlockHeader']['gasUsed'],
'timestamp': fixture['genesisBlockHeader']['timestamp'],
'extra_data': fixture['genesisBlockHeader']['extraData'],
'mix_hash': fixture['genesisBlockHeader']['mixHash'],
'nonce': fixture['genesisBlockHeader']['nonce'],
}
expected_genesis_header = BlockHeader(**genesis_params)
# TODO: find out if this is supposed to pass?
# if 'genesisRLP' in fixture:
# assert rlp.encode(genesis_header) == fixture['genesisRLP']
db = BaseChainDB(get_db_backend())
ChainForTesting = MainnetChain.configure(
'ChainForTesting',
vm_configuration=chain_vm_configuration,
)
chain = ChainForTesting.from_genesis(
db,
genesis_params=genesis_params,
genesis_state=fixture['pre'],
)
genesis_block = chain.get_canonical_block_by_number(0)
genesis_header = genesis_block.header
assert_rlp_equal(genesis_header, expected_genesis_header)
# 1 - mine the genesis block
# 2 - loop over blocks:
# - apply transactions
# - mine block
# 4 - profit!!
for block_data in fixture['blocks']:
should_be_good_block = 'blockHeader' in block_data
if 'rlp_error' in block_data:
assert not should_be_good_block
continue
# The block to import may be in a different block-class-range than the
# chain's current one, so we use the block number specified in the
# fixture to look up the correct block class.
if should_be_good_block:
block_number = block_data['blockHeader']['number']
block_class = chain.get_vm_class_for_block_number(
block_number).get_block_class()
else:
block_class = chain.get_vm().get_block_class()
try:
block = rlp.decode(block_data['rlp'],
sedes=block_class,
chaindb=chain.chaindb)
except (TypeError, rlp.DecodingError, rlp.DeserializationError) as err:
assert not should_be_good_block, "Block should be good: {0}".format(
err)
continue
try:
mined_block = chain.import_block(block)
except ValidationError as err:
assert not should_be_good_block, "Block should be good: {0}".format(
err)
continue
else:
assert_rlp_equal(mined_block, block)
assert should_be_good_block, "Block should have caused a validation error"
latest_block_hash = chain.get_canonical_block_by_number(
chain.get_block().number - 1).hash
assert latest_block_hash == fixture['lastblockhash']
with chain.get_vm().state_db(read_only=True) as state_db:
verify_state_db(fixture['postState'], state_db)