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

chia/cmds/cmds_util.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import contextlib
 import dataclasses
 import logging
 import traceback
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import Any, AsyncIterator, Callable, Dict, List, Optional, Tuple, Type, TypeVar
+from typing import Any, Callable, Optional, TypeVar
 
 import click
 from aiohttp import ClientConnectorCertificateError, ClientConnectorError
@@ -24,7 +26,6 @@ from chia.simulator.simulator_full_node_rpc_client import SimulatorFullNodeRpcCl
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.mempool_submission_status import MempoolSubmissionStatus
 from chia.util.config import load_config
-from chia.util.default_root import DEFAULT_ROOT_PATH
 from chia.util.errors import CliRpcConnectionError, InvalidPathError
 from chia.util.ints import uint16, uint32, uint64
 from chia.util.keychain import KeyData
@@ -33,7 +34,7 @@ from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import CoinSelectionConfig, CoinSelectionConfigLoader, TXConfig, TXConfigLoader
 
-NODE_TYPES: Dict[str, Type[RpcClient]] = {
+NODE_TYPES: dict[str, type[RpcClient]] = {
     "base": RpcClient,
     "farmer": FarmerRpcClient,
     "wallet": WalletRpcClient,
@@ -43,7 +44,7 @@ NODE_TYPES: Dict[str, Type[RpcClient]] = {
     "simulator": SimulatorFullNodeRpcClient,
 }
 
-node_config_section_names: Dict[Type[RpcClient], str] = {
+node_config_section_names: dict[type[RpcClient], str] = {
     RpcClient: "base",
     FarmerRpcClient: "farmer",
     WalletRpcClient: "wallet",
@@ -92,21 +93,18 @@ async def validate_client_connection(
 
 @asynccontextmanager
 async def get_any_service_client(
-    client_type: Type[_T_RpcClient],
+    client_type: type[_T_RpcClient],
+    root_path: Path,
     rpc_port: Optional[int] = None,
-    root_path: Optional[Path] = None,
     consume_errors: bool = True,
     use_ssl: bool = True,
-) -> AsyncIterator[Tuple[_T_RpcClient, Dict[str, Any]]]:
+) -> AsyncIterator[tuple[_T_RpcClient, dict[str, Any]]]:
     """
     Yields a tuple with a RpcClient for the applicable node type a dictionary of the node's configuration,
     and a fingerprint if applicable. However, if connecting to the node fails then we will return None for
     the RpcClient.
     """
 
-    if root_path is None:
-        root_path = DEFAULT_ROOT_PATH
-
     node_type = node_config_section_names.get(client_type)
     if node_type is None:
         # Click already checks this, so this should never happen
@@ -116,42 +114,44 @@ async def get_any_service_client(
     self_hostname = config["self_hostname"]
     if rpc_port is None:
         rpc_port = config[node_type]["rpc_port"]
-    # select node client type based on string
-    if use_ssl:
-        node_client = await client_type.create(self_hostname, uint16(rpc_port), root_path=root_path, net_config=config)
-    else:
-        node_client = await client_type.create(self_hostname, uint16(rpc_port), root_path=None, net_config=None)
 
-    try:
-        # check if we can connect to node
-        await validate_client_connection(node_client, node_type, rpc_port, consume_errors)
-        yield node_client, config
-    except ResponseFailureError as e:
-        if not consume_errors:
-            raise
+    async with contextlib.AsyncExitStack() as exit_stack:
+        # select node client type based on string
+        if use_ssl:
+            node_client = await exit_stack.enter_async_context(
+                client_type.create_as_context(self_hostname, uint16(rpc_port), root_path=root_path, net_config=config)
+            )
+        else:
+            node_client = await exit_stack.enter_async_context(
+                client_type.create_as_context(self_hostname, uint16(rpc_port), root_path=None, net_config=None)
+            )
 
-        response = dict(e.response)
-        tb = response.pop("traceback", None)
+        try:
+            # check if we can connect to node
+            await validate_client_connection(node_client, node_type, rpc_port, consume_errors)
+            yield node_client, config
+        except ResponseFailureError as e:
+            if not consume_errors:
+                raise
 
-        print(f"{ResponseFailureError(response=response)}")
+            response = dict(e.response)
+            tb = response.pop("traceback", None)
 
-        if tb is not None:
-            print(f"Traceback:\n{tb}")
-    except Exception as e:  # this is only here to make the errors more user-friendly.
-        if not consume_errors or isinstance(e, (CliRpcConnectionError, click.Abort)):
-            # CliRpcConnectionError will be handled by click.
-            raise
-        print(f"Exception from '{node_type}' {e}:\n{traceback.format_exc()}")
+            print(f"{ResponseFailureError(response=response)}")
 
-    finally:
-        node_client.close()  # this can run even if already closed, will just do nothing.
-        await node_client.await_closed()
+            if tb is not None:
+                print(f"Traceback:\n{tb}")
+        except Exception as e:  # this is only here to make the errors more user-friendly.
+            if not consume_errors or isinstance(e, (CliRpcConnectionError, click.Abort)):
+                # CliRpcConnectionError will be handled by click.
+                raise
+            print(f"Exception from '{node_type}' {e}:\n{traceback.format_exc()}")
 
 
 async def get_wallet(root_path: Path, wallet_client: WalletRpcClient, fingerprint: Optional[int]) -> int:
     selected_fingerprint: int
     keychain_proxy: Optional[KeychainProxy] = None
-    all_keys: List[KeyData] = []
+    all_keys: list[KeyData] = []
 
     try:
         if fingerprint is not None:
@@ -177,9 +177,10 @@ async def get_wallet(root_path: Path, wallet_client: WalletRpcClient, fingerprin
                 current_sync_status: str = ""
                 indent = "   "
                 if logged_in_key is not None:
-                    if await wallet_client.get_synced():
+                    sync_response = await wallet_client.get_sync_status()
+                    if sync_response.synced:
                         current_sync_status = "Synced"
-                    elif await wallet_client.get_sync_status():
+                    elif sync_response.syncing:
                         current_sync_status = "Syncing"
                     else:
                         current_sync_status = "Not Synced"
@@ -243,12 +244,12 @@ async def get_wallet(root_path: Path, wallet_client: WalletRpcClient, fingerprin
 
 @asynccontextmanager
 async def get_wallet_client(
+    root_path: Path,
     wallet_rpc_port: Optional[int] = None,
     fingerprint: Optional[int] = None,
-    root_path: Path = DEFAULT_ROOT_PATH,
     consume_errors: bool = True,
-) -> AsyncIterator[Tuple[WalletRpcClient, int, Dict[str, Any]]]:
-    async with get_any_service_client(WalletRpcClient, wallet_rpc_port, root_path, consume_errors) as (
+) -> AsyncIterator[tuple[WalletRpcClient, int, dict[str, Any]]]:
+    async with get_any_service_client(WalletRpcClient, root_path, wallet_rpc_port, consume_errors) as (
         wallet_client,
         config,
     ):
@@ -261,7 +262,7 @@ def cli_confirm(input_message: str, abort_message: str = "Did not confirm. Abort
     Raise a click.Abort if the user does not respond with 'y' or 'yes'
     """
     response = input(input_message).lower()
-    if response not in ["y", "yes"]:
+    if response not in {"y", "yes"}:
         print(abort_message)
         raise click.Abort()
 
@@ -323,7 +324,7 @@ def timelock_args(enable: Optional[bool] = None) -> Callable[[Callable[..., None
                     min_time=uint64.construct_optional(kwargs["valid_at"]),
                     max_time=uint64.construct_optional(kwargs["expires_at"]),
                 ),
-                **{k: v for k, v in kwargs.items() if k not in ("valid_at", "expires_at")},
+                **{k: v for k, v in kwargs.items() if k not in {"valid_at", "expires_at"}},
             )
 
         return click.option(
@@ -350,27 +351,26 @@ def timelock_args(enable: Optional[bool] = None) -> Callable[[Callable[..., None
 @streamable
 @dataclasses.dataclass(frozen=True)
 class TransactionBundle(Streamable):
-    txs: List[TransactionRecord]
+    txs: list[TransactionRecord]
 
 
 def tx_out_cmd(
     enable_timelock_args: Optional[bool] = None,
-) -> Callable[[Callable[..., List[TransactionRecord]]], Callable[..., None]]:
-
-    def _tx_out_cmd(func: Callable[..., List[TransactionRecord]]) -> Callable[..., None]:
+) -> Callable[[Callable[..., list[TransactionRecord]]], Callable[..., None]]:
+    def _tx_out_cmd(func: Callable[..., list[TransactionRecord]]) -> Callable[..., None]:
         @timelock_args(enable=enable_timelock_args)
-        def original_cmd(transaction_file: Optional[str] = None, **kwargs: Any) -> None:
-            txs: List[TransactionRecord] = func(**kwargs)
-            if transaction_file is not None:
-                print(f"Writing transactions to file {transaction_file}:")
-                with open(Path(transaction_file), "wb") as file:
+        def original_cmd(transaction_file_out: Optional[str] = None, **kwargs: Any) -> None:
+            txs: list[TransactionRecord] = func(**kwargs)
+            if transaction_file_out is not None:
+                print(f"Writing transactions to file {transaction_file_out}:")
+                with open(Path(transaction_file_out), "wb") as file:
                     file.write(bytes(TransactionBundle(txs)))
 
         return click.option(
             "--push/--no-push", help="Push the transaction to the network", type=bool, is_flag=True, default=True
         )(
             click.option(
-                "--transaction-file",
+                "--transaction-file-out",
                 help="A file to write relevant transactions to",
                 type=str,
                 required=False,
@@ -385,8 +385,8 @@ def tx_out_cmd(
 class CMDCoinSelectionConfigLoader:
     min_coin_amount: CliAmount = cli_amount_none
     max_coin_amount: CliAmount = cli_amount_none
-    excluded_coin_amounts: Optional[List[CliAmount]] = None
-    excluded_coin_ids: Optional[List[bytes32]] = None
+    excluded_coin_amounts: Optional[list[CliAmount]] = None
+    excluded_coin_ids: Optional[list[bytes32]] = None
 
     def to_coin_selection_config(self, mojo_per_unit: int) -> CoinSelectionConfig:
         return CoinSelectionConfigLoader(
@@ -405,7 +405,7 @@ class CMDCoinSelectionConfigLoader:
 class CMDTXConfigLoader(CMDCoinSelectionConfigLoader):
     reuse_puzhash: Optional[bool] = None
 
-    def to_tx_config(self, mojo_per_unit: int, config: Dict[str, Any], fingerprint: int) -> TXConfig:
+    def to_tx_config(self, mojo_per_unit: int, config: dict[str, Any], fingerprint: int) -> TXConfig:
         cs_config = self.to_coin_selection_config(mojo_per_unit)
         return TXConfigLoader(
             cs_config.min_coin_amount,
@@ -476,16 +476,6 @@ def format_minutes(minutes: int) -> str:
     return "Unknown"
 
 
-def prompt_yes_no(prompt: str) -> bool:
-    while True:
-        response = str(input(prompt + " (y/n): ")).lower().strip()
-        ch = response[:1]
-        if ch == "y":
-            return True
-        elif ch == "n":
-            return False
-
-
 def validate_directory_writable(path: Path) -> None:
     write_test_path = path / ".write_test"
     try:

chia/cmds/coin_funcs.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 import dataclasses
 import sys
-from typing import List, Optional, Sequence, Tuple
+from collections.abc import Sequence
+from typing import Optional
 
-from chia.cmds.cmds_util import CMDCoinSelectionConfigLoader, CMDTXConfigLoader, cli_confirm, get_wallet_client
+from chia.cmds.cmd_helpers import WalletClientInfo
+from chia.cmds.cmds_util import CMDCoinSelectionConfigLoader, CMDTXConfigLoader, cli_confirm
 from chia.cmds.param_types import CliAmount
 from chia.cmds.wallet_funcs import get_mojo_per_unit, get_wallet_type, print_balance
 from chia.rpc.wallet_request_types import CombineCoins, SplitCoins
@@ -20,8 +22,7 @@ from chia.wallet.util.wallet_types import WalletType
 
 async def async_list(
     *,
-    wallet_rpc_port: Optional[int],
-    fingerprint: Optional[int],
+    client_info: WalletClientInfo,
     wallet_id: int,
     max_coin_amount: CliAmount,
     min_coin_amount: CliAmount,
@@ -30,61 +31,60 @@ async def async_list(
     show_unconfirmed: bool,
     paginate: Optional[bool],
 ) -> None:
-    async with get_wallet_client(wallet_rpc_port, fingerprint) as (wallet_client, _, config):
-        addr_prefix = selected_network_address_prefix(config)
-        if paginate is None:
-            paginate = sys.stdout.isatty()
-        try:
-            wallet_type = await get_wallet_type(wallet_id=wallet_id, wallet_client=wallet_client)
-            mojo_per_unit = get_mojo_per_unit(wallet_type)
-        except LookupError:
-            print(f"Wallet id: {wallet_id} not found.")
-            return
-        if not await wallet_client.get_synced():
-            print("Wallet not synced. Please wait.")
-            return
-        conf_coins, unconfirmed_removals, unconfirmed_additions = await wallet_client.get_spendable_coins(
-            wallet_id=wallet_id,
-            coin_selection_config=CMDCoinSelectionConfigLoader(
-                max_coin_amount=max_coin_amount,
-                min_coin_amount=min_coin_amount,
-                excluded_coin_amounts=list(excluded_amounts),
-                excluded_coin_ids=list(excluded_coin_ids),
-            ).to_coin_selection_config(mojo_per_unit),
+    addr_prefix = selected_network_address_prefix(client_info.config)
+    if paginate is None:
+        paginate = sys.stdout.isatty()
+    try:
+        wallet_type = await get_wallet_type(wallet_id=wallet_id, wallet_client=client_info.client)
+        mojo_per_unit = get_mojo_per_unit(wallet_type)
+    except LookupError:
+        print(f"Wallet id: {wallet_id} not found.")
+        return
+    if not (await client_info.client.get_sync_status()).synced:
+        print("Wallet not synced. Please wait.")
+        return
+    conf_coins, unconfirmed_removals, unconfirmed_additions = await client_info.client.get_spendable_coins(
+        wallet_id=wallet_id,
+        coin_selection_config=CMDCoinSelectionConfigLoader(
+            max_coin_amount=max_coin_amount,
+            min_coin_amount=min_coin_amount,
+            excluded_coin_amounts=list(excluded_amounts),
+            excluded_coin_ids=list(excluded_coin_ids),
+        ).to_coin_selection_config(mojo_per_unit),
+    )
+    print(f"There are a total of {len(conf_coins) + len(unconfirmed_additions)} coins in wallet {wallet_id}.")
+    print(f"{len(conf_coins)} confirmed coins.")
+    print(f"{len(unconfirmed_additions)} unconfirmed additions.")
+    print(f"{len(unconfirmed_removals)} unconfirmed removals.")
+    print("Confirmed coins:")
+    print_coins(
+        "\tAddress: {} Amount: {}, Confirmed in block: {}\n",
+        [(cr.coin, str(cr.confirmed_block_index)) for cr in conf_coins],
+        mojo_per_unit,
+        addr_prefix,
+        paginate,
+    )
+    if show_unconfirmed:
+        print("\nUnconfirmed Removals:")
+        print_coins(
+            "\tPrevious Address: {} Amount: {}, Confirmed in block: {}\n",
+            [(cr.coin, str(cr.confirmed_block_index)) for cr in unconfirmed_removals],
+            mojo_per_unit,
+            addr_prefix,
+            paginate,
         )
-        print(f"There are a total of {len(conf_coins) + len(unconfirmed_additions)} coins in wallet {wallet_id}.")
-        print(f"{len(conf_coins)} confirmed coins.")
-        print(f"{len(unconfirmed_additions)} unconfirmed additions.")
-        print(f"{len(unconfirmed_removals)} unconfirmed removals.")
-        print("Confirmed coins:")
+        print("\nUnconfirmed Additions:")
         print_coins(
-            "\tAddress: {} Amount: {}, Confirmed in block: {}\n",
-            [(cr.coin, str(cr.confirmed_block_index)) for cr in conf_coins],
+            "\tNew Address: {} Amount: {}, Not yet confirmed in a block.{}\n",
+            [(coin, "") for coin in unconfirmed_additions],
             mojo_per_unit,
             addr_prefix,
             paginate,
         )
-        if show_unconfirmed:
-            print("\nUnconfirmed Removals:")
-            print_coins(
-                "\tPrevious Address: {} Amount: {}, Confirmed in block: {}\n",
-                [(cr.coin, str(cr.confirmed_block_index)) for cr in unconfirmed_removals],
-                mojo_per_unit,
-                addr_prefix,
-                paginate,
-            )
-            print("\nUnconfirmed Additions:")
-            print_coins(
-                "\tNew Address: {} Amount: {}, Not yet confirmed in a block.{}\n",
-                [(coin, "") for coin in unconfirmed_additions],
-                mojo_per_unit,
-                addr_prefix,
-                paginate,
-            )
 
 
 def print_coins(
-    target_string: str, coins: List[Tuple[Coin, str]], mojo_per_unit: int, addr_prefix: str, paginate: bool
+    target_string: str, coins: list[tuple[Coin, str]], mojo_per_unit: int, addr_prefix: str, paginate: bool
 ) -> None:
     if len(coins) == 0:
         print("\tNo Coins.")
@@ -113,15 +113,14 @@ def print_coins(
 
 async def async_combine(
     *,
-    wallet_rpc_port: Optional[int],
-    fingerprint: Optional[int],
+    client_info: WalletClientInfo,
     wallet_id: int,
     fee: uint64,
     max_coin_amount: CliAmount,
     min_coin_amount: CliAmount,
     excluded_amounts: Sequence[CliAmount],
     coins_to_exclude: Sequence[bytes32],
-    reuse_puzhash: bool,
+    reuse_puzhash: Optional[bool],
     number_of_coins: int,
     target_coin_amount: Optional[CliAmount],
     target_coin_ids: Sequence[bytes32],
@@ -129,132 +128,148 @@ async def async_combine(
     push: bool,
     condition_valid_times: ConditionValidTimes,
     override: bool,
-) -> List[TransactionRecord]:
-    async with get_wallet_client(wallet_rpc_port, fingerprint) as (wallet_client, fingerprint, config):
-        try:
-            wallet_type = await get_wallet_type(wallet_id=wallet_id, wallet_client=wallet_client)
-            mojo_per_unit = get_mojo_per_unit(wallet_type)
-        except LookupError:
-            print(f"Wallet id: {wallet_id} not found.")
-            return []
-        if not await wallet_client.get_synced():
-            print("Wallet not synced. Please wait.")
-            return []
+) -> list[TransactionRecord]:
+    try:
+        wallet_type = await get_wallet_type(wallet_id=wallet_id, wallet_client=client_info.client)
+        mojo_per_unit = get_mojo_per_unit(wallet_type)
+    except LookupError:
+        print(f"Wallet id: {wallet_id} not found.")
+        return []
+    if not (await client_info.client.get_sync_status()).synced:
+        print("Wallet not synced. Please wait.")
+        return []
 
-        tx_config = CMDTXConfigLoader(
-            max_coin_amount=max_coin_amount,
-            min_coin_amount=min_coin_amount,
-            excluded_coin_amounts=list(excluded_amounts),
-            excluded_coin_ids=list(coins_to_exclude),
-            reuse_puzhash=reuse_puzhash,
-        ).to_tx_config(mojo_per_unit, config, fingerprint)
+    tx_config = CMDTXConfigLoader(
+        max_coin_amount=max_coin_amount,
+        min_coin_amount=min_coin_amount,
+        excluded_coin_amounts=list(excluded_amounts),
+        excluded_coin_ids=list(coins_to_exclude),
+        reuse_puzhash=reuse_puzhash,
+    ).to_tx_config(mojo_per_unit, client_info.config, client_info.fingerprint)
 
-        final_target_coin_amount = (
-            None if target_coin_amount is None else target_coin_amount.convert_amount(mojo_per_unit)
-        )
+    final_target_coin_amount = None if target_coin_amount is None else target_coin_amount.convert_amount(mojo_per_unit)
 
-        combine_request = CombineCoins(
-            wallet_id=uint32(wallet_id),
-            target_coin_amount=final_target_coin_amount,
-            number_of_coins=uint16(number_of_coins),
-            target_coin_ids=list(target_coin_ids),
-            largest_first=largest_first,
-            fee=fee,
-            push=False,
-        )
-        resp = await wallet_client.combine_coins(
-            combine_request,
+    combine_request = CombineCoins(
+        wallet_id=uint32(wallet_id),
+        target_coin_amount=final_target_coin_amount,
+        number_of_coins=uint16(number_of_coins),
+        target_coin_ids=list(target_coin_ids),
+        largest_first=largest_first,
+        fee=fee,
+        push=False,
+    )
+    resp = await client_info.client.combine_coins(
+        combine_request,
+        tx_config,
+        timelock_info=condition_valid_times,
+    )
+
+    if not override and wallet_id == 1 and fee >= sum(coin.amount for tx in resp.transactions for coin in tx.removals):
+        print("Fee is >= the amount of coins selected. To continue, please use --override flag.")
+        return []
+
+    print(f"Transactions would combine up to {number_of_coins} coins.")
+    if push:
+        cli_confirm("Would you like to Continue? (y/n): ")
+        resp = await client_info.client.combine_coins(
+            dataclasses.replace(combine_request, push=True),
             tx_config,
             timelock_info=condition_valid_times,
         )
-
-        if (
-            not override
-            and wallet_id == 1
-            and fee >= sum(coin.amount for tx in resp.transactions for coin in tx.removals)
-        ):
-            print("Fee is >= the amount of coins selected. To continue, please use --override flag.")
-            return []
-
-        print(f"Transactions would combine up to {number_of_coins} coins.")
-        if push:
-            cli_confirm("Would you like to Continue? (y/n): ")
-            resp = await wallet_client.combine_coins(
-                dataclasses.replace(combine_request, push=True),
-                tx_config,
-                timelock_info=condition_valid_times,
+        for tx in resp.transactions:
+            print(f"Transaction sent: {tx.name}")
+            print(
+                f"To get status, use command: chia wallet get_transaction -f {client_info.fingerprint} -tx 0x{tx.name}"
             )
-            for tx in resp.transactions:
-                print(f"Transaction sent: {tx.name}")
-                print(f"To get status, use command: chia wallet get_transaction -f {fingerprint} -tx 0x{tx.name}")
 
-        return resp.transactions
+    return resp.transactions
 
 
 async def async_split(
     *,
-    wallet_rpc_port: Optional[int],
-    fingerprint: Optional[int],
+    client_info: WalletClientInfo,
     wallet_id: int,
     fee: uint64,
-    number_of_coins: int,
-    amount_per_coin: CliAmount,
+    number_of_coins: Optional[int],
+    amount_per_coin: Optional[CliAmount],
     target_coin_id: bytes32,
     max_coin_amount: CliAmount,
     min_coin_amount: CliAmount,
     excluded_amounts: Sequence[CliAmount],
     coins_to_exclude: Sequence[bytes32],
-    reuse_puzhash: bool,
+    reuse_puzhash: Optional[bool],
     push: bool,
     condition_valid_times: ConditionValidTimes,
-) -> List[TransactionRecord]:
-    async with get_wallet_client(wallet_rpc_port, fingerprint) as (wallet_client, fingerprint, config):
-        try:
-            wallet_type = await get_wallet_type(wallet_id=wallet_id, wallet_client=wallet_client)
-            mojo_per_unit = get_mojo_per_unit(wallet_type)
-        except LookupError:
-            print(f"Wallet id: {wallet_id} not found.")
+) -> list[TransactionRecord]:
+    try:
+        wallet_type = await get_wallet_type(wallet_id=wallet_id, wallet_client=client_info.client)
+        mojo_per_unit = get_mojo_per_unit(wallet_type)
+    except LookupError:
+        print(f"Wallet id: {wallet_id} not found.")
+        return []
+    if not (await client_info.client.get_sync_status()).synced:
+        print("Wallet not synced. Please wait.")
+        return []
+
+    if number_of_coins is None and amount_per_coin is None:
+        print("Must use either -a or -n. For more information run --help.")
+        return []
+
+    if number_of_coins is None:
+        coins = await client_info.client.get_coin_records_by_names([target_coin_id])
+        if len(coins) == 0:
+            print("Could not find target coin.")
             return []
-        if not await wallet_client.get_synced():
-            print("Wallet not synced. Please wait.")
+        assert amount_per_coin is not None
+        number_of_coins = int(coins[0].coin.amount // amount_per_coin.convert_amount(mojo_per_unit))
+    elif amount_per_coin is None:
+        coins = await client_info.client.get_coin_records_by_names([target_coin_id])
+        if len(coins) == 0:
+            print("Could not find target coin.")
             return []
+        assert number_of_coins is not None
+        amount_per_coin = CliAmount(True, uint64(coins[0].coin.amount // number_of_coins))
 
-        final_amount_per_coin = amount_per_coin.convert_amount(mojo_per_unit)
+    final_amount_per_coin = amount_per_coin.convert_amount(mojo_per_unit)
 
-        tx_config = CMDTXConfigLoader(
-            max_coin_amount=max_coin_amount,
-            min_coin_amount=min_coin_amount,
-            excluded_coin_amounts=list(excluded_amounts),
-            excluded_coin_ids=list(coins_to_exclude),
-            reuse_puzhash=reuse_puzhash,
-        ).to_tx_config(mojo_per_unit, config, fingerprint)
+    tx_config = CMDTXConfigLoader(
+        max_coin_amount=max_coin_amount,
+        min_coin_amount=min_coin_amount,
+        excluded_coin_amounts=list(excluded_amounts),
+        excluded_coin_ids=list(coins_to_exclude),
+        reuse_puzhash=reuse_puzhash,
+    ).to_tx_config(mojo_per_unit, client_info.config, client_info.fingerprint)
 
-        transactions: List[TransactionRecord] = (
-            await wallet_client.split_coins(
-                SplitCoins(
-                    wallet_id=uint32(wallet_id),
-                    number_of_coins=uint16(number_of_coins),
-                    amount_per_coin=uint64(final_amount_per_coin),
-                    target_coin_id=target_coin_id,
-                    fee=fee,
-                    push=push,
-                ),
-                tx_config=tx_config,
-                timelock_info=condition_valid_times,
-            )
-        ).transactions
+    transactions: list[TransactionRecord] = (
+        await client_info.client.split_coins(
+            SplitCoins(
+                wallet_id=uint32(wallet_id),
+                number_of_coins=uint16(number_of_coins),
+                amount_per_coin=uint64(final_amount_per_coin),
+                target_coin_id=target_coin_id,
+                fee=fee,
+                push=push,
+            ),
+            tx_config=tx_config,
+            timelock_info=condition_valid_times,
+        )
+    ).transactions
 
-        if push:
-            for tx in transactions:
-                print(f"Transaction sent: {tx.name}")
-                print(f"To get status, use command: chia wallet get_transaction -f {fingerprint} -tx 0x{tx.name}")
-        dust_threshold = config.get("xch_spam_amount", 1000000)  # min amount per coin in mojo
-        spam_filter_after_n_txs = config.get("spam_filter_after_n_txs", 200)  # how many txs to wait before filtering
-        if final_amount_per_coin < dust_threshold and wallet_type == WalletType.STANDARD_WALLET:
+    if push:
+        for tx in transactions:
+            print(f"Transaction sent: {tx.name}")
             print(
-                f"WARNING: The amount per coin: {amount_per_coin.amount} is less than the dust threshold: "
-                f"{dust_threshold / (1 if amount_per_coin.mojos else mojo_per_unit)}. Some or all of the Coins "
-                f"{'will' if number_of_coins > spam_filter_after_n_txs else 'may'} not show up in your wallet unless "
-                f"you decrease the dust limit to below {final_amount_per_coin} mojos or disable it by setting it to 0."
+                f"To get status, use command: chia wallet get_transaction -f {client_info.fingerprint} -tx 0x{tx.name}"
             )
-        return transactions
+    dust_threshold = client_info.config.get("xch_spam_amount", 1000000)  # min amount per coin in mojo
+    spam_filter_after_n_txs = client_info.config.get(
+        "spam_filter_after_n_txs", 200
+    )  # how many txs to wait before filtering
+    if final_amount_per_coin < dust_threshold and wallet_type == WalletType.STANDARD_WALLET:
+        print(
+            f"WARNING: The amount per coin: {amount_per_coin.amount} is less than the dust threshold: "
+            f"{dust_threshold / (1 if amount_per_coin.mojos else mojo_per_unit)}. Some or all of the Coins "
+            f"{'will' if number_of_coins > spam_filter_after_n_txs else 'may'} not show up in your wallet unless "
+            f"you decrease the dust limit to below {final_amount_per_coin} mojos or disable it by setting it to 0."
+        )
+    return transactions