ethereum-execution 2.18.0rc6.dev2__py3-none-any.whl

ethereum_spec_tools/lint/lints/glacier_forks_hygiene.py

@@ -0,0 +1,273 @@
+"""
+Glacier Fork Hygiene Lint
+^^^^^^^^^^^^^^^^^^^^^^^^^
+Ensures that the glacier forks have changes only in BOMB_DELAY_BLOCKS.
+"""
+
+import ast
+import sys
+from typing import Dict, List, Sequence
+
+from typing_extensions import override
+
+from ethereum_spec_tools.forks import Hardfork
+from ethereum_spec_tools.lint import (
+    Diagnostic,
+    Lint,
+    compare_ast,
+    walk_sources,
+)
+
+EXCEPTIONAL_FILES = [
+    ("dao_fork", ".dao"),
+]
+
+EXCEPTIONAL_DIFFS = [
+    # The DAO Fork has an irregular state transition and minor changes to the
+    # graffiti near the fork block.
+    ("dao_fork", ".fork", "apply_fork"),
+    ("dao_fork", ".fork", "validate_header"),
+    # There are some differences between london and arrow_glacier
+    # in terms of how the fork block is handled.
+    ("arrow_glacier", ".fork", "calculate_base_fee_per_gas"),
+    ("arrow_glacier", ".fork", "validate_header"),
+    ("arrow_glacier", ".fork", "INITIAL_BASE_FEE"),
+]
+
+
+def add_diagnostic(diagnostics: List[Diagnostic], message: str) -> None:
+    """
+    Adds a new diagnostic message.
+    """
+    diagnostic = Diagnostic(message=message)
+    diagnostics.append(diagnostic)
+
+
+class GlacierForksHygiene(Lint):
+    """
+    Ensures that the glacier forks have changes only in BOMB_DELAY_BLOCKS.
+    """
+
+    def __init__(self) -> None:
+        self.delay_blocks = {
+            "muir_glacier": 9000000,
+            "arrow_glacier": 10700000,
+            "gray_glacier": 11400000,
+        }
+
+    def lint(
+        self, forks: List[Hardfork], position: int
+    ) -> Sequence[Diagnostic]:
+        """
+        Walks the sources for each hardfork and emits Diagnostic messages.
+        """
+        fork_name = forks[position].short_name
+        if position == 0:
+            # Nothing to compare against!
+            return []
+
+        if fork_name != "dao_fork" and not fork_name.endswith("_glacier"):
+            # Nothing to compare against or non-glacier fork!
+            return []
+
+        diagnostics: List[Diagnostic] = []
+
+        all_previous = dict(walk_sources(forks[position - 1]))
+        all_current = dict(walk_sources(forks[position]))
+
+        all_files = set(all_previous.keys()) | set(all_current.keys())
+        for file in all_files:
+            if (fork_name, file) in EXCEPTIONAL_FILES:
+                continue
+
+            if file not in all_previous:
+                add_diagnostic(
+                    diagnostics,
+                    f"the file `{file}` is added to `{fork_name}`. "
+                    "Glacier forks may only differ in difficulty block.",
+                )
+                continue
+
+            if file not in all_current:
+                add_diagnostic(
+                    diagnostics,
+                    f"the file `{file}` is deleted from `{fork_name}`. "
+                    "Glacier forks may only differ in difficulty block.",
+                )
+                continue
+
+            current_node = self._parse(all_current[file], _Visitor()).items
+            previous_node = self._parse(all_previous[file], _Visitor()).items
+
+            diagnostics += self.compare(
+                fork_name, file, current_node, previous_node
+            )
+
+        return diagnostics
+
+    def compare(
+        self, fork_name: str, name: str, current: Dict, previous: Dict
+    ) -> List[Diagnostic]:
+        """
+        Compare nodes from two different modules for changes and
+        emit diagnostics.
+        """
+        diagnostics: List[Diagnostic] = []
+
+        all_items = set(previous.keys()) | set(current.keys())
+
+        for item in all_items:
+            if (fork_name, name, item) in EXCEPTIONAL_DIFFS:
+                continue
+            try:
+                previous_item = previous[item]
+            except KeyError:
+                add_diagnostic(
+                    diagnostics,
+                    f"{item} in {name} has been added. "
+                    "Glacier forks may only differ in difficulty block.",
+                )
+                continue
+
+            try:
+                current_item = current[item]
+            except KeyError:
+                add_diagnostic(
+                    diagnostics,
+                    f"{item} in {name} has been deleted. "
+                    "Glacier forks may only differ in difficulty block.",
+                )
+                continue
+
+            if item == "BOMB_DELAY_BLOCKS":
+                previous_item.value.value = self.delay_blocks[fork_name]
+
+            if not compare_ast(previous_item, current_item):
+                add_diagnostic(
+                    diagnostics,
+                    f"`{item}` in `{name}` has changed. "
+                    "Glacier forks may only differ in difficulty block.",
+                )
+
+        return diagnostics
+
+
+class _Visitor(ast.NodeVisitor):
+    """
+    Visits nodes in a syntax tree and collects functions, classes, and
+    assignments.
+    """
+
+    path: List[str]
+    _items: dict
+
+    def __init__(self) -> None:
+        self.path = []
+        self._items = {}
+
+    def generic_visit(self, node: ast.AST) -> None:
+        """
+        Called if no explicit visitor function exists for a node.
+        Do not visit any child nodes.
+        """
+        sys.exit(
+            f"No visit function defined for {node}. Please implement one."
+        )
+
+    def _insert(self, name: str, node: ast.AST) -> None:
+        item = ".".join(self.path + [name])
+        if item in self._items:
+            raise ValueError(f"duplicate path {item}")
+        self._items[item] = node
+
+    @property
+    def items(self) -> Dict:
+        """
+        Sequence of all identifiers found while visiting the source.
+        """
+        return self._items
+
+    def visit_Module(self, module: ast.Module) -> None:
+        """
+        Visit a python module.
+        """
+        for item in module.__dict__["body"]:
+            self.visit(item)
+
+    @override
+    def visit_Import(self, import_: ast.Import) -> None:
+        """
+        Visit an Import.
+        """
+        del import_
+
+    @override
+    def visit_ImportFrom(self, import_from: ast.ImportFrom) -> None:
+        """
+        Visit an Import From.
+        """
+        del import_from
+
+    def visit_Expr(self, expr: ast.Expr) -> None:
+        """
+        Visit an Expression.
+        """
+        # This is a way to identify comments in the current specs code
+        # ignore comments
+        if isinstance(expr.value, ast.Constant) and isinstance(
+            expr.value.value, str
+        ):
+            return
+
+        print(f"The expression {type(expr)} has been ignored.")
+
+    def visit_AsyncFunctionDef(self, function: ast.AsyncFunctionDef) -> None:
+        """
+        Visit an asynchronous function.
+        """
+        self._insert(function.name, function)
+
+    def visit_FunctionDef(self, function: ast.FunctionDef) -> None:
+        """
+        Visit a function.
+        """
+        self._insert(function.name, function)
+
+    def visit_ClassDef(self, klass: ast.ClassDef) -> None:
+        """
+        Visit a class.
+        """
+        self._insert(klass.name, klass)
+
+    def visit_Assign(self, assign: ast.Assign) -> None:
+        """
+        Visit an assignment.
+        """
+        if isinstance(assign.targets[0], ast.Name):
+            self._insert(assign.targets[0].id, assign)
+        else:
+            print(
+                "Assign node with target of type "
+                f"{type(assign.targets[0])} has been ignored."
+            )
+
+    def visit_AnnAssign(self, assign: ast.AnnAssign) -> None:
+        """
+        Visit an annotated assignment.
+        """
+        if isinstance(assign.target, ast.Name):
+            self._insert(assign.target.id, assign)
+        else:
+            print(
+                f"AnnAssign node with target of type {type(assign.target)}"
+                " has been ignored."
+            )
+
+    def visit_If(self, node: ast.If) -> None:
+        """
+        Visit an if statement.
+        """
+        for child in node.body:
+            self.visit(child)
+        for child in node.orelse:
+            self.visit(child)

ethereum_spec_tools/lint/lints/import_hygiene.py

@@ -0,0 +1,145 @@
+"""
+Import Hygiene Lint.
+
+Ensures that the import statements follow the relevant rules.
+"""
+
+import ast
+import inspect
+from types import ModuleType
+from typing import List, Sequence, Tuple
+
+from ethereum_spec_tools.forks import Hardfork
+from ethereum_spec_tools.lint import Diagnostic, Lint
+
+
+class ImportHygiene(Lint):
+    """
+    Ensures that the import statements follow the relevant rules.
+
+    The rules when inside a hard fork file:
+
+     - Deny absolute imports from within the active fork.
+     - Deny absolute imports from future forks.
+     - Deny absolute imports from active-minus-two and earlier hard forks.
+     - Deny relative imports of non-fork specific things.
+     - Allow relative imports from the active hard fork.
+     - Allow absolute imports from the active-minus-one hard fork.
+     - Allow absolute imports of non-fork specific things.
+    """
+
+    def lint(
+        self, forks: List[Hardfork], position: int
+    ) -> Sequence[Diagnostic]:
+        """
+        Walks the sources for each hardfork and emits Diagnostic messages.
+        """
+        fork = forks[position]
+        all_modules: List[ModuleType] = [
+            fork.module(x.name.removeprefix(fork.name + "."))
+            for x in fork.walk_packages()
+        ]
+
+        diagnostics: List[Diagnostic] = []
+        for mod in all_modules:
+            diagnostics += self.check_import(forks, position, mod)
+
+        return diagnostics
+
+    def check_import(
+        self, forks: List[Hardfork], position: int, mod: ModuleType
+    ) -> List[Diagnostic]:
+        """
+        Checks a Python source and emits diagnostic
+        messages if there are any invalid imports.
+        """
+        source = inspect.getsource(mod)
+        name = mod.__name__
+        diagnostics: List[Diagnostic] = []
+
+        active_fork = forks[position].name
+        future_forks = tuple(fork.name for fork in forks[position + 1 :])
+        ancient_forks = (
+            tuple(fork.name for fork in forks[: position - 1])
+            if position > 1
+            else tuple()
+        )
+
+        relative_name = name.removeprefix(active_fork)
+        assert name != relative_name
+
+        current_depth = relative_name.count(".")
+        if hasattr(mod, "__path__"):
+            # `__init__.py` doesn't add a `.` to the name, so we have to
+            # account for it. Checking for `__path__` is, apparently, how to do
+            # that.
+            current_depth += 1
+
+        current_imports = self._parse(source, _Visitor()).item_imports
+
+        for level, item in current_imports:
+            if item is None:
+                continue
+
+            if level > current_depth:
+                dots = "." * level
+                diagnostic = Diagnostic(
+                    message=(
+                        f"The relative import `{dots}{item}` in `{name}` "
+                        "ascends above the current fork. Please use an "
+                        "absolute import."
+                    )
+                )
+                diagnostics.append(diagnostic)
+            elif item.startswith(active_fork):
+                diagnostic = Diagnostic(
+                    message=(
+                        f"The import `{item}` in `{name}` is "
+                        "from the current fork. Please use a relative import."
+                    )
+                )
+                diagnostics.append(diagnostic)
+
+            elif item.startswith(future_forks):
+                diagnostic = Diagnostic(
+                    message=(
+                        f"The import `{item}` in `{name}` "
+                        "is from a future fork. This is not allowed."
+                    )
+                )
+                diagnostics.append(diagnostic)
+            elif item.startswith(ancient_forks):
+                diagnostic = Diagnostic(
+                    message=(
+                        f"The import `{item}` in `{name}` is from an "
+                        "older fork. Only imports from the previous "
+                        "fork are allowed."
+                    )
+                )
+                diagnostics.append(diagnostic)
+
+        return diagnostics
+
+
+class _Visitor(ast.NodeVisitor):
+    """
+    Visits nodes in a syntax tree and collects functions, classes, and
+    assignments.
+    """
+
+    item_imports: List[Tuple[(int, str)]]
+
+    def __init__(self) -> None:
+        self.item_imports = []
+
+    def visit_Import(self, mod: ast.Import) -> None:
+        """
+        Visit an Import.
+        """
+        self.item_imports.append((0, mod.names[0].name))
+
+    def visit_ImportFrom(self, mod: ast.ImportFrom) -> None:
+        """
+        Visit an ImportFrom.
+        """
+        self.item_imports.append((mod.level, str(mod.module)))

ethereum_spec_tools/lint/lints/patch_hygiene.py

@@ -0,0 +1,161 @@
+"""
+Patch Hygiene Lint.
+
+Ensures that the order of identifiers between each hardfork is consistent.
+"""
+
+import ast
+from typing import List, Optional, OrderedDict, Sequence
+
+from ethereum_spec_tools.forks import Hardfork
+from ethereum_spec_tools.lint import Diagnostic, Lint, walk_sources
+
+
+class PatchHygiene(Lint):
+    """
+    Ensures that the order of identifiers between each hardfork is consistent.
+    """
+
+    def lint(
+        self, forks: List[Hardfork], position: int
+    ) -> Sequence[Diagnostic]:
+        """
+        Walks the sources for each hardfork and emits Diagnostic messages.
+        """
+        if position == 0:
+            # Nothing to compare against!
+            return []
+
+        all_previous = dict(walk_sources(forks[position - 1]))
+        all_current = dict(walk_sources(forks[position]))
+
+        items = (
+            (k, v, all_previous.get(k, None)) for (k, v) in all_current.items()
+        )
+
+        diagnostics: List[Diagnostic] = []
+        for name, current, previous in items:
+            diagnostics += self.compare(name, current, previous)
+
+        return diagnostics
+
+    def compare(
+        self, name: str, current_source: str, previous_source: Optional[str]
+    ) -> List[Diagnostic]:
+        """
+        Compares two strings containing Python source and emits diagnostic
+        messages if any identifiers have changed relative positions.
+        """
+        if previous_source is None:
+            # Entire file is new, so nothing to compare!
+            return []
+
+        current_nodes = self._parse(current_source, _Visitor()).items
+        previous_nodes = {
+            item: idx
+            for (idx, item) in enumerate(
+                self._parse(previous_source, _Visitor()).items
+            )
+        }
+
+        diagnostics: List[Diagnostic] = []
+        maximum = None
+
+        for item in current_nodes:
+            previous_position = previous_nodes.get(item)
+            if previous_position is None:
+                continue
+
+            if maximum is None or previous_position > maximum:
+                maximum = previous_position
+            elif previous_position <= maximum:
+                diagnostic = Diagnostic(
+                    message=(
+                        f"the item `{item}` in `{name}` has changed "
+                        "relative positions"
+                    )
+                )
+                diagnostics.append(diagnostic)
+
+        return diagnostics
+
+
+class _Visitor(ast.NodeVisitor):
+    """
+    Visits nodes in a syntax tree and collects functions, classes, and
+    assignments.
+    """
+
+    path: List[str]
+    _items: "OrderedDict[str, None]"
+    in_assign: int
+
+    def __init__(self) -> None:
+        self.path = []
+        self._items = OrderedDict()
+        self.in_assign = 0
+
+    def _insert(self, item: str) -> None:
+        item = ".".join(self.path + [item])
+        if item in self._items:
+            raise ValueError(f"duplicate path {item}")
+        self._items[item] = None
+
+    @property
+    def items(self) -> Sequence[str]:
+        """
+        Sequence of all identifiers found while visiting the source.
+        """
+        return list(self._items.keys())
+
+    def visit_AsyncFunctionDef(self, function: ast.AsyncFunctionDef) -> None:
+        """
+        Visit an asynchronous function.
+        """
+        self._insert(function.name)
+        # Explicitly don't visit the children of functions.
+
+    def visit_FunctionDef(self, function: ast.FunctionDef) -> None:
+        """
+        Visit a function.
+        """
+        self._insert(function.name)
+        # Explicitly don't visit the children of functions.
+
+    def visit_ClassDef(self, klass: ast.ClassDef) -> None:
+        """
+        Visit a class.
+        """
+        self._insert(klass.name)
+        self.path.append(klass.name)
+        self.generic_visit(klass)
+        got = self.path.pop()
+        assert klass.name == got
+
+    def visit_Assign(self, assign: ast.Assign) -> None:
+        """
+        Visit an assignment.
+        """
+        self.in_assign += 1
+        for target in assign.targets:
+            self.visit(target)
+        self.in_assign -= 1
+        self.visit(assign.value)
+
+    def visit_AnnAssign(self, assign: ast.AnnAssign) -> None:
+        """
+        Visit an annotated assignment.
+        """
+        self.in_assign += 1
+        self.visit(assign.target)
+        self.in_assign -= 1
+        self.visit(assign.annotation)
+        if assign.value is not None:
+            self.visit(assign.value)
+
+    def visit_Name(self, identifier: ast.Name) -> None:
+        """
+        Visit an identifier.
+        """
+        if self.in_assign > 0:
+            self._insert(identifier.id)

ethereum_spec_tools/new_fork/__init__.py

@@ -0,0 +1,4 @@
+"""
+Command-line tool for creating a new fork package (eg. `src/ethereum/osaka`)
+from an existing fork package.
+"""