rpc: eth_estimateGas

carver · carver · commit 2ee9f8f7de2f · 2018-08-06T15:53:52.000-07:00
diff --git a/eth/chains/base.py b/eth/chains/base.py
@@ -59,6 +59,9 @@
     ValidationError,
     VMNotFound,
 )
+from eth.utils.spoof import (
+    SpoofTransaction,
+)
 from eth.validation import (
     validate_block_number,
     validate_uint256,
@@ -248,7 +251,10 @@ def get_canonical_transaction(self, transaction_hash: Hash32) -> BaseTransaction
     # Execution API
     #
     @abstractmethod
-    def estimate_gas(self, transaction: BaseTransaction, at_header: BlockHeader=None) -> int:
+    def estimate_gas(
+            self,
+            transaction: Union[BaseTransaction, SpoofTransaction],
+            at_header: BlockHeader=None) -> int:
         raise NotImplementedError("Chain classes must implement this method")
 
     @abstractmethod
@@ -544,7 +550,10 @@ def create_unsigned_transaction(self,
     #
     # Execution API
     #
-    def estimate_gas(self, transaction: BaseTransaction, at_header: BlockHeader=None) -> int:
+    def estimate_gas(
+            self,
+            transaction: Union[BaseTransaction, SpoofTransaction],
+            at_header: BlockHeader=None) -> int:
         """
         Returns an estimation of the amount of gas the given transaction will
         use if executed on top of the block specified by the given header.
diff --git a/tests/trinity/conftest.py b/tests/trinity/conftest.py
@@ -74,8 +74,7 @@ async def ipc_server(
         chain_with_block_validation):
     '''
     This fixture runs a single RPC server over IPC over
-    the course of all tests. It never needs to be actually
-    used as a fixture, so it doesn't return (yield) a value.
+    the course of all tests. It yields the IPC server only for monkeypatching purposes
     '''
 
     rpc = RPCServer(chain_with_block_validation, p2p_server.peer_pool)
@@ -84,6 +83,6 @@ async def ipc_server(
     asyncio.ensure_future(ipc_server.run(), loop=event_loop)
 
     try:
-        yield
+        yield ipc_server
     finally:
         await ipc_server.cancel()
diff --git a/tests/trinity/core/json-rpc/test_ipc.py b/tests/trinity/core/json-rpc/test_ipc.py
@@ -35,39 +35,66 @@ def __len__(self):
         return self.peer_count
 
 
-@pytest.fixture
-def p2p_server(monkeypatch, p2p_server, mock_peer_pool):
-    monkeypatch.setattr(p2p_server, 'peer_pool', mock_peer_pool)
-    return p2p_server
+def id_from_rpc_request(param):
+    if isinstance(param, bytes):
+        request = json.loads(param.decode())
+        if 'method' in request and 'params' in request:
+            rpc_params = (repr(p) for p in request['params'])
+            return '%s(%s)' % (request['method'], ', '.join(rpc_params))
+        else:
+            return repr(param)
+    else:
+        return repr(param)
+
+
+def can_decode_json(potential):
+    try:
+        json.loads(potential.decode())
+        return True
+    except json.decoder.JSONDecodeError:
+        return False
+
+
+async def get_ipc_response(
+        jsonrpc_ipc_pipe_path,
+        request_msg,
+        event_loop):
+    assert wait_for(jsonrpc_ipc_pipe_path), "IPC server did not successfully start with IPC file"
+
+    reader, writer = await asyncio.open_unix_connection(str(jsonrpc_ipc_pipe_path), loop=event_loop)
+
+    writer.write(request_msg)
+    await writer.drain()
+    result_bytes = b''
+    while not can_decode_json(result_bytes):
+        result_bytes += await asyncio.tasks.wait_for(reader.readuntil(b'}'), 0.25, loop=event_loop)
+
+    writer.close()
+    return json.loads(result_bytes.decode())
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    'request_msg, mock_peer_pool, expected',
+    'request_msg, expected',
     (
         (
             b'{}',
-            MockPeerPool(),
             {'error': "Invalid Request: empty"},
         ),
         (
             build_request('notamethod'),
-            MockPeerPool(),
             {'error': "Invalid RPC method: 'notamethod'", 'id': 3, 'jsonrpc': '2.0'},
         ),
         (
             build_request('eth_mining'),
-            MockPeerPool(),
             {'result': False, 'id': 3, 'jsonrpc': '2.0'},
         ),
         (
             build_request('web3_clientVersion'),
-            MockPeerPool(),
             {'result': construct_trinity_client_identifier(), 'id': 3, 'jsonrpc': '2.0'},
         ),
         (
             build_request('web3_sha3', ['0x89987239849872']),
-            MockPeerPool(),
             {
                 'result': '0xb3406131994d9c859de3c4400e12f630638e1e992c6453358c16d0e6ce2b1a70',
                 'id': 3,
@@ -76,7 +103,6 @@ def p2p_server(monkeypatch, p2p_server, mock_peer_pool):
         ),
         (
             build_request('web3_sha3', ['0x']),
-            MockPeerPool(),
             {
                 'result': '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
                 'id': 3,
@@ -85,9 +111,119 @@ def p2p_server(monkeypatch, p2p_server, mock_peer_pool):
         ),
         (
             build_request('net_version'),
-            MockPeerPool(),
             {'result': '1337', 'id': 3, 'jsonrpc': '2.0'},
         ),
+        (
+            build_request('net_listening'),
+            {'result': True, 'id': 3, 'jsonrpc': '2.0'},
+        ),
+    ),
+)
+async def test_ipc_requests(
+        jsonrpc_ipc_pipe_path,
+        request_msg,
+        expected,
+        event_loop,
+        ipc_server):
+    result = await get_ipc_response(jsonrpc_ipc_pipe_path, request_msg, event_loop)
+    assert result == expected
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'request_msg, expected',
+    (
+        (
+            # simple transaction, with all fields inferred
+            # (except 'to', which must be provided when not creating a contract)
+            build_request('eth_estimateGas', params=[{'to': '0x' + '00' * 20}, 'latest']),
+            # simple transactions are correctly identified as 21000 gas during estimation
+            {'result': hex(21000), 'id': 3, 'jsonrpc': '2.0'},
+        ),
+        (
+            # test block number
+            build_request('eth_estimateGas', params=[{'to': '0x' + '00' * 20}, '0x0']),
+            {'result': hex(21000), 'id': 3, 'jsonrpc': '2.0'},
+        ),
+        (
+            # another simple transaction, with all fields provided
+            build_request('eth_estimateGas', params=[{
+                'to': '0x' + '00' * 20,
+                'from': '0x' + '11' * 20,
+                'gasPrice': '0x2',
+                'gas': '0x3',
+                'value': '0x0',
+                'data': '0x',
+            }, 'latest']),
+            {'result': hex(21000), 'id': 3, 'jsonrpc': '2.0'},
+        ),
+        (
+            # try adding garbage data to increase estimate
+            build_request('eth_estimateGas', params=[{
+                'to': '0x' + '00' * 20,
+                'data': '0x01',
+            }, 'latest']),
+            {'result': hex(21068), 'id': 3, 'jsonrpc': '2.0'},
+        ),
+        (
+            # deploy a tiny contract
+            build_request('eth_estimateGas', params=[{
+                'data': '0x3838533838f3',
+            }, 'latest']),
+            {'result': hex(65483), 'id': 3, 'jsonrpc': '2.0'},
+        ),
+        (
+            # specifying v,r,s is invalid
+            build_request('eth_estimateGas', params=[{
+                'v': '0x' + '00' * 20,
+                'r': '0x' + '00' * 20,
+                's': '0x' + '00' * 20,
+            }, 'latest']),
+            {
+                'error': "The following invalid fields were given in a transaction: ['r', 's', 'v']. Only ['data', 'from', 'gas', 'gasPrice', 'to', 'value'] are allowed",  # noqa: E501
+                'id': 3,
+                'jsonrpc': '2.0',
+            }
+        ),
+        (
+            # specifying gas_price is invalid
+            build_request('eth_estimateGas', params=[{
+                'gas_price': '0x0',
+            }, 'latest']),
+            {
+                'error': "The following invalid fields were given in a transaction: ['gas_price']. Only ['data', 'from', 'gas', 'gasPrice', 'to', 'value'] are allowed",  # noqa: E501
+                'id': 3,
+                'jsonrpc': '2.0',
+            }
+        ),
+        (
+            # specifying nonce is invalid
+            build_request('eth_estimateGas', params=[{
+                'nonce': '0x01',
+            }, 'latest']),
+            {
+                'error': "The following invalid fields were given in a transaction: ['nonce']. Only ['data', 'from', 'gas', 'gasPrice', 'to', 'value'] are allowed",  # noqa: E501
+                'id': 3,
+                'jsonrpc': '2.0',
+            }
+        ),
+    ),
+    ids=id_from_rpc_request,
+)
+async def test_estimate_gas_on_ipc(
+        jsonrpc_ipc_pipe_path,
+        request_msg,
+        expected,
+        event_loop,
+        ipc_server):
+    result = await get_ipc_response(jsonrpc_ipc_pipe_path, request_msg, event_loop)
+    assert result == expected
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    'request_msg, mock_peer_pool, expected',
+    (
         (
             build_request('net_peerCount'),
             MockPeerPool(peer_count=1),
@@ -98,31 +234,19 @@ def p2p_server(monkeypatch, p2p_server, mock_peer_pool):
             MockPeerPool(peer_count=0),
             {'result': '0x0', 'id': 3, 'jsonrpc': '2.0'},
         ),
-        (
-            build_request('net_listening'),
-            MockPeerPool(),
-            {'result': True, 'id': 3, 'jsonrpc': '2.0'},
-        ),
     ),
     ids=[
-        'empty', 'notamethod', 'eth_mining', 'web3_clientVersion',
-        'web3_sha3_1', 'web3_sha3_2', 'net_version', 'net_peerCount_1',
-        'net_peerCount_0', 'net_listening_true',
+        'net_peerCount_1', 'net_peerCount_0',
     ],
 )
-async def test_ipc_requests(jsonrpc_ipc_pipe_path,
-                            request_msg,
-                            expected,
-                            event_loop,
-                            ipc_server):
-    assert wait_for(jsonrpc_ipc_pipe_path), "IPC server did not successfully start with IPC file"
-
-    reader, writer = await asyncio.open_unix_connection(str(jsonrpc_ipc_pipe_path), loop=event_loop)
-
-    writer.write(request_msg)
-    await writer.drain()
-    result_bytes = await asyncio.tasks.wait_for(reader.readuntil(b'}'), 0.25, loop=event_loop)
-
-    result = json.loads(result_bytes.decode())
+async def test_peer_pool_over_ipc(
+        monkeypatch,
+        jsonrpc_ipc_pipe_path,
+        request_msg,
+        mock_peer_pool,
+        expected,
+        event_loop,
+        ipc_server):
+    monkeypatch.setattr(ipc_server.rpc.modules['net'], '_peer_pool', mock_peer_pool)
+    result = await get_ipc_response(jsonrpc_ipc_pipe_path, request_msg, event_loop)
     assert result == expected
-    writer.close()
diff --git a/tests/trinity/json-fixtures-over-rpc/test_rpc_fixtures.py b/tests/trinity/json-fixtures-over-rpc/test_rpc_fixtures.py
@@ -113,6 +113,7 @@
 
 RPC_TRANSACTION_REMAPPERS = {
     'data': 'input',
+    'gasLimit': 'gas',
 }
 
 RPC_TRANSACTION_NORMALIZERS = {
diff --git a/trinity/chains/light.py b/trinity/chains/light.py
@@ -46,6 +46,9 @@
     BaseTransaction,
     BaseUnsignedTransaction,
 )
+from eth.utils.spoof import (
+    SpoofTransaction,
+)
 from eth.vm.computation import (
     BaseComputation
 )
@@ -189,7 +192,10 @@ def apply_transaction(
             transaction: BaseTransaction) -> Tuple[BaseBlock, Receipt, BaseComputation]:
         raise NotImplementedError("Chain classes must implement " + inspect.stack()[0][3])
 
-    def estimate_gas(self, transaction: BaseTransaction, at_header: BlockHeader=None) -> int:
+    def estimate_gas(
+            self,
+            transaction: Union[BaseTransaction, SpoofTransaction],
+            at_header: BlockHeader=None) -> int:
         raise NotImplementedError("Chain classes must implement " + inspect.stack()[0][3])
 
     def import_block(self, block: BaseBlock, perform_validation: bool=True) -> BaseBlock:
diff --git a/trinity/rpc/format.py b/trinity/rpc/format.py
@@ -8,9 +8,12 @@
 )
 from cytoolz import (
     compose,
+    merge,
 )
 
 from eth_utils import (
+    apply_formatters_to_dict,
+    decode_hex,
     encode_hex,
     int_to_big_endian,
 )
@@ -20,6 +23,9 @@
 from eth.chains.base import (
     BaseChain
 )
+from eth.constants import (
+    CREATE_CONTRACT_ADDRESS,
+)
 from eth.rlp.blocks import (
     BaseBlock
 )
@@ -35,7 +41,7 @@ def transaction_to_dict(transaction: BaseTransaction) -> Dict[str, str]:
     return dict(
         hash=encode_hex(transaction.hash),
         nonce=hex(transaction.nonce),
-        gasLimit=hex(transaction.gas),
+        gas=hex(transaction.gas),
         gasPrice=hex(transaction.gas_price),
         to=encode_hex(transaction.to),
         value=hex(transaction.value),
@@ -46,6 +52,31 @@ def transaction_to_dict(transaction: BaseTransaction) -> Dict[str, str]:
     )
 
 
+hexstr_to_int = functools.partial(int, base=16)
+
+
+TRANSACTION_NORMALIZER = {
+    'data': decode_hex,
+    'from': decode_hex,
+    'gas': hexstr_to_int,
+    'gasPrice': hexstr_to_int,
+    'nonce': hexstr_to_int,
+    'to': decode_hex,
+    'value': hexstr_to_int,
+}
+
+SAFE_TRANSACTION_DEFAULTS = {
+    'data': b'',
+    'to': CREATE_CONTRACT_ADDRESS,
+    'value': 0,
+}
+
+
+def normalize_transaction_dict(transaction_dict: Dict[str, str]) -> Dict[str, Any]:
+    normalized_dict = apply_formatters_to_dict(TRANSACTION_NORMALIZER, transaction_dict)
+    return merge(SAFE_TRANSACTION_DEFAULTS, normalized_dict)
+
+
 def header_to_dict(header: BlockHeader) -> Dict[str, str]:
     logs_bloom = encode_hex(int_to_big_endian(header.bloom))[2:]
     logs_bloom = '0x' + logs_bloom.rjust(512, '0')
diff --git a/trinity/rpc/ipc.py b/trinity/rpc/ipc.py
diff --git a/trinity/rpc/modules/eth.py b/trinity/rpc/modules/eth.py
diff --git a/trinity/utils/validation.py b/trinity/utils/validation.py

Original file line number	Diff line number	Diff line change
`@@ -113,6 +113,7 @@`
`113`	`113`
`114`	`114`	`RPC_TRANSACTION_REMAPPERS = {`
`115`	`115`	`'data': 'input',`
	`116`	`+ 'gasLimit': 'gas',`
`116`	`117`	`}`
`117`	`118`
`118`	`119`	`RPC_TRANSACTION_NORMALIZERS = {`