Make eth_call free again

- when running a call, set the header's base gas fee to 0
- API update: state_in_temp_block -> in_costless_state to reference ^

Author: carver

eth/abc.py

@@ -1693,9 +1693,9 @@ def chain_id(self) -> int:
 
     @property
     @abstractmethod
-    def base_gas_fee(self) -> Optional[int]:
+    def base_fee_per_gas(self) -> Optional[int]:
         """
-        Return the base gas fee of the block
+        Return the base fee per gas of the block
         """
         ...
 
@@ -3501,10 +3501,10 @@ def get_state_class(cls) -> Type[StateAPI]:
         ...
 
     @abstractmethod
-    def state_in_temp_block(self) -> ContextManager[StateAPI]:
+    def in_costless_state(self) -> ContextManager[StateAPI]:
         """
         Return a :class:`~typing.ContextManager` with the current state wrapped in a temporary
-        block.
+        block. In this state, the ability to pay gas costs is ignored.
         """
         ...
 

eth/chains/base.py

@@ -443,7 +443,7 @@ def get_transaction_result(
             transaction: SignedTransactionAPI,
             at_header: BlockHeaderAPI) -> bytes:
 
-        with self.get_vm(at_header).state_in_temp_block() as state:
+        with self.get_vm(at_header).in_costless_state() as state:
             computation = state.costless_execute_transaction(transaction)
 
         computation.raise_if_error()
@@ -455,7 +455,7 @@ def estimate_gas(
             at_header: BlockHeaderAPI = None) -> int:
         if at_header is None:
             at_header = self.get_canonical_head()
-        with self.get_vm(at_header).state_in_temp_block() as state:
+        with self.get_vm(at_header).in_costless_state() as state:
             return self.gas_estimator(state, transaction)
 
     def import_block(self,

eth/vm/base.py

@@ -183,7 +183,7 @@ def create_execution_context(cls,
             gas_limit=header.gas_limit,
             prev_hashes=prev_hashes,
             chain_id=chain_context.chain_id,
-            base_gas_fee=header.base_fee_per_gas,
+            base_fee_per_gas=header.base_fee_per_gas,
         )
 
     def execute_bytecode(self,
@@ -676,13 +676,19 @@ def get_state_class(cls) -> Type[StateAPI]:
         return cls._state_class
 
     @contextlib.contextmanager
-    def state_in_temp_block(self) -> Iterator[StateAPI]:
+    def in_costless_state(self) -> Iterator[StateAPI]:
         header = self.get_header()
+
         temp_block = self.generate_block_from_parent_header_and_coinbase(header, header.coinbase)
         prev_hashes = itertools.chain((header.hash,), self.previous_hashes)
 
+        if temp_block.header.base_fee_per_gas is None:
+            free_header = temp_block.header
+        else:
+            free_header = temp_block.header.copy(base_fee_per_gas=0)
+
         state = self.build_state(self.chaindb.db,
-                                 temp_block.header,
+                                 free_header,
                                  self.chain_context,
                                  prev_hashes)
 

eth/vm/execution_context.py

@@ -22,7 +22,7 @@ class ExecutionContext(ExecutionContextAPI):
     _gas_limit = None
     _prev_hashes = None
     _chain_id = None
-    _base_gas_fee = None
+    _base_fee_per_gas = None
 
     def __init__(
             self,
@@ -33,15 +33,15 @@ def __init__(
             gas_limit: int,
             prev_hashes: Iterable[Hash32],
             chain_id: int,
-            base_gas_fee: Optional[int]) -> None:
+            base_fee_per_gas: Optional[int]) -> None:
         self._coinbase = coinbase
         self._timestamp = timestamp
         self._block_number = block_number
         self._difficulty = difficulty
         self._gas_limit = gas_limit
         self._prev_hashes = CachedIterable(prev_hashes)
         self._chain_id = chain_id
-        self._base_gas_fee = base_gas_fee
+        self._base_fee_per_gas = base_fee_per_gas
 
     @property
     def coinbase(self) -> Address:
@@ -72,8 +72,8 @@ def chain_id(self) -> int:
         return self._chain_id
 
     @property
-    def base_gas_fee(self) -> int:
-        if self._base_gas_fee is None:
+    def base_fee_per_gas(self) -> int:
+        if self._base_fee_per_gas is None:
             raise AttributeError(f"This header at Block #{self.block_number} does not have a base gas fee")
         else:
-            return self._base_gas_fee
+            return self._base_fee_per_gas

eth/vm/forks/london/state.py

@@ -45,8 +45,7 @@ def build_evm_message(
         self,
         transaction: SignedTransactionAPI,
     ) -> MessageAPI:
-        transaction_context = self.vm_state.get_transaction_context(transaction)
-        gas_fee = transaction.gas * transaction_context.gas_price
+        gas_fee = transaction.gas * self.vm_state.get_gas_price(transaction)
 
         # Buy Gas
         self.vm_state.delta_balance(transaction.sender, -1 * gas_fee)
@@ -172,7 +171,7 @@ def validate_transaction(
         validate_london_normalized_transaction(
             state=self,
             transaction=transaction,
-            base_fee_per_gas=self.execution_context.base_gas_fee
+            base_fee_per_gas=self.execution_context.base_fee_per_gas
         )
 
     def get_transaction_context(self: StateAPI,
@@ -184,15 +183,15 @@ def get_transaction_context(self: StateAPI,
         if isinstance(transaction, LondonTypedTransaction):  # TODO probably do this somewhere else
             priority_fee_per_gas = min(
                 transaction.max_priority_fee_per_gas,
-                transaction.max_fee_per_gas - self.execution_context.base_gas_fee
+                transaction.max_fee_per_gas - self.execution_context.base_fee_per_gas
             )
         else:
             priority_fee_per_gas = min(
                 transaction.gas_price,
-                transaction.gas_price - self.execution_context.base_gas_fee
+                transaction.gas_price - self.execution_context.base_fee_per_gas
             )
 
-        effective_gas_price = self.execution_context.base_gas_fee + priority_fee_per_gas
+        effective_gas_price = self.execution_context.base_fee_per_gas + priority_fee_per_gas
         return self.get_transaction_context_class()(
             gas_price=effective_gas_price,
             origin=transaction.sender

eth/vm/state.py

@@ -88,6 +88,14 @@ def difficulty(self) -> int:
     def gas_limit(self) -> int:
         return self.execution_context.gas_limit
 
+    def get_gas_price(self, transaction: SignedTransactionAPI) -> int:
+        base_gas_price = self.execution_context.base_fee_per_gas
+        priority_fee_per_gas = min(
+            transaction.max_priority_fee_per_gas,
+            transaction.max_fee_per_gas - base_gas_price,
+        )
+        return priority_fee_per_gas + base_gas_price
+
     #
     # Access to account db
     #