Merge remote-tracking branch 'upstream/develop' into develop

Author: Georgi87

.travis.yml

@@ -4,8 +4,8 @@ sudo: false
 env:
 - TOX_ENV=py27
 install:
-- pip install -r requirements.txt
-- pip install -r dev_requirements.txt
+- pip install -Ur requirements.txt
+- pip install -Ur dev_requirements.txt
 script:
 - coverage run --source ethereum -m py.test --ignore ethereum/tests/test_vm.py --ignore
   ethereum/tests/test_state.py

dev_requirements.txt

@@ -1,6 +1,6 @@
 tox
 coveralls
-pytest
-pytest-catchlog==1.1
-pytest-timeout==0.5
+pytest>=2.9.0
+pytest-catchlog==1.2.2
+pytest-timeout==1.0.0
 https://github.com/ethereum/serpent/tarball/develop

ethereum/abi.py

@@ -100,7 +100,7 @@ def decode(self, name, data):
     def is_unknown_type(self, name):
         return self.function_data[name]["is_unknown_type"]
 
-    def listen(self, log, noprint=False):
+    def listen(self, log, noprint=True):
         if not len(log.topics) or log.topics[0] not in self.event_data:
             return
         types = self.event_data[log.topics[0]]['types']
@@ -149,7 +149,7 @@ class ValueOutOfBounds(EncodingError):
 def decint(n):
     if isinstance(n, str):
         n = utils.to_string(n)
-    if is_numeric(n) and n < 2**256 and n > -2**255:
+    if is_numeric(n) and n < 2**256 and n >= -2**255:
         return n
     elif is_numeric(n):
         raise EncodingError("Number out of range: %r" % n)
@@ -194,13 +194,14 @@ def encode_single(typ, arg):
         high, low = [int(x) for x in sub.split('x')]
         if not 0 <= arg < 2**high:
             raise ValueOutOfBounds(repr(arg))
-        return zpad(encode_int(arg * 2**low), 32)
+        return zpad(encode_int(int(arg * 2**low)), 32)
     # Signed reals: real<high>x<low>
     elif base == 'real':
         high, low = [int(x) for x in sub.split('x')]
         if not -2**(high - 1) <= arg < 2**(high - 1):
             raise ValueOutOfBounds(repr(arg))
-        return zpad(encode_int((arg % 2**high) * 2**low), 32)
+        i = int(arg * 2**low)
+        return zpad(encode_int(i % 2**(high+low)), 32)
     # Strings
     elif base == 'string' or base == 'bytes':
         if not is_string(arg):
@@ -221,9 +222,9 @@ def encode_single(typ, arg):
             raise EncodingError("too long: %r" % arg)
         if isnumeric(arg):
             return zpad(encode_int(arg), 32)
-        elif len(arg) == len(sub):
+        elif len(arg) == int(sub):
             return zpad(arg, 32)
-        elif len(arg) == len(sub) * 2:
+        elif len(arg) == int(sub) * 2:
             return zpad(decode_hex(arg), 32)
         else:
             raise EncodingError("Could not parse hash: %r" % arg)
@@ -236,7 +237,7 @@ def encode_single(typ, arg):
             return zpad(arg, 32)
         elif len(arg) == 40:
             return zpad(decode_hex(arg), 32)
-        elif len(arg) == 42 and arg[2:] == '0x':
+        elif len(arg) == 42 and arg[:2] == '0x':
             return zpad(decode_hex(arg[2:]), 32)
         else:
             raise EncodingError("Could not parse address: %r" % arg)
@@ -255,6 +256,8 @@ def process_type(typ):
     if base == 'string' or base == 'bytes':
         assert re.match('^[0-9]*$', sub), \
             "String type must have no suffix or numerical suffix"
+        assert not sub or int(sub) <= 32, \
+            "Maximum 32 bytes for fixed-length str or bytes"
     # Check validity of integer type
     elif base == 'uint' or base == 'int':
         assert re.match('^[0-9]+$', sub), \
@@ -263,12 +266,6 @@ def process_type(typ):
             "Integer size out of bounds"
         assert int(sub) % 8 == 0, \
             "Integer size must be multiple of 8"
-    # Check validity of string type
-    if base == 'string' or base == 'bytes':
-        assert re.match('^[0-9]*$', sub), \
-            "String type must have no suffix or numerical suffix"
-        assert not sub or int(sub) <= 32, \
-            "Maximum 32 bytes for fixed-length str or bytes"
     # Check validity of real type
     elif base == 'ureal' or base == 'real':
         assert re.match('^[0-9]+x[0-9]+$', sub), \
@@ -375,8 +372,14 @@ def decode_single(typ, data):
     base, sub, _ = typ
     if base == 'address':
         return encode_hex(data[12:])
-    elif base == 'string' or base == 'bytes' or base == 'hash':
-        return data[:int(sub)] if len(sub) else data
+    elif base == 'hash':
+        return data[32-int(sub):]
+    elif base == 'string' or base == 'bytes':
+        if len(sub):
+            return data[:int(sub)]
+        else:
+            l = big_endian_to_int(data[0:32])
+            return data[32:][:l]
     elif base == 'uint':
         return big_endian_to_int(data)
     elif base == 'int':
@@ -387,7 +390,9 @@ def decode_single(typ, data):
         return big_endian_to_int(data) * 1.0 / 2**low
     elif base == 'real':
         high, low = [int(x) for x in sub.split('x')]
-        return (big_endian_to_int(data) * 1.0 / 2**low) % 2**high
+        o = big_endian_to_int(data)
+        i = (o - 2**(high+low)) if o >= 2**(high+low-1) else o
+        return (i * 1.0 / 2**low)
     elif base == 'bool':
         return bool(int(data.encode('hex'), 16))
 

ethereum/blocks.py

@@ -34,6 +34,16 @@
 Log = processblock.Log
 
 
+class lazy_encode(object):
+    def __init__(self, data):
+        self.data = data
+
+    def __repr__(self):
+        return repr([[k, encode_hex(a), v if k != 'code' else encode_hex(v)] for k, a, v in self.data])
+
+    def __str__(self):
+        return str(repr(self))
+
 
 # Difficulty adjustment algo
 def calc_difficulty(parent, timestamp):
@@ -257,12 +267,10 @@ def receipts_root(self, value):
         else:
             self._receipts_root = value
 
-    _fimxe_hash = None
-
     @property
     def hash(self):
         """The binary block hash"""
-        return self._fimxe_hash or utils.sha3(rlp.encode(self))
+        return utils.sha3(rlp.encode(self))
 
     def hex_hash(self):
         """The hex encoded block hash"""
@@ -381,7 +389,6 @@ def __init__(self, header, transaction_list=[], uncles=[], env=None,
         self.header = header
         self.uncles = uncles
 
-        self.uncles = uncles
         self.suicides = []
         self.logs = []
         self.log_listeners = []
@@ -647,6 +654,10 @@ def validate_uncles(self):
             parent = get_block(self.env, uncle.prevhash)
             if uncle.difficulty != calc_difficulty(parent, uncle.timestamp):
                 return False
+            if uncle.number != parent.number + 1:
+                return False
+            if uncle.timestamp < parent.timestamp:
+                return False
             if not uncle.check_pow():
                 return False
             if uncle.prevhash not in eligible_ancestor_hashes:
@@ -1018,7 +1029,7 @@ def commit_state(self):
                     t.delete(enckey)
             acct.storage = t.root_hash
             self.state.update(addr, rlp.encode(acct))
-        log_state.trace('delta', changes=changes)
+        log_state.trace('delta', changes=lazy_encode(changes))
         self.reset_cache()
         self.db.put_temporarily(b'validated:' + self.hash, '1')
 

ethereum/bloom.py

@@ -13,7 +13,7 @@
 
 bloom(0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6)
 sha3: bd2b01afcd27800b54d2179edc49e2bffde5078bb6d0b204694169b1643fb108
-first double-bytes: bd2b, 01af, cd27 -- which leads to bits in bloom --> 299, 431, 295
+first double-bytes: bd2b, 01af, cd27 -- which leads to bits in bloom --> 1323, 431, 1319
 
 blooms in this module are of type 'int'
 """

ethereum/chain.py

@@ -9,9 +9,9 @@
 from rlp.utils import encode_hex
 from ethereum import blocks
 from ethereum import processblock
+from ethereum.exceptions import VerificationFailed, InvalidTransaction
 from ethereum.slogging import get_logger
 from ethereum.config import Env
-import sys
 log = get_logger('eth.chain')
 
 
@@ -301,7 +301,7 @@ def add_block(self, block, forward_pending_transactions=True):
         if block.has_parent():
             try:
                 processblock.verify(block, block.get_parent())
-            except processblock.VerificationFailed as e:
+            except VerificationFailed as e:
                 _log.critical('VERIFICATION FAILED', error=e)
                 f = os.path.join(utils.data_dir, 'badblock.log')
                 open(f, 'w').write(to_string(block.hex_serialize()))
@@ -351,7 +351,7 @@ def add_transaction(self, transaction):
         head_candidate.state_root = self.pre_finalize_state_root
         try:
             success, output = processblock.apply_transaction(head_candidate, transaction)
-        except processblock.InvalidTransaction as e:
+        except InvalidTransaction as e:
             # if unsuccessful the prerequisites were not fullfilled
             # and the tx is invalid, state must not have changed
             log.debug('invalid tx', error=e)

ethereum/processblock.py

@@ -1,15 +1,17 @@
 import sys
 import rlp
 from rlp.sedes import CountableList, binary
-from rlp.utils import decode_hex, encode_hex, ascii_chr, str_to_bytes
+from rlp.utils import decode_hex, encode_hex, ascii_chr
 from ethereum import opcodes
 from ethereum import utils
 from ethereum import specials
 from ethereum import bloom
 from ethereum import vm as vm
-from ethereum.exceptions import *
-from ethereum.utils import safe_ord, normalize_address, mk_contract_address
+from ethereum.exceptions import InvalidNonce, InsufficientStartGas, UnsignedTransaction, \
+        BlockGasLimitReached, InsufficientBalance
+from ethereum.utils import safe_ord, mk_contract_address
 from ethereum import transactions
+import ethereum.config as config
 
 sys.setrecursionlimit(100000)
 
@@ -80,6 +82,8 @@ def rp(what, actual, target):
     # (1) The transaction signature is valid;
     if not tx.sender:  # sender is set and validated on Transaction initialization
         raise UnsignedTransaction(tx)
+    if block.number >= config.default_config["HOMESTEAD_FORK_BLKNUM"]:
+            tx.check_low_s()
 
     # (2) the transaction nonce is valid (equivalent to the
     #     sender account's current nonce);
@@ -105,6 +109,30 @@ def rp(what, actual, target):
     return True
 
 
+class lazy_safe_encode(object):
+    """Creates a lazy and logging safe representation of transaction data.
+    Use this in logging of transactions; instead of
+
+        >>> log.debug(data=data)
+
+    do this:
+
+        >>> log.debug(data=lazy_safe_encode(data))
+    """
+
+    def __init__(self, data):
+        self.data = data
+
+    def __str__(self):
+        if not isinstance(self.data, (str, unicode)):
+            return repr(self.data)
+        else:
+            return encode_hex(self.data)
+
+    def __repr__(self):
+        return str(self)
+
+
 def apply_transaction(block, tx):
     validate_transaction(block, tx)
 
@@ -124,7 +152,7 @@ def rp(what, actual, target):
     log_tx.debug('TX NEW', tx_dict=tx.log_dict())
     # start transacting #################
     block.increment_nonce(tx.sender)
-                
+
     # buy startgas
     assert block.get_balance(tx.sender) >= tx.startgas * tx.gasprice
     block.delta_balance(tx.sender, -tx.startgas * tx.gasprice)
@@ -136,16 +164,16 @@ def rp(what, actual, target):
     ext = VMExt(block, tx)
     if tx.to and tx.to != CREATE_CONTRACT_ADDRESS:
         result, gas_remained, data = apply_msg(ext, message)
-        log_tx.debug('_res_', result=result, gas_remained=gas_remained, data=data)
+        log_tx.debug('_res_', result=result, gas_remained=gas_remained, data=lazy_safe_encode(data))
     else:  # CREATE
         result, gas_remained, data = create_contract(ext, message)
         assert utils.is_numeric(gas_remained)
-        log_tx.debug('_create_', result=result, gas_remained=gas_remained, data=data)
+        log_tx.debug('_create_', result=result, gas_remained=gas_remained, data=lazy_safe_encode(data))
 
     assert gas_remained >= 0
 
     log_tx.debug("TX APPLIED", result=result, gas_remained=gas_remained,
-                 data=data)
+                 data=lazy_safe_encode(data))
 
     if not result:  # 0 = OOG failure in both cases
         log_tx.debug('TX FAILED', reason='out of gas',
@@ -155,7 +183,7 @@ def rp(what, actual, target):
         output = b''
         success = 0
     else:
-        log_tx.debug('TX SUCCESS', data=data)
+        log_tx.debug('TX SUCCESS', data=lazy_safe_encode(data))
         gas_used = tx.startgas - gas_remained
         block.refunds += len(set(block.suicides)) * opcodes.GSUICIDEREFUND
         if block.refunds > 0:
@@ -251,7 +279,7 @@ def _apply_msg(ext, msg, code):
     # assert utils.is_numeric(gas)
     if trace_msg:
         log_msg.debug('MSG APPLIED', gas_remained=gas,
-                      sender=msg.sender, to=msg.to, data=dat)
+                      sender=encode_hex(msg.sender), to=encode_hex(msg.to), data=dat)
         if log_state.is_active('trace'):
             log_state.trace('MSG POST STATE SENDER', account=msg.sender.encode('hex'),
                             bal=ext.get_balance(msg.sender),