Add State to tester & add change_head to Chain

Author: karlfloersch

ethereum/tests/test_tester.py

@@ -34,7 +34,7 @@ def test_abicontract_interface():
     abi_json = json.dumps(simple_data['abi']).encode('utf-8')
 
     abi = ABIContract(
-        _chain=tester_state,
+        _tester=tester_state,
         _abi=abi_json,
         address=simple_address,
     )

ethereum/tools/tester.py

@@ -1,6 +1,6 @@
 from ethereum.utils import sha3, privtoaddr, int_to_addr, to_string, big_endian_to_int, checksum_encode, int_to_big_endian, encode_hex
 from ethereum.genesis_helpers import mk_basic_state
-from ethereum.pow import chain
+from ethereum.pow import chain as pow_chain
 from ethereum.transactions import Transaction
 from ethereum.consensus_strategy import get_consensus_strategy
 from ethereum.config import config_homestead, config_tangerine, config_spurious, config_metropolis, default_config, Env
@@ -63,9 +63,10 @@ class TransactionFailed(Exception):
 config_string = ':info'
 # configure_logging(config_string=config_string)
 
+
 class ABIContract(object):  # pylint: disable=too-few-public-methods
 
-    def __init__(self, _chain, _abi, address):
+    def __init__(self, _tester, _abi, address):
         self.address = address
 
         if isinstance(_abi, ContractTranslator):
@@ -76,25 +77,29 @@ def __init__(self, _chain, _abi, address):
         self.translator = abi_translator
 
         for function_name in self.translator.function_data:
-            function = self.method_factory(_chain, function_name)
+            if self.translator.function_data[function_name]['is_constant']:
+                function = self.method_factory(_tester.call, function_name)
+            else:
+                function = self.method_factory(_tester.tx, function_name)
             method = types.MethodType(function, self)
             setattr(self, function_name, method)
 
     @staticmethod
-    def method_factory(test_chain, function_name):
+    def method_factory(tx_or_call, function_name):
         """ Return a proxy for calling a contract method with automatic encoding of
         argument and decoding of results.
         """
 
         def kall(self, *args, **kwargs):
             key = kwargs.get('sender', k0)
 
-            result = test_chain.tx(  # pylint: disable=protected-access
+            result = tx_or_call(  # pylint: disable=protected-access
                 sender=key,
                 to=self.address,
                 value=kwargs.get('value', 0),
                 data=self.translator.encode(function_name, args),
-                startgas=kwargs.get('startgas', STARTGAS)
+                startgas=kwargs.get('startgas', STARTGAS),
+                gasprice=kwargs.get('gasprice', GASPRICE)
             )
 
             if result is False:
@@ -117,14 +122,36 @@ def get_env(env):
     return env if isinstance(env, Env) else Env(config=d[env])
 
 
+class State(object):
+    def __init__(self, genesis):
+        self.state = genesis
+
+    def tx(self, sender=k0, to=b'\x00' * 20, value=0, data=b'', startgas=STARTGAS, gasprice=GASPRICE):
+        sender_addr = privtoaddr(sender)
+        transaction = Transaction(self.state.get_nonce(sender_addr), gasprice, startgas,
+                                  to, value, data).sign(sender)
+        success, output = apply_transaction(self.state, transaction)
+        if not success:
+            raise TransactionFailed()
+        return output
+
+    def call(self, sender=k0, to=b'\x00' * 20, value=0, data=b'', startgas=STARTGAS, gasprice=GASPRICE):
+        state = self.state
+        self.state = self.state.ephemeral_clone()
+        try:
+            output = self.tx(sender, to, value, data, startgas, gasprice)
+            self.state = state
+            return output
+        except Exception as e:
+            self.state = state
+            raise e
+
 class Chain(object):
-    def __init__(self, alloc=None, env=None):
-        self.chain = chain.Chain(
-            genesis=mk_basic_state(base_alloc if alloc is None else alloc,
-                                   None,
-                                   get_env(env)),
-            reset_genesis=True
-        )
+    def __init__(self, alloc=base_alloc, env=None, genesis=None):
+        if genesis:
+            self.chain = pow_chain.Chain(genesis, reset_genesis=True)
+        else:
+            self.chain = pow_chain.Chain(mk_basic_state(alloc, None, get_env(env)), reset_genesis=True)
         self.cs = get_consensus_strategy(self.chain.env.config)
         self.block = mk_block_from_prevstate(self.chain, timestamp=self.chain.state.timestamp + 1)
         self.head_state = self.chain.state.ephemeral_clone()
@@ -144,9 +171,19 @@ def tx(self, sender=k0, to=b'\x00' * 20, value=0, data=b'', startgas=STARTGAS, g
         sender_addr = privtoaddr(sender)
         transaction = Transaction(self.head_state.get_nonce(sender_addr), gasprice, startgas,
                                   to, value, data).sign(sender)
-        o = self.direct_tx(transaction)
+        output = self.direct_tx(transaction)
         self.last_sender = sender
-        return o
+        return output
+
+    def call(self, sender=k0, to=b'\x00' * 20, value=0, data=b'', startgas=STARTGAS, gasprice=GASPRICE):
+        snapshot = self.snapshot()
+        try:
+            output = self.tx(sender, to, value, data, startgas, gasprice)
+            self.revert(snapshot)
+            return output
+        except Exception as e:
+            self.revert(snapshot)
+            raise e
 
     def contract(self, sourcecode, args=[], sender=k0, value=0, language='evm', startgas=STARTGAS, gasprice=GASPRICE):
         if language == 'evm':
@@ -165,13 +202,17 @@ def mine(self, number_of_blocks=1, coinbase=a0):
         set_execution_results(self.head_state, self.block)
         self.block = Miner(self.block).mine(rounds=100, start_nonce=0)
         assert self.chain.add_block(self.block)
-        assert self.head_state.trie.root_hash == self.chain.state.trie.root_hash
+        b = self.block
         for i in range(1, number_of_blocks):
-            b, _ = make_head_candidate(self.chain, timestamp=self.chain.state.timestamp + 14)
+            b, _ = make_head_candidate(self.chain, parent=b, timestamp=self.chain.state.timestamp + 14, coinbase=coinbase)
             b = Miner(b).mine(rounds=100, start_nonce=0)
             assert self.chain.add_block(b)
-        self.block = mk_block_from_prevstate(self.chain, timestamp=self.chain.state.timestamp + 14)
-        self.head_state = self.chain.state.ephemeral_clone()
+        self.change_head(b.header.hash, coinbase)
+        return b
+
+    def change_head(self, parent, coinbase=a0):
+        self.head_state = self.chain.mk_poststate_of_blockhash(parent).ephemeral_clone()
+        self.block = mk_block_from_prevstate(self.chain, self.head_state, timestamp=self.chain.state.timestamp, coinbase=coinbase)
         self.cs.initialize(self.head_state, self.block)
 
     def snapshot(self):
@@ -190,7 +231,7 @@ def int_to_0x_hex(v):
         return '0x' + o[1:]
     else:
         return '0x' + o
-    
+
 
 def mk_state_test_prefill(c):
     env = {