[WIP] Eth to method

ens/utils.py

@@ -212,3 +212,15 @@ def assert_signer_in_modifier_kwargs(modifier_kwargs: Any) -> ChecksumAddress:
 
 def is_none_or_zero_address(addr: Union[Address, ChecksumAddress, HexAddress]) -> bool:
     return not addr or addr == EMPTY_ADDR_HEX
+
+
+# Check everything short of validating that a name
+# resolves to an address
+def is_valid_domain(domain: str) -> bool:
+    split_domain = domain.split('.')
+    if len(split_domain) == 1:
+        return False
+    for name in split_domain:
+        if not is_valid_name(name):
+            return False
+    return True

ethpm/_utils/deployments.py

@@ -6,6 +6,9 @@
     Tuple,
 )
 
+from eth_typing import (
+    HexStr,
+)
 from eth_utils import (
     is_same_address,
     to_bytes,
@@ -14,9 +17,6 @@
 from eth_utils.toolz import (
     get_in,
 )
-from hexbytes import (
-    HexBytes,
-)
 
 from ethpm.exceptions import (
     BytecodeLinkingError,
@@ -47,7 +47,7 @@ def get_linked_deployments(deployments: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def validate_linked_references(
-    link_deps: Tuple[Tuple[int, bytes], ...], bytecode: HexBytes
+    link_deps: Tuple[Tuple[int, bytes], ...], bytecode: HexStr
 ) -> None:
     """
     Validates that normalized linked_references (offset, expected_bytes)

setup.py

@@ -73,7 +73,7 @@
         "eth-account>=0.5.2,<0.6.0",
         "eth-hash[pycryptodome]>=0.2.0,<1.0.0",
         "eth-typing>=2.0.0,<3.0.0",
-        "eth-utils>=1.9.3,<2.0.0",
+        "eth-utils==1.9.3",
         "hexbytes>=0.1.0,<1.0.0",
         "ipfshttpclient>=0.4.13,<1",
         "jsonschema>=3.2.0,<4.0.0",

tests/core/eth-module/test_eth_properties.py

@@ -1,5 +1,5 @@
 def test_eth_protocolVersion(web3):
-    assert web3.eth.protocolVersion == '63'
+    assert web3.eth.protocolVersion == '65'
 
 
 def test_eth_chainId(web3):

tests/core/gas-strategies/test_time_based_gas_price_strategy.py

@@ -20,6 +20,7 @@ def _get_block_by_something(method, params):
     if (
         block_identifier == 'latest' or
         block_identifier == '0x0000000000000000000000000000000000000000000000000000000000000005' or
+        block_identifier == '0x5' or
         block_identifier == 5
     ):
         return {
@@ -35,11 +36,12 @@ def _get_block_by_something(method, params):
                 {'gasPrice': 5},
                 {'gasPrice': 50},
             ],
-            'miner': '0xA',
+            'miner': '0x' + 'AA' * 20,
             'timestamp': 120,
         }
     elif (
         block_identifier == '0x0000000000000000000000000000000000000000000000000000000000000004' or
+        block_identifier == '0x4' or
         block_identifier == 4
     ):
         return {
@@ -51,11 +53,12 @@ def _get_block_by_something(method, params):
                 {'gasPrice': 80},
                 {'gasPrice': 60},
             ],
-            'miner': '0xB',
+            'miner': '0x' + 'BB' * 20,
             'timestamp': 90,
         }
     elif (
         block_identifier == '0x0000000000000000000000000000000000000000000000000000000000000003' or
+        block_identifier == '0x3' or
         block_identifier == 3
     ):
         return {
@@ -65,11 +68,12 @@ def _get_block_by_something(method, params):
             'transactions': [
                 {'gasPrice': 100},
             ],
-            'miner': '0xC',
+            'miner': '0x' + 'CC' * 20,
             'timestamp': 60,
         }
     elif (
         block_identifier == '0x0000000000000000000000000000000000000000000000000000000000000002' or
+        block_identifier == '0x2' or
         block_identifier == 2
     ):
         return {
@@ -78,11 +82,12 @@ def _get_block_by_something(method, params):
             'parentHash': '0x0000000000000000000000000000000000000000000000000000000000000001',
             'transactions': [
             ],
-            'miner': '0xB',
+            'miner': '0x' + 'BB' * 20,
             'timestamp': 30,
         }
     elif (
         block_identifier == '0x0000000000000000000000000000000000000000000000000000000000000001' or
+        block_identifier == '0x1' or
         block_identifier == 1
     ):
         return {
@@ -94,11 +99,12 @@ def _get_block_by_something(method, params):
                 {'gasPrice': 35},
                 {'gasPrice': 65},
             ],
-            'miner': '0xA',
+            'miner': '0x' + 'AA' * 20,
             'timestamp': 15,
         }
     elif (
         block_identifier == '0x0000000000000000000000000000000000000000000000000000000000000000' or
+        block_identifier == '0x0' or
         block_identifier == 0
     ):
         return {
@@ -119,7 +125,7 @@ def _get_block_by_something(method, params):
                 {'gasPrice': 54},
                 {'gasPrice': 10000000000000000000000},
             ],
-            'miner': '0xA',
+            'miner': '0x' + 'AA' * 20,
             'timestamp': 0,
         }
     else:

tests/core/middleware/test_filter_middleware.py

@@ -1,6 +1,13 @@
 import pytest
 
+from hexbytes import (
+    HexBytes,
+)
+
 from web3 import Web3
+from web3.datastructures import (
+    AttributeDict,
+)
 from web3.middleware import (
     construct_result_generator_middleware,
     local_filter_middleware,
@@ -35,11 +42,15 @@ def iterator():
     return block_number
 
 
+BLOCK_HASH = '0xfe88c94d860f01a17f961bf4bdfb6e0c6cd10d3fda5cc861e805ca1240c58553'
+FILTER_LOG = [AttributeDict({'address': '0xDc3A9Db694BCdd55EBaE4A89B22aC6D12b3F0c24', 'blockHash': HexBytes('0xb72256286ca528e09022ffd408856a73ef90e7216ac560187c6e43b4c4efd2f0'), 'blockNumber': 2217196, 'data': '0x0000000000000000000000000000000000000000000000000000000000000001', 'logIndex': 0, 'topics': [HexBytes('0xe65b00b698ba37c614af350761c735c5f4a82b4ab365a1f1022d49d9dfc8e930'), HexBytes('0x000000000000000000000000754c50465885f1ed1fa1a55b95ee8ecf3f1f4324'), HexBytes('0x296c7fb6ccafa3e689950b947c2895b07357c95b066d5cdccd58c301f41359a3')], 'transactionHash': HexBytes('0xfe1289fd3915794b99702202f65eea2e424b2f083a12749d29b4dd51f6dce40d'), 'transactionIndex': 1})]  # noqa: E501
+
+
 @pytest.fixture(scope='function')
 def result_generator_middleware(iter_block_number):
     return construct_result_generator_middleware({
-        'eth_getLogs': lambda *_: ["middleware"],
-        'eth_getBlockByNumber': lambda *_: type('block', (object,), {'hash': 'middleware'}),
+        'eth_getLogs': lambda *_: FILTER_LOG,
+        'eth_getBlockByNumber': lambda *_: {'hash': BLOCK_HASH},
         'net_version': lambda *_: 1,
         'eth_blockNumber': lambda *_: next(iter_block_number),
     })
@@ -141,13 +152,13 @@ def test_local_filter_middleware(w3, iter_block_number):
 
     log_filter = w3.eth.filter(filter_params={'fromBlock': 'latest'})
 
-    assert w3.eth.getFilterChanges(block_filter.filter_id) == ["middleware"]
+    assert w3.eth.getFilterChanges(block_filter.filter_id) == [HexBytes(BLOCK_HASH)]
 
     iter_block_number.send(2)
     results = w3.eth.getFilterChanges(log_filter.filter_id)
-    assert results == ["middleware"]
+    assert results == FILTER_LOG
 
-    assert w3.eth.getFilterLogs(log_filter.filter_id) == ["middleware"]
+    assert w3.eth.getFilterLogs(log_filter.filter_id) == FILTER_LOG
 
     filter_ids = (
         block_filter.filter_id,

tests/core/middleware/test_latest_block_based_cache_middleware.py

@@ -5,6 +5,7 @@
 import uuid
 
 from eth_utils import (
+    is_hex,
     is_integer,
     to_tuple,
 )
@@ -13,6 +14,9 @@
 from web3._utils.caching import (
     generate_cache_key,
 )
+from web3._utils.formatters import (
+    hex_to_integer,
+)
 from web3.middleware import (  # noqa: F401
     construct_error_generator_middleware,
     construct_latest_block_based_cache_middleware,
@@ -77,7 +81,9 @@ def _get_block_by_number(method, params, block_info=_block_info):
                 return blocks[head_block_number + 1]
             elif block_id == 'earliest':
                 return blocks[0]
-            elif is_integer(block_id):
+            elif is_integer(block_id) or is_hex(block_id):
+                if is_hex(block_id):
+                    block_id = hex_to_integer(block_id)
                 if block_id <= head_block_number:
                     return blocks[block_id]
                 else:

tests/core/middleware/test_request_param_normalizer.py

@@ -1,6 +1,13 @@
 import pytest
 
+from hexbytes import (
+    HexBytes,
+)
+
 from web3 import Web3
+from web3.datastructures import (
+    AttributeDict,
+)
 from web3.middleware import (  # noqa: F401
     construct_result_generator_middleware,
     request_parameter_normalizer,
@@ -17,8 +24,23 @@ def w3_base():
 
 @pytest.fixture
 def result_generator_middleware():
+    result = [
+        AttributeDict({
+            'address': '0x2F141Ce366a2462f02cEA3D12CF93E4DCa49e4Fd',
+            'blockHash': HexBytes('0x919e1d4b2e0cae57084bcb9ccf4b46553fee48fe1422f7c58765095cd43d9f2c'),  # noqa: E501
+            'blockNumber': 9346779,
+            'data': '0x0000000000000000000000000000000000000000000002e820b216795fe09280',
+            'logIndex': 67,
+            'removed': False,
+            'topics': [HexBytes('0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef'),  # noqa: E501
+            HexBytes('0x000000000000000000000000d58b159801499d9b7d56629e4606ae51a1b4fb28'),
+            HexBytes('0x0000000000000000000000001f84683e962b7dec4a6a3bd382b8adfc554da8a7')],
+            'transactionHash': HexBytes('0x081a7bfd0943d8b3ba7e15e3d905e60340f0f5559171b4b18d42ee166a27d4a1'),  # noqa: E501
+            'transactionIndex': 62,
+        })
+    ]
     return construct_result_generator_middleware({
-        'eth_getLogs': lambda _, params: params,
+        'eth_getLogs': lambda _, params: result
     })
 
 
@@ -32,4 +54,4 @@ def w3(w3_base, result_generator_middleware):
 def test_eth_getLogs_param_normalization(w3):
     result = w3.eth.getLogs({
         'from': 'latest', 'address': '0x1111111111111111111111111111111111111111'})
-    assert isinstance(result[0]['address'], list)
+    assert isinstance(result[0]['address'], str)

tests/ens/test_utils.py

@@ -1,10 +1,22 @@
+import pytest
 
 from ens.utils import (
     init_web3,
+    is_valid_domain,
 )
 
 
 def test_init_adds_middlewares():
     w3 = init_web3()
     middlewares = map(str, w3.manager.middleware_onion)
     assert 'stalecheck_middleware' in next(middlewares)
+
+
+@pytest.mark.parametrize('domain,expected', [
+    ('thedao.eth', True),
+    ('thedao', False),
+    ('blog.ethereum.org', True)
+])
+def test_is_valid_domain(domain, expected):
+    actual = is_valid_domain(domain)
+    assert actual == expected

web3/_utils/blocks.py

@@ -10,6 +10,9 @@
     is_text,
     remove_0x_prefix,
 )
+from eth_utils.toolz import (
+    curry,
+)
 
 from web3.types import (
     RPCEndpoint,
@@ -51,6 +54,7 @@ def is_hex_encoded_block_number(value: Any) -> bool:
     return 0 <= value_as_int < 2**256
 
 
+@curry
 def select_method_for_block_identifier(
     value: Any, if_hash: RPCEndpoint, if_number: RPCEndpoint, if_predefined: RPCEndpoint
 ) -> RPCEndpoint: