Fixed homestead changes

Author: vub

ethereum/fast_rlp.py

@@ -1,6 +1,6 @@
 import sys
 import rlp
-from utils import int_to_big_endian
+from utils import int_to_big_endian, big_endian_to_int, safe_ord
 import db
 
 
@@ -29,11 +29,51 @@ def length_prefix(length, offset):
         length_string = int_to_big_endian(length)
         return chr(offset + 56 - 1 + len(length_string)) + length_string
 
+def _decode_optimized(rlp):
+    o = []
+    pos = 0
+    _typ, _len, pos = consume_length_prefix(rlp, pos)
+    if _typ != list:
+        return rlp[pos: pos + _len]
+    while pos < len(rlp):
+        _, _l, _p = consume_length_prefix(rlp, pos)
+        o.append(_decode_optimized(rlp[pos: _l + _p]))
+        pos = _l + _p
+    return o
+
+def consume_length_prefix(rlp, start):
+    """Read a length prefix from an RLP string.
+
+    :param rlp: the rlp string to read from
+    :param start: the position at which to start reading
+    :returns: a tuple ``(type, length, end)``, where ``type`` is either ``str``
+              or ``list`` depending on the type of the following payload,
+              ``length`` is the length of the payload in bytes, and ``end`` is
+              the position of the first payload byte in the rlp string
+    """
+    b0 = safe_ord(rlp[start])
+    if b0 < 128:  # single byte
+        return (str, 1, start)
+    elif b0 < 128 + 56:  # short string
+        return (str, b0 - 128, start + 1)
+    elif b0 < 192:  # long string
+        ll = b0 - 128 - 56 + 1
+        l = big_endian_to_int(rlp[start + 1:start + 1 + ll])
+        return (str, l, start + 1 + ll)
+    elif b0 < 192 + 56:  # short list
+        return (list, b0 - 192, start + 1)
+    else:  # long list
+        ll = b0 - 192 - 56 + 1
+        l = big_endian_to_int(rlp[start + 1:start + 1 + ll])
+        return (list, l, start + 1 + ll)
+
 #
 if sys.version_info.major == 2:
     encode_optimized = _encode_optimized
+    decode_optimized = _decode_optimized
 else:
     encode_optimized = rlp.codec.encode_raw
+    decode_optimized = rlp.codec.decode_raw
 
 
 def main():

ethereum/opcodes.py

@@ -65,7 +65,7 @@
     0xf1: ['CALL', 7, 1, 40],
     0xf2: ['CALLCODE', 7, 1, 40],
     0xf3: ['RETURN', 2, 0, 0],
-    0xf4: ['DELEGATECALL', 2, 0, 0],
+    0xf4: ['DELEGATECALL', 6, 0, 40],
     0xff: ['SUICIDE', 1, 0, 0],
 }
 

ethereum/processblock.py

@@ -8,7 +8,8 @@
 from ethereum import bloom
 from ethereum import vm as vm
 from ethereum.exceptions import *
-from ethereum.utils import safe_ord, normalize_address
+from ethereum.utils import safe_ord, normalize_address, mk_contract_address
+from ethereum import transactions
 
 sys.setrecursionlimit(100000)
 
@@ -27,10 +28,6 @@
 CREATE_CONTRACT_ADDRESS = b''
 
 
-def mk_contract_address(sender, nonce):
-    return utils.sha3(rlp.encode([normalize_address(sender), nonce]))[12:]
-
-
 def verify(block, parent):
     from ethereum import blocks
     try:
@@ -75,14 +72,6 @@ def __repr__(self):
             (encode_hex(self.address), self.topics, self.data)
 
 
-def intrinsic_gas_used(tx):
-    num_zero_bytes = str_to_bytes(tx.data).count(ascii_chr(0))
-    num_non_zero_bytes = len(tx.data) - num_zero_bytes
-    return (opcodes.GTXCOST
-            + opcodes.GTXDATAZERO * num_zero_bytes
-            + opcodes.GTXDATANONZERO * num_non_zero_bytes)
-
-
 def validate_transaction(block, tx):
 
     def rp(what, actual, target):
@@ -100,8 +89,8 @@ def rp(what, actual, target):
 
     # (3) the gas limit is no smaller than the intrinsic gas,
     # g0, used by the transaction;
-    if tx.startgas < intrinsic_gas_used(tx):
-        raise InsufficientStartGas(rp('startgas', tx.startgas, intrinsic_gas_used))
+    if tx.startgas < tx.intrinsic_gas_used:
+        raise InsufficientStartGas(rp('startgas', tx.startgas, tx.intrinsic_gas_used))
 
     # (4) the sender account balance contains at least the
     # cost, v0, required in up-front payment.
@@ -119,18 +108,22 @@ def rp(what, actual, target):
 def apply_transaction(block, tx):
     validate_transaction(block, tx)
 
-    log_tx.debug('TX NEW', tx_dict=tx.log_dict())
-    # start transacting #################
-    block.increment_nonce(tx.sender)
     # print block.get_nonce(tx.sender), '@@@'
 
-    intrinsic_gas = intrinsic_gas_used(tx)
+    def rp(what, actual, target):
+        return '%r: %r actual:%r target:%r' % (tx, what, actual, target)
+
+    intrinsic_gas = tx.intrinsic_gas_used
     if block.number >= block.config['HOMESTEAD_FORK_BLKNUM']:
         assert tx.s * 2 < transactions.secpk1n
         if not tx.to or tx.to == CREATE_CONTRACT_ADDRESS:
             intrinsic_gas += opcodes.CREATE[3]
             if tx.startgas < intrinsic_gas:
                 raise InsufficientStartGas(rp('startgas', tx.startgas, intrinsic_gas))
+
+    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
@@ -290,6 +283,7 @@ def create_contract(ext, msg):
     # assert not ext.get_code(msg.to)
     code = msg.data.extract_all()
     msg.data = vm.CallData([], 0, 0)
+    snapshot = ext._block.snapshot()
     res, gas, dat = _apply_msg(ext, msg, code)
     assert utils.is_numeric(gas)
 
@@ -301,10 +295,10 @@ def create_contract(ext, msg):
             gas -= gcost
         else:
             dat = []
-            #print('CONTRACT CREATION OOG', 'have', gas, 'want', gcost)
+            log_msg.debug('CONTRACT CREATION OOG', have=gas, want=gcost)
             if ext._block.number >= ext._block.config['HOMESTEAD_FORK_BLKNUM']:
+                ext._block.revert(snapshot)
                 return 0, 0, b''
-            log_msg.debug('CONTRACT CREATION OOG', have=gas, want=gcost)
         ext._block.set_code(msg.to, b''.join(map(ascii_chr, dat)))
         return 1, gas, msg.to
     else:

ethereum/slogging.py

@@ -16,6 +16,7 @@
 known_loggers = set()
 
 log_listeners = []
+print_logs=True
 
 
 # add level trace into logging
@@ -38,12 +39,17 @@ class LogRecorder(object):
     def __init__(self):
         self._records = []
         log_listeners.append(self._add_log_record)
+        global print_logs
+        self.prev_print_logs = print_logs
+        print_logs = False
 
     def pop_records(self):
         # can only be called once
         r = self._records[:]
         self._records = None
         log_listeners.remove(self._add_log_record)
+        global print_logs
+        print_logs = self.prev_print_logs
         return r
 
     def _add_log_record(self, msg):
@@ -126,13 +132,17 @@ def bind(self, **kwargs):
         return BoundLogger(self, kwargs)
 
     def _log(self, level, msg, args, **kwargs):
+        for listener in log_listeners:
+            kwargs['event'] = msg
+            listener(kwargs)
         exc_info = kwargs.pop('exc_info', None)
         extra = kwargs.pop('extra', {})
         highlight = kwargs.pop('highlight', False)
         extra['kwargs'] = kwargs
         extra['original_msg'] = msg
         msg = self.format_message(msg, kwargs, highlight)
-        super(SLogger, self)._log(level, msg, args, exc_info, extra)
+        if print_logs:
+            super(SLogger, self)._log(level, msg, args, exc_info, extra)
 
     def DEV(self, msg, *args, **kwargs):
         """Shortcut to output highlighted log text"""

ethereum/tester.py

@@ -167,6 +167,10 @@ def abi_contract(self, code, sender=k0, endowment=0, language='serpent', contrac
         _abi = language.mk_full_signature(code, **cn_args)
         return ABIContract(self, _abi, address, listen=listen, log_listener=log_listener)
 
+    def clear_listeners(self):
+        while len(self.block.log_listeners):
+            self.block.log_listeners.pop()
+
     def evm(self, evm, sender=k0, endowment=0, gas=None):
         sendnonce = self.block.get_nonce(u.privtoaddr(sender))
         tx = t.contract(sendnonce, gas_price, gas_limit, endowment, evm)
@@ -195,21 +199,25 @@ def _send(self, sender, to, value, evmdata='', output=None,
         tx = t.Transaction(sendnonce, gas_price, gas_limit, to, value, evmdata)
         self.last_tx = tx
         tx.sign(sender)
-        recorder = LogRecorder() if profiling > 1 else None
+        if profiling > 1:
+            set_logging_level(3)
+            recorder = LogRecorder()
         (s, o) = pb.apply_transaction(self.block, tx)
         if not s:
             raise TransactionFailed()
         out = {"output": o}
         if profiling > 0:
             zero_bytes = tx.data.count(ascii_chr(0))
             non_zero_bytes = len(tx.data) - zero_bytes
-            intrinsic_gas_used = opcodes.GTXDATAZERO * zero_bytes + \
+            intrinsic_gas_used = opcodes.GTXCOST + \
+                opcodes.GTXDATAZERO * zero_bytes + \
                 opcodes.GTXDATANONZERO * non_zero_bytes
             ntm, ng = time.time(), self.block.gas_used
             out["time"] = ntm - tm
             out["gas"] = ng - g - intrinsic_gas_used
         if profiling > 1:
             trace = recorder.pop_records()
+            set_logging_level(0)
             ops = [x['op'] for x in trace if x['event'] == 'vm']
             opdict = {}
             for op in ops:

ethereum/tests/test_contracts.py

@@ -1632,6 +1632,34 @@ def test_params_contract():
     c = s.abi_contract(params_code, FOO=4, BAR='horse')
     assert c.garble() == 4
     assert c.marble() == 'horse'
+
+prefix_types_in_functions_code = """
+type fixedp: fp_
+
+macro fixedp($x) * fixedp($y):
+    fixedp($x * $y / 2^64)
+
+macro fixedp($x) / fixedp($y):
+    fixedp($x * 2^64 / $y)
+
+macro raw_unfixedp(fixedp($x)):
+    $x / 2^64
+
+macro set(fixedp($x), $y):
+    $x = 2^64 * $y
+
+macro fixedp($x) = fixedp($y):
+    $x = $y
+
+def sqrdiv(fp_a, fp_b):
+    return(raw_unfixedp((fp_a / fp_b) * (fp_a / fp_b)))
+"""
+
+
+def test_prefix_types_in_functions():
+    s = tester.state()
+    c = s.abi_contract(prefix_types_in_functions_code)
+    assert c.sqrdiv(25, 2) == 156
 
 
 
@@ -1684,3 +1712,4 @@ def test_params_contract():
 # test_abi_address_output = None
 # test_string_logging = None
 # test_params_contract = None
+# test_prefix_types_in_functions = None

ethereum/testutils.py

@@ -7,7 +7,7 @@
 import copy
 from ethereum.db import EphemDB
 from ethereum.utils import to_string, safe_ord, parse_int_or_hex
-from ethereum.utils import remove_0x_head, int_to_hex
+from ethereum.utils import remove_0x_head, int_to_hex, normalize_address
 from ethereum.config import Env
 import json
 import os
@@ -27,6 +27,10 @@
     "previousHash": b"5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
 }
 
+# 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'
+# configure_logging(config_string=config_string)
+
 FILL = 1
 VERIFY = 2
 TIME = 3
@@ -332,7 +336,7 @@ def blkhash(n):
             nonce=parse_int_or_hex(exek['nonce'] or b"0"),
             gasprice=parse_int_or_hex(exek['gasPrice'] or b"0"),
             startgas=parse_int_or_hex(exek['gasLimit'] or b"0"),
-            to=decode_hex(exek['to'][2:] if exek['to'][:2] == b'0x' else exek['to']),
+            to=normalize_address(exek['to'], allow_blank=True),
             value=parse_int_or_hex(exek['value'] or b"0"),
             data=decode_hex(remove_0x_head(exek['data'])))
     except InvalidTransaction:
@@ -352,8 +356,10 @@ def blkhash(n):
 
         time_pre = time.time()
         try:
+            print 'trying'
             success, output = pb.apply_transaction(blk, tx)
             blk.commit_state()
+            print 'success', blk.get_receipts()[-1].gas_used
         except pb.InvalidTransaction:
             success, output = False, b''
             blk.commit_state()
@@ -372,7 +378,6 @@ def blkhash(n):
     params2['out'] = b'0x' + encode_hex(output)
     params2['post'] = copy.deepcopy(blk.to_dict(True)['state'])
     params2['postStateRoot'] = encode_hex(blk.state.root_hash)
-    assert 'post' in params  # we always have a post state in the tests
 
     if mode == FILL:
         return params2

ethereum/transactions.py

@@ -5,13 +5,13 @@
     from bitcoin import ecdsa_raw_sign, ecdsa_raw_recover
 import rlp
 from rlp.sedes import big_endian_int, binary
-from rlp.utils import decode_hex, encode_hex
+from rlp.utils import decode_hex, encode_hex, str_to_bytes, ascii_chr
 from ethereum import bloom
 from ethereum import utils
-from ethereum.processblock import mk_contract_address, intrinsic_gas_used
-from ethereum.utils import TT256
+from ethereum.utils import TT256, mk_contract_address
 from ethereum.exceptions import InvalidTransaction
 from ethereum.slogging import get_logger
+from ethereum import opcodes
 log = get_logger('eth.chain.tx')
 
 # in the yellow paper it is specified that s should be smaller than secpk1n (eq.205)
@@ -61,7 +61,7 @@ def __init__(self, nonce, gasprice, startgas, to, value, data, v=0, r=0, s=0):
         if self.gasprice >= TT256 or self.startgas >= TT256 or \
                 self.value >= TT256 or self.nonce >= TT256:
             raise InvalidTransaction("Values way too high!")
-        if self.startgas < intrinsic_gas_used(self):
+        if self.startgas < self.intrinsic_gas_used:
             raise InvalidTransaction("Startgas too low")
 
         log.debug('deserialized tx', tx=encode_hex(self.hash)[:8])
@@ -133,6 +133,14 @@ def log_dict(self):
         d['to'] = encode_hex(d['to'])
         return d
 
+    @property
+    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
+                + opcodes.GTXDATAZERO * num_zero_bytes
+                + opcodes.GTXDATANONZERO * num_non_zero_bytes)
+
     @property
     def creates(self):
         "returns the address of a contract created by this tx"

ethereum/utils.py

@@ -58,6 +58,10 @@ def to_string_for_regexp(value):
 isnumeric = is_numeric
 
 
+def mk_contract_address(sender, nonce):
+    return sha3(rlp.encode([normalize_address(sender), nonce]))[12:]
+
+
 def safe_ord(value):
     if isinstance(value, int):
         return value
@@ -139,7 +143,7 @@ def normalize_address(x, allow_blank=False):
         assert len(x) == 24 and sha3(x[:20])[:4] == x[-4:]
         x = x[:20]
     if len(x) != 20:
-        raise Exception("Invalid address format!")
+        raise Exception("Invalid address format: %r" % x)
     return x