Fixed some bugs, added more precompile support

Author: vbuterin

ethereum/config.py

@@ -3,6 +3,7 @@
 from ethereum import utils
 from ethereum.db import BaseDB, EphemDB
 from ethereum.child_dao_list import L as child_dao_list
+import copy
 
 default_config = dict(
     # Genesis block difficulty
@@ -88,3 +89,27 @@ def __init__(self, db=None, config=None, global_config=None):
         assert isinstance(self.db, BaseDB)
         self.config = config or dict(default_config)
         self.global_config = global_config or dict()
+
+config_homestead = copy.copy(default_config)
+config_homestead["HOMESTEAD_FORK_BLKNUM"] = 0
+config_homestead["ANTI_DOS_FORK_BLKNUM"] = 2**99
+config_homestead["CLEARING_FORK_BLKNUM"] = 2**99
+config_homestead["METROPOLIS_FORK_BLKNUM"] = 2**99
+
+config_tangerine = copy.copy(default_config)
+config_tangerine["HOMESTEAD_FORK_BLKNUM"] = 0
+config_tangerine["ANTI_DOS_FORK_BLKNUM"] = 0
+config_tangerine["CLEARING_FORK_BLKNUM"] = 2**99
+config_tangerine["METROPOLIS_FORK_BLKNUM"] = 2**99
+
+config_spurious = copy.copy(default_config)
+config_spurious["HOMESTEAD_FORK_BLKNUM"] = 0
+config_spurious["ANTI_DOS_FORK_BLKNUM"] = 0
+config_spurious["CLEARING_FORK_BLKNUM"] = 0
+config_spurious["METROPOLIS_FORK_BLKNUM"] = 2**99
+
+config_metropolis = copy.copy(default_config)
+config_metropolis["HOMESTEAD_FORK_BLKNUM"] = 0
+config_metropolis["ANTI_DOS_FORK_BLKNUM"] = 0
+config_metropolis["CLEARING_FORK_BLKNUM"] = 0
+config_metropolis["METROPOLIS_FORK_BLKNUM"] = 0

ethereum/messages.py

@@ -157,6 +157,10 @@ def validate_transaction(state, tx):
     if state.gas_used + tx.startgas > state.gas_limit:
         raise BlockGasLimitReached(rp(tx, 'gaslimit', state.gas_used + tx.startgas, state.gas_limit))
 
+    # EIP86-specific restrictions
+    if tx.sender == null_address and (tx.value != 0 or tx.gasprice != 0):
+        raise InvalidTransaction("EIP86 transactions must have 0 value and gasprice")
+
     return True
 
 
@@ -184,7 +188,7 @@ def apply_transaction(state, tx):
             if tx.startgas < intrinsic_gas:
                 raise InsufficientStartGas(rp(tx, 'startgas', tx.startgas, intrinsic_gas))
 
-    log_tx.debug('TX NEW', txdict=tx.to_dict(), a1=tx.intrinsic_gas_used, a2=intrinsic_gas, to=tx.to, h=state.is_HOMESTEAD())
+    log_tx.debug('TX NEW', txdict=tx.to_dict())
 
     # start transacting #################
     if tx.sender != null_address:
@@ -319,7 +323,8 @@ def _apply_msg(ext, msg, code):
     if trace_msg:
         log_msg.debug("MSG APPLY", sender=encode_hex(msg.sender), to=encode_hex(msg.to),
                       gas=msg.gas, value=msg.value,
-                      data=encode_hex(msg.data.extract_all()) if msg.data.size < 2500 else ("data<%d>" % msg.data.size))
+                      data=encode_hex(msg.data.extract_all()) if msg.data.size < 2500 else ("data<%d>" % msg.data.size),
+                      pre_storage=ext.log_storage(msg.to))
 
     # Transfer value, instaquit if not enough
     snapshot = ext.snapshot()
@@ -339,7 +344,8 @@ def _apply_msg(ext, msg, code):
     if trace_msg:
         log_msg.debug('MSG APPLIED', gas_remained=gas,
                       sender=encode_hex(msg.sender), to=encode_hex(msg.to),
-                      data=dat if len(dat) < 2500 else ("data<%d>" % len(dat)))
+                      data=dat if len(dat) < 2500 else ("data<%d>" % len(dat)),
+                      post_storage=ext.log_storage(msg.to))
 
     if res == 0:
         log_msg.debug('REVERTING')
@@ -374,7 +380,8 @@ def create_contract(ext, msg):
     # assert not ext.get_code(msg.to)
     msg.data = vm.CallData([], 0, 0)
     snapshot = ext.snapshot()
-    # if len(ext.get_code(msg.to)):
+    if len(ext.get_code(msg.to)):
+        log_msg.debug('CREATING CONTRACT ON TOP OF EXISTING CONTRACT')
     #     return 0, 0, b''
 
     ext.set_nonce(msg.to, 1 if ext.post_clearing_hardfork() else 0)

ethereum/opcodes.py

@@ -134,3 +134,7 @@
 CALL_CHILD_LIMIT_DENOM = 64
 SUICIDE_SUPPLEMENTAL_GAS = 5000
 EXP_SUPPLEMENTAL_GAS = 40
+
+GMODEXPQUADDIVISOR = 20
+GECADD = 500
+GECMUL = 2000

ethereum/specials.py

@@ -3,7 +3,7 @@
 from rlp.utils import ascii_chr
 
 from ethereum import utils, opcodes
-from ethereum.utils import safe_ord, decode_hex
+from ethereum.utils import safe_ord, decode_hex, encode_int32
 
 
 ZERO_PRIVKEY_ADDR = decode_hex('3f17f1962b36e491b30a40b2405849e597ba5fb5')
@@ -71,13 +71,87 @@ def proc_identity(ext, msg):
     msg.data.extract_copy(o, 0, 0, len(o))
     return 1, msg.gas - gas_cost, o
 
+def proc_modexp(ext, msg):
+    if not ext.post_metropolis_hardfork():
+        return 1, msg.gas, []
+    print('modexp proc', msg.gas)
+    baselen = msg.data.extract32(0)
+    explen = msg.data.extract32(32)
+    modlen = msg.data.extract32(64)
+    gas_cost = (max(modlen, baselen) ** 2 * max(explen, 1)) // opcodes.GMODEXPQUADDIVISOR
+    print(baselen, explen, modlen, 'expected gas cost', gas_cost)
+    if msg.gas < gas_cost:
+        return 0, 0, []
+    base = bytearray(baselen)
+    msg.data.extract_copy(base, 0, 96, baselen)
+    exp = bytearray(explen)
+    msg.data.extract_copy(exp, 0, 96 + baselen, explen)
+    mod = bytearray(modlen)
+    msg.data.extract_copy(mod, 0, 96 + baselen + explen, modlen)
+    if utils.big_endian_to_int(mod) == 0:
+        return 1, msg.gas - gas_cost, [0] * modlen
+    o = pow(utils.big_endian_to_int(base), utils.big_endian_to_int(exp), utils.big_endian_to_int(mod))
+    return 1, msg.gas - gas_cost, [safe_ord(x) for x in utils.zpad(utils.int_to_big_endian(o), modlen)]
+
+def validate_point(x, y):
+    import py_pairing
+    FQ = py_pairing.FQ
+    if x >= py_pairing.field_modulus or y >= py_pairing.field_modulus:
+        return False
+    if (x, y) != (0, 0):
+        p1 = (FQ(x), FQ(y), FQ(1))
+        if not py_pairing.is_on_curve(p1, py_pairing.b):
+            return False
+    else:
+        p1 = (FQ(1), FQ(1), FQ(0))
+    return p1
+
+def proc_ecadd(ext, msg):
+    if not ext.post_metropolis_hardfork():
+        return 1, msg.gas, []
+    import py_pairing
+    FQ = py_pairing.FQ
+    print('ecadd proc', msg.gas)
+    if msg.gas < opcodes.GECADD:
+        return 0, 0, []
+    x1 = msg.data.extract32(0)
+    y1 = msg.data.extract32(32)
+    x2 = msg.data.extract32(64)
+    y2 = msg.data.extract32(96)
+    p1 = validate_point(x1, y1)
+    p2 = validate_point(x2, y2)
+    if p1 is False or p2 is False:
+        return 0, 0, []
+    o = py_pairing.normalize(py_pairing.add(p1, p2))
+    return 1, msg.gas - opcodes.GECADD, [safe_ord(x) for x in (encode_int32(o[0].n) + encode_int32(o[1].n))]
+
+def proc_ecmul(ext, msg):
+    if not ext.post_metropolis_hardfork():
+        return 1, msg.gas, []
+    import py_pairing
+    FQ = py_pairing.FQ
+    print('ecmul proc', msg.gas)
+    if msg.gas < opcodes.GECMUL:
+        return 0, 0, []
+    x = msg.data.extract32(0)
+    y = msg.data.extract32(32)
+    m = msg.data.extract32(64)
+    p = validate_point(x, y)
+    if p is False:
+        return 0, 0, []
+    o = py_pairing.normalize(py_pairing.multiply(p, m))
+    return 1, msg.gas - opcodes.GECMUL, [safe_ord(x) for x in (encode_int32(o[0].n) + encode_int32(o[1].n))]
+
 specials = {
     decode_hex(k): v for k, v in
     {
         b'0000000000000000000000000000000000000001': proc_ecrecover,
         b'0000000000000000000000000000000000000002': proc_sha256,
         b'0000000000000000000000000000000000000003': proc_ripemd160,
         b'0000000000000000000000000000000000000004': proc_identity,
+        b'0000000000000000000000000000000000000005': proc_modexp,
+        b'0000000000000000000000000000000000000006': proc_ecadd,
+        b'0000000000000000000000000000000000000007': proc_ecmul,
     }.items()
 }
 

ethereum/tools/new_statetest_utils.py

@@ -2,7 +2,7 @@
 from ethereum.block import FakeHeader, Block
 from ethereum.utils import decode_hex, parse_int_or_hex, sha3, to_string, \
     remove_0x_head, encode_hex, big_endian_to_int
-from ethereum.config import default_config, Env
+from ethereum.config import default_config, config_homestead, config_tangerine, config_spurious, config_metropolis, Env
 from ethereum.exceptions import InvalidTransaction
 import ethereum.transactions as transactions
 from ethereum.messages import apply_transaction
@@ -13,6 +13,8 @@
 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,eth.pb.tx:debug'
 
+konfig=copy.copy(default_config)
+
 # configure_logging(config_string=config_string)
 
 fixture_path = os.path.join(os.path.dirname(__file__), '../..', 'fixtures')
@@ -25,45 +27,20 @@ def mk_fake_header(blknum):
     return fake_headers[blknum]
 
 basic_env = {
-    "currentCoinbase": "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
-    "currentDifficulty": "256",
-    "currentGasLimit": "1000000000",
-    "currentNumber": "257",
-    "currentTimestamp": "1",
-    "previousHash": "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+    "currentCoinbase": "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+    "currentDifficulty": "0x020000",
+    "currentGasLimit": "0x7fffffffffffffff",
+    "currentNumber": "0x01",
+    "currentTimestamp": "0x03e8",
+    "previousHash": "0x5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
 }
 
-konfig = copy.copy(default_config)
-
-konfig_homestead = copy.copy(konfig)
-konfig_homestead["HOMESTEAD_FORK_BLKNUM"] = 0
-konfig_homestead["ANTI_DOS_FORK_BLKNUM"] = 2**99
-konfig_homestead["CLEARING_FORK_BLKNUM"] = 2**99
-konfig_homestead["METROPOLIS_FORK_BLKNUM"] = 2**99
-
-konfig_tangerine = copy.copy(konfig)
-konfig_tangerine["HOMESTEAD_FORK_BLKNUM"] = 0
-konfig_tangerine["ANTI_DOS_FORK_BLKNUM"] = 0
-konfig_tangerine["CLEARING_FORK_BLKNUM"] = 2**99
-konfig_tangerine["METROPOLIS_FORK_BLKNUM"] = 2**99
-
-konfig_spurious = copy.copy(konfig)
-konfig_spurious["HOMESTEAD_FORK_BLKNUM"] = 0
-konfig_spurious["ANTI_DOS_FORK_BLKNUM"] = 0
-konfig_spurious["CLEARING_FORK_BLKNUM"] = 0
-konfig_spurious["METROPOLIS_FORK_BLKNUM"] = 2**99
-
-konfig_metropolis = copy.copy(konfig)
-konfig_metropolis["HOMESTEAD_FORK_BLKNUM"] = 0
-konfig_metropolis["ANTI_DOS_FORK_BLKNUM"] = 0
-konfig_metropolis["CLEARING_FORK_BLKNUM"] = 0
-konfig_metropolis["METROPOLIS_FORK_BLKNUM"] = 0
 
 configs = {
-    #"Homestead": konfig_homestead,
-    #"EIP150": konfig_tangerine,
-    "EIP158": konfig_spurious,
-    "Metropolis": konfig_metropolis
+    #"Homestead": config_homestead,
+    #"EIP150": config_tangerine,
+    "EIP158": config_spurious,
+    "Metropolis": config_metropolis
 }
 
 def mk_state_diff(prev, post):
@@ -178,3 +155,4 @@ def verify_state_test(test):
                 raise Exception("Hash mismatch, computed: %s, supplied: %s" % (computed["hash"], result["hash"]))
             else:
                 print("Hash matched!: %s" % computed["hash"])
+    return True

ethereum/tools/tester2.py

@@ -1,9 +1,9 @@
-from ethereum.utils import sha3, privtoaddr, int_to_addr, to_string, big_endian_to_int
+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.transactions import Transaction
 from ethereum.consensus_strategy import get_consensus_strategy
-from ethereum.config import Env
+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.common import verify_execution_results, mk_block_from_prevstate, set_execution_results
@@ -99,25 +99,35 @@ def kall(self, *args, **kwargs):
             return o[0] if len(o) == 1 else o
         return kall
 
+def get_env(env):
+    d = {
+        None: config_spurious,
+        'mainnet': default_config,
+        'homestead': config_homestead,
+        'tangerine': config_tangerine,
+        'spurious': config_spurious,
+        'metropolis': config_metropolis,
+    }
+    return env if isinstance(env, Env) else Env(config=d[env])
+
 
 class Chain(object):
     def __init__(self, alloc=None, env=None):
         self.chain = chain.Chain(mk_basic_state(base_alloc if alloc is None else alloc,
                                                 None,
-                                                Env() if env is None else env))
+                                                get_env(env)))
         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()
         self.cs.initialize(self.head_state, self.block)
-
-    @property
-    def last_tx(self):
-        return self.block.transactions[-1] if self.block.transactions else None
+        self.last_sender = None
+        self.last_tx = None
 
     def tx(self, sender=k0, to=b'\x00' * 20, value=0, data=b'', startgas=STARTGAS, gasprice=GASPRICE):
         sender_addr = privtoaddr(sender)
         transaction = Transaction(self.head_state.get_nonce(sender_addr), gasprice, startgas,
                                   to, value, data).sign(sender)
+        self.last_tx, self.last_sender = transaction, sender
         success, output = apply_transaction(self.head_state, transaction)
         self.block.transactions.append(transaction)
         if not success:
@@ -159,3 +169,53 @@ def revert(self, snapshot):
         assert blknum == self.block.number
         self.block.transactions = self.block.transactions[:txcount]
         self.head_state.revert(state_snapshot)
+
+def int_to_0x_hex(v):
+    o = encode_hex(int_to_big_endian(v))
+    if o and o[0] == '0':
+        return '0x' + o[1:]
+    else:
+        return '0x' + o
+    
+
+def mk_state_test_prefill(c):
+    env = {
+        "currentCoinbase": checksum_encode(c.head_state.block_coinbase),
+        "currentDifficulty": int_to_0x_hex(c.head_state.block_difficulty),
+        "currentGasLimit": int_to_0x_hex(c.head_state.gas_limit),
+        "currentNumber": int_to_0x_hex(c.head_state.block_number),
+        "currentTimestamp": int_to_0x_hex(c.head_state.timestamp),
+        "previousHash": "0x"+encode_hex(c.head_state.prev_headers[0].hash),
+    }
+    pre = c.head_state.to_dict()
+    return {"env": env, "pre": pre}
+
+def mk_state_test_postfill(c, prefill):
+    txdata = c.last_tx.to_dict()
+    modified_tx_data = {
+        "data": [ txdata["data"] ],
+        "gasLimit": [ int_to_0x_hex(txdata["startgas"]) ],
+        "gasPrice": int_to_0x_hex(txdata["gasprice"]),
+        "nonce": int_to_0x_hex(txdata["nonce"]),
+        "secretKey": '0x' + encode_hex(c.last_sender),
+        "to": txdata["to"],
+        "value": [ int_to_0x_hex(txdata["value"]) ],
+    }
+    c.head_state.commit()
+    postStateHash = '0x' + encode_hex(c.head_state.trie.root_hash)
+    if c.chain.config == config_homestead:
+        config = 'Homestead'
+    elif c.chain.config == config_tangerine:
+        config = 'EIP150'
+    elif c.chain.config == config_spurious:
+        config = 'EIP158'
+    elif c.chain.config == config_metropolis:
+        config = 'Metropolis'
+    else:
+        raise Exception("Cannot get config")
+    return {
+        "env": prefill["env"],
+        "pre": prefill["pre"],
+        "transaction": modified_tx_data,
+        "post": {config: [ { "hash": postStateHash, "indexes": {"data": 0, "gas": 0, "value": 0} } ] }
+    }

ethereum/utils.py

@@ -182,7 +182,7 @@ 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()):
+    for i, c in enumerate(encode_hex(addr)):
         if c in '0123456789':
             o += c
         else: