Support custom genesis file via EIP 1085

Author: cburgdorf

MANIFEST.in

@@ -5,3 +5,5 @@ include requirements.txt
 
 recursive-exclude * __pycache__
 recursive-exclude * *.py[co]
+
+include trinity/assets/*

eth/chains/__init__.py

@@ -1,5 +1,4 @@
 from .base import (  # noqa: F401
-    AsyncChain,
     Chain,
 )
 from .mainnet import (  # noqa: F401

eth/chains/base.py

@@ -143,10 +143,6 @@ def __init__(self) -> None:
     def get_chaindb_class(cls) -> Type[BaseChainDB]:
         raise NotImplementedError("Chain classes must implement this method")
 
-    @classmethod
-    def get_vm_configuration(cls) -> Tuple[Tuple[int, Type['BaseVM']], ...]:
-        return cls.vm_configuration
-
     #
     # Chain API
     #
@@ -918,39 +914,3 @@ def get_vm(self, at_header: BlockHeader=None) -> 'BaseVM':
             at_header = self.header
 
         return super().get_vm(at_header)
-
-
-# This class is a work in progress; its main purpose is to define the API of an asyncio-compatible
-# Chain implementation.
-class AsyncChain(Chain):
-    # TODO: this really belongs in the `trinity` module.
-
-    async def coro_import_block(self,
-                                block: BlockHeader,
-                                perform_validation: bool=True,
-                                ) -> Tuple[BaseBlock, Tuple[BaseBlock, ...], Tuple[BaseBlock, ...]]:
-        raise NotImplementedError()
-
-    async def coro_validate_chain(
-            self,
-            parent: BlockHeader,
-            chain: Tuple[BlockHeader, ...],
-            seal_check_random_sample_rate: int = 1) -> None:
-        raise NotImplementedError()
-
-    async def coro_validate_receipt(self,
-                                    receipt: Receipt,
-                                    at_header: BlockHeader) -> None:
-        raise NotImplementedError()
-
-    async def coro_get_block_by_hash(self,
-                                     block_hash: Hash32) -> BaseBlock:
-        raise NotImplementedError()
-
-    async def coro_get_block_by_header(self,
-                                       header: BlockHeader) -> BaseBlock:
-        raise NotImplementedError()
-
-    async def coro_get_canonical_block_by_number(self,
-                                                 block_number: BlockNumber) -> BaseBlock:
-        raise NotImplementedError()

setup.py

@@ -48,6 +48,7 @@
         "termcolor>=1.1.0,<2.0.0",
         "uvloop==0.11.2;platform_system=='Linux' or platform_system=='Darwin' or platform_system=='FreeBSD'",
         "websockets==5.0.1",
+        "jsonschema==2.6.0",
     ],
     'test': [
         "hypothesis==3.69.5",

tests/trinity/core/configuration/test_chain_config_object.py

@@ -0,0 +1,105 @@
+import pytest
+
+from eth_utils import (
+    decode_hex,
+    to_int,
+)
+
+from eth.db.atomic import AtomicDB
+from eth.vm.forks.constantinople import ConstantinopleVM
+from eth.vm.forks.homestead import HomesteadVM
+from eth.chains.mainnet import (
+    MainnetChain,
+    MAINNET_GENESIS_HEADER,
+)
+from eth.chains.ropsten import (
+    RopstenChain,
+    ROPSTEN_GENESIS_HEADER,
+)
+
+from trinity.config import (
+    ChainConfig,
+)
+from trinity.constants import (
+    MAINNET_NETWORK_ID,
+    ROPSTEN_NETWORK_ID,
+)
+from trinity.utils.db import MemoryDB
+from trinity.utils.eip1085 import validate_raw_eip1085_genesis_config
+
+
+def assert_vm_configuration_equal(left, right):
+    assert len(left) == len(right), "Length mismatch"
+
+    for ((left_block, left_vm), (right_block, right_vm)) in zip(left, right):
+        assert left_vm.fork is not None
+        assert left_vm.fork == right_vm.fork
+        assert left_block == right_block
+
+        if isinstance(left_vm, HomesteadVM):
+            assert left_vm.support_dao_fork is right_vm.support_dao_fork
+            assert left_vm.dao_fork_block_number == right_vm.dao_fork_block_number
+
+
+@pytest.mark.parametrize(
+    'network_id',
+    (MAINNET_NETWORK_ID, ROPSTEN_NETWORK_ID),
+)
+def test_chain_config_from_preconfigured_network(network_id):
+    chain_config = ChainConfig.from_preconfigured_network(network_id)
+    chain = chain_config.initialize_chain(AtomicDB(MemoryDB()))
+
+    if network_id == MAINNET_NETWORK_ID:
+        assert chain_config.chain_id == MainnetChain.chain_id
+        assert_vm_configuration_equal(chain_config.vm_configuration, MainnetChain.vm_configuration)
+        assert chain.get_canonical_head() == MAINNET_GENESIS_HEADER
+    elif network_id == ROPSTEN_NETWORK_ID:
+        assert chain_config.chain_id == RopstenChain.chain_id
+        assert_vm_configuration_equal(chain_config.vm_configuration, RopstenChain.vm_configuration)
+        assert chain.get_canonical_head() == ROPSTEN_GENESIS_HEADER
+    else:
+        assert False, "Invariant: unreachable code path"
+
+
+EIP1085_GENESIS_CONFIG = {
+    "version": "1",
+    "params": {
+        "miningMethod": "NoProof",
+        "homesteadForkBlock": "0x00",
+        "EIP150ForkBlock": "0x00",
+        "EIP158ForkBlock": "0x00",
+        "byzantiumForkBlock": "0x00",
+        "constantinopleForkBlock": "0x00",
+        "chainId": "0x04d2",
+    },
+    "genesis": {
+        "nonce": "0x0000000000000042",
+        "difficulty": "0x020000",
+        "author": "0x0000000000000000000000000000000000000000",
+        "timestamp": "0x00",
+        "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
+        "gasLimit": "0x1388"
+    }
+}
+
+
+def test_chain_config_eip1085_fixture_is_valid():
+    # Sanity check in case this fixture is no longer actually valid against the
+    # spec which has not been finalized at the time this was created.
+    validate_raw_eip1085_genesis_config(EIP1085_GENESIS_CONFIG)
+
+
+def test_chain_config_from_eip1085_genesis_config():
+    chain_config = ChainConfig.from_eip1085_genesis_config(EIP1085_GENESIS_CONFIG)
+
+    assert chain_config.chain_id == 1234
+    assert chain_config.vm_configuration == ((0, ConstantinopleVM),)
+
+    params = chain_config.genesis_params
+
+    assert params.nonce == decode_hex(EIP1085_GENESIS_CONFIG['genesis']['nonce'])
+    assert params.difficulty == to_int(hexstr=EIP1085_GENESIS_CONFIG['genesis']['difficulty'])
+    assert params.coinbase == decode_hex(EIP1085_GENESIS_CONFIG['genesis']['author'])
+    assert params.timestamp == to_int(hexstr=EIP1085_GENESIS_CONFIG['genesis']['timestamp'])
+    assert params.extra_data == decode_hex(EIP1085_GENESIS_CONFIG['genesis']['extraData'])
+    assert params.gas_limit == to_int(hexstr=EIP1085_GENESIS_CONFIG['genesis']['gasLimit'])

tests/trinity/core/eip1085-utils/test_eip1085_generate_vm_configuration.py

@@ -0,0 +1,140 @@
+import pytest
+
+from eth.vm.forks import (
+    TangerineWhistleVM,
+    FrontierVM,
+    HomesteadVM,
+    SpuriousDragonVM,
+    ByzantiumVM,
+    ConstantinopleVM,
+)
+
+from trinity.utils.eip1085 import extract_vm_configuration
+
+
+def wrap_config(v):
+    return {'params': v}
+
+
+CONSTANTINOPLE_AT_0 = wrap_config({
+    "homesteadForkBlock": "0x00",
+    "EIP150ForkBlock": "0x00",
+    "EIP158ForkBlock": "0x00",
+    "byzantiumForkBlock": "0x00",
+    "constantinopleForkBlock": "0x00",
+})
+CONSTANTINOPLE_AT_0_CONFIG = (
+    (0, ConstantinopleVM),
+)
+
+CONSTANTINOPLE_AT_5 = wrap_config({
+    "homesteadForkBlock": "0x00",
+    "EIP150ForkBlock": "0x00",
+    "EIP158ForkBlock": "0x00",
+    "byzantiumForkBlock": "0x00",
+    "constantinopleForkBlock": "0x05",
+})
+CONSTANTINOPLE_AT_5_CONFIG = (
+    (0, ByzantiumVM),
+    (5, ConstantinopleVM),
+)
+
+BYZANTIUM_AT_0 = wrap_config({
+    "homesteadForkBlock": "0x00",
+    "EIP150ForkBlock": "0x00",
+    "EIP158ForkBlock": "0x00",
+    "byzantiumForkBlock": "0x00",
+})
+BYZANTIUM_AT_0_CONFIG = (
+    (0, ByzantiumVM),
+)
+
+BYZANTIUM_AT_5 = wrap_config({
+    "homesteadForkBlock": "0x00",
+    "EIP150ForkBlock": "0x00",
+    "EIP158ForkBlock": "0x00",
+    "byzantiumForkBlock": "0x05",
+})
+BYZANTIUM_AT_5_CONFIG = (
+    (0, SpuriousDragonVM),
+    (5, ByzantiumVM),
+)
+
+SPURIOUS_AT_0 = wrap_config({
+    "homesteadForkBlock": "0x00",
+    "EIP150ForkBlock": "0x00",
+    "EIP158ForkBlock": "0x00",
+})
+SPURIOUS_AT_0_CONFIG = (
+    (0, SpuriousDragonVM),
+)
+
+SPURIOUS_AT_5 = wrap_config({
+    "homesteadForkBlock": "0x00",
+    "EIP150ForkBlock": "0x00",
+    "EIP158ForkBlock": "0x05",
+})
+SPURIOUS_AT_5_CONFIG = (
+    (0, TangerineWhistleVM),
+    (5, SpuriousDragonVM),
+)
+
+TANGERINE_AT_0 = wrap_config({
+    "homesteadForkBlock": "0x00",
+    "EIP150ForkBlock": "0x00",
+})
+TANGERINE_AT_0_CONFIG = (
+    (0, TangerineWhistleVM),
+)
+
+TANGERINE_AT_5 = wrap_config({
+    "homesteadForkBlock": "0x00",
+    "EIP150ForkBlock": "0x05",
+})
+TANGERINE_AT_5_CONFIG = (
+    (0, HomesteadVM),
+    (5, TangerineWhistleVM),
+)
+
+HOMESTEAD_AT_0 = wrap_config({
+    "homesteadForkBlock": "0x00",
+})
+HOMESTEAD_AT_0_CONFIG = (
+    (0, HomesteadVM),
+)
+
+HOMESTEAD_AT_5 = wrap_config({
+    "homesteadForkBlock": "0x05",
+})
+HOMESTEAD_AT_5_CONFIG = (
+    (0, FrontierVM),
+    (5, HomesteadVM),
+)
+
+FRONTIER_AT_0 = wrap_config({
+    "frontierForkBlock": "0x00",
+})
+FRONTIER_AT_0_CONFIG = (
+    (0, FrontierVM),
+)
+
+
+@pytest.mark.parametrize(
+    'genesis_config,expected',
+    (
+        (CONSTANTINOPLE_AT_0, CONSTANTINOPLE_AT_0_CONFIG),
+        (CONSTANTINOPLE_AT_5, CONSTANTINOPLE_AT_5_CONFIG),
+        (BYZANTIUM_AT_0, BYZANTIUM_AT_0_CONFIG),
+        (BYZANTIUM_AT_5, BYZANTIUM_AT_5_CONFIG),
+        (SPURIOUS_AT_0, SPURIOUS_AT_0_CONFIG),
+        (SPURIOUS_AT_5, SPURIOUS_AT_5_CONFIG),
+        (TANGERINE_AT_0, TANGERINE_AT_0_CONFIG),
+        (TANGERINE_AT_5, TANGERINE_AT_5_CONFIG),
+        (HOMESTEAD_AT_0, HOMESTEAD_AT_0_CONFIG),
+        (HOMESTEAD_AT_5, HOMESTEAD_AT_5_CONFIG),
+        (FRONTIER_AT_0, FRONTIER_AT_0_CONFIG),
+    ),
+)
+def test_eip1085_extract_vm_configuration(genesis_config, expected):
+    actual = extract_vm_configuration(genesis_config)
+    assert actual == expected

tests/trinity/core/eip1085-utils/test_extract_genesis_params.py

@@ -0,0 +1,69 @@
+import pytest
+
+from eth_utils import (
+    to_int,
+    to_hex,
+    to_bytes,
+    to_canonical_address,
+)
+from eth_utils.curried import (
+    hexstr_if_str,
+)
+from eth_utils.toolz import (
+    merge,
+    valmap,
+)
+
+from trinity.utils.eip1085 import (
+    GenesisParams,
+    extract_genesis_params,
+)
+
+
+PARAMS_DEFAULTS = {
+    "nonce": "0x0000000000000042",
+    "difficulty": "0x020000",
+    "author": "0x0000000000000000000000000000000000000000",
+    "timestamp": "0x00",
+    "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
+    "gasLimit": "0x1388"
+}
+N_PARAMS_DEFAULTS = {
+    "nonce": to_bytes(hexstr=PARAMS_DEFAULTS['nonce']),
+    "difficulty": to_int(hexstr=PARAMS_DEFAULTS['difficulty']),
+    "coinbase": to_canonical_address(PARAMS_DEFAULTS['author']),
+    "timestamp": to_int(hexstr=PARAMS_DEFAULTS['timestamp']),
+    "extra_data": to_bytes(hexstr=PARAMS_DEFAULTS['extraData']),
+    "gas_limit": to_int(hexstr=PARAMS_DEFAULTS['gasLimit']),
+}
+
+
+ADDRESS = b'12345678901234567890'
+HASH32 = b'unicornsrainbows' * 2
+
+
+def _mk_raw_params(**kwargs):
+    return {
+        'genesis': merge(PARAMS_DEFAULTS, valmap(hexstr_if_str(to_hex), kwargs)),
+    }
+
+
+def _mk_params(**kwargs):
+    return GenesisParams(**merge(N_PARAMS_DEFAULTS, kwargs))
+
+
+@pytest.mark.parametrize(
+    'raw_genesis_config,expected',
+    (
+        (_mk_raw_params(), _mk_params()),
+        (_mk_raw_params(nonce=b'unicorns'), _mk_params(nonce=b'unicorns')),
+        (_mk_raw_params(difficulty=1234), _mk_params(difficulty=1234)),
+        (_mk_raw_params(author=ADDRESS), _mk_params(coinbase=ADDRESS)),
+        (_mk_raw_params(timestamp=1234), _mk_params(timestamp=1234)),
+        (_mk_raw_params(extraData=HASH32), _mk_params(extra_data=HASH32)),
+        (_mk_raw_params(gasLimit=1234), _mk_params(gas_limit=1234)),
+    ),
+)
+def test_extract_genesis_params(raw_genesis_config, expected):
+    actual = extract_genesis_params(raw_genesis_config)
+    assert actual == expected