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

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -2,17 +2,18 @@ from __future__ import annotations
 
 import asyncio
 import dataclasses
+import io
 import json
 import logging
 import random
 from operator import attrgetter
-from typing import Any, Dict, List, Optional, Tuple, cast
+from typing import Any, Optional, cast
+from unittest.mock import patch
 
 import aiosqlite
 import pytest
 from chia_rs import G1Element, G2Element
 
-from chia._tests.conftest import ConsensusMode
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_not_none
 from chia._tests.wallet.test_wallet_coin_store import (
@@ -41,6 +42,8 @@ from chia._tests.wallet.test_wallet_coin_store import (
     record_8,
     record_9,
 )
+from chia.cmds.coins import CombineCMD, SplitCMD
+from chia.cmds.param_types import CliAmount
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.coinbase import create_puzzlehash_for_pk
 from chia.rpc.full_node_rpc_client import FullNodeRpcClient
@@ -55,9 +58,13 @@ from chia.rpc.wallet_request_types import (
     DIDGetPubkey,
     GetNotifications,
     GetPrivateKey,
+    GetSyncStatusResponse,
+    GetTimestampForHeight,
     LogIn,
+    PushTransactions,
+    PushTX,
+    SetWalletResyncOnStartup,
     SplitCoins,
-    SplitCoinsResponse,
     VerifySignature,
     VerifySignatureResponse,
 )
@@ -139,6 +146,10 @@ class WalletRpcTestEnvironment:
     full_node: FullNodeBundle
 
 
+async def check_client_synced(wallet_client: WalletRpcClient) -> bool:
+    return (await wallet_client.get_sync_status()).synced
+
+
 async def farm_transaction_block(full_node_api: FullNodeSimulator, wallet_node: WalletNode):
     await full_node_api.farm_blocks_to_puzzlehash(count=1)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
@@ -174,7 +185,7 @@ async def generate_funds(full_node_api: FullNodeSimulator, wallet_bundle: Wallet
     expected_unconfirmed = initial_balances["unconfirmed_wallet_balance"] + generated_funds
     await time_out_assert(20, get_confirmed_balance, expected_confirmed, wallet_bundle.rpc_client, wallet_id)
     await time_out_assert(20, get_unconfirmed_balance, expected_unconfirmed, wallet_bundle.rpc_client, wallet_id)
-    await time_out_assert(20, wallet_bundle.rpc_client.get_synced)
+    await time_out_assert(20, check_client_synced, True, wallet_bundle.rpc_client)
 
     return generated_funds
 
@@ -224,7 +235,7 @@ async def wallet_rpc_environment(two_wallet_nodes_services, request, self_hostna
                 yield WalletRpcTestEnvironment(wallet_bundle_1, wallet_bundle_2, node_bundle)
 
 
-async def create_tx_outputs(wallet: Wallet, output_args: List[Tuple[int, Optional[List[str]]]]) -> List[Dict[str, Any]]:
+async def create_tx_outputs(wallet: Wallet, output_args: list[tuple[int, Optional[list[str]]]]) -> list[dict[str, Any]]:
     outputs = []
     for args in output_args:
         output = {"amount": uint64(args[0]), "puzzle_hash": await wallet.get_new_puzzlehash()}
@@ -235,7 +246,7 @@ async def create_tx_outputs(wallet: Wallet, output_args: List[Tuple[int, Optiona
     return outputs
 
 
-async def assert_wallet_types(client: WalletRpcClient, expected: Dict[WalletType, int]) -> None:
+async def assert_wallet_types(client: WalletRpcClient, expected: dict[WalletType, int]) -> None:
     for wallet_type in WalletType:
         wallets = await client.get_wallets(wallet_type)
         wallet_count = len(wallets)
@@ -247,7 +258,7 @@ async def assert_wallet_types(client: WalletRpcClient, expected: Dict[WalletType
 
 def assert_tx_amounts(
     tx: TransactionRecord,
-    outputs: List[Dict[str, Any]],
+    outputs: list[dict[str, Any]],
     *,
     amount_fee: uint64,
     change_expected: bool,
@@ -274,7 +285,7 @@ async def assert_push_tx_error(node_rpc: FullNodeRpcClient, tx: TransactionRecor
     try:
         await node_rpc.push_tx(spend_bundle)
     except ValueError as error:
-        error_string = error.args[0]["error"]  # noqa:  # pylint: disable=E1126
+        error_string = error.args[0]["error"]
         if error_string.find("ASSERT_ANNOUNCE_CONSUMED_FAILED") == -1:
             raise ValueError from error
 
@@ -322,7 +333,7 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
 
     # Tests sending a basic transaction
     extra_conditions = (Remark(Program.to(("test", None))),)
-    non_existent_coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
+    non_existent_coin = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
     tx_no_push = (
         await client.send_transaction(
             1,
@@ -379,7 +390,7 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
     assert tx_confirmed.confirmed
     assert len(tx_confirmed.get_memos()) == 1
     assert [b"this is a basic tx"] in tx_confirmed.get_memos().values()
-    assert list(tx_confirmed.get_memos().keys())[0] in [a.name() for a in spend_bundle.additions()]
+    assert next(iter(tx_confirmed.get_memos().keys())) in [a.name() for a in spend_bundle.additions()]
 
     await time_out_assert(20, get_confirmed_balance, generated_funds - tx_amount, client, 1)
 
@@ -405,29 +416,30 @@ async def test_push_transactions(wallet_rpc_environment: WalletRpcTestEnvironmen
         )
     ).signed_tx
 
-    resp_client = await client.push_transactions([tx], fee=uint64(10))
+    resp_client = await client.push_transactions(
+        PushTransactions(transactions=[tx], fee=uint64(10)),
+        DEFAULT_TX_CONFIG,
+    )
     resp = await client.fetch(
         "push_transactions", {"transactions": [tx.to_json_dict_convenience(wallet_node.config)], "fee": 10}
     )
     assert resp["success"]
-    resp = await client.fetch("push_transactions", {"transactions": [tx.to_json_dict()], "fee": 10})
+    resp = await client.fetch("push_transactions", {"transactions": [bytes(tx).hex()], "fee": 10})
     assert resp["success"]
 
     spend_bundle = WalletSpendBundle.aggregate(
-        [
-            # We ARE checking that the spend bundle is not None but mypy can't recognize this
-            TransactionRecord.from_json_dict_convenience(tx).spend_bundle  # type: ignore[type-var]
-            for tx in resp_client["transactions"]
-            if tx["spend_bundle"] is not None
-        ]
+        [tx.spend_bundle for tx in resp_client.transactions if tx.spend_bundle is not None]
     )
     assert spend_bundle is not None
     await farm_transaction(full_node_api, wallet_node, spend_bundle)
 
-    for tx_json in resp_client["transactions"]:
-        tx = TransactionRecord.from_json_dict_convenience(tx_json)
-        tx = await client.get_transaction(transaction_id=tx.name)
-        assert tx.confirmed
+    for tx in resp_client.transactions:
+        assert (await client.get_transaction(transaction_id=tx.name)).confirmed
+
+    # Just testing NOT failure here really (parsing)
+    await client.push_tx(PushTX(spend_bundle))
+    resp = await client.fetch("push_tx", {"spend_bundle": bytes(spend_bundle).hex()})
+    assert resp["success"]
 
 
 @pytest.mark.anyio
@@ -461,7 +473,9 @@ async def test_get_farmed_amount(wallet_rpc_environment: WalletRpcTestEnvironmen
     await full_node_api.farm_blocks_to_wallet(2, wallet)
 
     get_farmed_amount_result = await wallet_rpc_client.get_farmed_amount()
-    get_timestamp_for_height_result = await wallet_rpc_client.get_timestamp_for_height(uint32(3))  # genesis + 2
+    get_timestamp_for_height_result = await wallet_rpc_client.get_timestamp_for_height(
+        GetTimestampForHeight(uint32(3))
+    )  # genesis + 2
 
     expected_result = {
         "blocks_won": 2,
@@ -469,7 +483,7 @@ async def test_get_farmed_amount(wallet_rpc_environment: WalletRpcTestEnvironmen
         "farmer_reward_amount": 500_000_000_000,
         "fee_amount": 0,
         "last_height_farmed": 3,
-        "last_time_farmed": get_timestamp_for_height_result,
+        "last_time_farmed": get_timestamp_for_height_result.timestamp,
         "pool_reward_amount": 3_500_000_000_000,
         "success": True,
     }
@@ -490,7 +504,7 @@ async def test_get_farmed_amount_with_fee(wallet_rpc_environment: WalletRpcTestE
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await wallet.generate_signed_transaction(
             amount=uint64(5),
-            puzzle_hash=bytes32([0] * 32),
+            puzzle_hash=bytes32.zeros,
             action_scope=action_scope,
             fee=uint64(fee_amount),
         )
@@ -513,8 +527,8 @@ async def test_get_timestamp_for_height(wallet_rpc_environment: WalletRpcTestEnv
 
     await generate_funds(full_node_api, env.wallet_1)
 
-    # This tests that the client returns a uint64, rather than raising or returning something unexpected
-    uint64(await client.get_timestamp_for_height(uint32(1)))
+    # This tests that the client returns successfully, rather than raising or returning something unexpected
+    await client.get_timestamp_for_height(GetTimestampForHeight(uint32(1)))
 
 
 @pytest.mark.parametrize(
@@ -536,7 +550,7 @@ async def test_get_timestamp_for_height(wallet_rpc_environment: WalletRpcTestEnv
 @pytest.mark.anyio
 async def test_create_signed_transaction(
     wallet_rpc_environment: WalletRpcTestEnvironment,
-    output_args: List[Tuple[int, Optional[List[str]]]],
+    output_args: list[tuple[int, Optional[list[str]]]],
     fee: int,
     select_coin: bool,
     is_cat: bool,
@@ -604,7 +618,7 @@ async def test_create_signed_transaction(
     await time_out_assert(20, get_confirmed_balance, generated_funds - amount_total, wallet_1_rpc, wallet_id)
 
     # Assert every coin comes from the same parent
-    additions: List[Coin] = spend_bundle.additions()
+    additions: list[Coin] = spend_bundle.additions()
     assert len({c.parent_coin_info for c in additions}) == 2 if is_cat else 1
 
     # Assert you can get the spend for each addition
@@ -617,8 +631,8 @@ async def test_create_signed_transaction(
         assert spend is not None
 
     # Assert the memos are all correct
-    addition_dict: Dict[bytes32, Coin] = {addition.name(): addition for addition in additions}
-    memo_dictionary: Dict[bytes32, List[bytes]] = compute_memos(spend_bundle)
+    addition_dict: dict[bytes32, Coin] = {addition.name(): addition for addition in additions}
+    memo_dictionary: dict[bytes32, list[bytes]] = compute_memos(spend_bundle)
     for output in outputs:
         if "memos" in output:
             found: bool = False
@@ -1044,7 +1058,7 @@ async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
 
     # Creates a CAT wallet with 100 mojos and a CAT with 20 mojos and fee=10
     await client.create_new_cat_and_wallet(uint64(100), fee=uint64(10), test=True)
-    await time_out_assert(20, client.get_synced)
+    await time_out_assert(20, check_client_synced, True, client)
 
     res = await client.create_new_cat_and_wallet(uint64(20), test=True)
     assert res["success"]
@@ -1068,7 +1082,7 @@ async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
     wid, name = result
     assert wid == cat_0_id
     assert name == "My cat"
-    result = await client.cat_asset_id_to_name(bytes32([0] * 32))
+    result = await client.cat_asset_id_to_name(bytes32.zeros)
     assert result is None
     verified_asset_id = next(iter(DEFAULT_CATS.items()))[1]["asset_id"]
     result = await client.cat_asset_id_to_name(bytes32.from_hexstr(verified_asset_id))
@@ -1119,7 +1133,7 @@ async def test_cat_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment):
             cat_0_id,
             DEFAULT_TX_CONFIG.override(
                 excluded_coin_amounts=[uint64(20)],
-                excluded_coin_ids=[bytes32([0] * 32)],
+                excluded_coin_ids=[bytes32.zeros],
             ),
             uint64(4),
             addr_1,
@@ -1217,7 +1231,7 @@ async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment)
     assert spend_bundle is not None
     await farm_transaction(full_node_api, wallet_node, spend_bundle)
     await time_out_assert(5, get_confirmed_balance, 4, wallet_2_rpc, cat_wallet_id)
-    test_crs: List[CoinRecord] = await wallet_1_rpc.get_coin_records_by_names(
+    test_crs: list[CoinRecord] = await wallet_1_rpc.get_coin_records_by_names(
         [a.name() for a in spend_bundle.additions() if a.amount != 4]
     )
     for cr in test_crs:
@@ -1231,7 +1245,7 @@ async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment)
     all_offers = await wallet_1_rpc.get_all_offers()
     assert len(all_offers) == 0
 
-    driver_dict: Dict[str, Any] = {cat_asset_id.hex(): {"type": "CAT", "tail": "0x" + cat_asset_id.hex()}}
+    driver_dict: dict[str, Any] = {cat_asset_id.hex(): {"type": "CAT", "tail": "0x" + cat_asset_id.hex()}}
 
     create_res = await wallet_1_rpc.create_offer_for_ids(
         {uint32(1): -5, cat_asset_id.hex(): 1},
@@ -1261,7 +1275,7 @@ async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment)
     }
     assert advanced_summary == summary
 
-    id, valid = await wallet_1_rpc.check_offer_validity(offer)
+    id, _valid = await wallet_1_rpc.check_offer_validity(offer)
     assert id == offer.name()
 
     all_offers = await wallet_1_rpc.get_all_offers(file_contents=True)
@@ -1412,7 +1426,7 @@ async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment)
         driver_dict=driver_dict,
     )
     assert len([o for o in await wallet_1_rpc.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 1
-    await wallet_1_rpc.cancel_offers(DEFAULT_TX_CONFIG, asset_id=bytes32([0] * 32))
+    await wallet_1_rpc.cancel_offers(DEFAULT_TX_CONFIG, asset_id=bytes32.zeros)
     assert len([o for o in await wallet_1_rpc.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 1
     await wallet_1_rpc.cancel_offers(DEFAULT_TX_CONFIG, asset_id=cat_asset_id)
     assert len([o for o in await wallet_1_rpc.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 0
@@ -1748,7 +1762,7 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
 
     await generate_funds(env.full_node.api, env.wallet_1)
 
-    assert (await client.get_height_info()) > 0
+    assert (await client.get_height_info()).height > 0
 
     ph = await wallet.get_new_puzzlehash()
     addr = encode_puzzle_hash(ph, "txch")
@@ -1810,7 +1824,7 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
     await client.log_in(LogIn(uint32(pks[1])))
     assert len((await client.get_public_keys()).pk_fingerprints) == 1
 
-    assert not (await client.get_sync_status())
+    assert not (await client.get_sync_status()).synced
 
     wallets = await client.get_wallets()
     assert len(wallets) == 1
@@ -1837,8 +1851,8 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
     funds = await generate_funds(full_node_api, env.wallet_1)
 
     addr = encode_puzzle_hash(await wallet_2.get_new_puzzlehash(), "txch")
-    coin_300: List[Coin]
-    tx_amounts: List[uint64] = [uint64(1000), uint64(300), uint64(1000), uint64(1000), uint64(10000)]
+    coin_300: list[Coin]
+    tx_amounts: list[uint64] = [uint64(1000), uint64(300), uint64(1000), uint64(1000), uint64(10000)]
     for tx_amount in tx_amounts:
         funds -= tx_amount
         # create coins for tests
@@ -1854,7 +1868,7 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         await time_out_assert(20, get_confirmed_balance, funds, client, 1)
 
     # test min coin amount
-    min_coins: List[Coin] = await client_2.select_coins(
+    min_coins: list[Coin] = await client_2.select_coins(
         amount=1000,
         wallet_id=1,
         coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(min_coin_amount=uint64(1001)),
@@ -1863,7 +1877,7 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
     assert len(min_coins) == 1 and min_coins[0].amount == uint64(10000)
 
     # test max coin amount
-    max_coins: List[Coin] = await client_2.select_coins(
+    max_coins: list[Coin] = await client_2.select_coins(
         amount=2000,
         wallet_id=1,
         coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
@@ -1875,7 +1889,7 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
 
     # test excluded coin amounts
     non_1000_amt: int = sum(a for a in tx_amounts if a != 1000)
-    excluded_amt_coins: List[Coin] = await client_2.select_coins(
+    excluded_amt_coins: list[Coin] = await client_2.select_coins(
         amount=non_1000_amt,
         wallet_id=1,
         coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),
@@ -1958,7 +1972,7 @@ async def test_get_coin_records_rpc(wallet_rpc_environment: WalletRpcTestEnviron
         test_case: str,
         test_request: GetCoinRecords,
         test_total_count: Optional[int],
-        test_records: List[WalletCoinRecord],
+        test_records: list[WalletCoinRecord],
     ):
         response = await client.get_coin_records(test_request)
         assert response["coin_records"] == [coin.to_json_dict_parsed_metadata() for coin in test_records], test_case
@@ -2089,7 +2103,7 @@ async def test_get_coin_records_rpc_failures(
         with pytest.raises(ValueError, match=name):
             await client.get_coin_records(request)
 
-    # Type validation is handled via `Streamable.from_json_dict´ but the below should make at least sure it triggers.
+    # Type validation is handled via `Streamable.from_json_dict` but the below should make at least sure it triggers.
     for field, value in {
         "offset": "invalid",
         "limit": "invalid",
@@ -2319,8 +2333,8 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
 async def test_verify_signature(
     wallet_rpc_environment: WalletRpcTestEnvironment,
-    rpc_request: Dict[str, Any],
-    rpc_response: Dict[str, Any],
+    rpc_request: dict[str, Any],
+    rpc_response: dict[str, Any],
     prefix_hex_strings: bool,
 ):
     rpc_server: Optional[RpcServer] = wallet_rpc_environment.wallet_1.service.rpc_server
@@ -2386,7 +2400,7 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
     await wc.create_new_did_wallet(1, DEFAULT_TX_CONFIG, 0)
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, env.wallet_1.node)
-    await time_out_assert(20, wc.get_synced)
+    await time_out_assert(20, check_client_synced, True, wc)
 
     nft_wallet = await wc.create_new_nft_wallet(None)
     nft_wallet_id = nft_wallet["wallet_id"]
@@ -2401,7 +2415,7 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
     )
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, env.wallet_1.node)
-    await time_out_assert(20, wc.get_synced)
+    await time_out_assert(20, check_client_synced, True, wc)
 
     wallet_node: WalletNode = env.wallet_1.node
     wallet_node_2: WalletNode = env.wallet_2.node
@@ -2419,7 +2433,7 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
     clawback_coin_id = tx.additions[0].name()
     assert tx.spend_bundle is not None
     await farm_transaction(full_node_api, wallet_node, tx.spend_bundle)
-    await time_out_assert(20, wc.get_synced)
+    await time_out_assert(20, check_client_synced, True, wc)
     await asyncio.sleep(10)
     resp = await wc.spend_clawback_coins([clawback_coin_id], 0)
     assert resp["success"]
@@ -2428,11 +2442,11 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
         10, full_node_api.full_node.mempool_manager.get_spendbundle, bytes32.from_hexstr(resp["transaction_ids"][0])
     )
     await farm_transaction_block(full_node_api, wallet_node)
-    await time_out_assert(20, wc.get_synced)
+    await time_out_assert(20, check_client_synced, True, wc)
     wallet_node_2._close()
     await wallet_node_2._await_closed()
     # set flag to reset wallet sync data on start
-    await client.set_wallet_resync_on_startup()
+    await client.set_wallet_resync_on_startup(SetWalletResyncOnStartup())
     fingerprint = wallet_node.logged_in_fingerprint
     assert wallet_node._wallet_state_manager
     # 2 reward coins, 1 DID, 1 NFT, 1 clawbacked coin
@@ -2484,12 +2498,12 @@ async def test_set_wallet_resync_on_startup_disable(wallet_rpc_environment: Wall
     wallet_node_2._close()
     await wallet_node_2._await_closed()
     # set flag to reset wallet sync data on start
-    await client.set_wallet_resync_on_startup()
+    await client.set_wallet_resync_on_startup(SetWalletResyncOnStartup())
     fingerprint = wallet_node.logged_in_fingerprint
     assert wallet_node._wallet_state_manager
     assert len(await wallet_node._wallet_state_manager.coin_store.get_all_unspent_coins()) == 2
     before_txs = await wallet_node.wallet_state_manager.tx_store.get_all_transactions()
-    await client.set_wallet_resync_on_startup(False)
+    await client.set_wallet_resync_on_startup(SetWalletResyncOnStartup(False))
     wallet_node._close()
     await wallet_node._await_closed()
     config = load_config(wallet_node.root_path, "config.yaml")
@@ -2625,16 +2639,16 @@ async def test_get_balances(wallet_rpc_environment: WalletRpcTestEnvironment):
 
     await generate_funds(full_node_api, env.wallet_1, 1)
 
-    await time_out_assert(20, client.get_synced)
+    await time_out_assert(20, check_client_synced, True, client)
     # Creates a CAT wallet with 100 mojos and a CAT with 20 mojos
     await client.create_new_cat_and_wallet(uint64(100), test=True)
 
-    await time_out_assert(20, client.get_synced)
+    await time_out_assert(20, check_client_synced, True, client)
     res = await client.create_new_cat_and_wallet(uint64(20), test=True)
     assert res["success"]
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 2)
     await farm_transaction_block(full_node_api, wallet_node)
-    await time_out_assert(20, client.get_synced)
+    await time_out_assert(20, check_client_synced, True, client)
     bal = await client.get_wallet_balances()
     assert len(bal) == 3
     assert bal["1"]["confirmed_wallet_balance"] == 1999999999880
@@ -2656,9 +2670,9 @@ async def test_get_balances(wallet_rpc_environment: WalletRpcTestEnvironment):
     ],
     indirect=True,
 )
-@pytest.mark.limit_consensus_modes([ConsensusMode.PLAIN], reason="irrelevant")
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_split_coins(wallet_environments: WalletTestFramework) -> None:
+async def test_split_coins(wallet_environments: WalletTestFramework, capsys: pytest.CaptureFixture[str]) -> None:
     env = wallet_environments.environments[0]
     env.wallet_aliases = {
         "xch": 1,
@@ -2667,60 +2681,62 @@ async def test_split_coins(wallet_environments: WalletTestFramework) -> None:
 
     # Test XCH first
     async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config) as action_scope:
-        target_coin = list(await env.xch_wallet.select_coins(uint64(250_000_000_000), action_scope))[0]
+        target_coin = next(iter(await env.xch_wallet.select_coins(uint64(250_000_000_000), action_scope)))
         assert target_coin.amount == 250_000_000_000
 
-    xch_request = SplitCoins(
-        wallet_id=uint32(1),
-        number_of_coins=uint16(100),
-        amount_per_coin=uint64(100),
-        target_coin_id=target_coin.name(),
-        fee=uint64(1_000_000_000_000),  # 1 XCH
-        push=True,
+    xch_request = SplitCMD(
+        **{
+            **wallet_environments.cmd_tx_endpoint_args(env),
+            **dict(
+                id=env.wallet_aliases["xch"],
+                number_of_coins=100,
+                amount_per_coin=CliAmount(amount=uint64(100), mojos=True),
+                target_coin_id=target_coin.name(),
+                fee=uint64(1_000_000_000_000),  # 1 XCH
+                push=True,
+            ),
+        }
     )
 
     with pytest.raises(ResponseFailureError, match="501 coins is greater then the maximum limit of 500 coins"):
-        await env.rpc_client.split_coins(
-            dataclasses.replace(xch_request, number_of_coins=uint16(501)),
-            wallet_environments.tx_config,
-        )
+        await dataclasses.replace(xch_request, number_of_coins=501).run()
 
     with pytest.raises(ResponseFailureError, match="Could not find coin with ID 00000000000000000"):
-        await env.rpc_client.split_coins(
-            dataclasses.replace(xch_request, target_coin_id=bytes32([0] * 32)),
-            wallet_environments.tx_config,
-        )
+        await dataclasses.replace(xch_request, target_coin_id=bytes32.zeros).run()
 
     with pytest.raises(ResponseFailureError, match="is less than the total amount of the split"):
-        await env.rpc_client.split_coins(
-            dataclasses.replace(xch_request, amount_per_coin=uint64(1_000_000_000_000)),
-            wallet_environments.tx_config,
-        )
+        await dataclasses.replace(
+            xch_request, amount_per_coin=CliAmount(amount=uint64(1_000_000_000_000), mojos=True)
+        ).run()
 
-    with pytest.raises(ResponseFailureError, match="Wallet with ID 42 does not exist"):
-        await env.rpc_client.split_coins(
-            dataclasses.replace(xch_request, wallet_id=uint32(42)),
-            wallet_environments.tx_config,
-        )
+    # We catch this one
+    capsys.readouterr()
+    await dataclasses.replace(xch_request, id=50).run()
+    output = (capsys.readouterr()).out
+    assert "Wallet id: 50 not found" in output
 
+    # This one only "works" on the RPC
     env.wallet_state_manager.wallets[uint32(42)] = object()  # type: ignore[assignment]
     with pytest.raises(ResponseFailureError, match="Cannot split coins from non-fungible wallet types"):
-        await env.rpc_client.split_coins(
-            dataclasses.replace(xch_request, wallet_id=uint32(42)),
-            wallet_environments.tx_config,
+        assert xch_request.amount_per_coin is not None  # hey there mypy
+        rpc_request = SplitCoins(
+            wallet_id=uint32(42),
+            number_of_coins=uint16(xch_request.number_of_coins),
+            amount_per_coin=xch_request.amount_per_coin.convert_amount(1),
+            target_coin_id=xch_request.target_coin_id,
+            fee=xch_request.fee,
+            push=xch_request.push,
         )
+        await env.rpc_client.split_coins(rpc_request, wallet_environments.tx_config)
+
     del env.wallet_state_manager.wallets[uint32(42)]
 
-    response = await env.rpc_client.split_coins(
-        dataclasses.replace(xch_request, number_of_coins=uint16(0)),
-        wallet_environments.tx_config,
-    )
-    assert response == SplitCoinsResponse([], [])
+    await dataclasses.replace(xch_request, number_of_coins=0).run()
+    output = (capsys.readouterr()).out
+    assert "Transaction sent" not in output
 
-    await env.rpc_client.split_coins(
-        xch_request,
-        wallet_environments.tx_config,
-    )
+    with wallet_environments.new_puzzle_hashes_allowed():
+        await xch_request.run()
 
     await wallet_environments.process_pending_states(
         [
@@ -2775,21 +2791,24 @@ async def test_split_coins(wallet_environments: WalletTestFramework) -> None:
     )
 
     async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config) as action_scope:
-        target_coin = list(await cat_wallet.select_coins(uint64(50), action_scope))[0]
+        target_coin = next(iter(await cat_wallet.select_coins(uint64(50), action_scope)))
         assert target_coin.amount == 50
 
-    cat_request = SplitCoins(
-        wallet_id=uint32(2),
-        number_of_coins=uint16(50),
-        amount_per_coin=uint64(1),
-        target_coin_id=target_coin.name(),
-        push=True,
+    cat_request = SplitCMD(
+        **{
+            **wallet_environments.cmd_tx_endpoint_args(env),
+            **dict(
+                id=env.wallet_aliases["cat"],
+                number_of_coins=50,
+                amount_per_coin=CliAmount(amount=uint64(1), mojos=True),
+                target_coin_id=target_coin.name(),
+                push=True,
+            ),
+        }
     )
 
-    await env.rpc_client.split_coins(
-        cat_request,
-        wallet_environments.tx_config,
-    )
+    with wallet_environments.new_puzzle_hashes_allowed():
+        await dataclasses.replace(cat_request).run()
 
     await wallet_environments.process_pending_states(
         [
@@ -2817,6 +2836,17 @@ async def test_split_coins(wallet_environments: WalletTestFramework) -> None:
         ]
     )
 
+    # Test a not synced error
+    assert xch_request.rpc_info.client_info is not None
+
+    async def not_synced() -> GetSyncStatusResponse:
+        return GetSyncStatusResponse(False, False)
+
+    xch_request.rpc_info.client_info.client.get_sync_status = not_synced  # type: ignore[method-assign]
+    await xch_request.run()
+    output = (capsys.readouterr()).out
+    assert "Wallet not synced. Please wait." in output
+
 
 @pytest.mark.parametrize(
     "wallet_environments",
@@ -2828,9 +2858,9 @@ async def test_split_coins(wallet_environments: WalletTestFramework) -> None:
     ],
     indirect=True,
 )
-@pytest.mark.limit_consensus_modes([ConsensusMode.PLAIN], reason="irrelevant")
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_combine_coins(wallet_environments: WalletTestFramework) -> None:
+async def test_combine_coins(wallet_environments: WalletTestFramework, capsys: pytest.CaptureFixture[str]) -> None:
     env = wallet_environments.environments[0]
     env.wallet_aliases = {
         "xch": 1,
@@ -2841,7 +2871,7 @@ async def test_combine_coins(wallet_environments: WalletTestFramework) -> None:
 
     # Grab one of the 0.25 ones to specify
     async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config) as action_scope:
-        target_coin = list(await env.xch_wallet.select_coins(uint64(250_000_000_000), action_scope))[0]
+        target_coin = next(iter(await env.xch_wallet.select_coins(uint64(250_000_000_000), action_scope)))
         assert target_coin.amount == 250_000_000_000
 
     # These parameters will give us the maximum amount of behavior coverage
@@ -2849,53 +2879,55 @@ async def test_combine_coins(wallet_environments: WalletTestFramework) -> None:
     # - Less amount than will have to be selected in order create it
     # - Higher # coins than necessary to create it
     fee = uint64(100)
-    xch_combine_request = CombineCoins(
-        wallet_id=uint32(1),
-        target_coin_amount=uint64(1_000_000_000_000),
-        number_of_coins=uint16(3),
-        target_coin_ids=[target_coin.name()],
-        fee=fee,
-        push=True,
+    xch_combine_request = CombineCMD(
+        **{
+            **wallet_environments.cmd_tx_endpoint_args(env),
+            **dict(
+                id=env.wallet_aliases["xch"],
+                target_amount=CliAmount(amount=uint64(1_000_000_000_000), mojos=True),
+                number_of_coins=uint16(3),
+                input_coins=(target_coin.name(),),
+                fee=fee,
+                push=True,
+            ),
+        }
     )
 
     # Test some error cases first
     with pytest.raises(ResponseFailureError, match="greater then the maximum limit"):
-        await env.rpc_client.combine_coins(
-            dataclasses.replace(xch_combine_request, number_of_coins=uint16(501)),
-            wallet_environments.tx_config,
-        )
+        await dataclasses.replace(xch_combine_request, number_of_coins=uint16(501)).run()
 
     with pytest.raises(ResponseFailureError, match="You need at least two coins to combine"):
-        await env.rpc_client.combine_coins(
-            dataclasses.replace(xch_combine_request, number_of_coins=uint16(0)),
-            wallet_environments.tx_config,
-        )
+        await dataclasses.replace(xch_combine_request, number_of_coins=uint16(0)).run()
 
     with pytest.raises(ResponseFailureError, match="More coin IDs specified than desired number of coins to combine"):
-        await env.rpc_client.combine_coins(
-            dataclasses.replace(xch_combine_request, target_coin_ids=[bytes32([0] * 32)] * 100),
-            wallet_environments.tx_config,
-        )
+        await dataclasses.replace(xch_combine_request, input_coins=(bytes32.zeros,) * 100).run()
 
-    with pytest.raises(ResponseFailureError, match="Wallet with ID 50 does not exist"):
-        await env.rpc_client.combine_coins(
-            dataclasses.replace(xch_combine_request, wallet_id=uint32(50)),
-            wallet_environments.tx_config,
-        )
+    # We catch this one
+    capsys.readouterr()
+    await dataclasses.replace(xch_combine_request, id=50).run()
+    output = (capsys.readouterr()).out
+    assert "Wallet id: 50 not found" in output
 
+    # This one only "works" on the RPC
     env.wallet_state_manager.wallets[uint32(42)] = object()  # type: ignore[assignment]
     with pytest.raises(ResponseFailureError, match="Cannot combine coins from non-fungible wallet types"):
-        await env.rpc_client.combine_coins(
-            dataclasses.replace(xch_combine_request, wallet_id=uint32(42)),
-            wallet_environments.tx_config,
+        assert xch_combine_request.target_amount is not None  # hey there mypy
+        rpc_request = CombineCoins(
+            wallet_id=uint32(42),
+            target_coin_amount=xch_combine_request.target_amount.convert_amount(1),
+            number_of_coins=uint16(xch_combine_request.number_of_coins),
+            target_coin_ids=list(xch_combine_request.input_coins),
+            fee=xch_combine_request.fee,
+            push=xch_combine_request.push,
         )
+        await env.rpc_client.combine_coins(rpc_request, wallet_environments.tx_config)
+
     del env.wallet_state_manager.wallets[uint32(42)]
 
     # Now push the request
-    await env.rpc_client.combine_coins(
-        xch_combine_request,
-        wallet_environments.tx_config,
-    )
+    with patch("sys.stdin", new=io.StringIO("y\n")):
+        await xch_combine_request.run()
 
     await wallet_environments.process_pending_states(
         [
@@ -2955,7 +2987,7 @@ async def test_combine_coins(wallet_environments: WalletTestFramework) -> None:
     async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         await cat_wallet.generate_signed_transaction(
             [BIG_COIN_AMOUNT, SMALL_COIN_AMOUNT, REALLY_SMALL_COIN_AMOUNT],
-            [await env.xch_wallet.get_puzzle_hash(new=action_scope.config.tx_config.reuse_puzhash)] * 3,
+            [await env.xch_wallet.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)] * 3,
             action_scope,
         )
 
@@ -2976,20 +3008,23 @@ async def test_combine_coins(wallet_environments: WalletTestFramework) -> None:
     )
 
     # We're going to test that we select the two smaller coins
-    cat_combine_request = CombineCoins(
-        wallet_id=uint32(2),
-        target_coin_amount=None,
-        number_of_coins=uint16(2),
-        target_coin_ids=[],
-        largest_first=False,
-        fee=fee,
-        push=True,
+    cat_combine_request = CombineCMD(
+        **{
+            **wallet_environments.cmd_tx_endpoint_args(env),
+            **dict(
+                id=env.wallet_aliases["cat"],
+                target_amount=None,
+                number_of_coins=uint16(2),
+                input_coins=(),
+                largest_first=False,
+                fee=fee,
+                push=True,
+            ),
+        }
     )
 
-    await env.rpc_client.combine_coins(
-        cat_combine_request,
-        wallet_environments.tx_config,
-    )
+    with patch("sys.stdin", new=io.StringIO("y\n")):
+        await cat_combine_request.run()
 
     await wallet_environments.process_pending_states(
         [
@@ -3023,6 +3058,17 @@ async def test_combine_coins(wallet_environments: WalletTestFramework) -> None:
         ]
     )
 
+    # Test a not synced error
+    assert xch_combine_request.rpc_info.client_info is not None
+
+    async def not_synced() -> GetSyncStatusResponse:
+        return GetSyncStatusResponse(False, False)
+
+    xch_combine_request.rpc_info.client_info.client.get_sync_status = not_synced  # type: ignore[method-assign]
+    await xch_combine_request.run()
+    output = (capsys.readouterr()).out
+    assert "Wallet not synced. Please wait." in output
+
 
 @pytest.mark.parametrize(
     "wallet_environments",
@@ -3053,31 +3099,32 @@ async def test_fee_bigger_than_selection_coin_combining(wallet_environments: Wal
 
     # Grab one of the 0.25 ones to specify
     async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config) as action_scope:
-        target_coin = list(await env.xch_wallet.select_coins(uint64(250_000_000_000), action_scope))[0]
+        target_coin = next(iter(await env.xch_wallet.select_coins(uint64(250_000_000_000), action_scope)))
         assert target_coin.amount == 250_000_000_000
 
     fee = uint64(1_750_000_000_000)
     # Under standard circumstances we would select the small coins, but this is not enough to pay the fee
     # Instead, we will grab the big coin first and combine it with one of the smaller coins
-    xch_combine_request = CombineCoins(
-        wallet_id=uint32(1),
-        number_of_coins=uint16(2),
-        fee=fee,
-        largest_first=False,
-        push=True,
+    xch_combine_request = CombineCMD(
+        **{
+            **wallet_environments.cmd_tx_endpoint_args(env),
+            **dict(
+                id=env.wallet_aliases["xch"],
+                number_of_coins=uint16(2),
+                input_coins=(),
+                fee=fee,
+                push=True,
+                largest_first=False,
+            ),
+        }
     )
 
     # First test an error where fee selection causes too many coins to be selected
     with pytest.raises(ResponseFailureError, match="without selecting more coins than specified: 3"):
-        await env.rpc_client.combine_coins(
-            dataclasses.replace(xch_combine_request, fee=uint64(2_250_000_000_000)),
-            wallet_environments.tx_config,
-        )
+        await dataclasses.replace(xch_combine_request, fee=uint64(2_250_000_000_000)).run()
 
-    await env.rpc_client.combine_coins(
-        xch_combine_request,
-        wallet_environments.tx_config,
-    )
+    with patch("sys.stdin", new=io.StringIO("y\n")):
+        await xch_combine_request.run()
 
     await wallet_environments.process_pending_states(
         [