py-geth 4.3.0__py3-none-any.whl → 5.2.0__py3-none-any.whl

geth/mixins.py

@@ -1,5 +1,5 @@
 from __future__ import (
-    absolute_import,
+    annotations,
 )
 
 import datetime
@@ -7,7 +7,15 @@ import logging
 import os
 import queue
 import time
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+)
 
+from geth.exceptions import (
+    PyGethAttributeError,
+)
 from geth.utils.filesystem import (
     ensure_path_exists,
 )
@@ -19,13 +27,13 @@ from geth.utils.timeout import (
 )
 
 
-def construct_logger_file_path(prefix, suffix):
+def construct_logger_file_path(prefix: str, suffix: str) -> str:
     ensure_path_exists("./logs")
     timestamp = datetime.datetime.now().strftime(f"{prefix}-%Y%m%d-%H%M%S-{suffix}.log")
     return os.path.join("logs", timestamp)
 
 
-def _get_file_logger(name, filename):
+def _get_file_logger(name: str, filename: str) -> logging.Logger:
     # create logger with 'spam_application'
     logger = logging.getLogger(name)
     logger.setLevel(logging.DEBUG)
@@ -46,8 +54,15 @@ def _get_file_logger(name, filename):
     return logger
 
 
-class JoinableQueue(queue.Queue):
-    def __iter__(self):
+# only needed until we drop support for python 3.8
+if TYPE_CHECKING:
+    BaseQueue = queue.Queue[Any]
+else:
+    BaseQueue = queue.Queue
+
+
+class JoinableQueue(BaseQueue):
+    def __iter__(self) -> Any:
         while True:
             item = self.get()
 
@@ -65,62 +80,70 @@ class JoinableQueue(queue.Queue):
 
             yield item
 
-    def join(self, timeout=None):
+    def join(self, timeout: int | None = None) -> None:
         with Timeout(timeout) as _timeout:
             while not self.empty():
                 time.sleep(0)
                 _timeout.check()
 
 
-class InterceptedStreamsMixin(object):
+class InterceptedStreamsMixin:
     """
     Mixin class for GethProcess instances that feeds all of the stdout and
     stderr lines into some set of provided callback functions.
     """
 
-    stdout_callbacks = None
-    stderr_callbacks = None
+    stdout_callbacks: list[Callable[[str], None]]
+    stderr_callbacks: list[Callable[[str], None]]
 
-    def __init__(self, *args, **kwargs):
-        super(InterceptedStreamsMixin, self).__init__(*args, **kwargs)
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
         self.stdout_callbacks = []
         self.stdout_queue = JoinableQueue()
 
         self.stderr_callbacks = []
         self.stderr_queue = JoinableQueue()
 
-    def register_stdout_callback(self, callback_fn):
+    def register_stdout_callback(self, callback_fn: Callable[[str], None]) -> None:
         self.stdout_callbacks.append(callback_fn)
 
-    def register_stderr_callback(self, callback_fn):
+    def register_stderr_callback(self, callback_fn: Callable[[str], None]) -> None:
         self.stderr_callbacks.append(callback_fn)
 
-    def produce_stdout_queue(self):
-        for line in iter(self.proc.stdout.readline, b""):
-            self.stdout_queue.put(line)
-            time.sleep(0)
+    def produce_stdout_queue(self) -> None:
+        if hasattr(self, "proc"):
+            for line in iter(self.proc.stdout.readline, b""):
+                self.stdout_queue.put(line)
+                time.sleep(0)
+        else:
+            raise PyGethAttributeError("No `proc` attribute found")
 
-    def produce_stderr_queue(self):
-        for line in iter(self.proc.stderr.readline, b""):
-            self.stderr_queue.put(line)
-            time.sleep(0)
+    def produce_stderr_queue(self) -> None:
+        if hasattr(self, "proc"):
+            for line in iter(self.proc.stderr.readline, b""):
+                self.stderr_queue.put(line)
+                time.sleep(0)
+        else:
+            raise PyGethAttributeError("No `proc` attribute found")
 
-    def consume_stdout_queue(self):
+    def consume_stdout_queue(self) -> None:
         for line in self.stdout_queue:
             for fn in self.stdout_callbacks:
                 fn(line.strip())
             self.stdout_queue.task_done()
             time.sleep(0)
 
-    def consume_stderr_queue(self):
+    def consume_stderr_queue(self) -> None:
         for line in self.stderr_queue:
             for fn in self.stderr_callbacks:
                 fn(line.strip())
             self.stderr_queue.task_done()
             time.sleep(0)
 
-    def start(self):
-        super(InterceptedStreamsMixin, self).start()
+    def start(self) -> None:
+        # type ignored because this is a mixin but will always have a start method
+        # because it will be mixed with BaseGethProcess
+        super().start()  # type: ignore[misc]
 
         spawn(self.produce_stdout_queue)
         spawn(self.produce_stderr_queue)
@@ -128,8 +151,10 @@ class InterceptedStreamsMixin(object):
         spawn(self.consume_stdout_queue)
         spawn(self.consume_stderr_queue)
 
-    def stop(self):
-        super(InterceptedStreamsMixin, self).stop()
+    def stop(self) -> None:
+        # type ignored because this is a mixin but will always have a stop method
+        # because it will be mixed with BaseGethProcess
+        super().stop()  # type: ignore[misc]
 
         try:
             self.stdout_queue.put(StopIteration)
@@ -145,7 +170,7 @@ class InterceptedStreamsMixin(object):
 
 
 class LoggingMixin(InterceptedStreamsMixin):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: Any, **kwargs: Any):
         stdout_logfile_path = kwargs.pop(
             "stdout_logfile_path",
             construct_logger_file_path("geth", "stdout"),
@@ -155,7 +180,7 @@ class LoggingMixin(InterceptedStreamsMixin):
             construct_logger_file_path("geth", "stderr"),
         )
 
-        super(LoggingMixin, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
         stdout_logger = _get_file_logger("geth-stdout", stdout_logfile_path)
         stderr_logger = _get_file_logger("geth-stderr", stderr_logfile_path)

geth/process.py

@@ -1,21 +1,34 @@
+from __future__ import (
+    annotations,
+)
+
+from abc import (
+    ABC,
+    abstractmethod,
+)
+import json
 import logging
 import os
-import socket
 import subprocess
 import time
-import warnings
-
-try:
-    from urllib.request import (
-        URLError,
-        urlopen,
-    )
-except ImportError:
-    from urllib2 import (
-        urlopen,
-        URLError,
-    )
+from types import (
+    TracebackType,
+)
+from typing import (
+    cast,
+)
+from urllib.error import (
+    URLError,
+)
+from urllib.request import (
+    urlopen,
+)
+
+import semantic_version
 
+from geth import (
+    get_geth_version,
+)
 from geth.accounts import (
     ensure_account_exists,
     get_accounts,
@@ -25,13 +38,18 @@ from geth.chain import (
     get_default_base_dir,
     get_genesis_file_path,
     get_live_data_dir,
-    get_ropsten_data_dir,
+    get_sepolia_data_dir,
     initialize_chain,
     is_live_chain,
-    is_ropsten_chain,
+    is_sepolia_chain,
+)
+from geth.exceptions import (
+    PyGethNotImplementedError,
+    PyGethValueError,
 )
-from geth.utils.dag import (
-    is_dag_generated,
+from geth.types import (
+    GethKwargsTypedDict,
+    IO_Any,
 )
 from geth.utils.networking import (
     get_ipc_socket,
@@ -42,24 +60,32 @@ from geth.utils.proc import (
 from geth.utils.timeout import (
     Timeout,
 )
+from geth.utils.validation import (
+    GenesisDataTypedDict,
+    validate_genesis_data,
+    validate_geth_kwargs,
+)
 from geth.wrapper import (
     construct_popen_command,
     construct_test_chain_kwargs,
 )
 
 logger = logging.getLogger(__name__)
+with open(os.path.join(os.path.dirname(__file__), "genesis.json")) as genesis_file:
+    GENESIS_JSON = json.load(genesis_file)
 
 
-class BaseGethProcess(object):
+class BaseGethProcess(ABC):
     _proc = None
 
     def __init__(
         self,
-        geth_kwargs,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
+        geth_kwargs: GethKwargsTypedDict,
+        stdin: IO_Any = subprocess.PIPE,
+        stdout: IO_Any = subprocess.PIPE,
+        stderr: IO_Any = subprocess.PIPE,
     ):
+        validate_geth_kwargs(geth_kwargs)
         self.geth_kwargs = geth_kwargs
         self.command = construct_popen_command(**geth_kwargs)
         self.stdin = stdin
@@ -68,12 +94,12 @@ class BaseGethProcess(object):
 
     is_running = False
 
-    def start(self):
+    def start(self) -> None:
         if self.is_running:
-            raise ValueError("Already running")
+            raise PyGethValueError("Already running")
         self.is_running = True
 
-        logger.info("Launching geth: %s", " ".join(self.command))
+        logger.info(f"Launching geth: {' '.join(self.command)}")
         self.proc = subprocess.Popen(
             self.command,
             stdin=self.stdin,
@@ -81,48 +107,61 @@ class BaseGethProcess(object):
             stderr=self.stderr,
         )
 
-    def __enter__(self):
+    def __enter__(self) -> BaseGethProcess:
         self.start()
         return self
 
-    def stop(self):
+    def stop(self) -> None:
         if not self.is_running:
-            raise ValueError("Not running")
+            raise PyGethValueError("Not running")
 
         if self.proc.poll() is None:
             kill_proc(self.proc)
 
         self.is_running = False
 
-    def __exit__(self, *exc_info):
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
         self.stop()
 
     @property
-    def is_alive(self):
+    @abstractmethod
+    def data_dir(self) -> str:
+        raise PyGethNotImplementedError("Must be implemented by subclasses.")
+
+    @property
+    def is_alive(self) -> bool:
         return self.is_running and self.proc.poll() is None
 
     @property
-    def is_stopped(self):
+    def is_stopped(self) -> bool:
         return self.proc is not None and self.proc.poll() is not None
 
     @property
-    def accounts(self):
+    def accounts(self) -> tuple[str, ...]:
         return get_accounts(**self.geth_kwargs)
 
     @property
-    def rpc_enabled(self):
-        return self.geth_kwargs.get("rpc_enabled", False)
+    def rpc_enabled(self) -> bool:
+        _rpc_enabled = self.geth_kwargs.get("rpc_enabled", False)
+        return cast(bool, _rpc_enabled)
 
     @property
-    def rpc_host(self):
-        return self.geth_kwargs.get("rpc_host", "127.0.0.1")
+    def rpc_host(self) -> str:
+        _rpc_host = self.geth_kwargs.get("rpc_host", "127.0.0.1")
+        return cast(str, _rpc_host)
 
     @property
-    def rpc_port(self):
-        return self.geth_kwargs.get("rpc_port", "8545")
+    def rpc_port(self) -> str:
+        _rpc_port = self.geth_kwargs.get("rpc_port", "8545")
+        return cast(str, _rpc_port)
 
     @property
-    def is_rpc_ready(self):
+    def is_rpc_ready(self) -> bool:
         try:
             urlopen(f"http://{self.rpc_host}:{self.rpc_port}")
         except URLError:
@@ -130,9 +169,9 @@ class BaseGethProcess(object):
         else:
             return True
 
-    def wait_for_rpc(self, timeout=0):
+    def wait_for_rpc(self, timeout: int = 0) -> None:
         if not self.rpc_enabled:
-            raise ValueError("RPC interface is not enabled")
+            raise PyGethValueError("RPC interface is not enabled")
 
         with Timeout(timeout) as _timeout:
             while True:
@@ -142,36 +181,33 @@ class BaseGethProcess(object):
                 _timeout.check()
 
     @property
-    def ipc_enabled(self):
+    def ipc_enabled(self) -> bool:
         return not self.geth_kwargs.get("ipc_disable", None)
 
     @property
-    def ipc_path(self):
-        return self.geth_kwargs.get(
-            "ipc_path",
-            os.path.abspath(
-                os.path.expanduser(
-                    os.path.join(
-                        self.data_dir,
-                        "geth.ipc",
-                    )
+    def ipc_path(self) -> str:
+        return self.geth_kwargs.get("ipc_path") or os.path.abspath(
+            os.path.expanduser(
+                os.path.join(
+                    self.data_dir,
+                    "geth.ipc",
                 )
-            ),
+            )
         )
 
     @property
-    def is_ipc_ready(self):
+    def is_ipc_ready(self) -> bool:
         try:
             with get_ipc_socket(self.ipc_path):
                 pass
-        except socket.error:
+        except OSError:
             return False
         else:
             return True
 
-    def wait_for_ipc(self, timeout=0):
+    def wait_for_ipc(self, timeout: int = 0) -> None:
         if not self.ipc_enabled:
-            raise ValueError("IPC interface is not enabled")
+            raise PyGethValueError("IPC interface is not enabled")
 
         with Timeout(timeout) as _timeout:
             while True:
@@ -180,78 +216,49 @@ class BaseGethProcess(object):
                 time.sleep(0.1)
                 _timeout.check()
 
-    @property
-    def is_dag_generated(self):
-        return is_dag_generated()
-
-    @property
-    def is_mining(self):
-        return self.geth_kwargs.get("mine", False)
-
-    def wait_for_dag(self, timeout=0):
-        if not self.is_mining and not self.geth_kwargs.get("autodag", False):
-            raise ValueError("Geth not configured to generate DAG")
-
-        with Timeout(timeout) as _timeout:
-            while True:
-                if self.is_dag_generated:
-                    break
-                time.sleep(0.1)
-                _timeout.check()
-
 
 class MainnetGethProcess(BaseGethProcess):
-    def __init__(self, geth_kwargs=None):
+    def __init__(self, geth_kwargs: GethKwargsTypedDict | None = None):
         if geth_kwargs is None:
             geth_kwargs = {}
 
         if "data_dir" in geth_kwargs:
-            raise ValueError("You cannot specify `data_dir` for a MainnetGethProcess")
+            raise PyGethValueError(
+                "You cannot specify `data_dir` for a MainnetGethProcess"
+            )
 
-        super(MainnetGethProcess, self).__init__(geth_kwargs)
+        super().__init__(geth_kwargs)
 
     @property
-    def data_dir(self):
+    def data_dir(self) -> str:
         return get_live_data_dir()
 
 
-class LiveGethProcess(MainnetGethProcess):
-    def __init__(self, *args, **kwargs):
-        warnings.warn(
-            DeprecationWarning(
-                "The `LiveGethProcess` has been renamed to `MainnetGethProcess`. "
-                "The `LiveGethProcess` alias will be removed in subsequent releases"
-            ),
-            stacklevel=2,
-        )
-        super(LiveGethProcess, self).__init__(*args, **kwargs)
-
-
-class RopstenGethProcess(BaseGethProcess):
-    def __init__(self, geth_kwargs=None):
+class SepoliaGethProcess(BaseGethProcess):
+    def __init__(self, geth_kwargs: GethKwargsTypedDict | None = None):
         if geth_kwargs is None:
             geth_kwargs = {}
 
         if "data_dir" in geth_kwargs:
-            raise ValueError(
+            raise PyGethValueError(
                 f"You cannot specify `data_dir` for a {type(self).__name__}"
             )
         if "network_id" in geth_kwargs:
-            raise ValueError(
+            raise PyGethValueError(
                 f"You cannot specify `network_id` for a {type(self).__name__}"
             )
 
-        geth_kwargs["network_id"] = "3"
-        geth_kwargs["data_dir"] = get_ropsten_data_dir()
+        geth_kwargs["network_id"] = "11155111"
+        geth_kwargs["data_dir"] = get_sepolia_data_dir()
 
-        super(RopstenGethProcess, self).__init__(geth_kwargs)
+        super().__init__(geth_kwargs)
 
     @property
-    def data_dir(self):
-        return get_ropsten_data_dir()
+    def data_dir(self) -> str:
+        return get_sepolia_data_dir()
 
 
-class TestnetGethProcess(RopstenGethProcess):
+class TestnetGethProcess(SepoliaGethProcess):
     """
     Alias for whatever the current primary testnet chain is.
     """
@@ -259,53 +266,70 @@ class TestnetGethProcess(RopstenGethProcess):
 
 class DevGethProcess(BaseGethProcess):
     """
-    A local private chain for development.
+    Geth developer mode process for testing purposes.
     """
 
-    def __init__(self, chain_name, base_dir=None, overrides=None, genesis_data=None):
+    _data_dir: str
+
+    def __init__(
+        self,
+        chain_name: str,
+        base_dir: str | None = None,
+        overrides: GethKwargsTypedDict | None = None,
+        genesis_data: GenesisDataTypedDict | None = None,
+    ):
         if overrides is None:
             overrides = {}
 
         if genesis_data is None:
-            genesis_data = {}
+            genesis_data = GenesisDataTypedDict(**GENESIS_JSON)
+
+        validate_genesis_data(genesis_data)
 
         if "data_dir" in overrides:
-            raise ValueError("You cannot specify `data_dir` for a DevGethProcess")
+            raise PyGethValueError("You cannot specify `data_dir` for a DevGethProcess")
 
         if base_dir is None:
             base_dir = get_default_base_dir()
 
-        self.data_dir = get_chain_data_dir(base_dir, chain_name)
-        geth_kwargs = construct_test_chain_kwargs(data_dir=self.data_dir, **overrides)
+        self._data_dir = get_chain_data_dir(base_dir, chain_name)
+        overrides["data_dir"] = self.data_dir
+        geth_kwargs = construct_test_chain_kwargs(**overrides)
+        validate_geth_kwargs(geth_kwargs)
 
         # ensure that an account is present
         coinbase = ensure_account_exists(**geth_kwargs)
 
         # ensure that the chain is initialized
         genesis_file_path = get_genesis_file_path(self.data_dir)
-
         needs_init = all(
             (
                 not os.path.exists(genesis_file_path),
                 not is_live_chain(self.data_dir),
-                not is_ropsten_chain(self.data_dir),
+                not is_sepolia_chain(self.data_dir),
             )
         )
-
         if needs_init:
-            genesis_data.setdefault(
-                "alloc",
-                dict(
-                    [
-                        (
-                            coinbase,
-                            {
-                                "balance": "1000000000000000000000000000000"  # 1 billion ether  # noqa: E501
-                            },
-                        ),
-                    ]
-                ),
+            genesis_data["coinbase"] = coinbase
+            genesis_data.setdefault("alloc", {}).setdefault(
+                coinbase, {"balance": "1000000000000000000000000000000"}
             )
-            initialize_chain(genesis_data, **geth_kwargs)
 
-        super(DevGethProcess, self).__init__(geth_kwargs)
+            modify_genesis_based_on_geth_version(genesis_data)
+            initialize_chain(genesis_data, self.data_dir)
+
+        super().__init__(geth_kwargs)
+
+    @property
+    def data_dir(self) -> str:
+        return self._data_dir
+
+
+def modify_genesis_based_on_geth_version(genesis_data: GenesisDataTypedDict) -> None:
+    geth_version = get_geth_version()
+    if geth_version <= semantic_version.Version("1.14.0"):
+        # geth <= v1.14.0 needs negative `terminalTotalDifficulty` to load EVM
+        # instructions correctly: https://github.com/ethereum/go-ethereum/pull/29579
+        if "config" not in genesis_data:
+            genesis_data["config"] = {}
+        genesis_data["config"]["terminalTotalDifficulty"] = -1