Merge branch 'develop' of github.com:ethereum/pyethereum into develop

Author: vbuterin

ethereum/slogging.py

@@ -312,12 +312,16 @@ def configure(config_string=None, log_json=False, log_file=None):
         if hasattr(logger, 'setLevel'):
             # Guard against `logging.PlaceHolder` instances
             logger.setLevel(logging.NOTSET)
-            logger.propagate = True
+            if config_string == ":{}".format(DEFAULT_LOGLEVEL):
+                logger.propagate = True
+            else:
+                logger.propagate = False
 
     for name_levels in config_string.split(','):
         name, _, level = name_levels.partition(':')
         logger = getLogger(name)
         logger.setLevel(level.upper())
+        logger.propagate = True
 
 configure_logging = configure
 

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,11 +1,11 @@
 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
 from ethereum.pow.ethpow import Miner
-from ethereum.messages import apply_transaction
+from ethereum.messages import apply_transaction, apply_message
 from ethereum.common import verify_execution_results, mk_block_from_prevstate, set_execution_results
 from ethereum.meta import make_head_candidate
 from ethereum.abi import ContractTranslator
@@ -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,32 @@ 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):
+        sender_addr = privtoaddr(sender)
+        result = apply_message(self.state.ephemeral_clone(), sender=sender_addr, to=to, value=value, data=data, gas=startgas)
+        if result is None:
+            raise TransactionFailed()
+        return result
+
 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 +167,16 @@ 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):
+        sender_addr = privtoaddr(sender)
+        result = apply_message(self.head_state.ephemeral_clone(), sender=sender_addr, to=to, value=value, data=data, gas=startgas)
+        if result is None:
+            raise TransactionFailed()
+        return result
 
     def last_gas_used(self, with_tx=False):
         if len(self.head_state.receipts) == 1:
@@ -174,13 +204,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):
@@ -199,7 +233,7 @@ def int_to_0x_hex(v):
         return '0x' + o[1:]
     else:
         return '0x' + o
-    
+
 
 def mk_state_test_prefill(c):
     env = {

ethereum/transactions.py

@@ -155,6 +155,9 @@ def creates(self):
     def __eq__(self, other):
         return isinstance(other, self.__class__) and self.hash == other.hash
 
+    def __lt__(self, other):
+        return isinstance(other, self.__class__) and self.hash < other.hash
+
     def __hash__(self):
         return utils.big_endian_to_int(self.hash)
 

requirements.txt

@@ -6,3 +6,4 @@ scrypt
 py_ecc
 rlp>=0.4.7
 https://github.com/ethereum/ethash/tarball/master
+pycryptodome==3.4.6