chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/cmds/rpc.py

@@ -3,30 +3,40 @@ from __future__ import annotations
 import asyncio
 import json
 import sys
-from typing import Any, Dict, List, Optional, TextIO
+from pathlib import Path
+from typing import Any, Optional, TextIO
 
 import click
 from aiohttp import ClientResponseError
 
+from chia.cmds.cmd_classes import ChiaCliContext
 from chia.util.config import load_config
-from chia.util.default_root import DEFAULT_ROOT_PATH
 from chia.util.ints import uint16
 
-services: List[str] = ["crawler", "daemon", "farmer", "full_node", "harvester", "timelord", "wallet", "data_layer"]
+services: list[str] = ["crawler", "daemon", "farmer", "full_node", "harvester", "timelord", "wallet", "data_layer"]
 
 
 async def call_endpoint(
-    service: str, endpoint: str, request: Dict[str, Any], config: Dict[str, Any], quiet: bool = False
-) -> Dict[str, Any]:
+    service: str,
+    endpoint: str,
+    request: dict[str, Any],
+    config: dict[str, Any],
+    root_path: Path,
+    quiet: bool = False,
+) -> dict[str, Any]:
     if service == "daemon":
-        return await call_daemon_command(endpoint, request, config, quiet)
+        return await call_daemon_command(endpoint, request, config, root_path=root_path, quiet=quiet)
 
-    return await call_rpc_service_endpoint(service, endpoint, request, config)
+    return await call_rpc_service_endpoint(service, endpoint, request, config, root_path=root_path)
 
 
 async def call_rpc_service_endpoint(
-    service: str, endpoint: str, request: Dict[str, Any], config: Dict[str, Any]
-) -> Dict[str, Any]:
+    service: str,
+    endpoint: str,
+    request: dict[str, Any],
+    config: dict[str, Any],
+    root_path: Path,
+) -> dict[str, Any]:
     from chia.rpc.rpc_client import RpcClient
 
     port: uint16
@@ -37,10 +47,10 @@ async def call_rpc_service_endpoint(
         port = uint16(config[service]["rpc_port"])
 
     try:
-        client = await RpcClient.create(config["self_hostname"], port, DEFAULT_ROOT_PATH, config)
+        client = await RpcClient.create(config["self_hostname"], port, root_path, config)
     except Exception as e:
         raise Exception(f"Failed to create RPC client {service}: {e}")
-    result: Dict[str, Any]
+    result: dict[str, Any]
     try:
         result = await client.fetch(endpoint, request)
     except ClientResponseError as e:
@@ -56,16 +66,16 @@ async def call_rpc_service_endpoint(
 
 
 async def call_daemon_command(
-    command: str, request: Dict[str, Any], config: Dict[str, Any], quiet: bool = False
-) -> Dict[str, Any]:
+    command: str, request: dict[str, Any], config: dict[str, Any], root_path: Path, quiet: bool = False
+) -> dict[str, Any]:
     from chia.daemon.client import connect_to_daemon_and_validate
 
-    daemon = await connect_to_daemon_and_validate(DEFAULT_ROOT_PATH, config, quiet=quiet)
+    daemon = await connect_to_daemon_and_validate(root_path, config, quiet=quiet)
 
     if daemon is None:
         raise Exception("Failed to connect to chia daemon")
 
-    result: Dict[str, Any]
+    result: dict[str, Any]
     try:
         ws_request = daemon.format_request(command, request)
         ws_response = await daemon._get(ws_request)
@@ -77,12 +87,12 @@ async def call_daemon_command(
     return result
 
 
-def print_result(json_dict: Dict[str, Any]) -> None:
+def print_result(json_dict: dict[str, Any]) -> None:
     print(json.dumps(json_dict, indent=2, sort_keys=True))
 
 
-def get_routes(service: str, config: Dict[str, Any], quiet: bool = False) -> Dict[str, Any]:
-    return asyncio.run(call_endpoint(service, "get_routes", {}, config, quiet))
+def get_routes(service: str, config: dict[str, Any], root_path: Path, quiet: bool = False) -> dict[str, Any]:
+    return asyncio.run(call_endpoint(service, "get_routes", {}, config, root_path=root_path, quiet=quiet))
 
 
 @click.group("rpc", help="RPC Client")
@@ -92,10 +102,12 @@ def rpc_cmd() -> None:
 
 @rpc_cmd.command("endpoints", help="Print all endpoints of a service")
 @click.argument("service", type=click.Choice(services))
-def endpoints_cmd(service: str) -> None:
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
+@click.pass_context
+def endpoints_cmd(ctx: click.Context, service: str) -> None:
+    root_path = ChiaCliContext.set_default(ctx).root_path
+    config = load_config(root_path, "config.yaml")
     try:
-        routes = get_routes(service, config)
+        routes = get_routes(service, config, root_path=root_path)
         for route in routes["routes"]:
             print(route.lstrip("/"))
     except Exception as e:
@@ -104,10 +116,12 @@ def endpoints_cmd(service: str) -> None:
 
 @rpc_cmd.command("status", help="Print the status of all available RPC services")
 @click.option("--json-output", "json_output", is_flag=True, help="Output status as JSON")
-def status_cmd(json_output: bool) -> None:
+@click.pass_context
+def status_cmd(ctx: click.Context, json_output: bool) -> None:
     import json
 
-    config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
+    root_path = ChiaCliContext.set_default(ctx).root_path
+    config = load_config(root_path, "config.yaml")
 
     def print_row(c0: str, c1: str) -> None:
         print(f"│ {c0:<12} │ {c1:<9} │")
@@ -116,7 +130,7 @@ def status_cmd(json_output: bool) -> None:
     for service in services:
         status = "ACTIVE"
         try:
-            if not get_routes(service, config, quiet=True)["success"]:
+            if not get_routes(service, config, root_path=root_path, quiet=True)["success"]:
                 raise Exception()
         except Exception:
             status = "INACTIVE"
@@ -156,16 +170,22 @@ def create_commands() -> None:
             type=click.File("r"),
             default=None,
         )
+        @click.pass_context
         def rpc_client_cmd(
-            endpoint: str, request: Optional[str], json_file: Optional[TextIO], service: str = service
+            ctx: click.Context,
+            endpoint: str,
+            request: Optional[str],
+            json_file: Optional[TextIO],
+            service: str = service,
         ) -> None:
-            config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
+            root_path: Path = ChiaCliContext.set_default(ctx).root_path
+            config = load_config(root_path, "config.yaml")
             if request is not None and json_file is not None:
                 sys.exit(
                     "Can only use one request source: REQUEST argument OR -j/--json-file option. See the help with -h"
                 )
 
-            request_json: Dict[str, Any] = {}
+            request_json: dict[str, Any] = {}
             if json_file is not None:
                 try:
                     request_json = json.load(json_file)
@@ -180,7 +200,7 @@ def create_commands() -> None:
             try:
                 if endpoint[0] == "/":
                     endpoint = endpoint[1:]
-                print_result(asyncio.run(call_endpoint(service, endpoint, request_json, config)))
+                print_result(asyncio.run(call_endpoint(service, endpoint, request_json, config, root_path=root_path)))
             except Exception as e:
                 sys.exit(str(e))
 

chia/cmds/show.py

@@ -4,6 +4,7 @@ from typing import Optional
 
 import click
 
+from chia.cmds.cmd_classes import ChiaCliContext
 from chia.cmds.show_funcs import show_async
 
 
@@ -62,7 +63,7 @@ def show_cmd(
     asyncio.run(
         show_async(
             rpc_port,
-            ctx.obj["root_path"],
+            ChiaCliContext.set_default(ctx).root_path,
             fee,
             state,
             block_header_hash_by_height,

chia/cmds/show_funcs.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 from chia.rpc.full_node_rpc_client import FullNodeRpcClient
 from chia.types.blockchain_format.sized_bytes import bytes32
 
 
-async def print_blockchain_state(node_client: FullNodeRpcClient, config: Dict[str, Any]) -> bool:
+async def print_blockchain_state(node_client: FullNodeRpcClient, config: dict[str, Any]) -> bool:
     import time
 
     from chia.cmds.cmds_util import format_bytes
@@ -43,7 +43,8 @@ async def print_blockchain_state(node_client: FullNodeRpcClient, config: Dict[st
         sync_current_block = blockchain_state["sync"]["sync_progress_height"]
         print(
             f"Current Blockchain Status: Syncing {sync_current_block}/{sync_max_block} "
-            f"({sync_max_block - sync_current_block} behind). ({sync_current_block*100.0/sync_max_block:2.2f}% synced)"
+            f"({sync_max_block - sync_current_block} behind). "
+            f"({sync_current_block * 100.0 / sync_max_block:2.2f}% synced)"
         )
         print("Peak: Hash:", bytes32(peak.header_hash) if peak is not None else "")
     elif peak is not None:
@@ -78,7 +79,7 @@ async def print_blockchain_state(node_client: FullNodeRpcClient, config: Dict[st
         print(f"Current VDF sub_slot_iters: {sub_slot_iters}")
         print("\n  Height: |   Hash:")
 
-        added_blocks: List[BlockRecord] = []
+        added_blocks: list[BlockRecord] = []
         curr = await node_client.get_block_record(peak.header_hash)
         while curr is not None and len(added_blocks) < num_blocks and curr.height > 0:
             added_blocks.append(curr)
@@ -92,7 +93,7 @@ async def print_blockchain_state(node_client: FullNodeRpcClient, config: Dict[st
 
 
 async def print_block_from_hash(
-    node_client: FullNodeRpcClient, config: Dict[str, Any], block_by_header_hash: str
+    node_client: FullNodeRpcClient, config: dict[str, Any], block_by_header_hash: str
 ) -> None:
     import time
 
@@ -196,7 +197,7 @@ async def show_async(
 ) -> None:
     from chia.cmds.cmds_util import get_any_service_client
 
-    async with get_any_service_client(FullNodeRpcClient, rpc_port, root_path) as (node_client, config):
+    async with get_any_service_client(FullNodeRpcClient, root_path, rpc_port) as (node_client, config):
         # Check State
         if print_state:
             if await print_blockchain_state(node_client, config) is True:

chia/cmds/signer.py

@@ -3,26 +3,31 @@ from __future__ import annotations
 import itertools
 import os
 import time
+from collections.abc import Sequence
 from dataclasses import replace
-from functools import cached_property
 from pathlib import Path
 from threading import Event, Thread
-from typing import List, Sequence, Type, TypeVar
+from typing import TypeVar
 
 import click
 from chia_rs import AugSchemeMPL, G2Element
 from hsms.util.byte_chunks import create_chunks_for_blob, optimal_chunk_size_for_max_chunk_size
 from segno import QRCode, make_qr
 
-from chia.cmds.cmd_classes import NeedsWalletRPC, chia_command, command_helper, option
-from chia.cmds.cmds_util import TransactionBundle
-from chia.cmds.wallet import wallet_cmd
+from chia.cmds.cmd_classes import chia_command, command_helper, option
+from chia.cmds.cmd_helpers import NeedsWalletRPC, TransactionsIn, TransactionsOut
 from chia.rpc.util import ALL_TRANSLATION_LAYERS
-from chia.rpc.wallet_request_types import ApplySignatures, ExecuteSigningInstructions, GatherSigningInfo
+from chia.rpc.wallet_request_types import (
+    ApplySignatures,
+    ExecuteSigningInstructions,
+    GatherSigningInfo,
+    PushTransactions,
+)
 from chia.util.streamable import Streamable
 from chia.wallet.signer_protocol import SignedTransaction, SigningInstructions, SigningResponse, Spend
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.clvm_streamable import byte_deserialize_clvm_streamable, byte_serialize_clvm_streamable
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
@@ -31,7 +36,7 @@ def _clear_screen() -> None:
     os.system("cls" if os.name == "nt" else "clear")
 
 
-@wallet_cmd.group("signer", help="Get information for an external signer")
+@click.group("signer", help="Get information for an external signer")
 def signer_cmd() -> None:
     pass  # pragma: no cover
 
@@ -55,7 +60,7 @@ class QrCodeDisplay:
         show_default=True,
     )
 
-    def _display_qr(self, index: int, max_index: int, code_list: List[QRCode], stop_event: Event) -> None:
+    def _display_qr(self, index: int, max_index: int, code_list: list[QRCode], stop_event: Event) -> None:
         while not stop_event.is_set():
             for qr_code in itertools.cycle(code_list):
                 _clear_screen()
@@ -68,7 +73,7 @@ class QrCodeDisplay:
                     if stop_event.is_set():
                         return
 
-    def display_qr_codes(self, blobs: List[bytes]) -> None:
+    def display_qr_codes(self, blobs: list[bytes]) -> None:
         chunk_sizes = [optimal_chunk_size_for_max_chunk_size(len(blob), self.qr_density) for blob in blobs]
         chunks = [create_chunks_for_blob(blob, chunk_size) for blob, chunk_size in zip(blobs, chunk_sizes)]
         qr_codes = [[make_qr(chunk) for chunk in chks] for chks in chunks]
@@ -86,37 +91,6 @@ class QrCodeDisplay:
                 stop_event.clear()
 
 
-@command_helper
-class TransactionsIn:
-    transaction_file_in: str = option(
-        "--transaction-file-in",
-        "-i",
-        type=str,
-        help="Transaction file to use as input",
-        required=True,
-    )
-
-    @cached_property
-    def transaction_bundle(self) -> TransactionBundle:
-        with open(Path(self.transaction_file_in), "rb") as file:
-            return TransactionBundle.from_bytes(file.read())
-
-
-@command_helper
-class TransactionsOut:
-    transaction_file_out: str = option(
-        "--transaction-file-out",
-        "-o",
-        type=str,
-        help="Transaction filename to use as output",
-        required=True,
-    )
-
-    def handle_transaction_output(self, output: List[TransactionRecord]) -> None:
-        with open(Path(self.transaction_file_out), "wb") as file:
-            file.write(bytes(TransactionBundle(output)))
-
-
 @command_helper
 class _SPTranslation:
     translation: str = option(
@@ -142,9 +116,9 @@ class SPIn(_SPTranslation):
         required=True,
     )
 
-    def read_sp_input(self, typ: Type[_T_ClvmStreamable]) -> List[_T_ClvmStreamable]:
-        final_list: List[_T_ClvmStreamable] = []
-        for filename in self.signer_protocol_input:  # pylint: disable=not-an-iterable
+    def read_sp_input(self, typ: type[_T_ClvmStreamable]) -> list[_T_ClvmStreamable]:
+        final_list: list[_T_ClvmStreamable] = []
+        for filename in self.signer_protocol_input:
             with open(Path(filename), "rb") as file:
                 final_list.append(
                     byte_deserialize_clvm_streamable(
@@ -176,7 +150,7 @@ class SPOut(QrCodeDisplay, _SPTranslation):
         help="The file(s) to output to (if --output-format=file)",
     )
 
-    def handle_clvm_output(self, outputs: List[Streamable]) -> None:
+    def handle_clvm_output(self, outputs: list[Streamable]) -> None:
         translation_layer = ALL_TRANSLATION_LAYERS[self.translation] if self.translation != "none" else None
         if self.output_format == "hex":
             for output in outputs:
@@ -202,9 +176,10 @@ class SPOut(QrCodeDisplay, _SPTranslation):
 
 
 @chia_command(
-    signer_cmd,
-    "gather_signing_info",
-    "Gather the information from a transaction that a signer needs in order to create a signature",
+    group=signer_cmd,
+    name="gather_signing_info",
+    short_help="gather signer information",
+    help="Gather the information from a transaction that a signer needs in order to create a signature",
 )
 class GatherSigningInfoCMD:
     sp_out: SPOut
@@ -213,7 +188,7 @@ class GatherSigningInfoCMD:
 
     async def run(self) -> None:
         async with self.rpc_info.wallet_rpc() as wallet_rpc:
-            spends: List[Spend] = [
+            spends: list[Spend] = [
                 Spend.from_coin_spend(cs)
                 for tx in self.txs_in.transaction_bundle.txs
                 if tx.spend_bundle is not None
@@ -225,7 +200,12 @@ class GatherSigningInfoCMD:
             self.sp_out.handle_clvm_output([signing_instructions])
 
 
-@chia_command(signer_cmd, "apply_signatures", "Apply a signer's signatures to a transaction bundle")
+@chia_command(
+    group=signer_cmd,
+    name="apply_signatures",
+    short_help="apply signatures",
+    help="Apply a signer's signatures to a transaction bundle",
+)
 class ApplySignaturesCMD:
     txs_out: TransactionsOut
     sp_in: SPIn
@@ -234,19 +214,19 @@ class ApplySignaturesCMD:
 
     async def run(self) -> None:
         async with self.rpc_info.wallet_rpc() as wallet_rpc:
-            signing_responses: List[SigningResponse] = self.sp_in.read_sp_input(SigningResponse)
-            spends: List[Spend] = [
+            signing_responses: list[SigningResponse] = self.sp_in.read_sp_input(SigningResponse)
+            spends: list[Spend] = [
                 Spend.from_coin_spend(cs)
                 for tx in self.txs_in.transaction_bundle.txs
                 if tx.spend_bundle is not None
                 for cs in tx.spend_bundle.coin_spends
             ]
-            signed_transactions: List[SignedTransaction] = (
+            signed_transactions: list[SignedTransaction] = (
                 await wallet_rpc.client.apply_signatures(
                     ApplySignatures(spends=spends, signing_responses=signing_responses)
                 )
             ).signed_transactions
-            signed_spends: List[Spend] = [spend for tx in signed_transactions for spend in tx.transaction_info.spends]
+            signed_spends: list[Spend] = [spend for tx in signed_transactions for spend in tx.transaction_info.spends]
             final_signature: G2Element = G2Element()
             for signature in [sig for tx in signed_transactions for sig in tx.signatures]:
                 if signature.type != "bls_12381_aug_scheme":  # pragma: no cover
@@ -254,7 +234,7 @@ class ApplySignaturesCMD:
                     return
                 final_signature = AugSchemeMPL.aggregate([final_signature, G2Element.from_bytes(signature.signature)])
             new_spend_bundle = WalletSpendBundle([spend.as_coin_spend() for spend in signed_spends], final_signature)
-            new_transactions: List[TransactionRecord] = [
+            new_transactions: list[TransactionRecord] = [
                 replace(
                     self.txs_in.transaction_bundle.txs[0], spend_bundle=new_spend_bundle, name=new_spend_bundle.name()
                 ),
@@ -263,7 +243,12 @@ class ApplySignaturesCMD:
             self.txs_out.handle_transaction_output(new_transactions)
 
 
-@chia_command(signer_cmd, "execute_signing_instructions", "Given some signing instructions, return signing responses")
+@chia_command(
+    group=signer_cmd,
+    name="execute_signing_instructions",
+    short_help="execute signing instructions",
+    help="Given some signing instructions, return signing responses",
+)
 class ExecuteSigningInstructionsCMD:
     sp_out: SPOut
     sp_in: SPIn
@@ -271,7 +256,7 @@ class ExecuteSigningInstructionsCMD:
 
     async def run(self) -> None:
         async with self.rpc_info.wallet_rpc() as wallet_rpc:
-            signing_instructions: List[SigningInstructions] = self.sp_in.read_sp_input(SigningInstructions)
+            signing_instructions: list[SigningInstructions] = self.sp_in.read_sp_input(SigningInstructions)
             self.sp_out.handle_clvm_output(
                 [
                     signing_response
@@ -285,14 +270,21 @@ class ExecuteSigningInstructionsCMD:
             )
 
 
-@chia_command(wallet_cmd, "push_transactions", "Push a transaction bundle to the wallet to send to the network")
+@chia_command(
+    name="push_transactions",
+    short_help="push transaction bundle",
+    help="Push a transaction bundle to the wallet to send to the network",
+)
 class PushTransactionsCMD:
     txs_in: TransactionsIn
     rpc_info: NeedsWalletRPC
 
     async def run(self) -> None:
         async with self.rpc_info.wallet_rpc() as wallet_rpc:
-            await wallet_rpc.client.push_transactions(self.txs_in.transaction_bundle.txs)
+            # TODO: provide access to additional parameters instead of filling with the defaults constant
+            await wallet_rpc.client.push_transactions(
+                PushTransactions(transactions=self.txs_in.transaction_bundle.txs), DEFAULT_TX_CONFIG
+            )
 
 
 # Uncomment this for testing of qr code display

chia/cmds/sim.py

@@ -7,6 +7,7 @@ from typing import Any, Optional
 import click
 
 from chia.cmds import options
+from chia.cmds.cmd_classes import ChiaCliContext
 from chia.cmds.sim_funcs import async_config_wizard, farm_blocks, print_status, revert_block_height, set_auto_farm
 from chia.util.default_root import SIMULATOR_ROOT_PATH
 
@@ -34,10 +35,9 @@ from chia.util.default_root import SIMULATOR_ROOT_PATH
 )
 @click.pass_context
 def sim_cmd(ctx: click.Context, rpc_port: Optional[int], root_path: str, simulator_name: str) -> None:
-    ctx.ensure_object(dict)
-    ctx.obj["root_path"] = Path(root_path) / simulator_name
-    ctx.obj["sim_name"] = simulator_name
-    ctx.obj["rpc_port"] = rpc_port
+    context = ChiaCliContext.set_default(ctx)
+    context.root_path = Path(root_path) / simulator_name
+    context.rpc_port = rpc_port
 
 
 @sim_cmd.command("create", help="Guides you through the process of setting up a Chia Simulator")
@@ -73,13 +73,14 @@ def create_simulator_config(
     docker_mode: bool,
     no_bitfield: bool,
 ) -> None:
-    print(f"Using this Directory: {ctx.obj['root_path']}\n")
+    root_path = ChiaCliContext.set_default(ctx).root_path
+    print(f"Using this Directory: {root_path}\n")
     if fingerprint and mnemonic:
         print("You can't use both a fingerprint and a mnemonic. Please choose one.")
         return None
     asyncio.run(
         async_config_wizard(
-            ctx.obj["root_path"],
+            root_path,
             fingerprint,
             reward_address,
             plot_directory,
@@ -132,10 +133,12 @@ def status_cmd(
     include_rewards: bool,
     show_addresses: bool,
 ) -> None:
+    context = ChiaCliContext.set_default(ctx)
+
     asyncio.run(
         print_status(
-            ctx.obj["rpc_port"],
-            ctx.obj["root_path"],
+            context.rpc_port,
+            context.root_path,
             fingerprint,
             show_key,
             show_coins,
@@ -174,10 +177,13 @@ def revert_cmd(
     if reset and blocks != 1:
         print("\nBlocks, '-b' must not be set if all blocks are selected by reset, '-r'. Exiting.\n")
         return
+
+    context = ChiaCliContext.set_default(ctx)
+
     asyncio.run(
         revert_block_height(
-            ctx.obj["rpc_port"],
-            ctx.obj["root_path"],
+            context.rpc_port,
+            context.root_path,
             blocks,
             new_blocks,
             reset,
@@ -192,10 +198,11 @@ def revert_cmd(
 @click.option("-a", "--target-address", type=str, default="", help="Block reward address")
 @click.pass_context
 def farm_cmd(ctx: click.Context, blocks: int, non_transaction: bool, target_address: str) -> None:
+    context = ChiaCliContext.set_default(ctx)
     asyncio.run(
         farm_blocks(
-            ctx.obj["rpc_port"],
-            ctx.obj["root_path"],
+            context.rpc_port,
+            context.root_path,
             blocks,
             not non_transaction,
             target_address,
@@ -208,10 +215,11 @@ def farm_cmd(ctx: click.Context, blocks: int, non_transaction: bool, target_addr
 @click.pass_context
 def autofarm_cmd(ctx: click.Context, set_autofarm: str) -> None:
     autofarm = bool(set_autofarm == "on")
+    context = ChiaCliContext.set_default(ctx)
     asyncio.run(
         set_auto_farm(
-            ctx.obj["rpc_port"],
-            ctx.obj["root_path"],
+            context.rpc_port,
+            context.root_path,
             autofarm,
         )
     )

chia/cmds/sim_funcs.py

@@ -5,7 +5,7 @@ import os
 import sys
 from pathlib import Path, PureWindowsPath
 from random import randint
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from aiohttp import ClientConnectorError
 from chia_rs import PrivateKey
@@ -47,7 +47,7 @@ def create_chia_directory(
     plot_directory: Optional[str],
     auto_farm: Optional[bool],
     docker_mode: bool,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     This function creates a new chia directory and returns a heavily modified config,
     suitable for use in the simulator.
@@ -57,7 +57,7 @@ def create_chia_directory(
     if not chia_root.is_dir() or not Path(chia_root / "config" / "config.yaml").exists():
         # create chia directories & load config
         chia_init(chia_root, testnet=True, fix_ssl_permissions=True)
-        config: Dict[str, Any] = load_config(chia_root, "config.yaml")
+        config: dict[str, Any] = load_config(chia_root, "config.yaml")
         # apply standard block-tools config.
         config["full_node"]["send_uncompact_interval"] = 0
         config["full_node"]["target_uncompact_proofs"] = 30
@@ -243,7 +243,7 @@ def select_fingerprint(
     return fingerprint
 
 
-async def generate_plots(config: Dict[str, Any], root_path: Path, fingerprint: int, bitfield: bool) -> None:
+async def generate_plots(config: dict[str, Any], root_path: Path, fingerprint: int, bitfield: bool) -> None:
     """
     Pre-Generate plots for the new simulator instance.
     """
@@ -345,14 +345,14 @@ def print_coin_record(
 
 
 async def print_coin_records(
-    config: Dict[str, Any],
+    config: dict[str, Any],
     node_client: SimulatorFullNodeRpcClient,
     include_reward_coins: bool,
     include_spent: bool = False,
 ) -> None:
     import sys
 
-    coin_records: List[CoinRecord] = await node_client.get_all_coins(include_spent)
+    coin_records: list[CoinRecord] = await node_client.get_all_coins(include_spent)
     coin_records = [coin_record for coin_record in coin_records if not coin_record.coinbase or include_reward_coins]
     address_prefix = config["network_overrides"]["config"][config["selected_network"]]["address_prefix"]
     name = "mojo"
@@ -382,7 +382,7 @@ async def print_coin_records(
                         break
 
 
-async def print_wallets(config: Dict[str, Any], node_client: SimulatorFullNodeRpcClient) -> None:
+async def print_wallets(config: dict[str, Any], node_client: SimulatorFullNodeRpcClient) -> None:
     ph_and_amount = await node_client.get_all_puzzle_hashes()
     address_prefix = config["network_overrides"]["config"][config["selected_network"]]["address_prefix"]
     name = "mojo"
@@ -407,7 +407,7 @@ async def print_status(
     from chia.cmds.show_funcs import print_blockchain_state
     from chia.cmds.units import units
 
-    async with get_any_service_client(SimulatorFullNodeRpcClient, rpc_port, root_path) as (node_client, config):
+    async with get_any_service_client(SimulatorFullNodeRpcClient, root_path, rpc_port) as (node_client, config):
         # Display keychain info
         if show_key:
             if fingerprint is None:
@@ -451,7 +451,7 @@ async def revert_block_height(
     """
     This function allows users to easily revert the chain to a previous state or perform a reorg.
     """
-    async with get_any_service_client(SimulatorFullNodeRpcClient, rpc_port, root_path) as (node_client, _):
+    async with get_any_service_client(SimulatorFullNodeRpcClient, root_path, rpc_port) as (node_client, _):
         if use_revert_blocks:
             if num_new_blocks != 1:
                 print(f"Ignoring num_new_blocks: {num_new_blocks}, because we are not performing a reorg.")
@@ -479,7 +479,7 @@ async def farm_blocks(
     """
     This function is used to generate new blocks.
     """
-    async with get_any_service_client(SimulatorFullNodeRpcClient, rpc_port, root_path) as (node_client, config):
+    async with get_any_service_client(SimulatorFullNodeRpcClient, root_path, rpc_port) as (node_client, config):
         if target_address == "":
             target_address = config["simulator"]["farming_address"]
         if target_address is None:
@@ -500,7 +500,7 @@ async def set_auto_farm(rpc_port: Optional[int], root_path: Path, set_autofarm:
     """
     This function can be used to enable or disable Auto Farming.
     """
-    async with get_any_service_client(SimulatorFullNodeRpcClient, rpc_port, root_path) as (node_client, _):
+    async with get_any_service_client(SimulatorFullNodeRpcClient, root_path, rpc_port) as (node_client, _):
         current = await node_client.get_auto_farming()
         if current == set_autofarm:
             print(f"Auto farming is already {'on' if set_autofarm else 'off'}")