Improvements to testing modules

Author: vub

ethereum/new_statetest_utils.py

@@ -7,11 +7,12 @@
 import ethereum.transactions as transactions
 import ethereum.state_transition as state_transition
 import copy
+import json
 
 from ethereum.slogging import LogRecorder, configure_logging, set_level
 config_string = ':info,eth.vm.log:trace,eth.vm.op:trace,eth.vm.stack:trace,eth.vm.exit:trace,eth.pb.msg:trace,eth.pb.tx:debug'
 
-configure_logging(config_string=config_string)
+# configure_logging(config_string=config_string)
 
 fake_headers = {}
 
@@ -57,11 +58,37 @@ def mk_fake_header(blknum):
 
 configs = {
     #"Homestead": konfig_homestead,
-    "EIP150": konfig_tangerine,
+    #"EIP150": konfig_tangerine,
     "EIP158": konfig_spurious,
     "Metropolis": konfig_metropolis
 }
 
+def mk_state_diff(prev, post):
+    o = {}
+    for k in prev.keys():
+        if k not in post:
+            o[k] = ["-", prev[k]]
+    for k in post.keys():
+        if k not in prev:
+            o[k] = ["+", post[k]]
+        elif prev[k] != post[k]:
+            ok = {}
+            for key in ('nonce', 'balance', 'code'):
+                if prev[k][key] != post[k][key]:
+                    ok[key] = [prev[k][key], "->", post[k][key]]
+            if prev[k]["storage"] != post[k]["storage"]:
+                ok["storage"] = {}
+                for sk in prev[k]["storage"].keys():
+                    if sk not in post[k]["storage"]:
+                        ok["storage"][sk] = ["-", prev[k]["storage"][sk]]
+                for sk in post[k]["storage"].keys():
+                    if sk not in prev[k]["storage"]:
+                        ok["storage"][sk] = ["+", post[k]["storage"][sk]]
+                    else:
+                        ok["storage"][sk] = [prev[k]["storage"][sk], "->", post[k]["storage"][sk]]
+            o[k] = ok
+    return o
+
 def compute_state_test_unit(state, txdata, indices, konfig):
     state.env.config = konfig
     s = state.snapshot()
@@ -71,20 +98,24 @@ def compute_state_test_unit(state, txdata, indices, konfig):
             nonce=parse_int_or_hex(txdata['nonce'] or b"0"),
             gasprice=parse_int_or_hex(txdata['gasPrice'] or b"0"),
             startgas=parse_int_or_hex(txdata['gasLimit'][indices["gas"]] or b"0"),
-            to=decode_hex(txdata['to']),
+            to=decode_hex(remove_0x_head(txdata['to'])),
             value=parse_int_or_hex(txdata['value'][indices["value"]] or b"0"),
             data=decode_hex(remove_0x_head(txdata['data'][indices["data"]])))
-        tx.sign(decode_hex(txdata['secretKey']))
+        tx.sign(decode_hex(remove_0x_head(txdata['secretKey'])))
         # Run it
+        prev = state.to_dict()
         success, output = state_transition.apply_transaction(state, tx)
+        post = state.to_dict()
         print("Applied tx")
     except InvalidTransaction as e:
         print("Exception: %r" % e)
+        post = state.to_dict()
         success, output = False, b''
     state.commit()
     output_decl = {
-        "hash": encode_hex(state.trie.root_hash),
-        "indexes": indices
+        "hash": '0x' + encode_hex(state.trie.root_hash),
+        "indexes": indices,
+        "diff": mk_state_diff(prev, post)
     }
     state.revert(s)
     return output_decl
@@ -94,23 +125,23 @@ def init_state(env, pre):
     # Setup env
     state = State(
         env=Env(config=konfig),
-        block_prevhash=decode_hex(env['previousHash']),
+        block_prevhash=decode_hex(remove_0x_head(env['previousHash'])),
         prev_headers=[mk_fake_header(i) for i in range(parse_int_or_hex(env['currentNumber']) -1,
                                                        max(-1, parse_int_or_hex(env['currentNumber']) -257), -1)],
         block_number=parse_int_or_hex(env['currentNumber']),
-        block_coinbase=decode_hex(env['currentCoinbase']),
+        block_coinbase=decode_hex(remove_0x_head(env['currentCoinbase'])),
         block_difficulty=parse_int_or_hex(env['currentDifficulty']),
         gas_limit=parse_int_or_hex(env['currentGasLimit']),
         timestamp=parse_int_or_hex(env['currentTimestamp']))
 
     # Fill up pre
     for address, h in list(pre.items()):
-        assert len(address) == 40
-        address = decode_hex(address)
+        assert len(address) in (40, 42)
+        address = decode_hex(remove_0x_head(address))
         assert set(h.keys()) == set(['code', 'nonce', 'balance', 'storage'])
         state.set_nonce(address, parse_int_or_hex(h['nonce']))
         state.set_balance(address, parse_int_or_hex(h['balance']))
-        state.set_code(address, decode_hex(h['code'][2:]))
+        state.set_code(address, decode_hex(remove_0x_head(h['code'])))
         for k, v in h['storage'].items():
             state.set_storage_data(address,
                                    big_endian_to_int(decode_hex(k[2:])),
@@ -128,12 +159,17 @@ def verify_state_test(test):
             continue
         print("Testing for %s" % config_name)
         for result in results:
+            data = test["transaction"]['data'][result["indexes"]["data"]]
+            if len(data) > 2000:
+                data = "data<%d>" % (len(data) // 2 - 1)
             print("Checking for values: g %d v %d d %s" % (
                   parse_int_or_hex(test["transaction"]['gasLimit'][result["indexes"]["gas"]]),
                   parse_int_or_hex(test["transaction"]['value'][result["indexes"]["value"]]),
-                  test["transaction"]['data'][result["indexes"]["data"]]))
+                  data))
             computed = compute_state_test_unit(_state, test["transaction"], result["indexes"], configs[config_name])
             if computed["hash"] != result["hash"]:
+                for k in computed["diff"]:
+                    print(k, computed["diff"][k])
                 raise Exception("Hash mismatch, computed: %s, supplied: %s" % (computed["hash"], result["hash"]))
             else:
                 print("Hash matched!: %s" % computed["hash"])

ethereum/processblock.py

@@ -8,7 +8,7 @@
 from ethereum import bloom
 from ethereum import vm as vm
 from ethereum.utils import safe_ord, normalize_address, mk_contract_address, \
-    mk_metropolis_contract_address, int_to_addr, big_endian_to_int, encode_hex
+    mk_metropolis_contract_address, int_to_addr, big_endian_to_int, encode_hex, sha3
 from ethereum.exceptions import InvalidNonce, InsufficientStartGas, UnsignedTransaction, \
         BlockGasLimitReached, InsufficientBalance
 from ethereum import transactions
@@ -121,7 +121,10 @@ def create_contract(ext, msg):
     if ext.tx_origin != msg.sender:
         ext.increment_nonce(msg.sender)
     nonce = utils.encode_int(ext.get_nonce(msg.sender) - 1)
-    msg.to = mk_contract_address(sender, nonce)
+    if ext.post_metropolis_hardfork() and msg.sender == ext.tx_origin and False:
+        msg.to = sha3(msg.sender + code)[12:]
+    else:
+        msg.to = mk_contract_address(sender, nonce)
     b = ext.get_balance(msg.to)
     if b > 0:
         ext.set_balance(msg.to, b)
@@ -132,6 +135,8 @@ def create_contract(ext, msg):
     # assert not ext.get_code(msg.to)
     msg.data = vm.CallData([], 0, 0)
     snapshot = ext.snapshot()
+    # if len(ext.get_code(msg.to)):
+    #     return 0, 0, b''
     ext.set_nonce(msg.to, 1 if ext.post_clearing_hardfork() else 0)
     res, gas, dat = _apply_msg(ext, msg, code)
     assert utils.is_numeric(gas)
@@ -145,7 +150,7 @@ def create_contract(ext, msg):
             gas -= gcost
         else:
             dat = []
-            log_msg.debug('CONTRACT CREATION OOG', have=gas, want=gcost, block_number=ext.block_number)
+            log_msg.debug('CONTRACT CREATION FAILED', have=gas, want=gcost, block_number=ext.block_number)
             if ext.post_homestead_hardfork():
                 ext.revert(snapshot)
                 return 0, 0, b''

ethereum/state.py

@@ -353,7 +353,7 @@ def to_dict(self):
                     state_dump[encode_hex(address)][c] = snapshot_form(getattr(blanky, c))
             acct_dump = state_dump[encode_hex(address)]
             for key, val in v.items():
-                if key in ACCOUNT_SPECIAL_PARAMS:
+                if key in ACCOUNT_SPECIAL_PARAMS and key != 'storage':
                     acct_dump[key] = snapshot_form(val)
                 else:
                     if val:

ethereum/state_transition.py

@@ -237,7 +237,10 @@ def rp(what, actual, target):
             if tx.startgas < intrinsic_gas:
                 raise InsufficientStartGas(rp('startgas', tx.startgas, intrinsic_gas))
 
-    log_tx.debug('TX NEW', tx_dict=tx.to_dict())
+    txdict = tx.to_dict()
+    if len(txdict["data"]) > 2000:
+        txdict["data"] = "data<%d>" % (len(txdict["data"]) // 2 - 1)
+    log_tx.debug('TX NEW', tx_dict=txdict)
     # start transacting #################
     state.increment_nonce(tx.sender)
 

ethereum/transactions.py

@@ -138,7 +138,7 @@ def intrinsic_gas_used(self):
         num_zero_bytes = str_to_bytes(self.data).count(ascii_chr(0))
         num_non_zero_bytes = len(self.data) - num_zero_bytes
         return (opcodes.GTXCOST
-                + (0 if self.to else opcodes.CREATE[3])
+        #         + (0 if self.to else opcodes.CREATE[3])
                 + opcodes.GTXDATAZERO * num_zero_bytes
                 + opcodes.GTXDATANONZERO * num_non_zero_bytes)
 

ethereum/vm.py

@@ -15,6 +15,7 @@
 from ethereum.utils import to_string, encode_int, zpad
 
 log_log = get_logger('eth.vm.log')
+log_msg = get_logger('eth.pb.msg')
 log_vm_exit = get_logger('eth.vm.exit')
 log_vm_op = get_logger('eth.vm.op')
 log_vm_op_stack = get_logger('eth.vm.op.stack')
@@ -250,6 +251,7 @@ def vm_execute(ext, msg, code):
                 trace_data['depth'] = msg.depth
                 trace_data['address'] = msg.to
             trace_data['steps'] = steps
+            trace_data['depth'] = msg.depth
             if op[:4] == 'PUSH':
                 trace_data['pushvalue'] = pushval
             log_vm_op.trace('vm', op=op, **trace_data)
@@ -712,6 +714,7 @@ def vm_execute(ext, msg, code):
             ext.set_balance(to, ext.get_balance(to) + xfer)
             ext.set_balance(msg.to, 0)
             ext.add_suicide(msg.to)
+            log_msg.debug('SUICIDING', addr=utils.checksum_encode(msg.to), to=utils.checksum_encode(to), xferring=xfer)
             return 1, compustate.gas, []
 
         # assert utils.is_numeric(compustate.gas)