Removed bitcoin dependency, and made syncing work with receipt root skipping

Author: vbuterin

ethereum/config.py

@@ -96,6 +96,12 @@ def __init__(self, db=None, config=None, global_config=None):
         self.config = config or dict(default_config)
         self.global_config = global_config or dict()
 
+config_frontier = copy.copy(default_config)
+config_frontier["HOMESTEAD_FORK_BLKNUM"] = 2**99
+config_frontier["ANTI_DOS_FORK_BLKNUM"] = 2**99
+config_frontier["SPURIOUS_DRAGON_FORK_BLKNUM"] = 2**99
+config_frontier["METROPOLIS_FORK_BLKNUM"] = 2**99
+
 config_homestead = copy.copy(default_config)
 config_homestead["HOMESTEAD_FORK_BLKNUM"] = 0
 config_homestead["ANTI_DOS_FORK_BLKNUM"] = 2**99

ethereum/specials.py

@@ -1,5 +1,6 @@
 # -*- coding: utf8 -*-
-import bitcoin
+from py_ecc.secp256k1 import privtopub, ecdsa_raw_recover, N as secp256k1n
+import hashlib
 from rlp.utils import ascii_chr
 
 from ethereum import utils, opcodes
@@ -26,7 +27,7 @@ def proc_ecrecover(ext, msg):
     r = msg.data.extract32(64)
     s = msg.data.extract32(96)
 
-    if r >= bitcoin.N or s >= bitcoin.N or v < 27 or v > 28:
+    if r >= secp256k1n or s >= secp256k1n or v < 27 or v > 28:
         return 1, msg.gas - opcodes.GECRECOVER, []
     try:
         pub = utils.ecrecover_to_pub(message_hash, v, r, s)
@@ -44,7 +45,7 @@ def proc_sha256(ext, msg):
     if msg.gas < gas_cost:
         return 0, 0, []
     d = msg.data.extract_all()
-    o = [safe_ord(x) for x in bitcoin.bin_sha256(d)]
+    o = [safe_ord(x) for x in hashlib.sha256(d).digest()]
     return 1, msg.gas - gas_cost, o
 
 
@@ -56,7 +57,7 @@ def proc_ripemd160(ext, msg):
     if msg.gas < gas_cost:
         return 0, 0, []
     d = msg.data.extract_all()
-    o = [0] * 12 + [safe_ord(x) for x in bitcoin.ripemd.RIPEMD160(d).digest()]
+    o = [0] * 12 + [safe_ord(x) for x in hashlib.new('ripemd160', d).digest()]
     return 1, msg.gas - gas_cost, o
 
 
@@ -100,13 +101,13 @@ def proc_modexp(ext, msg):
     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:
+    import py_ecc.optimized_bn128 as bn128
+    FQ = bn128.FQ
+    if x >= bn128.field_modulus or y >= bn128.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):
+        if not bn128.is_on_curve(p1, bn128.b):
             return False
     else:
         p1 = (FQ(1), FQ(1), FQ(0))
@@ -115,8 +116,8 @@ def validate_point(x, y):
 def proc_ecadd(ext, msg):
     if not ext.post_metropolis_hardfork():
         return 1, msg.gas, []
-    import py_pairing
-    FQ = py_pairing.FQ
+    import py_ecc.optimized_bn128 as bn128
+    FQ = bn128.FQ
     print('ecadd proc', msg.gas)
     if msg.gas < opcodes.GECADD:
         return 0, 0, []
@@ -128,14 +129,14 @@ def proc_ecadd(ext, msg):
     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))
+    o = bn128.normalize(bn128.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
+    import py_ecc.optimized_bn128 as bn128
+    FQ = bn128.FQ
     print('ecmul proc', msg.gas)
     if msg.gas < opcodes.GECMUL:
         return 0, 0, []
@@ -145,24 +146,24 @@ def proc_ecmul(ext, msg):
     p = validate_point(x, y)
     if p is False:
         return 0, 0, []
-    o = py_pairing.normalize(py_pairing.multiply(p, m))
+    o = bn128.normalize(bn128.multiply(p, m))
     return (1, msg.gas - opcodes.GECMUL,
             [safe_ord(c) for c in (encode_int32(o[0].n) + encode_int32(o[1].n))])
 
 def proc_ecpairing(ext, msg):
     if not ext.post_metropolis_hardfork():
         return 1, msg.gas, []
-    import py_pairing
-    FQ = py_pairing.FQ
+    import py_ecc.optimized_bn128 as bn128
+    FQ = bn128.FQ
     print('pairing proc', msg.gas)
     # Data must be an exact multiple of 192 byte
     if msg.data.size % 192:
         return 0, 0, []
     gascost = opcodes.GPAIRINGBASE + msg.data.size // 192 * opcodes.GPAIRINGPERPOINT
     if msg.gas < gascost:
         return 0, 0, []
-    zero = (py_pairing.FQ2.one(), py_pairing.FQ2.one(), py_pairing.FQ2.zero())
-    exponent = py_pairing.FQ12.one()
+    zero = (bn128.FQ2.one(), bn128.FQ2.one(), bn128.FQ2.zero())
+    exponent = bn128.FQ12.one()
     for i in range(0, msg.data.size, 192):
         x1 = msg.data.extract32(i)
         y1 = msg.data.extract32(i + 32)
@@ -174,20 +175,20 @@ def proc_ecpairing(ext, msg):
         if p1 is False:
             return 0, 0, []
         for v in (x2_i, x2_r, y2_i, y2_r):
-            if v >= py_pairing.field_modulus:
+            if v >= bn128.field_modulus:
                 return 0, 0, []
-        fq2_x = py_pairing.FQ2([x2_r, x2_i])
-        fq2_y = py_pairing.FQ2([y2_r, y2_i])
-        if (fq2_x, fq2_y) != (py_pairing.FQ2.zero(), py_pairing.FQ2.zero()):
-            p2 = (fq2_x, fq2_y, py_pairing.FQ2.one())
-            if not py_pairing.is_on_curve(p2, py_pairing.b2):
+        fq2_x = bn128.FQ2([x2_r, x2_i])
+        fq2_y = bn128.FQ2([y2_r, y2_i])
+        if (fq2_x, fq2_y) != (bn128.FQ2.zero(), bn128.FQ2.zero()):
+            p2 = (fq2_x, fq2_y, bn128.FQ2.one())
+            if not bn128.is_on_curve(p2, bn128.b2):
                 return 0, 0, []
         else:
             p2 = zero
-        if py_pairing.multiply(p2, py_pairing.curve_order)[-1] != py_pairing.FQ2.zero():
+        if bn128.multiply(p2, bn128.curve_order)[-1] != bn128.FQ2.zero():
             return 0, 0, []
         exponent *= py_pairing.pairing(p2, p1, final_exponentiate=False)
-    result = py_pairing.final_exponentiate(exponent) == py_pairing.FQ12.one()
+    result = bn128.final_exponentiate(exponent) == bn128.FQ12.one()
     return 1, msg.gas - gascost, [0] * 31 + [1 if result else 0]
 
 specials = {

ethereum/state.py

@@ -91,7 +91,6 @@ def code(self, value):
         # thing that fails to get garbage collected is when code disappears due
         # to a suicide
         self.env.db.put(self.code_hash, value)
-        # self.env.db.inc_refcount(self.code_hash, value)
 
     def get_storage_data(self, key):
         if key not in self.storage_cache:
@@ -115,7 +114,7 @@ def is_blank(self):
     @property
     def exists(self):
         if self.is_blank():
-            return self.existent_at_start and not self.touched
+            return self.touched or (self.existent_at_start and not self.deleted)
         return True
 
     def to_dict(self):
@@ -296,10 +295,12 @@ def account_exists(self, address):
             o = not self.get_and_cache_account(utils.normalize_address(address)).is_blank()
         else:
             a = self.get_and_cache_account(address)
+            if a.deleted and not a.touched:
+                return False
             if a.touched:
-                o = not a.deleted
+                return True
             else:
-                o = a.existent_at_start
+                return a.existent_at_start
         return o
 
     def transfer_value(self, from_addr, to_addr, value):
@@ -315,15 +316,16 @@ def account_to_dict(self, address):
 
     def commit(self, allow_empties=False):
         for addr, acct in self.cache.items():
-            if acct.touched:
+            if acct.touched or acct.deleted:
                 acct.commit()
                 self.deletes.extend(acct.storage_trie.deletes)
-                if acct.exists or allow_empties or (not self.is_SPURIOUS_DRAGON() and not acct.deleted):
-                    # print('upd', encode_hex(addr))
+                if self.account_exists(addr) or allow_empties:
                     self.trie.update(addr, rlp.encode(acct))
+                    #self.db.update(b'acct:'+addr, rlp.encode(acct))
                 else:
-                    # print('del', encode_hex(addr))
                     self.trie.delete(addr)
+                    # self.db.update(b'acct:'+addr, rlp.encode(acct))
+                    # self.trie.db.
         self.deletes.extend(self.trie.deletes)
         self.trie.deletes = []
         self.cache = {}
@@ -340,6 +342,8 @@ def del_account(self, address):
         self.set_code(address, b'')
         self.reset_storage(address)
         self.set_and_journal(self.get_and_cache_account(utils.normalize_address(address)), 'deleted', True)
+        self.set_and_journal(self.get_and_cache_account(utils.normalize_address(address)), 'touched', False)
+        # self.set_and_journal(self.get_and_cache_account(utils.normalize_address(address)), 'existent_at_start', False)
 
     def reset_storage(self, address):
         acct = self.get_and_cache_account(address)
@@ -434,7 +438,7 @@ def ephemeral_clone(self):
         s.recent_uncles = self.recent_uncles
         s.prev_headers = self.prev_headers
         for acct in self.cache.values():
-            assert not acct.touched
+            assert not acct.touched or not acct.deleted
         s.journal = copy.copy(self.journal)
         s.cache = {}
         return s

ethereum/todo_tests/tst_frontier.py

@@ -12,8 +12,8 @@
 import time
 import random
 
-# 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'
+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'
 # configure_logging(config_string=config_string)
 
 messages.SKIP_MEDSTATES = True
@@ -121,14 +121,19 @@ def snapshot(c, num_blocks):
 # don't check pow
 BlockHeader.check_pow = lambda *args: True
 
+#print(block_rlps[116525].encode('hex'))
+#sys.exit()
+
 # process blocks
 st = time.time()
 num_blks = 0
 num_txs = 0
 gas_used = 0
-for block in block_rlps[1:50000]:
+for i, block in list(enumerate(block_rlps))[1:250000]:
     # print 'prevh:', s.prev_headers
     block = rlp.decode(block, Block)
+    #if i == 116525:
+    #    configure_logging(config_string=config_string)
     assert c.add_block(block)
     num_blks += 1
     num_txs += len(block.transactions)

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, config_homestead, config_tangerine, config_spurious, config_metropolis, Env
+from ethereum.config import default_config, config_frontier, 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
@@ -37,8 +37,9 @@ def mk_fake_header(blknum):
 
 
 configs = {
-    #"Homestead": config_homestead,
-    #"EIP150": config_tangerine,
+    "Frontier": config_frontier,
+    "Homestead": config_homestead,
+    "EIP150": config_tangerine,
     "EIP158": config_spurious,
     #"Metropolis": config_metropolis
 }

ethereum/transactions.py

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
 import rlp
-from bitcoin import encode_pubkey, N, encode_privkey
 from rlp.sedes import big_endian_int, binary
 from rlp.utils import str_to_bytes, ascii_chr
 from ethereum.utils import encode_hex
@@ -82,7 +81,7 @@ def sender(self):
                     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:
+                if self.r >= secpk1n or self.s >= secpk1n 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:
@@ -172,11 +171,11 @@ def __structlog__(self):
     # The >= operator is replaced by > because the integer division N/2 always produces the value
     # which is by 0.5 less than the real N/2
     def check_low_s_metropolis(self):
-        if self.s > N // 2:
+        if self.s > secpk1n // 2:
             raise InvalidTransaction("Invalid signature S value!")
 
     def check_low_s_homestead(self):
-        if self.s > N // 2 or self.s == 0:
+        if self.s > secpk1n // 2 or self.s == 0:
             raise InvalidTransaction("Invalid signature S value!")
 
 

ethereum/utils.py

@@ -4,7 +4,7 @@
 except ImportError:
     import sha3 as _sha3
     sha3_256 = lambda x: _sha3.keccak_256(x).digest()
-from bitcoin import privtopub, ecdsa_raw_sign, ecdsa_raw_recover, encode_pubkey
+from py_ecc.secp256k1 import privtopub, ecdsa_raw_sign, ecdsa_raw_recover
 import sys
 import rlp
 from rlp.sedes import big_endian_int, BigEndianInt, Binary
@@ -104,8 +104,8 @@ def ecrecover_to_pub(rawhash, v, r, s):
         except:
             pub = b"\x00" * 64
     else:
-        recovered_addr = ecdsa_raw_recover(rawhash, (v, r, s))
-        pub = encode_pubkey(recovered_addr, 'bin_electrum')
+        x, y = ecdsa_raw_recover(rawhash, (v, r, s))
+        pub = encode_int32(x) + encode_int32(y)
     assert len(pub) == 64
     return pub
 
@@ -184,10 +184,10 @@ def sha3(seed):
 assert encode_hex(sha3(b'')) == 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
 
 
-def privtoaddr(x):
-    if len(x) > 32:
-        x = decode_hex(x)
-    return sha3(privtopub(x)[1:])[12:]
+def privtoaddr(k):
+    k = normalize_key(k)
+    x, y  = privtopub(k)
+    return sha3(encode_int32(x) + encode_int32(y))[12:]
 
 
 def checksum_encode(addr): # Takes a 20-byte binary address as input

requirements.txt

@@ -1,9 +1,8 @@
-bitcoin
 pysha3>=1.0.1
 PyYAML
 repoze.lru
 pbkdf2
-pycryptodome>=3.3.1
 scrypt
+py_ecc
 rlp>=0.4.7
 https://github.com/ethereum/ethash/tarball/master