Merge branch 'state_revamp' of github.com:ethereum/pyethereum into state_revamp

Author: vub

ethereum/chain.py

@@ -1,4 +1,5 @@
 import time
+import itertools
 from ethereum import utils
 from ethereum.utils import parse_as_bin, big_endian_to_int
 from ethereum import parse_genesis_declaration
@@ -59,11 +60,11 @@ def __init__(self, genesis=None, env=None, coinbase=b'\x00' * 20, \
 
         self.head_hash = self.state.prev_headers[0].hash
         self.genesis = Block(self.state.prev_headers[0], [], [])
-        self.db.put('state:'+self.head_hash, self.state.trie.root_hash)
+        self.db.put(b'state:' + self.head_hash, self.state.trie.root_hash)
         self.db.put('GENESIS_NUMBER', str(self.state.block_number))
-        self.db.put('GENESIS_HASH', str(self.state.prev_headers[0].hash))
+        self.db.put('GENESIS_HASH', self.state.prev_headers[0].hash)
         assert self.state.block_number == self.state.prev_headers[0].number
-        self.db.put('score:' + self.state.prev_headers[0].hash, "0")
+        self.db.put(b'score:' + self.state.prev_headers[0].hash, "0")
         self.db.put('GENESIS_STATE', json.dumps(self.state.to_snapshot()))
         self.db.put(self.head_hash, 'GENESIS')
         self.min_gasprice = kwargs.get('min_gasprice', 5 * 10**9)
@@ -90,7 +91,7 @@ def mk_poststate_of_blockhash(self, blockhash):
         if self.db.get(blockhash) == 'GENESIS':
             return State.from_snapshot(json.loads(self.db.get('GENESIS_STATE')), self.env)
         state = State(env=self.env)
-        state.trie.root_hash = self.db.get('state:'+blockhash)
+        state.trie.root_hash = self.db.get(b'state:' + blockhash)
         block = rlp.decode(self.db.get(blockhash), Block)
         update_block_env_variables(state, block)
         state.gas_used = block.header.gas_used
@@ -141,14 +142,14 @@ def get_block(self, blockhash):
     # parent hash and see that it is one of its children
     def add_child(self, child):
         try:
-            existing = self.db.get('child:' + child.header.prevhash)
+            existing = self.db.get(b'child:' + child.header.prevhash)
         except:
-            existing = ''
+            existing = b''
         existing_hashes = []
         for i in range(0, len(existing), 32):
             existing_hashes.append(existing[i: i+32])
         if child.header.hash not in existing_hashes:
-            self.db.put('child:' + child.header.prevhash, existing + child.header.hash)
+            self.db.put(b'child:' + child.header.prevhash, existing + child.header.hash)
 
     def get_blockhash_by_number(self, number):
         try:
@@ -163,7 +164,7 @@ def get_block_by_number(self, number):
     def get_child_hashes(self, blockhash):
         o = []
         try:
-            data = self.db.get('child:' + blockhash)
+            data = self.db.get(b'child:' + blockhash)
             for i in range(0, len(data), 32):
                 o.append(data[i:i + 32])
             return o
@@ -181,14 +182,14 @@ def get_children(self, block):
     def get_score(self, block):
         if not block:
             return 0
-        key = 'score:' + block.header.hash
+        key = b'score:' + block.header.hash
         if key not in self.db:
             try:
                 parent_score = self.get_score(self.get_parent(block))
                 self.db.put(key, str(parent_score + block.difficulty +
                                      random.randrange(block.difficulty // 10**6 + 1)))
             except:
-                return int(self.db.get('score:' + block.prevhash))
+                return int(self.db.get(b'score:' + block.prevhash))
         return int(self.db.get(key))
 
     # These two functions should be called periodically so as to
@@ -234,20 +235,20 @@ def add_block(self, block):
                 log.info('Block %s with parent %s invalid, reason: %s' % (encode_hex(block.header.hash), encode_hex(block.header.prevhash), e))
                 return False
             self.db.put('block:' + str(block.header.number), block.header.hash)
-            self.db.put('state:' + block.header.hash, self.state.trie.root_hash)
+            self.db.put(b'state:' + block.header.hash, self.state.trie.root_hash)
             self.head_hash = block.header.hash
             for i, tx in enumerate(block.transactions):
-                self.db.put('txindex:' + tx.hash, rlp.encode([block.number, i]))
+                self.db.put(b'txindex:' + tx.hash, rlp.encode([block.number, i]))
         elif block.header.prevhash in self.env.db:
             log.info('Receiving block not on head, adding to secondary post state',
                      prevhash=encode_hex(block.header.prevhash))
             temp_state = self.mk_poststate_of_blockhash(block.header.prevhash)
             try:
                 apply_block(temp_state, block)
-            except (KeyError, ValueError), e:  # FIXME add relevant exceptions here
+            except (KeyError, ValueError) as e:  # FIXME add relevant exceptions here
                 log.info('Block %s with parent %s invalid, reason: %s' % (encode_hex(block.header.hash), encode_hex(block.header.prevhash), e))
                 return False
-            self.db.put('state:' + block.header.hash, temp_state.trie.root_hash)
+            self.db.put(b'state:' + block.header.hash, temp_state.trie.root_hash)
             block_score = self.get_score(block)
             # Replace the head
             if block_score > self.get_score(self.head):
@@ -263,21 +264,21 @@ def add_block(self, block):
                         break
                     b = self.get_parent(b)
                 replace_from = b.header.number
-                for i in xrange(replace_from, 2**63 - 1):
+                for i in itertools.count(replace_from):
                     log.info('Rewriting height %d' % i)
                     key = 'block:' + str(i)
                     orig_at_height = self.db.get(key) if key in self.db else None
                     if orig_at_height:
                         self.db.delete(key)
                         orig_block_at_height = self.get_block(orig_at_height)
                         for tx in orig_block_at_height.transactions:
-                            if 'txindex:' + tx.hash in self.db:
-                                self.db.delete('txindex:' + tx.hash)
+                            if b'txindex:' + tx.hash in self.db:
+                                self.db.delete(b'txindex:' + tx.hash)
                     if i in new_chain:
                         new_block_at_height = new_chain[i]
                         self.db.put(key, new_block_at_height.header.hash)
                         for i, tx in enumerate(new_block_at_height.transactions):
-                            self.db.put('txindex:' + tx.hash,
+                            self.db.put(b'txindex:' + tx.hash,
                                         rlp.encode([new_block_at_height.number, i]))
                     if i not in new_chain and not orig_at_height:
                         break
@@ -324,7 +325,7 @@ def get_chain(self, frm=None, to=2**63 - 1):
         if frm is None:
             frm = int(self.db.get('GENESIS_NUMBER')) + 1
         chain = []
-        for i in xrange(frm, to):
+        for i in itertools.islice(itertools.count(), frm, to):
             h = self.get_blockhash_by_number(i)
             if not h:
                 return chain
@@ -334,8 +335,8 @@ def get_chain(self, frm=None, to=2**63 - 1):
     def get_transaction(self, tx):
         if not isinstance(tx, (str, bytes)):
             tx = tx.hash
-        if 'txindex:' + tx in self.db:
-            data = rlp.decode(self.db.get('txindex:' + tx))
+        if b'txindex:' + tx in self.db:
+            data = rlp.decode(self.db.get(b'txindex:' + tx))
             blk, index = self.get_block_by_number(
                 big_endian_to_int(data[0])), big_endian_to_int(data[1])
             tx = blk.transactions[index]

ethereum/consensus_strategy.py

@@ -10,7 +10,7 @@ def __init__(self, header_check, header_validate, uncle_validate, block_setup, b
 
 def get_consensus_strategy(config):
     if config['CONSENSUS_STRATEGY'] in ('pow', 'ethpow', 'ethash', 'ethereum1'):
-        from ethpow_utils import ethereum1_check_header, ethereum1_validate_header, \
+        from ethereum.ethpow_utils import ethereum1_check_header, ethereum1_validate_header, \
                                  ethereum1_validate_uncle, ethereum1_pre_finalize_block, \
                                  ethereum1_post_finalize_block, ethereum1_setup_block
         return ConsensusStrategy(
@@ -23,7 +23,7 @@ def get_consensus_strategy(config):
             state_initialize=None
         )
     elif config['CONSENSUS_STRATEGY'] == 'casper':
-        from casper_utils import casper_validate_header, casper_state_initialize, casper_post_finalize_block, casper_setup_block
+        from ethereum.casper_utils import casper_validate_header, casper_state_initialize, casper_post_finalize_block, casper_setup_block
         return ConsensusStrategy(
             header_check=None,
             header_validate=casper_validate_header,

ethereum/state_transition.py

@@ -214,9 +214,9 @@ def apply_message(state, msg=None, **kwargs):
         msg = vm.Message(**kwargs)
     else:
         assert not kwargs
-    ext = VMExt(state, transactions.Transaction(0, 0, 21000, '', 0, ''))
+    ext = VMExt(state, transactions.Transaction(0, 0, 21000, b'', 0, b''))
     result, gas_remained, data = apply_msg(ext, msg)
-    return ''.join(map(chr, data)) if result else None
+    return b''.join(map(lambda d: bytes([d]), data)) if result else None
 
 
 def apply_transaction(state, tx):
@@ -464,7 +464,7 @@ def __init__(self, state):
         for k, v in state.config['CUSTOM_SPECIALS']:
             self.specials[k] = v
         self._state = state
-        self.get_code = lambda addr: ''
+        self.get_code = lambda addr: b''
         self.set_code = lambda addr, code: None
         self.get_balance = lambda addr: 0
         self.set_balance = lambda addr, value: None
@@ -485,10 +485,10 @@ def __init__(self, state):
         self.block_difficulty = 0
         self.block_gas_limit = 0
         self.log = lambda addr, topics, data: None
-        self.create = lambda msg: 0, 0, ''
+        self.create = lambda msg: 0, 0, b''
         self.msg = lambda msg: _apply_msg(
-            self, msg, '') if msg.code_address in self.specials else (0, 0, '')
-        self.blackbox_msg = lambda msg, code: 0, 0, ''
+            self, msg, '') if msg.code_address in self.specials else (0, 0, b'')
+        self.blackbox_msg = lambda msg, code: 0, 0, b''
         self.account_exists = lambda addr: False
         self.post_homestead_hardfork = lambda: state.is_HOMESTEAD()
         self.post_metropolis_hardfork = lambda: state.is_METROPOLIS()

ethereum/tests/test_chain.py

@@ -212,9 +212,9 @@ def test_invalid_transaction(db):
 def test_prevhash(db):
     chain = Chain({}, difficulty=1, min_gasprice=0)
     L1 = mine_on_chain(chain)
-    assert chain.state.get_block_hash(0) != '\x00'*32
-    assert chain.state.get_block_hash(1) != '\x00'*32
-    assert chain.state.get_block_hash(2) == '\x00'*32
+    assert chain.state.get_block_hash(0) != b'\x00'*32
+    assert chain.state.get_block_hash(1) != b'\x00'*32
+    assert chain.state.get_block_hash(2) == b'\x00'*32
 
 
 def test_genesis_chain(db):