Merge pull request #946 from ethereum/eips/prague/eip-7685

Implement EIP 7685 and 6110

Author: gurukamath

.github/workflows/test.yaml

@@ -41,7 +41,7 @@ jobs:
 
       - name: Run Tox (CPython)
         if: "${{ !startsWith(matrix.py, 'pypy') }}"
-        run: tox -e static,optimized,py3
+        run: tox -e static,py3
 
       - name: Run Tox (PyPy)
         if: "${{ startsWith(matrix.py, 'pypy') }}"

src/ethereum/base_types.py

@@ -910,6 +910,17 @@ class Bytes64(FixedBytes):
     """
 
 
+class Bytes96(FixedBytes):
+    """
+    Byte array of exactly 96 elements.
+    """
+
+    LENGTH = 96
+    """
+    Number of bytes in each instance of this class.
+    """
+
+
 class Bytes256(FixedBytes):
     """
     Byte array of exactly 256 elements.

src/ethereum/prague/blocks.py

@@ -11,18 +11,29 @@
 from dataclasses import dataclass
 from typing import Tuple, Union
 
+from ethereum.exceptions import InvalidBlock
+
+from .. import rlp
 from ..base_types import (
     U64,
     U256,
     Bytes,
     Bytes8,
     Bytes32,
+    Bytes48,
+    Bytes96,
     Uint,
     slotted_freezable,
 )
 from ..crypto.hash import Hash32
 from .fork_types import Address, Bloom, Root
 from .transactions import LegacyTransaction
+from .utils.hexadecimal import hex_to_address
+
+DEPOSIT_CONTRACT_ADDRESS = hex_to_address(
+    "0x00000000219ab540356cbb839cbe05303d7705fa"
+)
+DEPOSIT_REQUEST_TYPE = b"\x00"
 
 
 @slotted_freezable
@@ -65,6 +76,7 @@ class Header:
     blob_gas_used: U64
     excess_blob_gas: U64
     parent_beacon_block_root: Root
+    requests_root: Root
 
 
 @slotted_freezable
@@ -78,6 +90,7 @@ class Block:
     transactions: Tuple[Union[Bytes, LegacyTransaction], ...]
     ommers: Tuple[Header, ...]
     withdrawals: Tuple[Withdrawal, ...]
+    requests: Tuple[Bytes, ...]
 
 
 @slotted_freezable
@@ -103,3 +116,86 @@ class Receipt:
     cumulative_gas_used: Uint
     bloom: Bloom
     logs: Tuple[Log, ...]
+
+
+def validate_requests(requests: Tuple[Bytes, ...]) -> None:
+    """
+    Validate a list of requests.
+    """
+    current_request_type = b"\x00"
+    for request in requests:
+        request_type = request[:1]
+
+        # Ensure that no undefined requests are present.
+        if request_type != DEPOSIT_REQUEST_TYPE:
+            raise InvalidBlock("BlockException.INVALID_REQUESTS")
+
+        # Ensure that requests are in order.
+        if request_type < current_request_type:
+            raise InvalidBlock("BlockException.INVALID_REQUESTS")
+        current_request_type = request_type
+
+
+@slotted_freezable
+@dataclass
+class DepositRequest:
+    """
+    Requests for validator deposits on chain (See EIP-6110).
+    """
+
+    pubkey: Bytes48
+    withdrawal_credentials: Bytes32
+    amount: U64
+    signature: Bytes96
+    index: U64
+
+
+Request = Union[DepositRequest]
+
+
+def encode_request(req: Request) -> Bytes:
+    """
+    Encode a request.
+    """
+    if isinstance(req, DepositRequest):
+        return DEPOSIT_REQUEST_TYPE + rlp.encode(req)
+    else:
+        raise Exception("Unknown request type")
+
+
+def parse_deposit_data(data: Bytes) -> Bytes:
+    """
+    Parses Deposit Request from the DepositContract.DepositEvent data.
+    """
+    deposit_request = DepositRequest(
+        pubkey=Bytes48(data[192:240]),
+        withdrawal_credentials=Bytes32(data[288:320]),
+        amount=U64.from_le_bytes(data[352:360]),
+        signature=Bytes96(data[416:512]),
+        index=U64.from_le_bytes(data[544:552]),
+    )
+
+    return encode_request(deposit_request)
+
+
+def validate_deposit_requests(
+    receipts: Tuple[Receipt, ...], requests: Tuple[Bytes, ...]
+) -> None:
+    """
+    Validate a list of deposit requests.
+    """
+    # Retrieve all deposit requests from receipts.
+    expected_deposit_requests = []
+    for receipt in receipts:
+        for log in receipt.logs:
+            if log.address == DEPOSIT_CONTRACT_ADDRESS:
+                deposit_request_rlp = parse_deposit_data(log.data)
+                expected_deposit_requests.append(deposit_request_rlp)
+
+    # Retrieve all deposit requests from block body
+    deposit_requests = [
+        req for req in requests if req[:1] == DEPOSIT_REQUEST_TYPE
+    ]
+
+    if deposit_requests != expected_deposit_requests:
+        raise InvalidBlock("BlockException.INVALID_REQUESTS")

src/ethereum/prague/fork.py

@@ -23,7 +23,15 @@
 from .. import rlp
 from ..base_types import U64, U256, Bytes, Uint
 from . import vm
-from .blocks import Block, Header, Log, Receipt, Withdrawal
+from .blocks import (
+    Block,
+    Header,
+    Log,
+    Receipt,
+    Withdrawal,
+    validate_deposit_requests,
+    validate_requests,
+)
 from .bloom import logs_bloom
 from .fork_types import Address, Bloom, Root, VersionedHash
 from .state import (
@@ -188,6 +196,7 @@ def state_transition(chain: BlockChain, block: Block) -> None:
         block.withdrawals,
         block.header.parent_beacon_block_root,
         excess_blob_gas,
+        block.requests,
     )
     if apply_body_output.block_gas_used != block.header.gas_used:
         raise InvalidBlock
@@ -482,6 +491,8 @@ class ApplyBodyOutput:
         Trie root of all the withdrawals in the block.
     blob_gas_used : `ethereum.base_types.Uint`
         Total blob gas used in the block.
+    requests_root : `ethereum.fork_types.Root`
+        Trie root of all the requests in the block.
     """
 
     block_gas_used: Uint
@@ -491,6 +502,7 @@ class ApplyBodyOutput:
     state_root: Root
     withdrawals_root: Root
     blob_gas_used: Uint
+    requests_root: Root
 
 
 def apply_body(
@@ -506,6 +518,7 @@ def apply_body(
     withdrawals: Tuple[Withdrawal, ...],
     parent_beacon_block_root: Root,
     excess_blob_gas: U64,
+    requests: Tuple[Bytes, ...],
 ) -> ApplyBodyOutput:
     """
     Executes a block.
@@ -546,6 +559,8 @@ def apply_body(
         The root of the beacon block from the parent block.
     excess_blob_gas :
         Excess blob gas calculated from the previous block.
+    requests :
+        Requests to be processed in the current block.
 
     Returns
     -------
@@ -563,7 +578,11 @@ def apply_body(
     withdrawals_trie: Trie[Bytes, Optional[Union[Bytes, Withdrawal]]] = Trie(
         secured=False, default=None
     )
+    requests_trie: Trie[Bytes, Optional[Bytes]] = Trie(
+        secured=False, default=None
+    )
     block_logs: Tuple[Log, ...] = ()
+    receipts: Tuple[Receipt, ...] = ()
 
     beacon_block_roots_contract_code = get_account(
         state, BEACON_ROOTS_ADDRESS
@@ -658,6 +677,8 @@ def apply_body(
             rlp.encode(Uint(i)),
             receipt,
         )
+        if isinstance(receipt, Receipt):
+            receipts += (receipt,)
 
         block_logs += logs
         blob_gas_used += calculate_total_blob_gas(tx)
@@ -675,6 +696,13 @@ def apply_body(
         if account_exists_and_is_empty(state, wd.address):
             destroy_account(state, wd.address)
 
+    # Requests are to be in ascending order of request type
+    validate_requests(requests)
+
+    validate_deposit_requests(receipts, requests)
+    for i, request in enumerate(requests):
+        trie_set(requests_trie, rlp.encode(Uint(i)), request)
+
     return ApplyBodyOutput(
         block_gas_used,
         root(transactions_trie),
@@ -683,6 +711,7 @@ def apply_body(
         state_root(state),
         root(withdrawals_trie),
         blob_gas_used,
+        root(requests_trie),
     )
 
 

src/ethereum_spec_tools/evm_tools/loaders/fixture_loader.py

@@ -89,6 +89,20 @@ def json_to_withdrawals(self, raw: Any) -> Any:
 
         return self.fork.Withdrawal(*parameters)
 
+    def json_to_request(self, raw: Any) -> Any:
+        """Converts json requests data to a request object"""
+        deposit_request = self.fork.DepositRequest(
+            pubkey=hex_to_bytes(raw.get("pubkey")),
+            withdrawal_credentials=hex_to_bytes32(
+                raw.get("withdrawalCredentials")
+            ),
+            amount=hex_to_u64(raw.get("amount")),
+            signature=hex_to_bytes(raw.get("signature")),
+            index=hex_to_u64(raw.get("index")),
+        )
+
+        return self.fork.encode_request(deposit_request)
+
     def json_to_block(
         self,
         json_block: Any,
@@ -177,4 +191,8 @@ def json_to_header(self, raw: Any) -> Any:
             )
             parameters.append(parent_beacon_block_root)
 
+        if "requestsRoot" in raw:
+            requests_root = self.fork.hex_to_root(raw.get("requestsRoot"))
+            parameters.append(requests_root)
+
         return self.fork.Header(*parameters)

src/ethereum_spec_tools/evm_tools/loaders/fork_loader.py

@@ -127,6 +127,26 @@ def Block(self) -> Any:
         """Block class of the fork"""
         return self._module("blocks").Block
 
+    @property
+    def validate_requests(self) -> Any:
+        """validate_requests function of the fork"""
+        return self._module("blocks").validate_requests
+
+    @property
+    def validate_deposit_requests(self) -> Any:
+        """validate_deposit_requests function of the fork"""
+        return self._module("blocks").validate_deposit_requests
+
+    @property
+    def DepositRequest(self) -> Any:
+        """Deposit request class of the fork"""
+        return self._module("blocks").DepositRequest
+
+    @property
+    def encode_request(self) -> Any:
+        """encode_request function of the fork"""
+        return self._module("blocks").encode_request
+
     @property
     def Bloom(self) -> Any:
         """Bloom class of the fork"""

src/ethereum_spec_tools/evm_tools/t8n/__init__.py

@@ -6,7 +6,7 @@
 import json
 import os
 from functools import partial
-from typing import Any, TextIO
+from typing import Any, TextIO, Tuple
 
 from ethereum import rlp, trace
 from ethereum.base_types import U64, U256, Uint
@@ -312,6 +312,9 @@ def apply_body(self) -> None:
         receipts_trie = self.fork.Trie(secured=False, default=None)
         block_logs = ()
         blob_gas_used = Uint(0)
+        if self.fork.is_after_fork("ethereum.prague"):
+            requests_trie = self.fork.Trie(secured=False, default=None)
+            receipts: Tuple[bytes, ...] = ()
 
         if (
             self.fork.is_after_fork("ethereum.cancun")
@@ -411,6 +414,8 @@ def apply_body(self) -> None:
                     rlp.encode(Uint(i)),
                     receipt,
                 )
+                if self.fork.is_after_fork("ethereum.prague"):
+                    receipts += (receipt,)
 
                 self.txs.add_receipt(tx, gas_consumed)
 
@@ -448,6 +453,15 @@ def apply_body(self) -> None:
             self.result.blob_gas_used = blob_gas_used
             self.result.excess_blob_gas = self.env.excess_blob_gas
 
+        if self.fork.is_after_fork("ethereum.prague"):
+            if not self.fork.validate_requests(self.env.requests):
+                raise InvalidBlock
+
+            self.fork.validate_deposit_requests(receipts, self.env.requests)
+
+            for i, request in enumerate(self.env.requests):
+                self.fork.trie_set(requests_trie, rlp.encode(Uint(i)), request)
+
         self.result.state_root = self.fork.state_root(self.alloc.state)
         self.result.tx_root = self.fork.root(transactions_trie)
         self.result.receipt_root = self.fork.root(receipts_trie)
@@ -457,6 +471,9 @@ def apply_body(self) -> None:
         self.result.receipts = self.txs.successful_receipts
         self.result.gas_used = block_gas_used
 
+        if self.fork.is_after_fork("ethereum.prague"):
+            self.result.requests_root = self.fork.root(requests_trie)
+
     def run(self) -> int:
         """Run the transition and provide the relevant outputs"""
         try: