def fill_vm_test(filler,
*,
call_creates=None,
gas_price=None,
gas_remaining=0,
logs=None,
output=b""):
test_name = get_test_name(filler)
test = filler[test_name]
environment = normalize_environment(test["env"])
pre_state = normalize_state(test["pre"])
execution = normalize_execution(test["exec"])
assert len(test["expect"]) == 1
expect = test["expect"][0]
assert "network" not in test
assert "indexes" not in test
result = normalize_state(expect["result"])
post_state = deep_merge(pre_state, result)
call_creates = normalize_call_creates(call_creates or [])
gas_remaining = normalize_int(gas_remaining)
output = normalize_bytes(output)
logs = normalize_logs(logs or [])
log_hash = hash_log_entries(logs)
return {
test_name: {
"env": environment,
"pre": pre_state,
"exec": execution,
"post": post_state,
"callcreates": call_creates,
"gas": gas_remaining,
"output": output,
"logs": log_hash,
}
}
def test_state_fixtures(fixture, fixture_vm_class):
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
parent_hash=fixture['env']['previousHash'],
)
chaindb = ChainDB(get_db_backend())
vm = fixture_vm_class(header=header, chaindb=chaindb)
vm_state = vm.state
with vm_state.mutable_state_db() as state_db:
setup_state_db(fixture['pre'], state_db)
# Update state_root manually
vm.block.header.state_root = vm_state.state_root
if 'secretKey' in fixture['transaction']:
unsigned_transaction = vm.create_unsigned_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
)
private_key = keys.PrivateKey(fixture['transaction']['secretKey'])
transaction = unsigned_transaction.as_signed_transaction(
private_key=private_key)
elif 'vrs' in fixture['transaction']:
v, r, s = (
fixture['transaction']['v'],
fixture['transaction']['r'],
fixture['transaction']['s'],
)
transaction = vm.create_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
v=v,
r=r,
s=s,
)
try:
computation, _ = vm.apply_transaction(transaction)
except ValidationError as err:
transaction_error = err
LOGGER.warn("Got transaction error:")
LOGGER.warn(traceback.format_exc())
else:
transaction_error = False
if not transaction_error:
log_entries = computation.get_log_entries()
actual_logs_hash = hash_log_entries(log_entries)
if 'logs' in fixture['post']:
expected_logs_hash = fixture['post']['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log {0} entries. hash:{1}".format(
len(log_entries),
actual_logs_hash,
))
if 'out' in fixture:
expected_output = fixture['out']
if isinstance(expected_output, int):
assert len(computation.output) == expected_output
else:
assert computation.output == expected_output
assert vm.block.header.state_root == fixture['post']['hash']
def test_vm_fixtures(fixture, vm_class, computation_getter):
chaindb = ChainDB(get_db_backend())
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
)
vm = vm_class(header=header, chaindb=chaindb)
vm_state = vm.state
with vm_state.state_db() as state_db:
setup_state_db(fixture['pre'], state_db)
code = state_db.get_code(fixture['exec']['address'])
# Update state_root manually
vm.block.header.state_root = vm_state.state_root
computation = computation_getter(fixture, code, vm)
# Update state_root manually
vm.block.header.state_root = computation.vm_state.state_root
if 'post' in fixture:
#
# Success checks
#
assert not computation.is_error
log_entries = computation.get_log_entries()
if 'logs' in fixture:
actual_logs_hash = hash_log_entries(log_entries)
expected_logs_hash = fixture['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log entries: {0}".format(log_entries))
expected_output = fixture['out']
assert computation.output == expected_output
gas_meter = computation.gas_meter
expected_gas_remaining = fixture['gas']
actual_gas_remaining = gas_meter.gas_remaining
gas_delta = actual_gas_remaining - expected_gas_remaining
assert gas_delta == 0, "Gas difference: {0}".format(gas_delta)
call_creates = fixture.get('callcreates', [])
assert len(computation.children) == len(call_creates)
call_creates = fixture.get('callcreates', [])
for child_computation, created_call in zip(computation.children,
call_creates):
to_address = created_call['destination']
data = created_call['data']
gas_limit = created_call['gasLimit']
value = created_call['value']
assert child_computation.msg.to == to_address
assert data == child_computation.msg.data or child_computation.msg.code
assert gas_limit == child_computation.msg.gas
assert value == child_computation.msg.value
post_state = fixture['post']
else:
#
# Error checks
#
assert computation.is_error
assert isinstance(computation._error, VMError)
post_state = fixture['pre']
with vm.state.state_db(read_only=True) as state_db:
verify_state_db(post_state, state_db)
def test_state_fixtures(fixture, fixture_vm_class):
if fixture_vm_class is not ShardingVMForTesting:
account_state_class = MainAccountStateDB
trie_class = HexaryTrie
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
parent_hash=fixture['env']['previousHash'],
)
else:
account_state_class = ShardingAccountStateDB
trie_class = BinaryTrie
header = CollationHeader(
shard_id=fixture['env']['shardID'],
expected_period_number=fixture['env']['expectedPeriodNumber'],
period_start_prevhash=fixture['env']['periodStartHash'],
parent_hash=fixture['env']['previousHash'],
coinbase=fixture['env']['currentCoinbase'],
number=fixture['env']['currentNumber'],
)
chaindb = ChainDB(get_db_backend(),
account_state_class=account_state_class,
trie_class=trie_class)
vm = fixture_vm_class(header=header, chaindb=chaindb)
vm_state = vm.state
with vm_state.mutable_state_db() as state_db:
state_db.apply_state_dict(fixture['pre'])
# Update state_root manually
vm.block.header.state_root = vm_state.state_root
if 'secretKey' in fixture['transaction']:
unsigned_transaction = vm.create_unsigned_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
)
private_key = keys.PrivateKey(fixture['transaction']['secretKey'])
transaction = unsigned_transaction.as_signed_transaction(
private_key=private_key)
elif 'vrs' in fixture['transaction']:
v, r, s = (
fixture['transaction']['v'],
fixture['transaction']['r'],
fixture['transaction']['s'],
)
transaction = vm.create_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
v=v,
r=r,
s=s,
)
else:
# sharding transaction
transaction = vm.create_transaction(
chain_id=fixture['transaction']['chainID'],
shard_id=fixture['transaction']['shardID'],
to=fixture['transaction']['to'],
data=fixture['transaction']['data'],
gas=fixture['transaction']['gasLimit'],
gas_price=fixture['transaction']['gasPrice'],
access_list=fixture['transaction']['accessList'],
code=fixture['transaction']['code'],
)
try:
computation, _ = vm.apply_transaction(transaction)
except ValidationError as err:
transaction_error = err
LOGGER.warn("Got transaction error", exc_info=True)
else:
transaction_error = False
if not transaction_error:
log_entries = computation.get_log_entries()
actual_logs_hash = hash_log_entries(log_entries)
if 'logs' in fixture['post']:
expected_logs_hash = fixture['post']['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log {0} entries. hash:{1}".format(
len(log_entries),
actual_logs_hash,
))
if 'out' in fixture:
expected_output = fixture['out']
if isinstance(expected_output, int):
assert len(computation.output) == expected_output
else:
assert computation.output == expected_output
assert vm.block.header.state_root == fixture['post']['hash']
def test_state_fixtures(fixture, fixture_vm_class):
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
parent_hash=fixture['env']['previousHash'],
)
chaindb = ChainDB(get_db_backend())
vm = fixture_vm_class(header=header, chaindb=chaindb)
state = vm.state
apply_state_dict(state.account_db, fixture['pre'])
state.account_db.persist()
# Update state_root manually
vm.block = vm.block.copy(header=vm.block.header.copy(state_root=state.state_root))
if 'secretKey' in fixture['transaction']:
unsigned_transaction = vm.create_unsigned_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
)
private_key = keys.PrivateKey(fixture['transaction']['secretKey'])
transaction = unsigned_transaction.as_signed_transaction(private_key=private_key)
elif 'vrs' in fixture['transaction']:
v, r, s = (
fixture['transaction']['v'],
fixture['transaction']['r'],
fixture['transaction']['s'],
)
transaction = vm.create_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
v=v,
r=r,
s=s,
)
try:
header, receipt, computation = vm.apply_transaction(vm.block.header, transaction)
transactions = vm.block.transactions + (transaction, )
receipts = vm.block.get_receipts(chaindb) + (receipt, )
block = vm.set_block_transactions(vm.block, header, transactions, receipts)
except ValidationError as err:
block = vm.block
transaction_error = err
LOGGER.warn("Got transaction error", exc_info=True)
else:
transaction_error = False
if not transaction_error:
log_entries = computation.get_log_entries()
actual_logs_hash = hash_log_entries(log_entries)
if 'logs' in fixture['post']:
expected_logs_hash = fixture['post']['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log {0} entries. hash:{1}".format(
len(log_entries),
actual_logs_hash,
))
if 'out' in fixture:
expected_output = fixture['out']
if isinstance(expected_output, int):
assert len(computation.output) == expected_output
else:
assert computation.output == expected_output
assert block.header.state_root == fixture['post']['hash']
def test_vm_fixtures(fixture, vm_class, computation_getter):
chaindb = ChainDB(get_db_backend())
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
)
vm = vm_class(header=header, chaindb=chaindb)
state = vm.state
setup_account_db(fixture['pre'], state.account_db)
code = state.account_db.get_code(fixture['exec']['address'])
# Update state_root manually
vm.block = vm.block.copy(header=vm.block.header.copy(
state_root=state.state_root))
message = Message(
to=fixture['exec']['address'],
sender=fixture['exec']['caller'],
value=fixture['exec']['value'],
data=fixture['exec']['data'],
code=code,
gas=fixture['exec']['gas'],
)
transaction_context = BaseTransactionContext(
origin=fixture['exec']['origin'],
gas_price=fixture['exec']['gasPrice'],
)
computation = vm.state.get_computation(
message, transaction_context).apply_computation(
vm.state,
message,
transaction_context,
)
# Update state_root manually
vm.block = vm.block.copy(
header=vm.block.header.copy(state_root=computation.state.state_root), )
if 'post' in fixture:
#
# Success checks
#
assert not computation.is_error
log_entries = computation.get_log_entries()
if 'logs' in fixture:
actual_logs_hash = hash_log_entries(log_entries)
expected_logs_hash = fixture['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log entries: {0}".format(log_entries))
expected_output = fixture['out']
assert computation.output == expected_output
gas_meter = computation._gas_meter
expected_gas_remaining = fixture['gas']
actual_gas_remaining = gas_meter.gas_remaining
gas_delta = actual_gas_remaining - expected_gas_remaining
assert gas_delta == 0, "Gas difference: {0}".format(gas_delta)
call_creates = fixture.get('callcreates', [])
assert len(computation.children) == len(call_creates)
call_creates = fixture.get('callcreates', [])
for child_computation, created_call in zip(computation.children,
call_creates):
to_address = created_call['destination']
data = created_call['data']
gas_limit = created_call['gasLimit']
value = created_call['value']
assert child_computation.msg.to == to_address
assert data == child_computation.msg.data or child_computation.msg.code
assert gas_limit == child_computation.msg.gas
assert value == child_computation.msg.value
expected_account_db = fixture['post']
else:
#
# Error checks
#
assert computation.is_error
assert isinstance(computation._error, VMError)
expected_account_db = fixture['pre']
verify_account_db(expected_account_db, vm.state.account_db)
def test_state_fixtures(fixture, fixture_vm_class):
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
parent_hash=fixture['env']['previousHash'],
)
chaindb = ChainDB(get_db_backend())
vm = fixture_vm_class(header=header, chaindb=chaindb)
vm_state = vm.state
with vm_state.state_db() as state_db:
setup_state_db(fixture['pre'], state_db)
# Update state_root manually
vm.block.header.state_root = vm_state.state_root
if 'secretKey' in fixture['transaction']:
unsigned_transaction = vm.create_unsigned_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
)
private_key = keys.PrivateKey(fixture['transaction']['secretKey'])
transaction = unsigned_transaction.as_signed_transaction(private_key=private_key)
elif 'vrs' in fixture['transaction']:
v, r, s = (
fixture['transaction']['v'],
fixture['transaction']['r'],
fixture['transaction']['s'],
)
transaction = vm.create_transaction(
nonce=fixture['transaction']['nonce'],
gas_price=fixture['transaction']['gasPrice'],
gas=fixture['transaction']['gasLimit'],
to=fixture['transaction']['to'],
value=fixture['transaction']['value'],
data=fixture['transaction']['data'],
v=v,
r=r,
s=s,
)
try:
computation, _ = vm.apply_transaction(transaction)
except ValidationError as err:
transaction_error = err
LOGGER.warn("Got transaction error:")
LOGGER.warn(traceback.format_exc())
else:
transaction_error = False
if not transaction_error:
log_entries = computation.get_log_entries()
actual_logs_hash = hash_log_entries(log_entries)
if 'logs' in fixture['post']:
expected_logs_hash = fixture['post']['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log {0} entries. hash:{1}".format(
len(log_entries),
actual_logs_hash,
))
if 'out' in fixture:
expected_output = fixture['out']
if isinstance(expected_output, int):
assert len(computation.output) == expected_output
else:
assert computation.output == expected_output
assert vm.block.header.state_root == fixture['post']['hash']
def test_vm_fixtures(fixture, vm_class, computation_getter):
chaindb = ChainDB(get_db_backend())
header = BlockHeader(
coinbase=fixture['env']['currentCoinbase'],
difficulty=fixture['env']['currentDifficulty'],
block_number=fixture['env']['currentNumber'],
gas_limit=fixture['env']['currentGasLimit'],
timestamp=fixture['env']['currentTimestamp'],
)
vm = vm_class(header=header, chaindb=chaindb)
vm_state = vm.state
with vm_state.state_db() as state_db:
setup_state_db(fixture['pre'], state_db)
code = state_db.get_code(fixture['exec']['address'])
# Update state_root manually
vm.block.header.state_root = vm_state.state_root
computation = computation_getter(fixture, code, vm)
# Update state_root manually
vm.block.header.state_root = computation.vm_state.state_root
if 'post' in fixture:
#
# Success checks
#
assert not computation.is_error
log_entries = computation.get_log_entries()
if 'logs' in fixture:
actual_logs_hash = hash_log_entries(log_entries)
expected_logs_hash = fixture['logs']
assert expected_logs_hash == actual_logs_hash
elif log_entries:
raise AssertionError("Got log entries: {0}".format(log_entries))
expected_output = fixture['out']
assert computation.output == expected_output
gas_meter = computation.gas_meter
expected_gas_remaining = fixture['gas']
actual_gas_remaining = gas_meter.gas_remaining
gas_delta = actual_gas_remaining - expected_gas_remaining
assert gas_delta == 0, "Gas difference: {0}".format(gas_delta)
call_creates = fixture.get('callcreates', [])
assert len(computation.children) == len(call_creates)
call_creates = fixture.get('callcreates', [])
for child_computation, created_call in zip(computation.children, call_creates):
to_address = created_call['destination']
data = created_call['data']
gas_limit = created_call['gasLimit']
value = created_call['value']
assert child_computation.msg.to == to_address
assert data == child_computation.msg.data or child_computation.msg.code
assert gas_limit == child_computation.msg.gas
assert value == child_computation.msg.value
post_state = fixture['post']
else:
#
# Error checks
#
assert computation.is_error
assert isinstance(computation._error, VMError)
post_state = fixture['pre']
with vm.state.state_db(read_only=True) as state_db:
verify_state_db(post_state, state_db)