Merge pull request #718 from ethereum/state_revamp_with_p62

Catch the mainnet

Author: Jan Xie

ethereum/__init__.py

@@ -31,7 +31,7 @@
         match = GIT_DESCRIBE_RE.match(rev)
         if match:
             __version__ = "{}+git-{}".format(match.group("version"), match.group("git"))
-    except:
+    except:  # FIXME!
         pass
 
 if not __version__:

ethereum/abi.py

@@ -11,7 +11,7 @@
 
 from ethereum import utils
 from ethereum.utils import (
-    big_endian_to_int, ceil32, int_to_big_endian, encode_int, is_numeric, isnumeric, is_string,
+    big_endian_to_int, ceil32, int_to_big_endian, encode_int, is_numeric, is_string,
     rzpad, TT255, TT256, zpad,
 )
 
@@ -362,7 +362,7 @@ def encode_single(typ, arg):  # pylint: disable=too-many-return-statements,too-m
         if not (int(sub) and int(sub) <= 32):
             raise EncodingError('too long: %r' % arg)
 
-        if isnumeric(arg):
+        if is_numeric(arg):
             return zpad(encode_int(arg), 32)
 
         if len(arg) == int(sub):
@@ -376,7 +376,7 @@ def encode_single(typ, arg):  # pylint: disable=too-many-return-statements,too-m
     if base == 'address':
         assert sub == ''
 
-        if isnumeric(arg):
+        if is_numeric(arg):
             return zpad(encode_int(arg), 32)
 
         if len(arg) == 20:
@@ -734,9 +734,9 @@ def decode_single(typ, data):
             l = big_endian_to_int(data[0:32])
             return data[32:][:l]
     elif base == 'uint':
-        return big_endian_to_int(data)
+        return big_endian_to_int(data) % 2**int(sub)
     elif base == 'int':
-        o = big_endian_to_int(data)
+        o = big_endian_to_int(data) % 2 ** int(sub)
         return (o - 2 ** int(sub)) if o >= 2 ** (int(sub) - 1) else o
     elif base == 'ufixed':
         high, low = [int(x) for x in sub.split('x')]

ethereum/block.py

@@ -0,0 +1,202 @@
+import rlp
+from ethereum.utils import normalize_address, hash32, trie_root, \
+    big_endian_int, address, int256, encode_hex, encode_int, sha3
+from rlp.sedes import big_endian_int, Binary, binary, CountableList
+from ethereum import utils
+from ethereum import trie
+from ethereum.trie import Trie
+from ethereum.securetrie import SecureTrie
+from ethereum.config import default_config
+from ethereum.transactions import Transaction
+from ethereum.db import BaseDB
+import sys
+if sys.version_info.major == 2:
+    from repoze.lru import lru_cache
+else:
+    from functools import lru_cache
+
+
+class BlockHeader(rlp.Serializable):
+
+    """A block header.
+
+    If the block with this header exists as an instance of :class:`Block`, the
+    connection can be made explicit by setting :attr:`BlockHeader.block`. Then,
+    :attr:`BlockHeader.state_root`, :attr:`BlockHeader.tx_list_root` and
+    :attr:`BlockHeader.receipts_root` always refer to the up-to-date value in
+    the block instance.
+
+    :ivar block: an instance of :class:`Block` or `None`
+    :ivar prevhash: the 32 byte hash of the previous block
+    :ivar uncles_hash: the 32 byte hash of the RLP encoded list of uncle
+                       headers
+    :ivar coinbase: the 20 byte coinbase address
+    :ivar state_root: the root of the block's state trie
+    :ivar tx_list_root: the root of the block's transaction trie
+    :ivar receipts_root: the root of the block's receipts trie
+    :ivar bloom: TODO
+    :ivar difficulty: the block's difficulty
+    :ivar number: the number of ancestors of this block (0 for the genesis
+                  block)
+    :ivar gas_limit: the block's gas limit
+    :ivar gas_used: the total amount of gas used by all transactions in this
+                    block
+    :ivar timestamp: a UNIX timestamp
+    :ivar extra_data: up to 1024 bytes of additional data
+    :ivar nonce: a 32 byte nonce constituting a proof-of-work, or the empty
+                 string as a placeholder
+    """
+
+    fields = [
+        ('prevhash', hash32),
+        ('uncles_hash', hash32),
+        ('coinbase', address),
+        ('state_root', trie_root),
+        ('tx_list_root', trie_root),
+        ('receipts_root', trie_root),
+        ('bloom', int256),
+        ('difficulty', big_endian_int),
+        ('number', big_endian_int),
+        ('gas_limit', big_endian_int),
+        ('gas_used', big_endian_int),
+        ('timestamp', big_endian_int),
+        ('extra_data', binary),
+        ('mixhash', binary),
+        ('nonce', binary)
+    ]
+
+    def __init__(self,
+                 prevhash=default_config['GENESIS_PREVHASH'],
+                 uncles_hash=utils.sha3rlp([]),
+                 coinbase=default_config['GENESIS_COINBASE'],
+                 state_root=trie.BLANK_ROOT,
+                 tx_list_root=trie.BLANK_ROOT,
+                 receipts_root=trie.BLANK_ROOT,
+                 bloom=0,
+                 difficulty=default_config['GENESIS_DIFFICULTY'],
+                 number=0,
+                 gas_limit=default_config['GENESIS_GAS_LIMIT'],
+                 gas_used=0,
+                 timestamp=0,
+                 extra_data='',
+                 mixhash=default_config['GENESIS_MIXHASH'],
+                 nonce=''):
+        # at the beginning of a method, locals() is a dict of all arguments
+        fields = {k: v for k, v in locals().items() if k != 'self'}
+        if len(fields['coinbase']) == 40:
+            fields['coinbase'] = decode_hex(fields['coinbase'])
+        assert len(fields['coinbase']) == 20
+        self.block = None
+        super(BlockHeader, self).__init__(**fields)
+
+    @property
+    def hash(self):
+        """The binary block hash"""
+        return utils.sha3(rlp.encode(self))
+
+    @property
+    def hex_hash(self):
+        return encode_hex(self.hash)
+
+    @property
+    def mining_hash(self):
+        return utils.sha3(rlp.encode(self, BlockHeader.exclude(['mixhash', 'nonce'])))
+
+    @property
+    def signing_hash(self):
+        return utils.sha3(rlp.encode(self, BlockHeader.exclude(['extra_data'])))
+
+    def to_dict(self):
+        """Serialize the header to a readable dictionary."""
+        d = {}
+        for field in ('prevhash', 'uncles_hash', 'extra_data', 'nonce',
+                      'mixhash'):
+            d[field] = b'0x' + encode_hex(getattr(self, field))
+        for field in ('state_root', 'tx_list_root', 'receipts_root',
+                      'coinbase'):
+            d[field] = encode_hex(getattr(self, field))
+        for field in ('number', 'difficulty', 'gas_limit', 'gas_used',
+                      'timestamp'):
+            d[field] = to_string(getattr(self, field))
+        d['bloom'] = encode_hex(int256.serialize(self.bloom))
+        assert len(d) == len(BlockHeader.fields)
+        return d
+
+    def __repr__(self):
+        return '<%s(#%d %s)>' % (self.__class__.__name__, self.number,
+                                 encode_hex(self.hash)[:8])
+
+    def __eq__(self, other):
+        """Two blockheader are equal iff they have the same hash."""
+        return isinstance(other, BlockHeader) and self.hash == other.hash
+
+    def __hash__(self):
+        return utils.big_endian_to_int(self.hash)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
+class Block(rlp.Serializable):
+
+    """A block.
+
+    All attributes from the block header are accessible via properties
+    (i.e. ``block.prevhash`` is equivalent to ``block.header.prevhash``). It
+    is ensured that no discrepancies between header and block occur.
+
+    :param header: the block header
+    :param transactions: a list of transactions which are replayed if the
+                         state given by the header is not known. If the
+                         state is known, `None` can be used instead of the
+                         empty list.
+    :param uncles: a list of the headers of the uncles of this block
+    :param db: the database in which the block's  state, transactions and
+               receipts are stored (required)
+    :param parent: optional parent which if not given may have to be loaded from
+                   the database for replay
+    """
+
+    fields = [
+        ('header', BlockHeader),
+        ('transactions', CountableList(Transaction)),
+        ('uncles', CountableList(BlockHeader))
+    ]
+
+    def __init__(self, header, transactions=None, uncles=None, db=None):
+        # assert isinstance(db, BaseDB), "No database object given"
+        # self.db = db
+
+        self.header = header
+        self.transactions = transactions or []
+        self.uncles = uncles or []
+        self.uncles = list(self.uncles)
+
+    def __getattribute__(self, name):
+        try:
+            return rlp.Serializable.__getattribute__(self, name)
+        except AttributeError:
+            return getattr(self.header, name)
+
+    # TODO: remove chain_difficulty mock
+    def chain_difficulty(self):
+        return self.header.number + 1
+
+    @property
+    def transaction_count(self):
+        return len(self.transactions)
+
+
+BLANK_UNCLES_HASH = sha3(rlp.encode([]))
+
+
+class FakeHeader():
+
+    def __init__(self, hash='\x00' * 32, number=0, timestamp=0, difficulty=1, gas_limit=3141592, gas_used=0, uncles_hash=BLANK_UNCLES_HASH):
+        self.hash = hash
+        self.number = number
+        self.timestamp = timestamp
+        self.difficulty = difficulty
+        self.gas_limit = gas_limit
+        self.gas_used = gas_used
+        self.uncles_hash = uncles_hash

ethereum/block_creation.py

@@ -0,0 +1,63 @@
+import time
+import rlp
+from ethereum.config import default_config
+from ethereum.state_transition import check_gaslimit, initialize, \
+    validate_uncles, pre_seal_finalize, mk_receipt_sha, mk_transaction_sha, \
+    apply_transaction
+from ethereum.consensus_strategy import get_consensus_strategy
+from ethereum.exceptions import InsufficientBalance, BlockGasLimitReached, \
+    InsufficientStartGas, InvalidNonce, UnsignedTransaction
+from ethereum.utils import sha3
+from ethereum.state import State
+from ethereum import casper_utils, ethpow_utils
+from ethereum.slogging import get_logger
+log = get_logger('eth.block_creation')
+
+
+def add_transactions(state, block, txqueue, min_gasprice=0):
+    pre_txs = len(block.transactions)
+    log.info('Adding transactions, %d in txqueue, %d dunkles' % (len(txqueue.txs), pre_txs))
+    while 1:
+        tx = txqueue.pop_transaction(max_gas=state.gas_limit - state.gas_used,
+                                     min_gasprice=min_gasprice)
+        if tx is None:
+            break
+        try:
+            apply_transaction(state, tx)
+            block.transactions.append(tx)
+        except (InsufficientBalance, BlockGasLimitReached, InsufficientStartGas,
+                InvalidNonce, UnsignedTransaction) as e:
+            pass
+    log.info('Added %d transactions' % (len(block.transactions) - pre_txs))
+
+
+def pre_seal(state, block):
+    pre_seal_finalize(state, block)
+    block.header.receipts_root = mk_receipt_sha(state.receipts)
+    block.header.tx_list_root = mk_transaction_sha(block.transactions)
+    state.commit()
+    block.header.state_root = state.trie.root_hash
+    block.header.gas_used = state.gas_used
+    block.header.bloom = state.bloom
+    log.info('Block pre-sealed, %d gas used' % state.gas_used)
+
+
+def make_head_candidate(chain, txqueue,
+                        parent=None,
+                        timestamp=None,
+                        coinbase='\x35'*20,
+                        extra_data='moo ha ha says the laughing cow.',
+                        min_gasprice=0):
+    log.info('Creating head candidate')
+    if parent is None:
+        temp_state = State.from_snapshot(chain.state.to_snapshot(root_only=True), chain.env)
+    else:
+        temp_state = chain.mk_poststate_of_blockhash(parent.hash)
+
+    cs = get_consensus_strategy(chain.env.config)
+    block = cs.block_setup(chain, temp_state, timestamp, coinbase, extra_data)
+    add_transactions(temp_state, block, txqueue, min_gasprice)
+    pre_seal(temp_state, block)
+    assert validate_uncles(temp_state, block)
+    log.info('Created head candidate successfully')
+    return block