chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/server/signal_handlers.py

@@ -6,11 +6,14 @@ import dataclasses
 import functools
 import signal
 import sys
+from collections.abc import AsyncIterator
 from types import FrameType
-from typing import AsyncIterator, List, Optional, final
+from typing import Optional, final
 
 from typing_extensions import Protocol
 
+from chia.util.task_referencer import create_referenced_task
+
 
 class Handler(Protocol):
     def __call__(
@@ -33,7 +36,7 @@ class AsyncHandler(Protocol):
 @final
 @dataclasses.dataclass
 class SignalHandlers:
-    tasks: List[asyncio.Task[None]] = dataclasses.field(default_factory=list)
+    tasks: list[asyncio.Task[None]] = dataclasses.field(default_factory=list)
 
     @classmethod
     @contextlib.asynccontextmanager
@@ -58,7 +61,7 @@ class SignalHandlers:
     ) -> None:
         self.remove_done_handlers()
 
-        task = asyncio.create_task(
+        task = create_referenced_task(
             handler(signal_=signal_, stack_frame=stack_frame, loop=loop),
         )
         self.tasks.append(task)

chia/server/ssl_context.py

@@ -1,31 +1,31 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict, Tuple
+from typing import Any
 
 
-def public_ssl_paths(path: Path, config: Dict[str, Any]) -> Tuple[Path, Path]:
+def public_ssl_paths(path: Path, config: dict[str, Any]) -> tuple[Path, Path]:
     return (
         path / config["ssl"]["public_crt"],
         path / config["ssl"]["public_key"],
     )
 
 
-def private_ssl_paths(path: Path, config: Dict[str, Any]) -> Tuple[Path, Path]:
+def private_ssl_paths(path: Path, config: dict[str, Any]) -> tuple[Path, Path]:
     return (
         path / config["ssl"]["private_crt"],
         path / config["ssl"]["private_key"],
     )
 
 
-def private_ssl_ca_paths(path: Path, config: Dict[str, Any]) -> Tuple[Path, Path]:
+def private_ssl_ca_paths(path: Path, config: dict[str, Any]) -> tuple[Path, Path]:
     return (
         path / config["private_ssl_ca"]["crt"],
         path / config["private_ssl_ca"]["key"],
     )
 
 
-def chia_ssl_ca_paths(path: Path, config: Dict[str, Any]) -> Tuple[Path, Path]:
+def chia_ssl_ca_paths(path: Path, config: dict[str, Any]) -> tuple[Path, Path]:
     return (
         path / config["chia_ssl_ca"]["crt"],
         path / config["chia_ssl_ca"]["key"],

chia/server/start_data_layer.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import logging
+import os
 import pathlib
 import sys
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Optional, cast
 
+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_util import PluginRemote
@@ -18,22 +20,24 @@ 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 DEFAULT_ROOT_PATH
+from chia.util.default_root import resolve_root_path
 from chia.util.ints import uint16
+from chia.util.task_timing import maybe_manage_task_instrumentation
 
 # See: https://bugs.python.org/issue29288
 "".encode("idna")
 
 SERVICE_NAME = "data_layer"
+
 log = logging.getLogger(__name__)
 
 
 # TODO: Review need for config and if retained then hint it properly.
 def create_data_layer_service(
     root_path: pathlib.Path,
-    config: Dict[str, Any],
-    downloaders: List[PluginRemote],
-    uploaders: List[PluginRemote],  # dont add FilesystemUploader to this, it is the default uploader
+    config: dict[str, Any],
+    downloaders: list[PluginRemote],
+    uploaders: list[PluginRemote],  # dont add FilesystemUploader to this, it is the default uploader
     wallet_service: Optional[WalletService] = None,
     connect_to_daemon: bool = True,
 ) -> DataLayerService:
@@ -41,7 +45,11 @@ def create_data_layer_service(
         uploaders = []
     if downloaders is None:
         downloaders = []
+
     service_config = config[SERVICE_NAME]
+
+    network_id = service_config["selected_network"]
+
     self_hostname = config["self_hostname"]
     wallet_rpc_port = service_config["wallet_peer"]["port"]
     if wallet_service is None:
@@ -52,26 +60,26 @@ def create_data_layer_service(
         wallet_config = wallet_service.config
     wallet_rpc_init = WalletRpcClient.create(self_hostname, uint16(wallet_rpc_port), wallet_root_path, wallet_config)
 
-    data_layer = DataLayer.create(
+    # dont add Fil)
+    node = DataLayer.create(
         config=service_config,
         root_path=root_path,
         wallet_rpc_init=wallet_rpc_init,
         downloaders=downloaders,
         uploaders=uploaders,
-    )  # dont add Fil)
-    api = DataLayerAPI(data_layer)
-    network_id = service_config["selected_network"]
-    rpc_port = service_config.get("rpc_port")
+    )
+    peer_api = DataLayerAPI(node)
+
     rpc_info: Optional[RpcInfo[DataLayerRpcApi]] = None
-    if rpc_port is not None:
+    if service_config.get("start_rpc_server", True):
         rpc_info = (DataLayerRpcApi, cast(int, service_config["rpc_port"]))
 
     return Service(
         root_path=root_path,
         config=config,
-        node=data_layer,
+        node=node,
         # TODO: not for peers...
-        peer_api=api,
+        peer_api=peer_api,
         node_type=NodeType.DATA_LAYER,
         advertised_port=None,
         service_name=SERVICE_NAME,
@@ -79,34 +87,35 @@ def create_data_layer_service(
         max_request_body_size=service_config.get("rpc_server_max_request_body_size", 26214400),
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
     )
 
 
-async def async_main() -> int:
+async def async_main(root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml", fill_missing_services=True)
-    service_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME, fill_missing_services=True)
+    config = load_config(root_path, "config.yaml", fill_missing_services=True)
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME, fill_missing_services=True)
     config[SERVICE_NAME] = service_config
     initialize_logging(
         service_name=SERVICE_NAME,
         logging_config=service_config["logging"],
-        root_path=DEFAULT_ROOT_PATH,
+        root_path=root_path,
     )
 
     create_all_ssl(
-        root_path=DEFAULT_ROOT_PATH,
+        root_path=root_path,
         private_node_names=["data_layer"],
         public_node_names=["data_layer"],
         overwrite=False,
     )
 
     plugins_config = config["data_layer"].get("plugins", {})
-    service_dir = DEFAULT_ROOT_PATH / SERVICE_NAME
+    service_dir = root_path / SERVICE_NAME
 
     old_uploaders = config["data_layer"].get("uploaders", [])
     new_uploaders = plugins_config.get("uploaders", [])
     conf_file_uploaders = await load_plugin_configurations(service_dir, "uploaders", log)
-    uploaders: List[PluginRemote] = [
+    uploaders: list[PluginRemote] = [
         *(PluginRemote(url=url) for url in old_uploaders),
         *(PluginRemote.unmarshal(marshalled=marshalled) for marshalled in new_uploaders),
         *conf_file_uploaders,
@@ -115,13 +124,13 @@ async def async_main() -> int:
     old_downloaders = config["data_layer"].get("downloaders", [])
     new_downloaders = plugins_config.get("downloaders", [])
     conf_file_uploaders = await load_plugin_configurations(service_dir, "downloaders", log)
-    downloaders: List[PluginRemote] = [
+    downloaders: list[PluginRemote] = [
         *(PluginRemote(url=url) for url in old_downloaders),
         *(PluginRemote.unmarshal(marshalled=marshalled) for marshalled in new_downloaders),
         *conf_file_uploaders,
     ]
 
-    service = create_data_layer_service(DEFAULT_ROOT_PATH, config, downloaders, uploaders)
+    service = create_data_layer_service(root_path, config, downloaders, uploaders)
     async with SignalHandlers.manage() as signal_handlers:
         await service.setup_process_global_state(signal_handlers=signal_handlers)
         await service.run()
@@ -130,7 +139,12 @@ async def async_main() -> int:
 
 
 def main() -> int:
-    return async_run(async_main())
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        return async_run(coro=async_main(root_path=root_path))
 
 
 if __name__ == "__main__":

chia/server/start_farmer.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import os
 import pathlib
 import sys
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
+from chia.apis import ApiProtocolRegistry
 from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.farmer.farmer import Farmer
@@ -15,8 +17,9 @@ 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.default_root import DEFAULT_ROOT_PATH
+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
 
 # See: https://bugs.python.org/issue29288
 "".encode("idna")
@@ -26,8 +29,8 @@ SERVICE_NAME = "farmer"
 
 def create_farmer_service(
     root_path: pathlib.Path,
-    config: Dict[str, Any],
-    config_pool: Dict[str, Any],
+    config: dict[str, Any],
+    config_pool: dict[str, Any],
     consensus_constants: ConsensusConstants,
     keychain: Optional[Keychain] = None,
     connect_to_daemon: bool = True,
@@ -39,38 +42,42 @@ def create_farmer_service(
     update_testnet_overrides(network_id, overrides)
     updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
 
-    farmer = Farmer(
+    node = Farmer(
         root_path, service_config, config_pool, consensus_constants=updated_constants, local_keychain=keychain
     )
-    peer_api = FarmerAPI(farmer)
+    peer_api = FarmerAPI(node)
+
     rpc_info: Optional[RpcInfo[FarmerRpcApi]] = None
-    if service_config["start_rpc_server"]:
+    if service_config.get("start_rpc_server", True):
         rpc_info = (FarmerRpcApi, service_config["rpc_port"])
+
     return Service(
         root_path=root_path,
         config=config,
-        node=farmer,
+        node=node,
         peer_api=peer_api,
         node_type=NodeType.FARMER,
         advertised_port=service_config["port"],
         service_name=SERVICE_NAME,
         connect_peers=get_unresolved_peer_infos(service_config, NodeType.FULL_NODE),
-        on_connect_callback=farmer.on_connect,
+        on_connect_callback=node.on_connect,
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
     )
 
 
-async def async_main() -> int:
+async def async_main(root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
-    service_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
+    config = load_config(root_path, "config.yaml")
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
     config[SERVICE_NAME] = service_config
-    config_pool = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", "pool")
+    config_pool = load_config_cli(root_path, "config.yaml", "pool")
     config["pool"] = config_pool
-    initialize_service_logging(service_name=SERVICE_NAME, config=config)
-    service = create_farmer_service(DEFAULT_ROOT_PATH, config, config_pool, DEFAULT_CONSTANTS)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = create_farmer_service(root_path, config, config_pool, DEFAULT_CONSTANTS)
     async with SignalHandlers.manage() as signal_handlers:
         await service.setup_process_global_state(signal_handlers=signal_handlers)
         await service.run()
@@ -79,7 +86,12 @@ async def async_main() -> int:
 
 
 def main() -> int:
-    return async_run(async_main())
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        return async_run(coro=async_main(root_path=root_path))
 
 
 if __name__ == "__main__":

chia/server/start_full_node.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-import logging
 import os
 import pathlib
 import sys
 from multiprocessing import freeze_support
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
+from chia.apis import ApiProtocolRegistry
 from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.full_node.full_node import FullNode
@@ -18,7 +18,7 @@ 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.default_root import DEFAULT_ROOT_PATH
+from chia.util.default_root import resolve_root_path
 from chia.util.ints import uint16
 from chia.util.task_timing import maybe_manage_task_instrumentation
 
@@ -26,60 +26,63 @@ from chia.util.task_timing import maybe_manage_task_instrumentation
 "".encode("idna")
 
 SERVICE_NAME = "full_node"
-log = logging.getLogger(__name__)
 
 
 async def create_full_node_service(
     root_path: pathlib.Path,
-    config: Dict[str, Any],
+    config: dict[str, Any],
     consensus_constants: ConsensusConstants,
     connect_to_daemon: bool = True,
-    override_capabilities: Optional[List[Tuple[uint16, str]]] = None,
+    override_capabilities: Optional[list[tuple[uint16, str]]] = None,
 ) -> FullNodeService:
     service_config = config[SERVICE_NAME]
 
-    full_node = await FullNode.create(
+    network_id = service_config["selected_network"]
+    upnp_list = []
+    if service_config["enable_upnp"]:
+        upnp_list = [service_config["port"]]
+
+    node = await FullNode.create(
         service_config,
         root_path=root_path,
         consensus_constants=consensus_constants,
     )
-    api = FullNodeAPI(full_node)
+    peer_api = FullNodeAPI(node)
 
-    upnp_list = []
-    if service_config["enable_upnp"]:
-        upnp_list = [service_config["port"]]
-    network_id = service_config["selected_network"]
     rpc_info: Optional[RpcInfo[FullNodeRpcApi]] = None
-    if service_config["start_rpc_server"]:
+    if service_config.get("start_rpc_server", True):
         rpc_info = (FullNodeRpcApi, service_config["rpc_port"])
+
     return Service(
         root_path=root_path,
         config=config,
-        node=api.full_node,
-        peer_api=api,
+        node=node,
+        peer_api=peer_api,
         node_type=NodeType.FULL_NODE,
         advertised_port=service_config["port"],
         service_name=SERVICE_NAME,
         upnp_ports=upnp_list,
         connect_peers=get_unresolved_peer_infos(service_config, NodeType.FULL_NODE),
-        on_connect_callback=full_node.on_connect,
+        on_connect_callback=node.on_connect,
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
         override_capabilities=override_capabilities,
+        class_for_type=ApiProtocolRegistry,
     )
 
 
-async def async_main(service_config: Dict[str, Any]) -> int:
+async def async_main(service_config: dict[str, Any], root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
+    config = load_config(root_path, "config.yaml")
     config[SERVICE_NAME] = service_config
     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(DEFAULT_CONSTANTS, **overrides)
-    initialize_service_logging(service_name=SERVICE_NAME, config=config)
-    service = await create_full_node_service(DEFAULT_ROOT_PATH, config, updated_constants)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = await create_full_node_service(root_path, config, updated_constants)
     async with SignalHandlers.manage() as signal_handlers:
         await service.setup_process_global_state(signal_handlers=signal_handlers)
         await service.run()
@@ -89,9 +92,12 @@ async def async_main(service_config: Dict[str, Any]) -> int:
 
 def main() -> int:
     freeze_support()
+    root_path = resolve_root_path(override=None)
 
-    with maybe_manage_task_instrumentation(enable=os.environ.get("CHIA_INSTRUMENT_NODE") is not None):
-        service_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
         target_peer_count = service_config.get("target_peer_count", 40) - service_config.get(
             "target_outbound_peer_count", 8
         )
@@ -99,7 +105,7 @@ def main() -> int:
             target_peer_count = None
         if not service_config.get("use_chia_loop_policy", True):
             target_peer_count = None
-        return async_run(coro=async_main(service_config), connection_limit=target_peer_count)
+        return async_run(coro=async_main(service_config, root_path=root_path), connection_limit=target_peer_count)
 
 
 if __name__ == "__main__":

chia/server/start_harvester.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import os
 import pathlib
 import sys
-from typing import Any, Dict, Optional, Set
+from typing import Any, Optional
 
+from chia.apis import ApiProtocolRegistry
 from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.harvester.harvester import Harvester
@@ -16,7 +18,8 @@ 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.default_root import DEFAULT_ROOT_PATH
+from chia.util.default_root import resolve_root_path
+from chia.util.task_timing import maybe_manage_task_instrumentation
 
 # See: https://bugs.python.org/issue29288
 "".encode("idna")
@@ -26,26 +29,29 @@ SERVICE_NAME = "harvester"
 
 def create_harvester_service(
     root_path: pathlib.Path,
-    config: Dict[str, Any],
+    config: dict[str, Any],
     consensus_constants: ConsensusConstants,
-    farmer_peers: Set[UnresolvedPeerInfo],
+    farmer_peers: set[UnresolvedPeerInfo],
     connect_to_daemon: bool = True,
 ) -> HarvesterService:
     service_config = config[SERVICE_NAME]
 
-    overrides = service_config["network_overrides"]["constants"][service_config["selected_network"]]
+    network_id = service_config["selected_network"]
+    overrides = service_config["network_overrides"]["constants"][network_id]
     updated_constants = replace_str_to_bytes(consensus_constants, **overrides)
 
-    harvester = Harvester(root_path, service_config, updated_constants)
-    peer_api = HarvesterAPI(harvester)
+    node = Harvester(root_path, service_config, updated_constants)
+    peer_api = HarvesterAPI(node)
     network_id = service_config["selected_network"]
+
     rpc_info: Optional[RpcInfo[HarvesterRpcApi]] = None
-    if service_config["start_rpc_server"]:
+    if service_config.get("start_rpc_server", True):
         rpc_info = (HarvesterRpcApi, service_config["rpc_port"])
+
     return Service(
         root_path=root_path,
         config=config,
-        node=harvester,
+        node=node,
         peer_api=peer_api,
         node_type=NodeType.HARVESTER,
         advertised_port=None,
@@ -54,17 +60,19 @@ def create_harvester_service(
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
     )
 
 
-async def async_main() -> int:
+async def async_main(root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
-    service_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
+    config = load_config(root_path, "config.yaml")
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
     config[SERVICE_NAME] = service_config
-    initialize_service_logging(service_name=SERVICE_NAME, config=config)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
     farmer_peers = get_unresolved_peer_infos(service_config, NodeType.FARMER)
-    service = create_harvester_service(DEFAULT_ROOT_PATH, config, DEFAULT_CONSTANTS, farmer_peers)
+
+    service = create_harvester_service(root_path, config, DEFAULT_CONSTANTS, farmer_peers)
     async with SignalHandlers.manage() as signal_handlers:
         await service.setup_process_global_state(signal_handlers=signal_handlers)
         await service.run()
@@ -73,7 +81,12 @@ async def async_main() -> int:
 
 
 def main() -> int:
-    return async_run(async_main())
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        return async_run(coro=async_main(root_path=root_path))
 
 
 if __name__ == "__main__":

chia/server/start_introducer.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import os
 import pathlib
 import sys
-from typing import Any, Dict, Optional
+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
@@ -12,7 +14,8 @@ 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 DEFAULT_ROOT_PATH
+from chia.util.default_root import resolve_root_path
+from chia.util.task_timing import maybe_manage_task_instrumentation
 
 # See: https://bugs.python.org/issue29288
 "".encode("idna")
@@ -22,38 +25,42 @@ SERVICE_NAME = "introducer"
 
 def create_introducer_service(
     root_path: pathlib.Path,
-    config: Dict[str, Any],
+    config: dict[str, Any],
     advertised_port: Optional[int] = None,
     connect_to_daemon: bool = True,
 ) -> IntroducerService:
     service_config = config[SERVICE_NAME]
 
+    network_id = service_config["selected_network"]
+
     if advertised_port is None:
         advertised_port = service_config["port"]
 
-    introducer = Introducer(service_config["max_peers_to_send"], service_config["recent_peer_threshold"])
-    node__api = IntroducerAPI(introducer)
-    network_id = service_config["selected_network"]
+    node = Introducer(service_config["max_peers_to_send"], service_config["recent_peer_threshold"])
+    peer_api = IntroducerAPI(node)
+
     return Service(
         root_path=root_path,
         config=config,
-        node=introducer,
-        peer_api=node__api,
+        node=node,
+        peer_api=peer_api,
         node_type=NodeType.INTRODUCER,
+        advertised_port=advertised_port,
         service_name=SERVICE_NAME,
         network_id=network_id,
-        advertised_port=advertised_port,
         connect_to_daemon=connect_to_daemon,
+        class_for_type=ApiProtocolRegistry,
     )
 
 
-async def async_main() -> int:
+async def async_main(root_path: pathlib.Path) -> int:
     # TODO: refactor to avoid the double load
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
-    service_config = load_config_cli(DEFAULT_ROOT_PATH, "config.yaml", SERVICE_NAME)
+    config = load_config(root_path, "config.yaml")
+    service_config = load_config_cli(root_path, "config.yaml", SERVICE_NAME)
     config[SERVICE_NAME] = service_config
-    service = create_introducer_service(DEFAULT_ROOT_PATH, config)
-    initialize_service_logging(service_name=SERVICE_NAME, config=config)
+    initialize_service_logging(service_name=SERVICE_NAME, config=config, root_path=root_path)
+
+    service = create_introducer_service(root_path, config)
     async with SignalHandlers.manage() as signal_handlers:
         await service.setup_process_global_state(signal_handlers=signal_handlers)
         await service.run()
@@ -62,7 +69,12 @@ async def async_main() -> int:
 
 
 def main() -> int:
-    return async_run(async_main())
+    root_path = resolve_root_path(override=None)
+
+    with maybe_manage_task_instrumentation(
+        enable=os.environ.get(f"CHIA_INSTRUMENT_{SERVICE_NAME.upper()}") is not None
+    ):
+        return async_run(coro=async_main(root_path=root_path))
 
 
 if __name__ == "__main__":