feat(forks): New methods for EIP-7691+EIP-7762

Author: marioevz

src/ethereum_test_forks/base_fork.py

@@ -29,7 +29,7 @@ def __call__(self, block_number: int = 0, timestamp: int = 0) -> Any:
 
 class MemoryExpansionGasCalculator(Protocol):
     """
-    A protocol to calculate the gas cost of memory expansion for a given fork.
+    A protocol to calculate the gas cost of memory expansion at a given fork.
     """
 
     def __call__(self, *, new_bytes: int, previous_bytes: int = 0) -> int:
@@ -41,7 +41,7 @@ def __call__(self, *, new_bytes: int, previous_bytes: int = 0) -> int:
 
 class CalldataGasCalculator(Protocol):
     """
-    A protocol to calculate the transaction gas cost of calldata for a given fork.
+    A protocol to calculate the transaction gas cost of calldata at a given fork.
     """
 
     def __call__(self, *, data: BytesConvertible, floor: bool = False) -> int:
@@ -65,7 +65,7 @@ def __call__(self, *, data: BytesConvertible) -> int:
 
 class TransactionIntrinsicCostCalculator(Protocol):
     """
-    A protocol to calculate the intrinsic gas cost of a transaction for a given fork.
+    A protocol to calculate the intrinsic gas cost of a transaction at a given fork.
     """
 
     def __call__(
@@ -97,6 +97,37 @@ def __call__(
         pass
 
 
+class BlobGasPriceCalculator(Protocol):
+    """
+    A protocol to calculate the blob gas price given the excess blob gas at a given fork.
+    """
+
+    def __call__(self, *, excess_blob_gas: int) -> int:
+        """
+        Returns the blob gas price given the excess blob gas.
+        """
+        pass
+
+
+class ExcessBlobGasCalculator(Protocol):
+    """
+    A protocol to calculate the excess blob gas for a block at a given fork.
+    """
+
+    def __call__(
+        self,
+        *,
+        parent_excess_blob_gas: int | None = None,
+        parent_excess_blobs: int | None = None,
+        parent_blob_gas_used: int | None = None,
+        parent_blob_count: int | None = None,
+    ) -> int:
+        """
+        Returns the excess blob gas given the parent's excess blob gas and blob gas used.
+        """
+        pass
+
+
 class BaseForkMeta(ABCMeta):
     """
     Metaclass for BaseFork
@@ -218,23 +249,25 @@ def header_blob_gas_used_required(cls, block_number: int = 0, timestamp: int = 0
 
     @classmethod
     @abstractmethod
-    def header_beacon_root_required(cls, block_number: int, timestamp: int) -> bool:
+    def header_beacon_root_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
         """
         Returns true if the header must contain parent beacon block root
         """
         pass
 
     @classmethod
     @abstractmethod
-    def header_requests_required(cls, block_number: int, timestamp: int) -> bool:
+    def header_requests_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
         """
         Returns true if the header must contain beacon chain requests
         """
         pass
 
     @classmethod
     @abstractmethod
-    def header_target_blobs_per_block_required(cls, block_number: int, timestamp: int) -> bool:
+    def header_target_blobs_per_block_required(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> bool:
         """
         Returns true if the header must contain target blobs per block.
         """
@@ -293,25 +326,61 @@ def transaction_intrinsic_cost_calculator(
 
     @classmethod
     @abstractmethod
-    def blob_gas_per_blob(cls, block_number: int, timestamp: int) -> int:
+    def blob_gas_price_calculator(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> BlobGasPriceCalculator:
+        """
+        Returns a callable that calculates the blob gas price at a given fork.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def excess_blob_gas_calculator(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> ExcessBlobGasCalculator:
+        """
+        Returns a callable that calculates the excess blob gas for a block at a given fork.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def min_base_fee_per_blob_gas(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the minimum base fee per blob gas at a given fork.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def blob_gas_per_blob(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the amount of blob gas used per blob at a given fork.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
         """
-        Returns the amount of blob gas used per blob for a given fork.
+        Returns the blob base fee update fraction at a given fork.
         """
         pass
 
     @classmethod
     @abstractmethod
-    def target_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
+    def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
         """
-        Returns the target blobs per block for a given fork.
+        Returns the target blobs per block at a given fork.
         """
         pass
 
     @classmethod
     @abstractmethod
-    def max_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
+    def max_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
         """
-        Returns the max blobs per block for a given fork.
+        Returns the max blobs per block at a given fork.
         """
         pass
 

src/ethereum_test_forks/forks/forks.py

@@ -16,25 +16,20 @@
 
 from ..base_fork import (
     BaseFork,
+    BlobGasPriceCalculator,
     CalldataGasCalculator,
+    ExcessBlobGasCalculator,
     MemoryExpansionGasCalculator,
     TransactionDataFloorCostCalculator,
     TransactionIntrinsicCostCalculator,
 )
 from ..gas_costs import GasCosts
+from .helpers import ceiling_division, fake_exponential
 
 CURRENT_FILE = Path(realpath(__file__))
 CURRENT_FOLDER = CURRENT_FILE.parent
 
 
-def ceiling_division(a: int, b: int) -> int:
-    """
-    Calculates the ceil without using floating point.
-    Used by many of the EVM's formulas
-    """
-    return -(a // -b)
-
-
 # All forks must be listed here !!! in the order they were introduced !!!
 class Frontier(BaseFork, solc_name="homestead"):
     """
@@ -245,28 +240,60 @@ def fn(
         return fn
 
     @classmethod
-    def blob_gas_per_blob(cls, block_number: int, timestamp: int) -> int:
+    def blob_gas_price_calculator(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> BlobGasPriceCalculator:
         """
-        Returns the amount of blob gas used per blob for a given fork.
+        Returns a callable that calculates the blob gas price at a given fork.
         """
-        return 0
+        raise NotImplementedError("Blob gas price calculator is not supported in Frontier")
 
     @classmethod
-    def target_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
+    def excess_blob_gas_calculator(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> ExcessBlobGasCalculator:
         """
-        Returns the target number of blobs per block for a given fork.
+        Returns a callable that calculates the excess blob gas for a block at a given fork.
         """
-        return 0
+        raise NotImplementedError("Excess blob gas calculator is not supported in Frontier")
 
     @classmethod
-    def max_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
+    def min_base_fee_per_blob_gas(cls, block_number: int = 0, timestamp: int = 0) -> int:
         """
-        Returns the max number of blobs per block for a given fork.
+        Returns the amount of blob gas used per blob at a given fork.
         """
-        return 0
+        raise NotImplementedError("Base fee per blob gas is not supported in Frontier")
+
+    @classmethod
+    def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the blob base fee update fraction at a given fork.
+        """
+        raise NotImplementedError("Blob base fee update fraction is not supported in Frontier")
+
+    @classmethod
+    def blob_gas_per_blob(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the amount of blob gas used per blob at a given fork.
+        """
+        raise NotImplementedError("Blob gas per blob is not supported in Frontier")
+
+    @classmethod
+    def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the target number of blobs per block at a given fork.
+        """
+        raise NotImplementedError("Target blobs per block is not supported in Frontier")
 
     @classmethod
-    def header_requests_required(cls, block_number: int, timestamp: int) -> bool:
+    def max_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the max number of blobs per block at a given fork.
+        """
+        raise NotImplementedError("Max blobs per block is not supported in Frontier")
+
+    @classmethod
+    def header_requests_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
         """
         At genesis, header must not contain beacon chain requests.
         """
@@ -1011,21 +1038,85 @@ def header_beacon_root_required(cls, block_number: int = 0, timestamp: int = 0)
         return True
 
     @classmethod
-    def blob_gas_per_blob(cls, block_number: int, timestamp: int) -> int:
+    def blob_gas_price_calculator(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> BlobGasPriceCalculator:
+        """
+        Returns a callable that calculates the blob gas price at Cancun.
+        """
+        min_base_fee_per_blob_gas = cls.min_base_fee_per_blob_gas(block_number, timestamp)
+        blob_base_fee_update_fraction = cls.blob_base_fee_update_fraction(block_number, timestamp)
+
+        def fn(*, excess_blob_gas) -> int:
+            return fake_exponential(
+                min_base_fee_per_blob_gas,
+                excess_blob_gas,
+                blob_base_fee_update_fraction,
+            )
+
+        return fn
+
+    @classmethod
+    def excess_blob_gas_calculator(
+        cls, block_number: int = 0, timestamp: int = 0
+    ) -> ExcessBlobGasCalculator:
+        """
+        Returns a callable that calculates the excess blob gas for a block at Cancun.
+        """
+        target_blobs_per_block = cls.target_blobs_per_block(block_number, timestamp)
+        blob_gas_per_blob = cls.blob_gas_per_blob(block_number, timestamp)
+        target_blob_gas_per_block = target_blobs_per_block * blob_gas_per_blob
+
+        def fn(
+            *,
+            parent_excess_blob_gas: int | None = None,
+            parent_excess_blobs: int | None = None,
+            parent_blob_gas_used: int | None = None,
+            parent_blob_count: int | None = None,
+        ) -> int:
+            if parent_excess_blob_gas is None:
+                assert parent_excess_blobs is not None, "Parent excess blobs are required"
+                parent_excess_blob_gas = parent_excess_blobs * blob_gas_per_blob
+            if parent_blob_gas_used is None:
+                assert parent_blob_count is not None, "Parent blob count is required"
+                parent_blob_gas_used = parent_blob_count * blob_gas_per_blob
+            if parent_excess_blob_gas + parent_blob_gas_used < target_blob_gas_per_block:
+                return 0
+            else:
+                return parent_excess_blob_gas + parent_blob_gas_used - target_blob_gas_per_block
+
+        return fn
+
+    @classmethod
+    def min_base_fee_per_blob_gas(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the minimum base fee per blob gas for Cancun.
+        """
+        return 1
+
+    @classmethod
+    def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the blob base fee update fraction for Cancun.
+        """
+        return 3338477
+
+    @classmethod
+    def blob_gas_per_blob(cls, block_number: int = 0, timestamp: int = 0) -> int:
         """
         Blobs are enabled starting from Cancun.
         """
         return 2**17
 
     @classmethod
-    def target_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
+    def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
         """
         Blobs are enabled starting from Cancun, with a static target of 3 blobs.
         """
         return 3
 
     @classmethod
-    def max_blobs_per_block(cls, block_number: int, timestamp: int) -> int:
+    def max_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
         """
         Blobs are enabled starting from Cancun, with a static max of 6 blobs.
         """
@@ -1256,6 +1347,34 @@ def fn(
 
         return fn
 
+    @classmethod
+    def min_base_fee_per_blob_gas(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the minimum base fee per blob gas for Prague.
+        """
+        return 2**25
+
+    @classmethod
+    def blob_base_fee_update_fraction(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Returns the blob base fee update fraction for Prague.
+        """
+        return 5007716
+
+    @classmethod
+    def target_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Target blob count of 6 for Prague.
+        """
+        return 6
+
+    @classmethod
+    def max_blobs_per_block(cls, block_number: int = 0, timestamp: int = 0) -> int:
+        """
+        Max blob count of 9 for Prague.
+        """
+        return 9
+
     @classmethod
     def pre_allocation_blockchain(cls) -> Mapping:
         """
@@ -1319,7 +1438,7 @@ def pre_allocation_blockchain(cls) -> Mapping:
         return new_allocation | super(Prague, cls).pre_allocation_blockchain()  # type: ignore
 
     @classmethod
-    def header_requests_required(cls, block_number: int, timestamp: int) -> bool:
+    def header_requests_required(cls, block_number: int = 0, timestamp: int = 0) -> bool:
         """
         Prague requires that the execution layer header contains the beacon
         chain requests hash.