chia-blockchain 2.5.4rc1__py3-none-any.whl → 2.5.5__py3-none-any.whl

chia/server/chia_policy.py

@@ -8,7 +8,7 @@ import struct
 import sys
 
 if sys.platform == "win32":
-    import _overlapped
+    import _overlapped  # type: ignore[import-not-found]
     import _winapi
 
 from collections.abc import Iterable

chia/server/node_discovery.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import math
 import random
 import time
 import traceback
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
 from logging import Logger
 from pathlib import Path
 from random import Random
-from secrets import randbits
 from typing import Any, Optional
 
 import dns.asyncresolver
@@ -16,13 +18,13 @@ from chia_rs.sized_ints import uint16, uint64
 
 from chia.protocols.full_node_protocol import RequestPeers, RespondPeers
 from chia.protocols.introducer_protocol import RequestPeersIntroducer
+from chia.protocols.outbound_message import Message, NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.server.address_manager import AddressManager, ExtendedPeerInfo
-from chia.server.address_manager_store import AddressManagerStore
-from chia.server.outbound_message import Message, NodeType, make_msg
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import PeerInfo, TimestampedPeerInfo, UnresolvedPeerInfo
+from chia.util.files import write_file_async
 from chia.util.hash import std_hash
 from chia.util.ip_address import IPAddress
 from chia.util.network import resolve
@@ -40,59 +42,52 @@ NETWORK_ID_DEFAULT_PORTS = {
 }
 
 
+@dataclass
 class FullNodeDiscovery:
-    resolver: Optional[dns.asyncresolver.Resolver]
-    enable_private_networks: bool
-
-    def __init__(
-        self,
-        server: ChiaServer,
-        target_outbound_count: int,
-        peers_file_path: Path,
-        introducer_info: Optional[dict[str, Any]],
-        dns_servers: list[str],
-        peer_connect_interval: int,
-        selected_network: str,
-        default_port: Optional[int],
-        log: Logger,
-    ) -> None:
-        self.server: ChiaServer = server
-        self.is_closed = False
-        self.target_outbound_count = target_outbound_count
-        self.legacy_peer_db_migrated = False
-        self.peers_file_path = peers_file_path
-        self.dns_servers = dns_servers
-        random.shuffle(dns_servers)  # Don't always start with the same DNS server
-        self.introducer_info: Optional[UnresolvedPeerInfo] = None
-        if introducer_info is not None:
-            self.introducer_info = UnresolvedPeerInfo(introducer_info["host"], introducer_info["port"])
-            self.enable_private_networks = introducer_info.get("enable_private_networks", False)
-        else:
-            self.enable_private_networks = False
-        self.peer_connect_interval = peer_connect_interval
-        self.log = log
-        self.relay_queue: Optional[asyncio.Queue[tuple[TimestampedPeerInfo, int]]] = None
-        self.address_manager: Optional[AddressManager] = None
-        self.connection_time_pretest: dict[str, Any] = {}
-        self.received_count_from_peers: dict[str, Any] = {}
-        self.lock = asyncio.Lock()
-        self.connect_peers_task: Optional[asyncio.Task[None]] = None
-        self.serialize_task: Optional[asyncio.Task[None]] = None
-        self.cleanup_task: Optional[asyncio.Task[None]] = None
-        self.initial_wait: int = 0
+    server: ChiaServer
+    target_outbound_count: int
+    peers_file_path: Path
+    dns_servers: list[str]
+    peer_connect_interval: int
+    selected_network: str
+    log: Logger
+    introducer_info: Optional[dict[str, Any]] = None
+    default_port: Optional[int] = None
+    resolver: Optional[dns.asyncresolver.Resolver] = field(default=None)
+    enable_private_networks: bool = field(default=False)
+    is_closed: bool = field(default=False)
+    legacy_peer_db_migrated: bool = field(default=False)
+    relay_queue: Optional[asyncio.Queue[tuple[TimestampedPeerInfo, int]]] = field(default=None)
+    address_manager: Optional[AddressManager] = field(default=None)
+    connection_time_pretest: dict[str, Any] = field(default_factory=dict)
+    received_count_from_peers: dict[str, Any] = field(default_factory=dict)
+    lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+    connect_peers_task: Optional[asyncio.Task[None]] = field(default=None)
+    serialize_task: Optional[asyncio.Task[None]] = field(default=None)
+    cleanup_task: Optional[asyncio.Task[None]] = field(default=None)
+    initial_wait: int = field(default=0)
+    pending_outbound_connections: set[str] = field(default_factory=set)
+    pending_tasks: set[asyncio.Task[None]] = field(default_factory=set)
+    introducer_info_obj: Optional[UnresolvedPeerInfo] = field(default=None)
+
+    def __post_init__(self) -> None:
+        random.shuffle(self.dns_servers)  # Don't always start with the same DNS server
+
+        if self.introducer_info is not None:
+            self.introducer_info_obj = UnresolvedPeerInfo(self.introducer_info["host"], self.introducer_info["port"])
+            self.enable_private_networks = self.introducer_info.get("enable_private_networks", False)
+
         try:
-            self.resolver: Optional[dns.asyncresolver.Resolver] = dns.asyncresolver.Resolver()
+            self.resolver = dns.asyncresolver.Resolver()
         except Exception:
             self.resolver = None
             self.log.exception("Error initializing asyncresolver")
-        self.pending_outbound_connections: set[str] = set()
-        self.pending_tasks: set[asyncio.Task[None]] = set()
-        self.default_port: Optional[int] = default_port
-        if default_port is None and selected_network in NETWORK_ID_DEFAULT_PORTS:
-            self.default_port = NETWORK_ID_DEFAULT_PORTS[selected_network]
+
+        if self.default_port is None and self.selected_network in NETWORK_ID_DEFAULT_PORTS:
+            self.default_port = NETWORK_ID_DEFAULT_PORTS[self.selected_network]
 
     async def initialize_address_manager(self) -> None:
-        self.address_manager = await AddressManagerStore.create_address_manager(self.peers_file_path)
+        self.address_manager = await AddressManager.create_address_manager(self.peers_file_path)
         if self.enable_private_networks:
             self.address_manager.make_private_subnets_valid()
         self.server.set_received_message_callback(self.update_peer_timestamp_on_message)
@@ -175,7 +170,7 @@ class FullNodeDiscovery:
         )
 
     async def _introducer_client(self) -> None:
-        if self.introducer_info is None:
+        if self.introducer_info_obj is None:
             return None
 
         async def on_connect(peer: WSChiaConnection) -> None:
@@ -183,7 +178,8 @@ class FullNodeDiscovery:
             await peer.send_message(msg)
 
         await self.server.start_client(
-            PeerInfo(await resolve(self.introducer_info.host, prefer_ipv6=False), self.introducer_info.port), on_connect
+            PeerInfo(await resolve(self.introducer_info_obj.host, prefer_ipv6=False), self.introducer_info_obj.port),
+            on_connect,
         )
 
     async def _query_dns(self, dns_address: str) -> None:
@@ -418,7 +414,8 @@ class FullNodeDiscovery:
             serialize_interval = random.randint(15 * 60, 30 * 60)
             await asyncio.sleep(serialize_interval)
             async with self.address_manager.lock:
-                await AddressManagerStore.serialize(self.address_manager, self.peers_file_path)
+                serialised_bytes = self.address_manager.serialize_bytes()
+            await write_file_async(self.peers_file_path, serialised_bytes, file_mode=0o644)
 
     async def _periodically_cleanup(self) -> None:
         while not self.is_closed:
@@ -490,47 +487,33 @@ class FullNodeDiscovery:
             await self.address_manager.add_to_new_table(peers_adjusted_timestamp, None, 0)
 
 
+@dataclass
 class FullNodePeers(FullNodeDiscovery):
-    self_advertise_task: Optional[asyncio.Task[None]] = None
-    address_relay_task: Optional[asyncio.Task[None]] = None
-
-    def __init__(
-        self,
-        server: ChiaServer,
-        target_outbound_count: int,
-        peers_file_path: Path,
-        introducer_info: dict[str, Any],
-        dns_servers: list[str],
-        peer_connect_interval: int,
-        selected_network: str,
-        default_port: Optional[int],
-        log: Logger,
-    ) -> None:
-        super().__init__(
-            server,
-            target_outbound_count,
-            peers_file_path,
-            introducer_info,
-            dns_servers,
-            peer_connect_interval,
-            selected_network,
-            default_port,
-            log,
-        )
-        self.relay_queue = asyncio.Queue()
-        self.neighbour_known_peers: dict[PeerInfo, set[str]] = {}
-        self.key = randbits(256)
+    self_advertise_task: Optional[asyncio.Task[None]] = field(default=None)
+    address_relay_task: Optional[asyncio.Task[None]] = field(default=None)
+    relay_queue: asyncio.Queue[tuple[TimestampedPeerInfo, int]] = field(default_factory=asyncio.Queue)
+    neighbour_known_peers: dict[PeerInfo, set[str]] = field(default_factory=dict)
+    key: int = field(default_factory=lambda: random.getrandbits(256))
 
-    async def start(self) -> None:
-        await self.initialize_address_manager()
-        self.self_advertise_task = create_referenced_task(self._periodically_self_advertise_and_clean_data())
-        self.address_relay_task = create_referenced_task(self._address_relay())
-        await self.start_tasks()
+    def __post_init__(self) -> None:
+        super().__post_init__()
 
-    async def close(self) -> None:
-        await self._close_common()
-        cancel_task_safe(self.self_advertise_task, self.log)
-        cancel_task_safe(self.address_relay_task, self.log)
+    @contextlib.asynccontextmanager
+    async def manage(self) -> AsyncIterator[None]:
+        try:
+            self.log.info("Initialising Full Node peers discovery.")
+            await self.initialize_address_manager()
+            self.self_advertise_task = create_referenced_task(self._periodically_self_advertise_and_clean_data())
+            self.address_relay_task = create_referenced_task(self._address_relay())
+            await self.start_tasks()
+            self.log.info("Successfully initialised Full Node peers discovery.")
+            yield
+        finally:
+            self.log.info("Closing Full Node peers discovery.")
+            await self._close_common()
+            cancel_task_safe(self.self_advertise_task, self.log)
+            cancel_task_safe(self.address_relay_task, self.log)
+            self.log.info("Successfully closed Full Node peers discovery.")
 
     async def _periodically_self_advertise_and_clean_data(self) -> None:
         while not self.is_closed:
@@ -673,30 +656,10 @@ class FullNodePeers(FullNodeDiscovery):
                 self.log.error(f"Traceback: {traceback.format_exc()}")
 
 
+@dataclass
 class WalletPeers(FullNodeDiscovery):
-    def __init__(
-        self,
-        server: ChiaServer,
-        target_outbound_count: int,
-        peers_file_path: Path,
-        introducer_info: dict[str, Any],
-        dns_servers: list[str],
-        peer_connect_interval: int,
-        selected_network: str,
-        default_port: Optional[int],
-        log: Logger,
-    ) -> None:
-        super().__init__(
-            server,
-            target_outbound_count,
-            peers_file_path,
-            introducer_info,
-            dns_servers,
-            peer_connect_interval,
-            selected_network,
-            default_port,
-            log,
-        )
+    def __post_init__(self) -> None:
+        super().__post_init__()
 
     async def start(self) -> None:
         self.initial_wait = 1

chia/server/rate_limits.py

@@ -6,9 +6,9 @@ import time
 from collections import Counter
 from typing import Optional
 
+from chia.protocols.outbound_message import Message
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability
-from chia.server.outbound_message import Message
 from chia.server.rate_limit_numbers import RLSettings, Unlimited, get_rate_limits_to_use
 
 log = logging.getLogger(__name__)

chia/server/resolve_peer_info.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from chia.protocols.outbound_message import NodeType
+from chia.types.peer_info import UnresolvedPeerInfo
+
+log = logging.getLogger(__name__)
+
+PEER_INFO_MAPPING: dict[NodeType, str] = {
+    NodeType.FULL_NODE: "full_node_peer",
+    NodeType.FARMER: "farmer_peer",
+}
+
+
+def get_unresolved_peer_infos(service_config: dict[str, Any], peer_type: NodeType) -> set[UnresolvedPeerInfo]:
+    peer_info_key = PEER_INFO_MAPPING[peer_type]
+    peer_infos: list[dict[str, Any]] = service_config.get(f"{peer_info_key}s", [])
+    peer_info: Optional[dict[str, Any]] = service_config.get(peer_info_key)
+    if peer_info is not None:
+        peer_infos.append(peer_info)
+
+    return {UnresolvedPeerInfo(host=peer["host"], port=peer["port"]) for peer in peer_infos}
+
+
+def set_peer_info(
+    service_config: dict[str, Any],
+    peer_type: NodeType,
+    peer_host: Optional[str] = None,
+    peer_port: Optional[int] = None,
+) -> None:
+    peer_info_key = PEER_INFO_MAPPING[peer_type]
+    if peer_info_key in service_config:
+        if peer_host is not None:
+            service_config[peer_info_key]["host"] = peer_host
+        if peer_port is not None:
+            service_config[peer_info_key]["port"] = peer_port
+    elif f"{peer_info_key}s" in service_config and len(service_config[f"{peer_info_key}s"]) > 0:
+        if peer_host is not None:
+            service_config[f"{peer_info_key}s"][0]["host"] = peer_host
+        if peer_port is not None:
+            service_config[f"{peer_info_key}s"][0]["port"] = peer_port

chia/server/server.py

@@ -27,18 +27,18 @@ from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes, serialization
 from typing_extensions import final
 
+from chia.protocols.outbound_message import Message, NodeType
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.protocol_state_machine import message_requires_reply
 from chia.protocols.protocol_timing import INVALID_PROTOCOL_BAN_SECONDS
 from chia.server.api_protocol import ApiProtocol
 from chia.server.introducer_peers import IntroducerPeers
-from chia.server.outbound_message import Message, NodeType
 from chia.server.ssl_context import private_ssl_paths, public_ssl_paths
 from chia.server.ws_connection import ConnectionCallback, WSChiaConnection
+from chia.ssl.ssl_check import verify_ssl_certs_and_keys
 from chia.types.peer_info import PeerInfo
 from chia.util.errors import Err, ProtocolError
 from chia.util.network import WebServer, is_in_network, is_localhost, is_trusted_peer
-from chia.util.ssl_check import verify_ssl_certs_and_keys
 from chia.util.streamable import Streamable
 from chia.util.task_referencer import create_referenced_task
 
@@ -57,7 +57,7 @@ def ssl_context_for_server(
     if check_permissions:
         verify_ssl_certs_and_keys([ca_cert, cert_path], [ca_key, key_path], log)
 
-    ssl_context = ssl._create_unverified_context(purpose=ssl.Purpose.CLIENT_AUTH, cafile=str(ca_cert))
+    ssl_context = ssl._create_unverified_context(purpose=ssl.Purpose.CLIENT_AUTH, cafile=str(ca_cert))  # noqa: S323
     ssl_context.check_hostname = False
     ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
     ssl_context.set_ciphers(
@@ -99,7 +99,7 @@ def ssl_context_for_client(
     if check_permissions:
         verify_ssl_certs_and_keys([ca_cert, cert_path], [ca_key, key_path], log)
 
-    ssl_context = ssl._create_unverified_context(purpose=ssl.Purpose.SERVER_AUTH, cafile=str(ca_cert))
+    ssl_context = ssl._create_unverified_context(purpose=ssl.Purpose.SERVER_AUTH, cafile=str(ca_cert))  # noqa: S323
     ssl_context.check_hostname = False
     ssl_context.load_cert_chain(certfile=str(cert_path), keyfile=str(key_path))
     ssl_context.verify_mode = ssl.CERT_REQUIRED
@@ -142,7 +142,7 @@ class ChiaServer:
     connection_close_task: Optional[asyncio.Task[None]] = None
     received_message_callback: Optional[ConnectionCallback] = None
     banned_peers: dict[str, float] = field(default_factory=dict)
-    invalid_protocol_ban_seconds = INVALID_PROTOCOL_BAN_SECONDS
+    invalid_protocol_ban_seconds: int = INVALID_PROTOCOL_BAN_SECONDS
 
     @classmethod
     def create(

chia/server/start_data_layer.py

@@ -11,19 +11,19 @@ from chia_rs.sized_ints import uint16
 from chia.apis import ApiProtocolRegistry
 from chia.data_layer.data_layer import DataLayer
 from chia.data_layer.data_layer_api import DataLayerAPI
+from chia.data_layer.data_layer_rpc_api import DataLayerRpcApi
 from chia.data_layer.data_layer_util import PluginRemote
 from chia.data_layer.util.plugin import load_plugin_configurations
-from chia.rpc.data_layer_rpc_api import DataLayerRpcApi
-from chia.rpc.wallet_rpc_client import WalletRpcClient
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
+from chia.server.aliases import DataLayerService, WalletService
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
 from chia.ssl.create_ssl import create_all_ssl
-from chia.types.aliases import DataLayerService, WalletService
 from chia.util.chia_logging import initialize_logging
 from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path
 from chia.util.task_timing import maybe_manage_task_instrumentation
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
 # See: https://bugs.python.org/issue29288
 "".encode("idna")

chia/server/start_farmer.py

@@ -12,13 +12,14 @@ from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.farmer.farmer import Farmer
 from chia.farmer.farmer_api import FarmerAPI
-from chia.rpc.farmer_rpc_api import FarmerRpcApi
-from chia.server.outbound_message import NodeType
+from chia.farmer.farmer_rpc_api import FarmerRpcApi
+from chia.protocols.outbound_message import NodeType
+from chia.server.aliases import FarmerService
+from chia.server.resolve_peer_info import get_unresolved_peer_infos
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
-from chia.types.aliases import FarmerService
 from chia.util.chia_logging import initialize_service_logging
-from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
+from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path
 from chia.util.keychain import Keychain
 from chia.util.task_timing import maybe_manage_task_instrumentation

chia/server/start_full_node.py

@@ -14,13 +14,14 @@ from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
-from chia.rpc.full_node_rpc_api import FullNodeRpcApi
-from chia.server.outbound_message import NodeType
+from chia.full_node.full_node_rpc_api import FullNodeRpcApi
+from chia.protocols.outbound_message import NodeType
+from chia.server.aliases import FullNodeService
+from chia.server.resolve_peer_info import get_unresolved_peer_infos
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
-from chia.types.aliases import FullNodeService
 from chia.util.chia_logging import initialize_service_logging
-from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
+from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path
 from chia.util.task_timing import maybe_manage_task_instrumentation
 

chia/server/start_harvester.py

@@ -9,17 +9,18 @@ from chia_rs import ConsensusConstants
 
 from chia.apis import ApiProtocolRegistry
 from chia.consensus.constants import replace_str_to_bytes
-from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.harvester.harvester import Harvester
 from chia.harvester.harvester_api import HarvesterAPI
-from chia.rpc.harvester_rpc_api import HarvesterRpcApi
-from chia.server.outbound_message import NodeType
+from chia.harvester.harvester_rpc_api import HarvesterRpcApi
+from chia.protocols.outbound_message import NodeType
+from chia.server.aliases import HarvesterService
+from chia.server.resolve_peer_info import get_unresolved_peer_infos
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
-from chia.types.aliases import HarvesterService
 from chia.types.peer_info import UnresolvedPeerInfo
 from chia.util.chia_logging import initialize_service_logging
-from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
+from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path
 from chia.util.task_timing import maybe_manage_task_instrumentation
 
@@ -40,6 +41,7 @@ def create_harvester_service(
 
     network_id = service_config["selected_network"]
     overrides = service_config["network_overrides"]["constants"][network_id]
+    update_testnet_overrides(network_id, overrides)
     updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
 
     node = Harvester(root_path, service_config, updated_constants)

chia/server/start_introducer.py

@@ -8,10 +8,10 @@ from typing import Any, Optional
 from chia.apis import ApiProtocolRegistry
 from chia.introducer.introducer import Introducer
 from chia.introducer.introducer_api import IntroducerAPI
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
+from chia.server.aliases import IntroducerService
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import Service, async_run
-from chia.types.aliases import IntroducerService
 from chia.util.chia_logging import initialize_service_logging
 from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path

chia/server/start_service.py

@@ -14,11 +14,11 @@ from typing import Any, Callable, Generic, Optional, TypeVar, cast
 from chia_rs.sized_ints import uint16
 
 from chia.daemon.server import service_launch_lock_path
+from chia.protocols.outbound_message import NodeType
 from chia.protocols.shared_protocol import default_capabilities
 from chia.rpc.rpc_server import RpcApiProtocol, RpcServer, RpcServiceProtocol, start_rpc_server
 from chia.server.api_protocol import ApiProtocol
 from chia.server.chia_policy import set_chia_policy
-from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.ssl_context import chia_ssl_ca_paths, private_ssl_ca_paths

chia/server/start_timelord.py

@@ -9,16 +9,17 @@ from chia_rs import ConsensusConstants
 
 from chia.apis import ApiProtocolRegistry
 from chia.consensus.constants import replace_str_to_bytes
-from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.rpc.timelord_rpc_api import TimelordRpcApi
-from chia.server.outbound_message import NodeType
+from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
+from chia.protocols.outbound_message import NodeType
+from chia.server.aliases import TimelordService
+from chia.server.resolve_peer_info import get_unresolved_peer_infos
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
 from chia.timelord.timelord import Timelord
 from chia.timelord.timelord_api import TimelordAPI
-from chia.types.aliases import TimelordService
+from chia.timelord.timelord_rpc_api import TimelordRpcApi
 from chia.util.chia_logging import initialize_service_logging
-from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
+from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path
 from chia.util.task_timing import maybe_manage_task_instrumentation
 
@@ -38,6 +39,7 @@ def create_timelord_service(
 
     network_id = service_config["selected_network"]
     overrides = service_config["network_overrides"]["constants"][network_id]
+    update_testnet_overrides(network_id, overrides)
     updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
 
     node = Timelord(root_path, service_config, updated_constants)

chia/server/start_wallet.py

@@ -10,14 +10,14 @@ from chia_rs import ConsensusConstants
 
 from chia.apis import ApiProtocolRegistry
 from chia.consensus.constants import replace_str_to_bytes
-from chia.consensus.default_constants import DEFAULT_CONSTANTS
-from chia.rpc.wallet_rpc_api import WalletRpcApi
-from chia.server.outbound_message import NodeType
+from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
+from chia.protocols.outbound_message import NodeType
+from chia.server.aliases import WalletService
+from chia.server.resolve_peer_info import get_unresolved_peer_infos
 from chia.server.signal_handlers import SignalHandlers
 from chia.server.start_service import RpcInfo, Service, async_run
-from chia.types.aliases import WalletService
 from chia.util.chia_logging import initialize_service_logging
-from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
+from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path
 from chia.util.keychain import Keychain
 from chia.util.task_timing import maybe_manage_task_instrumentation
@@ -25,6 +25,7 @@ from chia.wallet.wallet_node import WalletNode
 
 # See: https://bugs.python.org/issue29288
 from chia.wallet.wallet_node_api import WalletNodeAPI
+from chia.wallet.wallet_rpc_api import WalletRpcApi
 
 "".encode("idna")
 
@@ -42,6 +43,7 @@ def create_wallet_service(
 
     network_id = service_config["selected_network"]
     overrides = service_config["network_overrides"]["constants"][network_id]
+    update_testnet_overrides(network_id, overrides)
     updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
     service_config.setdefault("short_sync_blocks_behind_threshold", 20)
 

chia/server/ws_connection.py

@@ -18,6 +18,7 @@ from packaging.version import Version
 from typing_extensions import Protocol, final
 
 from chia import __version__
+from chia.protocols.outbound_message import Message, NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.protocol_state_machine import message_response_ok
 from chia.protocols.protocol_timing import (
@@ -29,7 +30,6 @@ from chia.protocols.protocol_timing import (
 from chia.protocols.shared_protocol import Capability, Error, Handshake, protocol_version
 from chia.server.api_protocol import ApiMetadata, ApiProtocol
 from chia.server.capabilities import known_active_capabilities
-from chia.server.outbound_message import Message, NodeType, make_msg
 from chia.server.rate_limits import RateLimiter
 from chia.types.peer_info import PeerInfo
 from chia.util.errors import ApiError, ConsensusError, Err, ProtocolError, TimestampError

chia/simulator/add_blocks_in_batches.py

@@ -2,15 +2,15 @@ from __future__ import annotations
 
 from typing import Optional
 
+from chia_rs import FullBlock
 from chia_rs.sized_ints import uint32
 
+from chia.consensus.augmented_chain import AugmentedBlockchain
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
 from chia.full_node.full_node import FullNode, PeakPostProcessingResult
-from chia.types.full_block import FullBlock
 from chia.types.peer_info import PeerInfo
 from chia.types.validation_state import ValidationState
-from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.batches import to_batches