Added checksums, also passing EIP86 transaction tests

Author: vub

ethereum/config.py

@@ -26,6 +26,8 @@
     GASLIMIT_ADJMAX_FACTOR=1024,
     BLKLIM_FACTOR_NOM=3,
     BLKLIM_FACTOR_DEN=2,
+    # Network ID
+    NETWORK_ID=1,
     # Block reward
     BLOCK_REWARD=5000 * utils.denoms.finney,
     NEPHEW_REWARD=5000 * utils.denoms.finney // 32,  # BLOCK_REWARD / 32
@@ -51,7 +53,6 @@
     HOMESTEAD_DIFF_ADJUSTMENT_CUTOFF=10,
     # Metropolis fork
     METROPOLIS_FORK_BLKNUM=2**99,
-    METROPOLIS_ENTRY_POINT=utils.int_to_addr(2**160 - 1),
     METROPOLIS_STATEROOT_STORE=0x10,
     METROPOLIS_BLOCKHASH_STORE=0x20,
     METROPOLIS_WRAPAROUND=65536,

ethereum/processblock.py

@@ -142,7 +142,7 @@ def create_contract(ext, msg):
     # assert not ext.get_code(msg.to)
     msg.data = vm.CallData([], 0, 0)
     snapshot = ext.snapshot()
-    ext.set_nonce(msg.to, 1)
+    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)
     log_msg.debug('CONTRACT CREATION FINISHED', res=res, gas=gas, dat=dat)
@@ -151,7 +151,7 @@ def create_contract(ext, msg):
         if not len(dat):
             return 1, gas, msg.to
         gcost = len(dat) * opcodes.GCONTRACTBYTE
-        if gas >= gcost:
+        if gas >= gcost and len(dat) < 24000:
             gas -= gcost
         else:
             dat = []
@@ -160,7 +160,7 @@ def create_contract(ext, msg):
                 ext.revert(snapshot)
                 return 0, 0, b''
         ext.set_code(msg.to, b''.join(map(ascii_chr, dat)))
-        log_msg.debug('SETTING CODE', addr=encode_hex(msg.to))
+        log_msg.debug('SETTING CODE', addr=encode_hex(msg.to), lendat=len(dat))
         return 1, gas, msg.to
     else:
         ext.revert(snapshot)

ethereum/state_transition.py

@@ -31,6 +31,8 @@
     from functools import lru_cache
 from ethereum.slogging import get_logger
 
+null_address = b'\xff' * 20
+
 log = get_logger('eth.block')
 log_tx = get_logger('eth.pb.tx')
 log_msg = get_logger('eth.pb.msg')
@@ -150,21 +152,35 @@ def verify_execution_results(state, block):
                          (block.header.gas_used, state.gas_used))
     return True
 
+def config_fork_specific_validation(config, blknum, tx):
+    # (1) The transaction signature is valid;
+    _ = tx.sender
+    if blknum >= config['METROPOLIS_FORK_BLKNUM']:
+        tx.check_low_s_metropolis()
+    else:
+        if tx.sender == null_address:
+            raise VerificationFailed("EIP86 transactions not available yet")
+        if blknum >= config['HOMESTEAD_FORK_BLKNUM']:
+            tx.check_low_s_homestead()
+    print(tx.network_id, config["NETWORK_ID"])
+    if blknum >= config["CLEARING_FORK_BLKNUM"]:
+        if tx.network_id not in (None, config["NETWORK_ID"]):
+            raise VerificationFailed("Wrong network ID")
+    else:
+        if tx.network_id is not None:
+            raise VerificationFailed("Wrong network ID")
+    return True
+
 def validate_transaction(state, tx):
 
     def rp(what, actual, target):
         return '%r: %r actual:%r target:%r' % (tx, what, actual, target)
 
     # (1) The transaction signature is valid;
     if not tx.sender:  # sender is set and validated on Transaction initialization
-        if state.is_METROPOLIS():
-            tx._sender = normalize_address(state.config["METROPOLIS_ENTRY_POINT"])
-        else:
-            raise UnsignedTransaction(tx)
-    if state.is_METROPOLIS():
-        tx.check_low_s_metropolis()
-    elif state.is_HOMESTEAD():
-        tx.check_low_s_homestead()
+        raise UnsignedTransaction(tx)
+
+    assert config_fork_specific_validation(state.config, state.block_number, tx)
 
     # (2) the transaction nonce is valid (equivalent to the
     #     sender account's current nonce);

ethereum/tests/test_contracts.py

@@ -1533,7 +1533,7 @@ def test_abi_logging():
     o.pop()
     c.test_chicken(tester.a0)
     assert o == [{"_event_type": b"chicken",
-                  "m": utils.encode_hex(tester.a0)}]
+                  "m": "0x"+utils.encode_hex(tester.a0)}]
     o.pop()
 
 
@@ -1578,8 +1578,8 @@ def test_abi_address_output():
     c.register(123, b'1212121212121212121212121212121212121212')
     c.register(123, b'3434343434343434343434343434343434343434')
     c.register(125, b'5656565656565656565656565656565656565656')
-    assert c.get_address(123) == b'1212121212121212121212121212121212121212'
-    assert c.get_address(125) == b'5656565656565656565656565656565656565656'
+    assert c.get_address(123) == '0x1212121212121212121212121212121212121212'
+    assert c.get_address(125) == '0x5656565656565656565656565656565656565656'
 
 filename5 = 'abi_output_tester_1264876521746198724124'
 
@@ -1605,8 +1605,8 @@ def test_inner_abi_address_output():
     c.register(123, b'1212121212121212121212121212121212121212')
     c.register(123, b'3434343434343434343434343434343434343434')
     c.register(125, b'5656565656565656565656565656565656565656')
-    assert c.get_address(123) == b'1212121212121212121212121212121212121212'
-    assert c.get_address(125) == b'5656565656565656565656565656565656565656'
+    assert c.get_address(123) == '0x1212121212121212121212121212121212121212'
+    assert c.get_address(125) == '0x5656565656565656565656565656565656565656'
 
 
 string_logging_code = """

ethereum/tests/test_transactions.py

@@ -4,9 +4,13 @@
 from rlp.utils import decode_hex, encode_hex, str_to_bytes
 import ethereum.testutils as testutils
 from ethereum.testutils import fixture_to_bytes
+from ethereum.state_transition import config_fork_specific_validation
 import ethereum.config as config
 import sys
 import json
+import copy
+konfig = copy.copy(config.default_config)
+konfig['METROPOLIS_FORK_BLKNUM'] = 3000000
 
 from ethereum.slogging import get_logger
 logger = get_logger()
@@ -25,29 +29,32 @@ def test_transaction(filename, testname, testdata):
         o = {}
         tx = rlp.decode(rlpdata, transactions.Transaction)
         blknum = int(testdata["blocknumber"])
-        if blknum >= 1000000:  # config.default_config["HOMESTEAD_FORK_BLKNUM"]:
-            tx.check_low_s_homestead()
+        #if blknum >= 1000000:  # config.default_config["HOMESTEAD_FORK_BLKNUM"]:
+        #    tx.check_low_s_homestead()
+        assert config_fork_specific_validation(konfig, blknum, tx)
         o["sender"] = tx.sender
         o["transaction"] = {
-            "data": b'0x' * (len(tx.data) > 0) + encode_hex(tx.data),
-            "gasLimit": str_to_bytes(str(tx.startgas)),
-            "gasPrice": str_to_bytes(str(tx.gasprice)),
-            "nonce": str_to_bytes(str(tx.nonce)),
-            "r": b'0x' + encode_hex(utils.zpad(utils.int_to_big_endian(tx.r), 32)),
-            "s": b'0x' + encode_hex(utils.zpad(utils.int_to_big_endian(tx.s), 32)),
-            "v": str_to_bytes(str(tx.v)),
-            "value": str_to_bytes(str(tx.value)),
+            "data": '0x' * (len(tx.data) > 0) + encode_hex(tx.data),
+            "gasLimit": str(tx.startgas),
+            "gasPrice": str(tx.gasprice),
+            "nonce": str(tx.nonce),
+            "r": '0x' + encode_hex(utils.zpad(utils.int_to_big_endian(tx.r), 32)),
+            "s": '0x' + encode_hex(utils.zpad(utils.int_to_big_endian(tx.s), 32)),
+            "v": str(tx.v),
+            "value": str(tx.value),
             "to": encode_hex(tx.to),
         }
     except Exception as e:
         tx = None
         sys.stderr.write(str(e))
     if 'transaction' not in testdata:  # expected to fail
+        print(testdata)
         assert tx is None
     else:
+        print(testdata)
         assert set(o['transaction'].keys()) == set(testdata.get("transaction", dict()).keys())
         o.get("transaction", None) == testdata.get("transaction", None)
-        assert encode_hex(o.get("sender", '')) == testdata.get("sender", '')
+        assert str_to_bytes(encode_hex(o.get("sender", ''))) == testdata.get("sender", '')
 
 
 def pytest_generate_tests(metafunc):

ethereum/testutils.py

@@ -15,7 +15,7 @@
 from ethereum.config import default_config
 from ethereum.parse_genesis_declaration import state_from_genesis_declaration
 from ethereum import state_transition
-from state import State
+from ethereum.state import State
 import json
 import os
 import time

ethereum/transactions.py

@@ -16,6 +16,7 @@
 
 # in the yellow paper it is specified that s should be smaller than secpk1n (eq.205)
 secpk1n = 115792089237316195423570985008687907852837564279074904382605163141518161494337
+null_address = b'\xff' * 20
 
 
 class Transaction(rlp.Serializable):
@@ -59,6 +60,7 @@ def __init__(self, nonce, gasprice, startgas, to, value, data, v=0, r=0, s=0):
         assert len(to) == 20 or len(to) == 0
         super(Transaction, self).__init__(nonce, gasprice, startgas, to, value, data, v, r, s)
         self.logs = []
+        self.network_id = None
 
         if self.gasprice >= TT256 or self.startgas >= TT256 or \
                 self.value >= TT256 or self.nonce >= TT256:
@@ -73,30 +75,28 @@ def sender(self):
 
         if not self._sender:
             # Determine sender
-            if self.v:
-                if self.r >= N or self.s >= N or self.v not in (27, 28, 37, 38, 41, 42) \
-                or self.r == 0 or self.s == 0:
-                    raise InvalidTransaction("Invalid signature values!")
-                log.debug('reco< 27 or self.v > 28 \vering sender')
+            if self.r == 0 and self.s == 0:
+                self.network_id = self.v
+                self._sender = null_address
+            else:
                 if self.v in (27, 28):
-                    rlpdata = rlp.encode(self, UnsignedTransaction)
-                    rawhash = utils.sha3(rlpdata)
-                    v = self.v
-                elif self.v in (37, 38):
-                    rlpdata = rlp.encode(rlp.infer_sedes(self).serialize(self)[:-3] + ['\x01', '', ''])
-                    rawhash = utils.sha3(rlpdata)
-                    v = self.v - 10
-                elif self.v in (41, 42):
-                    rlpdata = rlp.encode(rlp.infer_sedes(self).serialize(self)[:-3] + ['\x03', '', ''])
-                    rawhash = utils.sha3(rlpdata)
-                    v = self.v - 14
-                pub = ecrecover_to_pub(rawhash, v, self.r, self.s)
+                    self.network_id = None
+                    vee = self.v
+                    sighash = utils.sha3(rlp.encode(self, UnsignedTransaction))
+                elif self.v >= 37:
+                    self.network_id = ((self.v - 1) // 2) - 17
+                    vee = self.v - self.network_id * 2 - 8
+                    assert vee in (27, 28)
+                    rlpdata = rlp.encode(rlp.infer_sedes(self).serialize(self)[:-3] + [self.network_id, '', ''])
+                    sighash = utils.sha3(rlpdata)
+                else:
+                    raise InvalidTransaction("Invalid V value")
+                if self.r >= N or self.s >= N or self.r == 0 or self.s == 0:
+                    raise InvalidTransaction("Invalid signature values!")
+                pub = ecrecover_to_pub(sighash, vee, self.r, self.s)
                 if pub == b"\x00" * 64:
                     raise InvalidTransaction("Invalid signature (zero privkey cannot sign)")
                 self._sender = utils.sha3(pub)[-20:]
-                assert self.sender == self._sender
-            else:
-                self._sender = 0
         return self._sender
 
     @sender.setter

ethereum/utils.py

@@ -173,26 +173,22 @@ def sha3(seed):
 assert encode_hex(sha3(b'')) == 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
 
 
-def privtoaddr(x, extended=False):
+def privtoaddr(x):
     if len(x) > 32:
         x = decode_hex(x)
-    o = sha3(privtopub(x)[1:])[12:]
-    return add_checksum(o) if extended else o
-
-
-def add_checksum(x):
-    if len(x) in (40, 48):
-        x = decode_hex(x)
-    if len(x) == 24:
-        return x
-    return x + sha3(x)[:4]
-
-
-def check_and_strip_checksum(x):
-    if len(x) in (40, 48):
-        x = decode_hex(x)
-    assert len(x) == 24 and sha3(x[:20])[:4] == x[-4:]
-    return x[:20]
+    return sha3(privtopub(x)[1:])[12:]
+
+
+def checksum_encode(addr): # Takes a 20-byte binary address as input
+    addr = normalize_address(addr)
+    o = ''
+    v = big_endian_to_int(sha3(encode_hex(addr)))
+    for i, c in enumerate(addr.hex()):
+        if c in '0123456789':
+            o += c
+        else:
+            o += c.upper() if (v & (2**(255 - 4*i))) else c.lower()
+    return '0x'+o
 
 
 def normalize_address(x, allow_blank=False):