chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7__py3-none-any.whl

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -6,9 +6,10 @@ import io
 import json
 import logging
 import random
+import re
 from collections.abc import AsyncIterator
 from operator import attrgetter
-from typing import Any, Optional, cast
+from typing import Any, Optional
 from unittest.mock import patch
 
 import aiosqlite
@@ -52,7 +53,6 @@ from chia.cmds.param_types import CliAmount
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.rpc.rpc_client import ResponseFailureError
-from chia.server.aliases import WalletService
 from chia.server.server import ChiaServer
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
@@ -105,26 +105,42 @@ from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_protocol import WalletProtocol
 from chia.wallet.wallet_request_types import (
     AddKey,
+    CATAssetIDToName,
+    CATGetAssetID,
+    CATGetName,
+    CATSetName,
+    CATSpend,
     CheckDeleteKey,
+    CheckOfferValidity,
+    ClawbackPuzzleDecoratorOverride,
     CombineCoins,
     DefaultCAT,
     DeleteKey,
+    DeleteNotifications,
+    DeleteUnconfirmedTransactions,
     DIDCreateBackupFile,
     DIDGetDID,
     DIDGetMetadata,
     DIDGetPubkey,
-    DIDGetRecoveryList,
     DIDGetWalletName,
     DIDMessageSpend,
     DIDSetWalletName,
     DIDTransferDID,
     DIDUpdateMetadata,
-    DIDUpdateRecoveryIDs,
     FungibleAsset,
+    GetCoinRecordsByNames,
+    GetNextAddress,
     GetNotifications,
     GetPrivateKey,
+    GetSpendableCoins,
     GetSyncStatusResponse,
     GetTimestampForHeight,
+    GetTransaction,
+    GetTransactionCount,
+    GetTransactions,
+    GetWalletBalance,
+    GetWalletBalances,
+    GetWallets,
     LogIn,
     NFTCalculateRoyalties,
     NFTGetInfo,
@@ -134,13 +150,18 @@ from chia.wallet.wallet_request_types import (
     PushTransactions,
     PushTX,
     RoyaltyAsset,
+    SelectCoins,
+    SendNotification,
+    SendTransaction,
     SetWalletResyncOnStartup,
+    SpendClawbackCoins,
     SplitCoins,
     VerifySignature,
     VerifySignatureResponse,
 )
 from chia.wallet.wallet_rpc_api import WalletRpcApi
 from chia.wallet.wallet_rpc_client import WalletRpcClient
+from chia.wallet.wallet_service import WalletService
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 log = logging.getLogger(__name__)
@@ -191,9 +212,11 @@ async def farm_transaction(
 
 
 async def generate_funds(full_node_api: FullNodeSimulator, wallet_bundle: WalletBundle, num_blocks: int = 1) -> int:
-    wallet_id = 1
-    initial_balances = await wallet_bundle.rpc_client.get_wallet_balance(wallet_id)
-    ph: bytes32 = decode_puzzle_hash(await wallet_bundle.rpc_client.get_next_address(wallet_id, True))
+    wallet_id = uint32(1)
+    initial_balances = (await wallet_bundle.rpc_client.get_wallet_balance(GetWalletBalance(wallet_id))).wallet_balance
+    ph: bytes32 = decode_puzzle_hash(
+        (await wallet_bundle.rpc_client.get_next_address(GetNextAddress(wallet_id, True))).address
+    )
     generated_funds = 0
     for _ in range(num_blocks):
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
@@ -204,8 +227,8 @@ async def generate_funds(full_node_api: FullNodeSimulator, wallet_bundle: Wallet
     # Farm a dummy block to confirm the created funds
     await farm_transaction_block(full_node_api, wallet_bundle.node)
 
-    expected_confirmed = initial_balances["confirmed_wallet_balance"] + generated_funds
-    expected_unconfirmed = initial_balances["unconfirmed_wallet_balance"] + generated_funds
+    expected_confirmed = initial_balances.confirmed_wallet_balance + generated_funds
+    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, check_client_synced, True, wallet_bundle.rpc_client)
@@ -282,12 +305,12 @@ async def create_tx_outputs(wallet: Wallet, output_args: list[tuple[int, Optiona
 
 async def assert_wallet_types(client: WalletRpcClient, expected: dict[WalletType, int]) -> None:
     for wallet_type in WalletType:
-        wallets = await client.get_wallets(wallet_type)
+        wallets = (await client.get_wallets(GetWallets(uint16(wallet_type.value)))).wallets
         wallet_count = len(wallets)
         if wallet_type in expected:
             assert wallet_count == expected.get(wallet_type, 0)
             for wallet in wallets:
-                assert wallet["type"] == wallet_type.value
+                assert wallet.type == wallet_type.value
 
 
 def assert_tx_amounts(
@@ -327,30 +350,35 @@ async def assert_push_tx_error(node_rpc: FullNodeRpcClient, tx: TransactionRecor
 async def assert_get_balance(rpc_client: WalletRpcClient, wallet_node: WalletNode, wallet: WalletProtocol[Any]) -> None:
     expected_balance = await wallet_node.get_balance(wallet.id())
     expected_balance_dict = expected_balance.to_json_dict()
+    expected_balance_dict.setdefault("pending_approval_balance", None)
     expected_balance_dict["wallet_id"] = wallet.id()
     expected_balance_dict["wallet_type"] = wallet.type()
     expected_balance_dict["fingerprint"] = wallet_node.logged_in_fingerprint
     if wallet.type() in {WalletType.CAT, WalletType.CRCAT}:
         assert isinstance(wallet, CATWallet)
-        expected_balance_dict["asset_id"] = wallet.get_asset_id()
-    assert await rpc_client.get_wallet_balance(wallet.id()) == expected_balance_dict
+        expected_balance_dict["asset_id"] = "0x" + wallet.get_asset_id()
+    else:
+        expected_balance_dict["asset_id"] = None
+    assert (
+        await rpc_client.get_wallet_balance(GetWalletBalance(wallet.id()))
+    ).wallet_balance.to_json_dict() == expected_balance_dict
 
 
 async def tx_in_mempool(client: WalletRpcClient, transaction_id: bytes32) -> bool:
-    tx = await client.get_transaction(transaction_id)
+    tx = (await client.get_transaction(GetTransaction(transaction_id))).transaction
     return tx.is_in_mempool()
 
 
 async def get_confirmed_balance(client: WalletRpcClient, wallet_id: int) -> uint128:
-    balance = await client.get_wallet_balance(wallet_id)
-    # TODO: casting due to lack of type checked deserialization
-    return cast(uint128, balance["confirmed_wallet_balance"])
+    return (
+        await client.get_wallet_balance(GetWalletBalance(uint32(wallet_id)))
+    ).wallet_balance.confirmed_wallet_balance
 
 
 async def get_unconfirmed_balance(client: WalletRpcClient, wallet_id: int) -> uint128:
-    balance = await client.get_wallet_balance(wallet_id)
-    # TODO: casting due to lack of type checked deserialization
-    return cast(uint128, balance["unconfirmed_wallet_balance"])
+    return (
+        await client.get_wallet_balance(GetWalletBalance(uint32(wallet_id)))
+    ).wallet_balance.unconfirmed_wallet_balance
 
 
 @pytest.mark.anyio
@@ -368,24 +396,25 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
         addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
     tx_amount = uint64(15600000)
     with pytest.raises(ValueError):
-        await client.send_transaction(1, uint64(100000000000000001), addr, DEFAULT_TX_CONFIG)
+        await client.send_transaction(
+            SendTransaction(wallet_id=uint32(1), amount=uint64(100000000000000001), address=addr, push=True),
+            DEFAULT_TX_CONFIG,
+        )
 
     # Tests sending a basic transaction
     extra_conditions = (Remark(Program.to(("test", None))),)
     non_existent_coin = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
     tx_no_push = (
         await client.send_transaction(
-            1,
-            tx_amount,
-            addr,
-            memos=["this is a basic tx"],
+            SendTransaction(
+                wallet_id=uint32(1), amount=tx_amount, address=addr, memos=["this is a basic tx"], push=False
+            ),
             tx_config=DEFAULT_TX_CONFIG.override(
                 excluded_coin_amounts=[uint64(250000000000)],
                 excluded_coin_ids=[non_existent_coin.name()],
                 reuse_puzhash=True,
             ),
             extra_conditions=extra_conditions,
-            push=False,
         )
     ).transaction
     response = await client.fetch(
@@ -407,7 +436,7 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
         },
     )
     assert response["success"]
-    tx = TransactionRecord.from_json_dict_convenience(response["transactions"][0])
+    tx = TransactionRecord.from_json_dict(response["transactions"][0])
     [
         byte_deserialize_clvm_streamable(
             bytes.fromhex(utx), UnsignedTransaction, translation_layer=BLIND_SIGNER_TRANSLATION
@@ -425,11 +454,11 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
     await farm_transaction(full_node_api, wallet_node, spend_bundle)
 
     # Checks that the memo can be retrieved
-    tx_confirmed = await client.get_transaction(transaction_id)
+    tx_confirmed = (await client.get_transaction(GetTransaction(transaction_id))).transaction
     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 next(iter(tx_confirmed.get_memos().keys())) in [a.name() for a in spend_bundle.additions()]
+    assert len(tx_confirmed.memos) == 1
+    assert [b"this is a basic tx"] in tx_confirmed.memos.values()
+    assert next(iter(tx_confirmed.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)
 
@@ -459,9 +488,7 @@ async def test_push_transactions(wallet_rpc_environment: WalletRpcTestEnvironmen
         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}
-    )
+    resp = await client.fetch("push_transactions", {"transactions": [tx.to_json_dict()], "fee": 10})
     assert resp["success"]
     resp = await client.fetch("push_transactions", {"transactions": [bytes(tx).hex()], "fee": 10})
     assert resp["success"]
@@ -473,7 +500,7 @@ async def test_push_transactions(wallet_rpc_environment: WalletRpcTestEnvironmen
     await farm_transaction(full_node_api, wallet_node, spend_bundle)
 
     for tx in resp_client.transactions:
-        assert (await client.get_transaction(transaction_id=tx.name)).confirmed
+        assert (await client.get_transaction(GetTransaction(transaction_id=tx.name))).transaction.confirmed
 
     # Just testing NOT failure here really (parsing)
     await client.push_tx(PushTX(spend_bundle))
@@ -629,25 +656,28 @@ async def test_create_signed_transaction(
 
     selected_coin = None
     if select_coin:
-        selected_coin = await wallet_1_rpc.select_coins(
-            amount=amount_total, wallet_id=wallet_id, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+        select_coins_response = await wallet_1_rpc.select_coins(
+            SelectCoins.from_coin_selection_config(
+                amount=amount_total, wallet_id=uint32(wallet_id), coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+            )
         )
-        assert len(selected_coin) == 1
+        assert len(select_coins_response.coins) == 1
+        selected_coin = select_coins_response.coins[0]
 
     txs = (
         await wallet_1_rpc.create_signed_transactions(
             outputs,
-            coins=selected_coin,
+            coins=[selected_coin] if selected_coin is not None else [],
             fee=amount_fee,
             wallet_id=wallet_id,
             # shouldn't actually block it
             tx_config=DEFAULT_TX_CONFIG.override(
-                excluded_coin_amounts=[uint64(selected_coin[0].amount)] if selected_coin is not None else [],
+                excluded_coin_amounts=[uint64(selected_coin.amount)] if selected_coin is not None else [],
             ),
             push=True,
         )
     ).transactions
-    change_expected = not selected_coin or selected_coin[0].amount - amount_total > 0
+    change_expected = not selected_coin or selected_coin.amount - amount_total > 0
     assert_tx_amounts(txs[-1], outputs, amount_fee=amount_fee, change_expected=change_expected, is_cat=is_cat)
 
     # Farm the transaction and make sure the wallet balance reflects it correct
@@ -768,38 +798,42 @@ async def test_create_signed_transaction_with_excluded_coins(wallet_rpc_environm
     await generate_funds(full_node_api, env.wallet_1)
 
     async def it_does_not_include_the_excluded_coins() -> None:
-        selected_coins = await wallet_1_rpc.select_coins(
-            amount=250000000000, wallet_id=1, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+        select_coins_response = await wallet_1_rpc.select_coins(
+            SelectCoins.from_coin_selection_config(
+                amount=uint64(250000000000), wallet_id=uint32(1), coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+            )
         )
-        assert len(selected_coins) == 1
+        assert len(select_coins_response.coins) == 1
         outputs = await create_tx_outputs(wallet_1, [(uint64(250000000000), None)])
 
         tx = (
             await wallet_1_rpc.create_signed_transactions(
                 outputs,
                 DEFAULT_TX_CONFIG.override(
-                    excluded_coin_ids=[c.name() for c in selected_coins],
+                    excluded_coin_ids=[c.name() for c in select_coins_response.coins],
                 ),
             )
         ).signed_tx
 
         assert len(tx.removals) == 1
-        assert tx.removals[0] != selected_coins[0]
+        assert tx.removals[0] != select_coins_response.coins[0]
         assert tx.removals[0].amount == uint64(1750000000000)
         await assert_push_tx_error(full_node_rpc, tx)
 
     async def it_throws_an_error_when_all_spendable_coins_are_excluded() -> None:
-        selected_coins = await wallet_1_rpc.select_coins(
-            amount=1750000000000, wallet_id=1, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+        select_coins_response = await wallet_1_rpc.select_coins(
+            SelectCoins.from_coin_selection_config(
+                amount=uint64(1750000000000), wallet_id=uint32(1), coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+            )
         )
-        assert len(selected_coins) == 1
+        assert len(select_coins_response.coins) == 1
         outputs = await create_tx_outputs(wallet_1, [(uint64(1750000000000), None)])
 
         with pytest.raises(ValueError):
             await wallet_1_rpc.create_signed_transactions(
                 outputs,
                 DEFAULT_TX_CONFIG.override(
-                    excluded_coin_ids=[c.name() for c in selected_coins],
+                    excluded_coin_ids=[c.name() for c in select_coins_response.coins],
                 ),
             )
 
@@ -818,7 +852,6 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
     wallet_1 = wallet_1_node.wallet_state_manager.main_wallet
     wallet_2 = wallet_2_node.wallet_state_manager.main_wallet
     full_node_api: FullNodeSimulator = env.full_node.api
-    wallet_2_api = WalletRpcApi(wallet_2_node)
 
     generated_funds = await generate_funds(full_node_api, env.wallet_1, 1)
     await generate_funds(full_node_api, env.wallet_2, 1)
@@ -829,12 +862,14 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
         wallet_2_puzhash = await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)
     tx = (
         await wallet_1_rpc.send_transaction(
-            wallet_id=1,
-            amount=uint64(500),
-            address=encode_puzzle_hash(wallet_2_puzhash, "txch"),
+            SendTransaction(
+                wallet_id=uint32(1),
+                amount=uint64(500),
+                address=encode_puzzle_hash(wallet_2_puzhash, "txch"),
+                puzzle_decorator=[ClawbackPuzzleDecoratorOverride(decorator="CLAWBACK", clawback_timelock=uint64(5))],
+                push=True,
+            ),
             tx_config=DEFAULT_TX_CONFIG,
-            fee=uint64(0),
-            puzzle_decorator_override=[{"decorator": "CLAWBACK", "clawback_timelock": 5}],
         )
     ).transaction
     clawback_coin_id_1 = tx.additions[0].name()
@@ -843,12 +878,14 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_2_node, timeout=20)
     tx = (
         await wallet_2_rpc.send_transaction(
-            wallet_id=1,
-            amount=uint64(500),
-            address=encode_puzzle_hash(wallet_1_puzhash, "txch"),
+            SendTransaction(
+                wallet_id=uint32(1),
+                amount=uint64(500),
+                address=encode_puzzle_hash(wallet_1_puzhash, "txch"),
+                puzzle_decorator=[ClawbackPuzzleDecoratorOverride(decorator="CLAWBACK", clawback_timelock=uint64(5))],
+                push=True,
+            ),
             tx_config=DEFAULT_TX_CONFIG,
-            fee=uint64(0),
-            puzzle_decorator_override=[{"decorator": "CLAWBACK", "clawback_timelock": 5}],
         )
     ).transaction
     assert tx.spend_bundle is not None
@@ -857,32 +894,28 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
     await time_out_assert(20, get_confirmed_balance, generated_funds - 500, wallet_1_rpc, 1)
     await time_out_assert(20, get_confirmed_balance, generated_funds - 500, wallet_2_rpc, 1)
     await asyncio.sleep(10)
-    # Test missing coin_ids
-    has_exception = False
-    try:
-        await wallet_2_api.spend_clawback_coins({})
-    except ValueError:
-        has_exception = True
-    assert has_exception
     # Test coin ID is not a Clawback coin
     invalid_coin_id = tx.removals[0].name()
-    resp = await wallet_2_rpc.spend_clawback_coins([invalid_coin_id], 500)
-    assert resp["success"]
-    assert resp["transaction_ids"] == []
+    resp = await wallet_2_rpc.spend_clawback_coins(
+        SpendClawbackCoins(coin_ids=[invalid_coin_id], fee=uint64(500), push=True), tx_config=DEFAULT_TX_CONFIG
+    )
+    assert resp.transaction_ids == []
     # Test unsupported wallet
     coin_record = await wallet_1_node.wallet_state_manager.coin_store.get_coin_record(clawback_coin_id_1)
     assert coin_record is not None
     await wallet_1_node.wallet_state_manager.coin_store.add_coin_record(
         dataclasses.replace(coin_record, wallet_type=WalletType.CAT)
     )
-    resp = await wallet_1_rpc.spend_clawback_coins([clawback_coin_id_1], 100)
-    assert resp["success"]
-    assert len(resp["transaction_ids"]) == 0
+    resp = await wallet_1_rpc.spend_clawback_coins(
+        SpendClawbackCoins(coin_ids=[clawback_coin_id_1], fee=uint64(100), push=True), tx_config=DEFAULT_TX_CONFIG
+    )
+    assert len(resp.transaction_ids) == 0
     # Test missing metadata
     await wallet_1_node.wallet_state_manager.coin_store.add_coin_record(dataclasses.replace(coin_record, metadata=None))
-    resp = await wallet_1_rpc.spend_clawback_coins([clawback_coin_id_1], 100)
-    assert resp["success"]
-    assert len(resp["transaction_ids"]) == 0
+    resp = await wallet_1_rpc.spend_clawback_coins(
+        SpendClawbackCoins(coin_ids=[clawback_coin_id_1], fee=uint64(100), push=True), tx_config=DEFAULT_TX_CONFIG
+    )
+    assert len(resp.transaction_ids) == 0
     # Test missing incoming tx
     coin_record = await wallet_1_node.wallet_state_manager.coin_store.get_coin_record(clawback_coin_id_2)
     assert coin_record is not None
@@ -890,8 +923,10 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
     await wallet_1_node.wallet_state_manager.coin_store.add_coin_record(
         dataclasses.replace(coin_record, coin=fake_coin)
     )
-    resp = await wallet_1_rpc.spend_clawback_coins([fake_coin.name()], 100)
-    assert resp["transaction_ids"] == []
+    resp = await wallet_1_rpc.spend_clawback_coins(
+        SpendClawbackCoins(coin_ids=[fake_coin.name()], fee=uint64(100), push=True), tx_config=DEFAULT_TX_CONFIG
+    )
+    assert resp.transaction_ids == []
     # Test coin puzzle hash doesn't match the puzzle
     farmed_tx = (await wallet_1.wallet_state_manager.tx_store.get_farming_rewards())[0]
     await wallet_1.wallet_state_manager.tx_store.add_transaction_record(
@@ -900,8 +935,10 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
     await wallet_1_node.wallet_state_manager.coin_store.add_coin_record(
         dataclasses.replace(coin_record, coin=fake_coin)
     )
-    resp = await wallet_1_rpc.spend_clawback_coins([fake_coin.name()], 100)
-    assert resp["transaction_ids"] == []
+    resp = await wallet_1_rpc.spend_clawback_coins(
+        SpendClawbackCoins(coin_ids=[fake_coin.name()], fee=uint64(100), push=True), tx_config=DEFAULT_TX_CONFIG
+    )
+    assert resp.transaction_ids == []
     # Test claim spend
     await wallet_2_rpc.set_auto_claim(
         AutoClaimSettings(
@@ -911,11 +948,12 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
             batch_size=uint16(1),
         )
     )
-    resp = await wallet_2_rpc.spend_clawback_coins([clawback_coin_id_1, clawback_coin_id_2], 100)
-    assert resp["success"]
-    assert len(resp["transaction_ids"]) == 2
-    for _tx in resp["transactions"]:
-        clawback_tx = TransactionRecord.from_json_dict_convenience(_tx)
+    resp = await wallet_2_rpc.spend_clawback_coins(
+        SpendClawbackCoins(coin_ids=[clawback_coin_id_1, clawback_coin_id_2], fee=uint64(100), push=True),
+        tx_config=DEFAULT_TX_CONFIG,
+    )
+    assert len(resp.transaction_ids) == 2
+    for clawback_tx in resp.transactions:
         if clawback_tx.spend_bundle is not None:
             await time_out_assert_not_none(
                 10, full_node_api.full_node.mempool_manager.get_spendbundle, clawback_tx.spend_bundle.name()
@@ -923,9 +961,10 @@ async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnviron
     await farm_transaction_block(full_node_api, wallet_2_node)
     await time_out_assert(20, get_confirmed_balance, generated_funds + 300, wallet_2_rpc, 1)
     # Test spent coin
-    resp = await wallet_2_rpc.spend_clawback_coins([clawback_coin_id_1], 500)
-    assert resp["success"]
-    assert resp["transaction_ids"] == []
+    resp = await wallet_2_rpc.spend_clawback_coins(
+        SpendClawbackCoins(coin_ids=[clawback_coin_id_1], fee=uint64(500), push=True), tx_config=DEFAULT_TX_CONFIG
+    )
+    assert resp.transaction_ids == []
 
 
 @pytest.mark.anyio
@@ -939,8 +978,10 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
 
     generated_funds = await generate_funds(full_node_api, env.wallet_1)
 
-    removals = await client.select_coins(
-        1750000000000, wallet_id=1, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+    select_coins_response = await client.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(1750000000000), wallet_id=uint32(1), coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+        )
     )  # we want a coin that won't be selected by default
     outputs = await create_tx_outputs(wallet_2, [(uint64(1), ["memo_1"]), (uint64(2), ["memo_2"])])
     amount_outputs = sum(output["amount"] for output in outputs)
@@ -951,7 +992,7 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
             1,
             outputs,
             DEFAULT_TX_CONFIG,
-            coins=removals,
+            coins=select_coins_response.coins,
             fee=amount_fee,
         )
     ).transaction
@@ -960,16 +1001,16 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
     assert send_tx_res is not None
 
     assert_tx_amounts(send_tx_res, outputs, amount_fee=amount_fee, change_expected=True)
-    assert send_tx_res.removals == removals
+    assert send_tx_res.removals == select_coins_response.coins
 
     await farm_transaction(full_node_api, wallet_node, spend_bundle)
 
     await time_out_assert(20, get_confirmed_balance, generated_funds - amount_outputs - amount_fee, client, 1)
 
     # Checks that the memo can be retrieved
-    tx_confirmed = await client.get_transaction(send_tx_res.name)
+    tx_confirmed = (await client.get_transaction(GetTransaction(send_tx_res.name))).transaction
     assert tx_confirmed.confirmed
-    memos = tx_confirmed.get_memos()
+    memos = tx_confirmed.memos
     assert len(memos) == len(outputs)
     for output in outputs:
         assert [output["memos"][0].encode()] in memos.values()
@@ -990,18 +1031,20 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
 
     await generate_funds(full_node_api, env.wallet_1, 5)
 
-    all_transactions = await client.get_transactions(1)
+    all_transactions = (await client.get_transactions(GetTransactions(uint32(1)))).transactions
     assert len(all_transactions) >= 10
     # Test transaction pagination
-    some_transactions = await client.get_transactions(1, 0, 5)
-    some_transactions_2 = await client.get_transactions(1, 5, 10)
+    some_transactions = (await client.get_transactions(GetTransactions(uint32(1), uint16(0), uint16(5)))).transactions
+    some_transactions_2 = (
+        await client.get_transactions(GetTransactions(uint32(1), uint16(5), uint16(10)))
+    ).transactions
     assert some_transactions == all_transactions[0:5]
     assert some_transactions_2 == all_transactions[5:10]
 
     # Testing sorts
     # Test the default sort (CONFIRMED_AT_HEIGHT)
     assert all_transactions == sorted(all_transactions, key=attrgetter("confirmed_at_height"))
-    all_transactions = await client.get_transactions(1, reverse=True)
+    all_transactions = (await client.get_transactions(GetTransactions(uint32(1), reverse=True))).transactions
     assert all_transactions == sorted(all_transactions, key=attrgetter("confirmed_at_height"), reverse=True)
 
     # Test RELEVANCE
@@ -1009,16 +1052,24 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
         puzhash = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
     await client.send_transaction(
-        1, uint64(1), encode_puzzle_hash(puzhash, "txch"), DEFAULT_TX_CONFIG
+        SendTransaction(wallet_id=uint32(1), amount=uint64(1), address=encode_puzzle_hash(puzhash, "txch"), push=True),
+        DEFAULT_TX_CONFIG,
     )  # Create a pending tx
 
-    all_transactions = await client.get_transactions(1, sort_key=SortKey.RELEVANCE)
+    with pytest.raises(ValueError, match="There is no known sort foo"):
+        await client.get_transactions(GetTransactions(uint32(1), sort_key="foo"))
+
+    all_transactions = (
+        await client.get_transactions(GetTransactions(uint32(1), sort_key=SortKey.RELEVANCE.name))
+    ).transactions
     sorted_transactions = sorted(all_transactions, key=attrgetter("created_at_time"), reverse=True)
     sorted_transactions = sorted(sorted_transactions, key=attrgetter("confirmed_at_height"), reverse=True)
     sorted_transactions = sorted(sorted_transactions, key=attrgetter("confirmed"))
     assert all_transactions == sorted_transactions
 
-    all_transactions = await client.get_transactions(1, sort_key=SortKey.RELEVANCE, reverse=True)
+    all_transactions = (
+        await client.get_transactions(GetTransactions(uint32(1), sort_key=SortKey.RELEVANCE.name, reverse=True))
+    ).transactions
     sorted_transactions = sorted(all_transactions, key=attrgetter("created_at_time"))
     sorted_transactions = sorted(sorted_transactions, key=attrgetter("confirmed_at_height"))
     sorted_transactions = sorted(sorted_transactions, key=attrgetter("confirmed"), reverse=True)
@@ -1028,23 +1079,32 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         ph_by_addr = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-    await client.send_transaction(1, uint64(1), encode_puzzle_hash(ph_by_addr, "txch"), DEFAULT_TX_CONFIG)
+    await client.send_transaction(
+        SendTransaction(
+            wallet_id=uint32(1), amount=uint64(1), address=encode_puzzle_hash(ph_by_addr, "txch"), push=True
+        ),
+        DEFAULT_TX_CONFIG,
+    )
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-    tx_for_address = await client.get_transactions(1, to_address=encode_puzzle_hash(ph_by_addr, "txch"))
+    tx_for_address = (
+        await client.get_transactions(GetTransactions(uint32(1), to_address=encode_puzzle_hash(ph_by_addr, "txch")))
+    ).transactions
     assert len(tx_for_address) == 1
     assert tx_for_address[0].to_puzzle_hash == ph_by_addr
 
     # Test type filter
-    all_transactions = await client.get_transactions(
-        1, type_filter=TransactionTypeFilter.include([TransactionType.COINBASE_REWARD])
-    )
+    all_transactions = (
+        await client.get_transactions(
+            GetTransactions(uint32(1), type_filter=TransactionTypeFilter.include([TransactionType.COINBASE_REWARD]))
+        )
+    ).transactions
     assert len(all_transactions) == 5
     assert all(transaction.type == TransactionType.COINBASE_REWARD.value for transaction in all_transactions)
     # Test confirmed filter
-    all_transactions = await client.get_transactions(1, confirmed=True)
+    all_transactions = (await client.get_transactions(GetTransactions(uint32(1), confirmed=True))).transactions
     assert len(all_transactions) == 10
     assert all(transaction.confirmed for transaction in all_transactions)
-    all_transactions = await client.get_transactions(1, confirmed=False)
+    all_transactions = (await client.get_transactions(GetTransactions(uint32(1), confirmed=False))).transactions
     assert len(all_transactions) == 2
     assert all(not transaction.confirmed for transaction in all_transactions)
 
@@ -1052,9 +1112,15 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
     await wallet.wallet_state_manager.tx_store.add_transaction_record(
         dataclasses.replace(all_transactions[0], type=uint32(TransactionType.INCOMING_CLAWBACK_SEND))
     )
-    all_transactions = await client.get_transactions(
-        1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_SEND]), confirmed=False
-    )
+    all_transactions = (
+        await client.get_transactions(
+            GetTransactions(
+                uint32(1),
+                type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_SEND]),
+                confirmed=False,
+            )
+        )
+    ).transactions
     assert len(all_transactions) == 1
 
 
@@ -1067,16 +1133,18 @@ async def test_get_transaction_count(wallet_rpc_environment: WalletRpcTestEnviro
 
     await generate_funds(full_node_api, env.wallet_1)
 
-    all_transactions = await client.get_transactions(1)
+    all_transactions = (await client.get_transactions(GetTransactions(uint32(1)))).transactions
     assert len(all_transactions) > 0
-    transaction_count = await client.get_transaction_count(1)
-    assert transaction_count == len(all_transactions)
-    transaction_count = await client.get_transaction_count(1, confirmed=False)
-    assert transaction_count == 0
-    transaction_count = await client.get_transaction_count(
-        1, type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_SEND])
+    transaction_count_response = await client.get_transaction_count(GetTransactionCount(uint32(1)))
+    assert transaction_count_response.count == len(all_transactions)
+    transaction_count_response = await client.get_transaction_count(GetTransactionCount(uint32(1), confirmed=False))
+    assert transaction_count_response.count == 0
+    transaction_count_response = await client.get_transaction_count(
+        GetTransactionCount(
+            uint32(1), type_filter=TransactionTypeFilter.include([TransactionType.INCOMING_CLAWBACK_SEND])
+        )
     )
-    assert transaction_count == 0
+    assert transaction_count_response.count == 0
 
 
 @pytest.mark.parametrize(
@@ -1134,33 +1202,31 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
         "cat1",
     )
 
-    cat_0_id = env_0.wallet_aliases["cat0"]
+    cat_0_id = uint32(env_0.wallet_aliases["cat0"])
     # The RPC response contains more than just the balance info but all the
     # balance info should match. We're leveraging the `<=` operator to check
     # for subset on `dict` `.items()`.
     assert (
         env_0.wallet_states[uint32(env_0.wallet_aliases["cat0"])].balance.to_json_dict().items()
-        <= (await env_0.rpc_client.get_wallet_balance(cat_0_id)).items()
-    )
-    asset_id = await env_0.rpc_client.get_cat_asset_id(cat_0_id)
-    assert (await env_0.rpc_client.get_cat_name(cat_0_id)) == wallet_type.default_wallet_name_for_unknown_cat(
-        asset_id.hex()
-    )
-    await env_0.rpc_client.set_cat_name(cat_0_id, "My cat")
-    assert (await env_0.rpc_client.get_cat_name(cat_0_id)) == "My cat"
-    result = await env_0.rpc_client.cat_asset_id_to_name(asset_id)
-    assert result is not None
-    wid, name = result
-    assert wid == cat_0_id
-    assert name == "My cat"
-    result = await env_0.rpc_client.cat_asset_id_to_name(bytes32.zeros)
-    assert result is None
+        <= (await env_0.rpc_client.get_wallet_balance(GetWalletBalance(cat_0_id))).wallet_balance.to_json_dict().items()
+    )
+    asset_id = (await env_0.rpc_client.get_cat_asset_id(CATGetAssetID(cat_0_id))).asset_id
+    assert (
+        await env_0.rpc_client.get_cat_name(CATGetName(cat_0_id))
+    ).name == wallet_type.default_wallet_name_for_unknown_cat(asset_id.hex())
+    await env_0.rpc_client.set_cat_name(CATSetName(cat_0_id, "My cat"))
+    assert (await env_0.rpc_client.get_cat_name(CATGetName(cat_0_id))).name == "My cat"
+    asset_to_name_response = await env_0.rpc_client.cat_asset_id_to_name(CATAssetIDToName(asset_id))
+    assert asset_to_name_response.wallet_id == cat_0_id
+    assert asset_to_name_response.name == "My cat"
+    asset_to_name_response = await env_0.rpc_client.cat_asset_id_to_name(CATAssetIDToName(bytes32.zeros))
+    assert asset_to_name_response.name is None
     verified_asset_id = next(iter(DEFAULT_CATS.items()))[1]["asset_id"]
-    result = await env_0.rpc_client.cat_asset_id_to_name(bytes32.from_hexstr(verified_asset_id))
-    assert result is not None
-    should_be_none, name = result
-    assert should_be_none is None
-    assert name == next(iter(DEFAULT_CATS.items()))[1]["name"]
+    asset_to_name_response = await env_0.rpc_client.cat_asset_id_to_name(
+        CATAssetIDToName(bytes32.from_hexstr(verified_asset_id))
+    )
+    assert asset_to_name_response.wallet_id is None
+    assert asset_to_name_response.name == next(iter(DEFAULT_CATS.items()))[1]["name"]
 
     # Creates a second wallet with the same CAT
     res = await env_1.rpc_client.create_wallet_for_existing_cat(asset_id)
@@ -1183,26 +1249,77 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
         ]
     )
 
-    addr_0 = await env_0.rpc_client.get_next_address(cat_0_id, False)
-    addr_1 = await env_1.rpc_client.get_next_address(cat_1_id, False)
+    addr_0 = (await env_0.rpc_client.get_next_address(GetNextAddress(cat_0_id, False))).address
+    addr_1 = (await env_1.rpc_client.get_next_address(GetNextAddress(cat_1_id, False))).address
 
     assert addr_0 != addr_1
 
     # Test CAT spend without a fee
     with pytest.raises(ValueError):
         await env_0.rpc_client.cat_spend(
-            cat_0_id,
-            DEFAULT_TX_CONFIG.override(
+            CATSpend(
+                wallet_id=cat_0_id,
+                amount=uint64(4),
+                inner_address=addr_1,
+                fee=uint64(0),
+                memos=["the cat memo"],
+                push=False,
+            ),
+            tx_config=wallet_environments.tx_config.override(
                 excluded_coin_amounts=[uint64(100)],
                 excluded_coin_ids=[bytes32.zeros],
             ),
-            uint64(4),
-            addr_1,
-            uint64(0),
-            ["the cat memo"],
         )
+
+    # Test some validation errors
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Must specify "additions" or "amount"+"inner_address"+"memos", but not both.'),
+    ):
+        await env_0.rpc_client.cat_spend(
+            CATSpend(
+                wallet_id=cat_0_id,
+                amount=uint64(4),
+                inner_address=addr_1,
+                memos=["the cat memo"],
+                additions=[],
+            ),
+            tx_config=wallet_environments.tx_config,
+        )
+
+    with pytest.raises(ValueError, match=re.escape('Must specify "amount" and "inner_address" together.')):
+        await env_0.rpc_client.cat_spend(
+            CATSpend(
+                wallet_id=cat_0_id,
+                amount=uint64(4),
+                inner_address=None,
+            ),
+            tx_config=wallet_environments.tx_config,
+        )
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Must specify \\"extra_delta\\", \\"tail_reveal\\" and \\"tail_solution\\" together.'),
+    ):
+        await env_0.rpc_client.cat_spend(
+            CATSpend(
+                wallet_id=cat_0_id,
+                additions=[],
+                extra_delta="1",
+            ),
+            tx_config=wallet_environments.tx_config,
+        )
+
     tx_res = await env_0.rpc_client.cat_spend(
-        cat_0_id, wallet_environments.tx_config, uint64(4), addr_1, uint64(0), ["the cat memo"]
+        CATSpend(
+            wallet_id=cat_0_id,
+            amount=uint64(4),
+            inner_address=addr_1,
+            fee=uint64(0),
+            memos=["the cat memo"],
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
     )
 
     spend_bundle = tx_res.transaction.spend_bundle
@@ -1248,7 +1365,15 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
 
     # Test CAT spend with a fee
     tx_res = await env_0.rpc_client.cat_spend(
-        cat_0_id, wallet_environments.tx_config, uint64(1), addr_1, uint64(5_000_000), ["the cat memo"]
+        CATSpend(
+            wallet_id=cat_0_id,
+            amount=uint64(1),
+            inner_address=addr_1,
+            fee=uint64(5_000_000),
+            memos=["the cat memo"],
+            push=True,
+        ),
+        wallet_environments.tx_config,
     )
 
     spend_bundle = tx_res.transaction.spend_bundle
@@ -1307,22 +1432,29 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     await wallet_environments.process_pending_states(cat_spend_changes)
 
     # Test CAT spend with a fee and pre-specified removals / coins
-    removals = await env_0.rpc_client.select_coins(
-        amount=uint64(2), wallet_id=cat_0_id, coin_selection_config=wallet_environments.tx_config.coin_selection_config
+    select_coins_response = await env_0.rpc_client.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(2),
+            wallet_id=cat_0_id,
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config,
+        )
     )
     tx_res = await env_0.rpc_client.cat_spend(
-        cat_0_id,
+        CATSpend(
+            wallet_id=cat_0_id,
+            amount=uint64(1),
+            inner_address=addr_1,
+            fee=uint64(5_000_000),
+            memos=["the cat memo"],
+            coins=select_coins_response.coins,
+            push=True,
+        ),
         wallet_environments.tx_config,
-        uint64(1),
-        addr_1,
-        uint64(5_000_000),
-        ["the cat memo"],
-        removals=removals,
     )
 
     spend_bundle = tx_res.transaction.spend_bundle
     assert spend_bundle is not None
-    assert removals[0] in {removal for tx in tx_res.transactions for removal in tx.removals}
+    assert select_coins_response.coins[0] in {removal for tx in tx_res.transactions for removal in tx.removals}
 
     await wallet_environments.process_pending_states(cat_spend_changes)
 
@@ -1330,14 +1462,18 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     await env_0.wallet_state_manager.interested_store.add_unacknowledged_token(
         asset_id, "Unknown", uint32(10000), bytes32(b"\00" * 32)
     )
-    cats = await env_0.rpc_client.get_stray_cats()
-    assert len(cats) == 1
+    stray_cats_response = await env_0.rpc_client.get_stray_cats()
+    assert len(stray_cats_response.stray_cats) == 1
 
     # Test CAT coin selection
-    selected_coins = await env_0.rpc_client.select_coins(
-        amount=1, wallet_id=cat_0_id, coin_selection_config=wallet_environments.tx_config.coin_selection_config
+    select_coins_response = await env_0.rpc_client.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(1),
+            wallet_id=cat_0_id,
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config,
+        )
     )
-    assert len(selected_coins) > 0
+    assert len(select_coins_response.coins) > 0
 
     # Test get_cat_list
     cat_list = (await env_0.rpc_client.get_cat_list()).cat_list
@@ -1349,69 +1485,135 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     assert default_cats_set == set(cat_list)
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 2,
+            "blocks_needed": [1, 1],
+        }
+    ],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
+@pytest.mark.parametrize("wallet_type", [CATWallet, RCATWallet])
 @pytest.mark.anyio
-async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet_node: WalletNode = env.wallet_1.node
-    wallet_1_rpc: WalletRpcClient = env.wallet_1.rpc_client
-    wallet_2_rpc: WalletRpcClient = env.wallet_2.rpc_client
-    full_node_api: FullNodeSimulator = env.full_node.api
+async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_type: type[CATWallet]) -> None:
+    env_1 = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
 
-    await generate_funds(full_node_api, env.wallet_1, 1)
-    await generate_funds(full_node_api, env.wallet_2, 1)
+    env_1.wallet_aliases = {
+        "xch": 1,
+        "cat": 2,
+    }
+    env_2.wallet_aliases = {
+        "xch": 1,
+        "cat": 2,
+    }
 
     # Creates a CAT wallet with 20 mojos
-    res = await wallet_1_rpc.create_new_cat_and_wallet(uint64(20), test=True)
-    assert res["success"]
-    cat_wallet_id = res["wallet_id"]
-    cat_asset_id = bytes32.fromhex(res["asset_id"])
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-    await farm_transaction_block(full_node_api, wallet_node)
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=5)
-
-    await time_out_assert(5, get_confirmed_balance, 20, wallet_1_rpc, cat_wallet_id)
+    cat_wallet = await mint_cat(
+        wallet_environments,
+        env_1,
+        "xch",
+        "cat",
+        uint64(20),
+        wallet_type,
+        "cat",
+    )
+    cat_wallet_id = cat_wallet.id()
+    cat_asset_id = cat_wallet.cat_info.limitations_program_hash
 
     # Creates a wallet for the same CAT on wallet_2 and send 4 CAT from wallet_1 to it
-    await wallet_2_rpc.create_wallet_for_existing_cat(cat_asset_id)
-    wallet_2_address = await wallet_2_rpc.get_next_address(cat_wallet_id, False)
+    await env_2.rpc_client.create_wallet_for_existing_cat(cat_asset_id)
+    wallet_2_address = (await env_2.rpc_client.get_next_address(GetNextAddress(cat_wallet_id, False))).address
     adds = [{"puzzle_hash": decode_puzzle_hash(wallet_2_address), "amount": uint64(4), "memos": ["the cat memo"]}]
     tx_res = (
-        await wallet_1_rpc.send_transaction_multi(
-            cat_wallet_id, additions=adds, tx_config=DEFAULT_TX_CONFIG, fee=uint64(0)
+        await env_1.rpc_client.send_transaction_multi(
+            cat_wallet_id, additions=adds, tx_config=wallet_environments.tx_config, fee=uint64(0)
         )
     ).transaction
     spend_bundle = tx_res.spend_bundle
     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(
-        [a.name() for a in spend_bundle.additions() if a.amount != 4]
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "cat": {
+                        "unconfirmed_wallet_balance": -4,
+                        "spendable_balance": -20,
+                        "max_send_amount": -20,
+                        "pending_change": 16,
+                        "pending_coin_removal_count": 1,
+                    }
+                },
+                post_block_balance_updates={
+                    "cat": {
+                        "confirmed_wallet_balance": -4,
+                        "spendable_balance": 16,
+                        "max_send_amount": 16,
+                        "pending_change": -16,
+                        "pending_coin_removal_count": -1,
+                    }
+                },
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={"cat": {"init": True}},
+                post_block_balance_updates={
+                    "cat": {
+                        "confirmed_wallet_balance": 4,
+                        "unconfirmed_wallet_balance": 4,
+                        "spendable_balance": 4,
+                        "max_send_amount": 4,
+                        "unspent_coin_count": 1,
+                    }
+                },
+            ),
+        ]
     )
+
+    test_crs: list[CoinRecord] = (
+        await env_1.rpc_client.get_coin_records_by_names(
+            GetCoinRecordsByNames([a.name() for a in spend_bundle.additions() if a.amount != 4])
+        )
+    ).coin_records
     for cr in test_crs:
         assert cr.coin in spend_bundle.additions()
     with pytest.raises(ValueError):
-        await wallet_1_rpc.get_coin_records_by_names([a.name() for a in spend_bundle.additions() if a.amount == 4])
+        await env_1.rpc_client.get_coin_records_by_names(
+            GetCoinRecordsByNames([a.name() for a in spend_bundle.additions() if a.amount == 4])
+        )
     # Create an offer of 5 chia for one CAT
-    await wallet_1_rpc.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1}, DEFAULT_TX_CONFIG, validate_only=True
+    await env_1.rpc_client.create_offer_for_ids(
+        {uint32(1): -5, cat_asset_id.hex(): 1}, wallet_environments.tx_config, validate_only=True
     )
-    all_offers = await wallet_1_rpc.get_all_offers()
+    all_offers = await env_1.rpc_client.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(),
+            **(
+                {}
+                if wallet_type is CATWallet
+                else {"also": {"type": "revocation layer", "hidden_puzzle_hash": "0x" + bytes32.zeros.hex()}}
+            ),
+        }
+    }
 
-    create_res = await wallet_1_rpc.create_offer_for_ids(
+    create_res = await env_1.rpc_client.create_offer_for_ids(
         {uint32(1): -5, cat_asset_id.hex(): 1},
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
         driver_dict=driver_dict,
         fee=uint64(1),
     )
     offer = create_res.offer
 
-    id, summary = await wallet_1_rpc.get_offer_summary(offer)
+    id, summary = await env_1.rpc_client.get_offer_summary(offer)
     assert id == offer.name()
-    id, advanced_summary = await wallet_1_rpc.get_offer_summary(offer, advanced=True)
+    id, advanced_summary = await env_1.rpc_client.get_offer_summary(offer, advanced=True)
     assert id == offer.name()
     assert summary == {
         "offered": {"xch": 5},
@@ -1429,120 +1631,263 @@ async def test_offer_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment)
     }
     assert advanced_summary == summary
 
-    id, _valid = await wallet_1_rpc.check_offer_validity(offer)
-    assert id == offer.name()
+    offer_validity_response = await env_1.rpc_client.check_offer_validity(CheckOfferValidity(offer.to_bech32()))
+    assert offer_validity_response.id == offer.name()
+    assert offer_validity_response.valid
 
-    all_offers = await wallet_1_rpc.get_all_offers(file_contents=True)
+    all_offers = await env_1.rpc_client.get_all_offers(file_contents=True)
     assert len(all_offers) == 1
     assert TradeStatus(all_offers[0].status) == TradeStatus.PENDING_ACCEPT
     assert all_offers[0].offer == bytes(offer)
 
-    offer_count = await wallet_1_rpc.get_offers_count()
+    offer_count = await env_1.rpc_client.get_offers_count()
     assert offer_count.total == 1
     assert offer_count.my_offers_count == 1
     assert offer_count.taken_offers_count == 0
 
-    trade_record = (await wallet_2_rpc.take_offer(offer, DEFAULT_TX_CONFIG, fee=uint64(1))).trade_record
+    trade_record = (await env_2.rpc_client.take_offer(offer, wallet_environments.tx_config, fee=uint64(1))).trade_record
     assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CONFIRM
 
-    await wallet_1_rpc.cancel_offer(offer.name(), DEFAULT_TX_CONFIG, secure=False)
+    await env_1.rpc_client.cancel_offer(offer.name(), wallet_environments.tx_config, secure=False)
 
-    trade_record = await wallet_1_rpc.get_offer(offer.name(), file_contents=True)
+    trade_record = await env_1.rpc_client.get_offer(offer.name(), file_contents=True)
     assert trade_record.offer == bytes(offer)
     assert TradeStatus(trade_record.status) == TradeStatus.CANCELLED
 
-    await wallet_1_rpc.cancel_offer(offer.name(), DEFAULT_TX_CONFIG, fee=uint64(1), secure=True)
+    failed_cancel_res = await env_1.rpc_client.cancel_offer(
+        offer.name(), wallet_environments.tx_config, fee=uint64(1), secure=True
+    )
 
-    trade_record = await wallet_1_rpc.get_offer(offer.name())
+    trade_record = await env_1.rpc_client.get_offer(offer.name())
     assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CANCEL
 
-    create_res = await wallet_1_rpc.create_offer_for_ids(
-        {uint32(1): -5, cat_wallet_id: 1}, DEFAULT_TX_CONFIG, fee=uint64(1)
+    create_res = await env_1.rpc_client.create_offer_for_ids(
+        {uint32(1): -5, cat_wallet_id: 1}, wallet_environments.tx_config, fee=uint64(1)
     )
-    all_offers = await wallet_1_rpc.get_all_offers()
+    all_offers = await env_1.rpc_client.get_all_offers()
     assert len(all_offers) == 2
-    offer_count = await wallet_1_rpc.get_offers_count()
+    offer_count = await env_1.rpc_client.get_offers_count()
     assert offer_count.total == 2
     assert offer_count.my_offers_count == 2
     assert offer_count.taken_offers_count == 0
     new_trade_record = create_res.trade_record
 
-    await farm_transaction_block(full_node_api, wallet_node)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": -1,  # The cancellation that won't complete
+                        "<=#spendable_balance": -5,
+                        "<=#max_send_amount": -5,
+                        "unspent_coin_count": 0,
+                        ">=#pending_change": 1,  # any amount increase (again, cancellation)
+                        "pending_coin_removal_count": 2,  # one for each open offer
+                    },
+                    "cat": {},
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "confirmed_wallet_balance": -5 - 1,
+                        "unconfirmed_wallet_balance": -5 - 1 + 1,  # cancellation TX now failed
+                        ">=#spendable_balance": 1,  # any amount increase
+                        ">=#max_send_amount": 1,  # any amount increase
+                        "<=#pending_change": -1,  # any amount decrease (cancellation TX now failed)
+                        "pending_coin_removal_count": -1,
+                    },
+                    "cat": {
+                        "confirmed_wallet_balance": 1,
+                        "unconfirmed_wallet_balance": 1,
+                        "spendable_balance": 1,
+                        "max_send_amount": 1,
+                        "unspent_coin_count": 1,
+                    },
+                },
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "unconfirmed_wallet_balance": 5 - 1,
+                        "<=#spendable_balance": -1,  # any amount decrease
+                        "<=#max_send_amount": -1,  # any amount decrease
+                        ">=#pending_change": 1,  # any amount increase
+                        "pending_coin_removal_count": 1,
+                    },
+                    "cat": {
+                        "unconfirmed_wallet_balance": -1,
+                        "<=#spendable_balance": -1,  # any amount decrease
+                        "<=#max_send_amount": -1,  # any amount decrease
+                        ">=#pending_change": 1,  # any amount increase
+                        "pending_coin_removal_count": 1,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        "confirmed_wallet_balance": 5 - 1,
+                        ">=#spendable_balance": 1,  # any amount increase
+                        ">=#max_send_amount": 1,  # any amount increase
+                        "<=#pending_change": -1,  # any amount decrease
+                        "pending_coin_removal_count": -1,
+                        "unspent_coin_count": 1,
+                    },
+                    "cat": {
+                        "confirmed_wallet_balance": -1,
+                        ">=#spendable_balance": 1,  # any amount increase
+                        ">=#max_send_amount": 1,  # any amount increase
+                        "<=#pending_change": -1,  # any amount decrease
+                        "pending_coin_removal_count": -1,
+                    },
+                },
+            ),
+        ],
+        invalid_transactions=[tx.name for tx in failed_cancel_res.transactions],
+    )
 
     async def is_trade_confirmed(client: WalletRpcClient, offer: Offer) -> bool:
         trade_record = await client.get_offer(offer.name())
         return TradeStatus(trade_record.status) == TradeStatus.CONFIRMED
 
-    await time_out_assert(15, is_trade_confirmed, True, wallet_1_rpc, offer)
+    await time_out_assert(15, is_trade_confirmed, True, env_1.rpc_client, offer)
 
     # Test trade sorting
     def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
         return [t.trade_id for t in trades]
 
-    trade_record = await wallet_1_rpc.get_offer(offer.name())
-    all_offers = await wallet_1_rpc.get_all_offers(include_completed=True)  # confirmed at index descending
+    trade_record = await env_1.rpc_client.get_offer(offer.name())
+    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True)  # confirmed at index descending
     assert len(all_offers) == 2
     assert only_ids(all_offers) == only_ids([trade_record, new_trade_record])
-    all_offers = await wallet_1_rpc.get_all_offers(include_completed=True, reverse=True)  # confirmed at index ascending
+    all_offers = await env_1.rpc_client.get_all_offers(
+        include_completed=True, reverse=True
+    )  # confirmed at index ascending
     assert only_ids(all_offers) == only_ids([new_trade_record, trade_record])
-    all_offers = await wallet_1_rpc.get_all_offers(include_completed=True, sort_key="RELEVANCE")  # most relevant
+    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True, sort_key="RELEVANCE")  # most relevant
     assert only_ids(all_offers) == only_ids([new_trade_record, trade_record])
-    all_offers = await wallet_1_rpc.get_all_offers(
+    all_offers = await env_1.rpc_client.get_all_offers(
         include_completed=True, sort_key="RELEVANCE", reverse=True
     )  # least relevant
     assert only_ids(all_offers) == only_ids([trade_record, new_trade_record])
     # Test pagination
-    all_offers = await wallet_1_rpc.get_all_offers(include_completed=True, start=0, end=1)
+    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True, start=0, end=1)
     assert len(all_offers) == 1
-    all_offers = await wallet_1_rpc.get_all_offers(include_completed=True, start=50)
+    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True, start=50)
     assert len(all_offers) == 0
-    all_offers = await wallet_1_rpc.get_all_offers(include_completed=True, start=0, end=50)
+    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True, start=0, end=50)
     assert len(all_offers) == 2
 
-    await wallet_1_rpc.create_offer_for_ids(
+    await env_1.rpc_client.create_offer_for_ids(
         {uint32(1): -5, cat_asset_id.hex(): 1},
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
         driver_dict=driver_dict,
     )
-    assert len([o for o in await wallet_1_rpc.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
-    await wallet_1_rpc.cancel_offers(DEFAULT_TX_CONFIG, batch_size=1)
-    assert len([o for o in await wallet_1_rpc.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 0
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 2)
-
-    await farm_transaction_block(full_node_api, wallet_node)
+    assert (
+        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
+    )
+    await env_1.rpc_client.cancel_offers(wallet_environments.tx_config, batch_size=1)
+    assert (
+        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 0
+    )
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "<=#spendable_balance": -5,
+                        "<=#max_send_amount": -5,
+                        ">=#pending_change": 1,  # any amount increase
+                        "pending_coin_removal_count": 1,
+                    },
+                    "cat": {},
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        ">=#spendable_balance": 1,  # any amount increase
+                        ">=#max_send_amount": 1,  # any amount increase
+                        "<=#pending_change": -1,  # any amount decrease
+                        "pending_coin_removal_count": -2,
+                    },
+                    "cat": {},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
 
-    await wallet_1_rpc.create_offer_for_ids(
+    await env_1.rpc_client.create_offer_for_ids(
         {uint32(1): -5, cat_asset_id.hex(): 1},
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
         driver_dict=driver_dict,
     )
-    await wallet_1_rpc.create_offer_for_ids(
+    await env_1.rpc_client.create_offer_for_ids(
         {uint32(1): 5, cat_asset_id.hex(): -1},
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
         driver_dict=driver_dict,
     )
-    assert len([o for o in await wallet_1_rpc.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
-    await wallet_1_rpc.cancel_offers(DEFAULT_TX_CONFIG, cancel_all=True)
-    assert len([o for o in await wallet_1_rpc.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 0
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-    await farm_transaction_block(full_node_api, wallet_node)
+    assert (
+        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
+    )
+    await env_1.rpc_client.cancel_offers(wallet_environments.tx_config, cancel_all=True)
+    assert (
+        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 0
+    )
 
-    await wallet_1_rpc.create_offer_for_ids(
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {
+                        "<=#spendable_balance": -5,
+                        "<=#max_send_amount": -5,
+                        ">=#pending_change": 1,  # any amount increase
+                        "pending_coin_removal_count": 1,
+                    },
+                    "cat": {
+                        "<=#spendable_balance": -1,
+                        "<=#max_send_amount": -1,
+                        ">=#pending_change": 1,  # any amount increase
+                        "pending_coin_removal_count": 1,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {
+                        ">=#spendable_balance": 5,
+                        ">=#max_send_amount": 5,
+                        "<=#pending_change": -1,  # any amount decrease
+                        "pending_coin_removal_count": -1,
+                    },
+                    "cat": {
+                        ">=#spendable_balance": 1,
+                        ">=#max_send_amount": 1,
+                        "<=#pending_change": -1,  # any amount decrease
+                        "pending_coin_removal_count": -1,
+                    },
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
+
+    await env_1.rpc_client.create_offer_for_ids(
         {uint32(1): 5, cat_asset_id.hex(): -1},
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
         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.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
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
+    assert (
+        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 1
+    )
+    await env_1.rpc_client.cancel_offers(wallet_environments.tx_config, asset_id=bytes32.zeros)
+    assert (
+        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 1
+    )
+    await env_1.rpc_client.cancel_offers(wallet_environments.tx_config, asset_id=cat_asset_id)
+    assert (
+        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 0
+    )
 
     with pytest.raises(ValueError, match="not currently supported"):
-        await wallet_1_rpc.create_offer_for_ids(
+        await env_1.rpc_client.create_offer_for_ids(
             {uint32(1): -5, cat_asset_id.hex(): 1},
-            DEFAULT_TX_CONFIG,
+            wallet_environments.tx_config,
             driver_dict=driver_dict,
             timelock_info=ConditionValidTimes(min_secs_since_created=uint64(1)),
         )
@@ -1564,7 +1909,12 @@ async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEn
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
     # Spend half of it back to the same wallet get some spent coins in the wallet
-    tx = (await client.send_transaction(1, uint64(generated_funds / 2), address, DEFAULT_TX_CONFIG)).transaction
+    tx = (
+        await client.send_transaction(
+            SendTransaction(wallet_id=uint32(1), amount=uint64(generated_funds / 2), address=address, push=True),
+            DEFAULT_TX_CONFIG,
+        )
+    ).transaction
     assert tx.spend_bundle is not None
     await time_out_assert(20, tx_in_mempool, True, client, tx.name)
     await farm_transaction(full_node_api, wallet_node, tx.spend_bundle)
@@ -1579,16 +1929,18 @@ async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEn
     assert len(coin_ids_unspent) > 0
     # Do some queries to trigger all parameters
     # 1. Empty coin_ids
-    assert await client.get_coin_records_by_names([]) == []
+    assert (await client.get_coin_records_by_names(GetCoinRecordsByNames([]))).coin_records == []
     # 2. All coins
-    rpc_result = await client.get_coin_records_by_names(coin_ids + coin_ids_unspent)
-    assert {record.coin for record in rpc_result} == {*coins, *coins_unspent}
+    rpc_result = await client.get_coin_records_by_names(GetCoinRecordsByNames(coin_ids + coin_ids_unspent))
+    assert {record.coin for record in rpc_result.coin_records} == {*coins, *coins_unspent}
     # 3. All spent coins
-    rpc_result = await client.get_coin_records_by_names(coin_ids, include_spent_coins=True)
-    assert {record.coin for record in rpc_result} == coins
+    rpc_result = await client.get_coin_records_by_names(GetCoinRecordsByNames(coin_ids, include_spent_coins=True))
+    assert {record.coin for record in rpc_result.coin_records} == coins
     # 4. All unspent coins
-    rpc_result = await client.get_coin_records_by_names(coin_ids_unspent, include_spent_coins=False)
-    assert {record.coin for record in rpc_result} == coins_unspent
+    rpc_result = await client.get_coin_records_by_names(
+        GetCoinRecordsByNames(coin_ids_unspent, include_spent_coins=False)
+    )
+    assert {record.coin for record in rpc_result.coin_records} == coins_unspent
     # 5. Filter start/end height
     filter_records = result.records[:10]
     assert len(filter_records) == 10
@@ -1597,11 +1949,13 @@ async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEn
     min_height = min(record.confirmed_block_height for record in filter_records)
     max_height = max(record.confirmed_block_height for record in filter_records)
     assert min_height != max_height
-    rpc_result = await client.get_coin_records_by_names(filter_coin_ids, start_height=min_height, end_height=max_height)
-    assert {record.coin for record in rpc_result} == filter_coins
+    rpc_result = await client.get_coin_records_by_names(
+        GetCoinRecordsByNames(filter_coin_ids, start_height=min_height, end_height=max_height)
+    )
+    assert {record.coin for record in rpc_result.coin_records} == filter_coins
     # 8. Test the failure case
     with pytest.raises(ValueError, match="not found"):
-        await client.get_coin_records_by_names(coin_ids, include_spent_coins=False)
+        await client.get_coin_records_by_names(GetCoinRecordsByNames(coin_ids, include_spent_coins=False))
 
 
 @pytest.mark.anyio
@@ -1646,20 +2000,6 @@ async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -
     # Create backup file
     await wallet_1_rpc.create_did_backup_file(DIDCreateBackupFile(did_wallet_id_0))
 
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-    await farm_transaction_block(full_node_api, wallet_1_node)
-    # Update recovery list
-    update_res = await wallet_1_rpc.update_did_recovery_list(
-        DIDUpdateRecoveryIDs(
-            wallet_id=uint32(did_wallet_id_0), new_list=[did_id_0], num_verifications_required=uint64(1), push=True
-        ),
-        DEFAULT_TX_CONFIG,
-    )
-    assert len(update_res.transactions) > 0
-    recovery_list_res = await wallet_1_rpc.get_did_recovery_list(DIDGetRecoveryList(did_wallet_id_0))
-    assert recovery_list_res.num_required == 1
-    assert recovery_list_res.recovery_list[0] == did_id_0
-
     await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
     await farm_transaction_block(full_node_api, wallet_1_node)
 
@@ -1929,7 +2269,7 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
     wallet_node: WalletNode = env.wallet_1.node
     client: WalletRpcClient = env.wallet_1.rpc_client
 
-    address = await client.get_next_address(1, True)
+    address = (await client.get_next_address(GetNextAddress(uint32(1), True))).address
     assert len(address) > 10
 
     pks = (await client.get_public_keys()).pk_fingerprints
@@ -1944,11 +2284,15 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
     addr = encode_puzzle_hash(ph, "txch")
     tx_amount = uint64(15600000)
     await env.full_node.api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-    created_tx = (await client.send_transaction(1, tx_amount, addr, DEFAULT_TX_CONFIG)).transaction
+    created_tx = (
+        await client.send_transaction(
+            SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True), DEFAULT_TX_CONFIG
+        )
+    ).transaction
 
     await time_out_assert(20, tx_in_mempool, True, client, created_tx.name)
     assert len(await wallet.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(1)) == 1
-    await client.delete_unconfirmed_transactions(1)
+    await client.delete_unconfirmed_transactions(DeleteUnconfirmedTransactions(uint32(1)))
     assert len(await wallet.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(1)) == 0
 
     sk_resp = await client.get_private_key(GetPrivateKey(pks[0]))
@@ -2002,12 +2346,15 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
 
     assert not (await client.get_sync_status()).synced
 
-    wallets = await client.get_wallets()
+    wallets = (await client.get_wallets(GetWallets())).wallets
     assert len(wallets) == 1
-    assert await get_unconfirmed_balance(client, int(wallets[0]["id"])) == 0
+    assert await get_unconfirmed_balance(client, int(wallets[0].id)) == 0
 
     with pytest.raises(ValueError):
-        await client.send_transaction(wallets[0]["id"], uint64(100), addr, DEFAULT_TX_CONFIG)
+        await client.send_transaction(
+            SendTransaction(wallet_id=uint32(wallets[0].id), amount=uint64(100), address=addr, push=True),
+            DEFAULT_TX_CONFIG,
+        )
 
     # Delete all keys
     await client.delete_all_keys()
@@ -2033,7 +2380,11 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
     for tx_amount in tx_amounts:
         funds -= tx_amount
         # create coins for tests
-        tx = (await client.send_transaction(1, tx_amount, addr, DEFAULT_TX_CONFIG)).transaction
+        tx = (
+            await client.send_transaction(
+                SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True), DEFAULT_TX_CONFIG
+            )
+        ).transaction
         spend_bundle = tx.spend_bundle
         assert spend_bundle is not None
         for coin in spend_bundle.additions():
@@ -2045,51 +2396,63 @@ 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(
-        amount=1000,
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(min_coin_amount=uint64(1001)),
+    min_coins_response = await client_2.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(1000),
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(min_coin_amount=uint64(1001)),
+        )
     )
-    assert len(min_coins) == 1
-    assert min_coins[0].amount == uint64(10_000)
+    assert len(min_coins_response.coins) == 1
+    assert min_coins_response.coins[0].amount == uint64(10_000)
 
     # test max coin amount
-    max_coins: list[Coin] = await client_2.select_coins(
-        amount=2000,
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
-            min_coin_amount=uint64(999), max_coin_amount=uint64(9999)
-        ),
+    max_coins_reponse = await client_2.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(2000),
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+                min_coin_amount=uint64(999), max_coin_amount=uint64(9999)
+            ),
+        )
     )
-    assert len(max_coins) == 2
-    assert max_coins[0].amount == uint64(1000)
+    assert len(max_coins_reponse.coins) == 2
+    assert max_coins_reponse.coins[0].amount == uint64(1000)
 
     # 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(
-        amount=non_1000_amt,
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),
+    excluded_amt_coins_response = await client_2.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(non_1000_amt),
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),
+        )
     )
-    assert len(excluded_amt_coins) == len([a for a in tx_amounts if a != 1000])
-    assert sum(c.amount for c in excluded_amt_coins) == non_1000_amt
+    assert len(excluded_amt_coins_response.coins) == len([a for a in tx_amounts if a != 1000])
+    assert sum(c.amount for c in excluded_amt_coins_response.coins) == non_1000_amt
 
     # test excluded coins
     with pytest.raises(ValueError):
         await client_2.select_coins(
-            amount=5000,
-            wallet_id=1,
+            SelectCoins.from_coin_selection_config(
+                amount=uint64(5000),
+                wallet_id=uint32(1),
+                coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+                    excluded_coin_ids=[c.name() for c in min_coins_response.coins]
+                ),
+            )
+        )
+    excluded_test_response = await client_2.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(1300),
+            wallet_id=uint32(1),
             coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
-                excluded_coin_ids=[c.name() for c in min_coins]
+                excluded_coin_ids=[c.name() for c in coin_300]
             ),
         )
-    excluded_test = await client_2.select_coins(
-        amount=1300,
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_ids=[c.name() for c in coin_300]),
     )
-    assert len(excluded_test) == 2
-    for coin in excluded_test:
+    assert len(excluded_test_response.coins) == 2
+    for coin in excluded_test_response.coins:
         assert coin != coin_300[0]
 
     # test backwards compatibility in the RPC
@@ -2108,27 +2471,40 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         assert coin != coin_300[0]
 
     # test get coins
-    all_coins, _, _ = await client_2.get_spendable_coins(
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
-            excluded_coin_ids=[c.name() for c in excluded_amt_coins]
+    spendable_coins_response = await client_2.get_spendable_coins(
+        GetSpendableCoins.from_coin_selection_config(
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+                excluded_coin_ids=[c.name() for c in excluded_amt_coins_response.coins]
+            ),
         ),
     )
-    assert set(excluded_amt_coins).intersection({rec.coin for rec in all_coins}) == set()
-    all_coins, _, _ = await client_2.get_spendable_coins(
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),
+    assert (
+        set(excluded_amt_coins_response.coins).intersection(
+            {rec.coin for rec in spendable_coins_response.confirmed_records}
+        )
+        == set()
+    )
+    spendable_coins_response = await client_2.get_spendable_coins(
+        GetSpendableCoins.from_coin_selection_config(
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),
+        )
     )
-    assert len([rec for rec in all_coins if rec.coin.amount == 1000]) == 0
-    all_coins_2, _, _ = await client_2.get_spendable_coins(
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(max_coin_amount=uint64(999)),
+    assert len([rec for rec in spendable_coins_response.confirmed_records if rec.coin.amount == 1000]) == 0
+    spendable_coins_response = await client_2.get_spendable_coins(
+        GetSpendableCoins.from_coin_selection_config(
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(max_coin_amount=uint64(999)),
+        )
     )
-    assert all_coins_2[0].coin == coin_300[0]
+    assert spendable_coins_response.confirmed_records[0].coin == coin_300[0]
     with pytest.raises(ValueError):  # validate fail on invalid coin id.
         await client_2.get_spendable_coins(
-            wallet_id=1,
-            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_ids=[b"a"]),
+            GetSpendableCoins.from_coin_selection_config(
+                wallet_id=uint32(1),
+                coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_ids=[b"a"]),
+            )
         )
 
 
@@ -2314,21 +2690,25 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
     env.wallet_2.node.config["enable_notifications"] = True
     env.wallet_2.node.config["required_notification_amount"] = 100000000000
     async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        tx = await client.send_notification(
-            await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager),
-            b"hello",
-            uint64(100000000000),
-            fee=uint64(100000000000),
+        response = await client.send_notification(
+            SendNotification(
+                target=(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)),
+                message=b"hello",
+                amount=uint64(100000000000),
+                fee=uint64(100000000000),
+                push=True,
+            ),
+            tx_config=DEFAULT_TX_CONFIG,
         )
 
-    assert tx.spend_bundle is not None
+    assert response.tx.spend_bundle is not None
     await time_out_assert(
         5,
         full_node_api.full_node.mempool_manager.get_spendbundle,
-        tx.spend_bundle,
-        tx.spend_bundle.name(),
+        response.tx.spend_bundle,
+        response.tx.spend_bundle.name(),
     )
-    await farm_transaction(full_node_api, wallet_node, tx.spend_bundle)
+    await farm_transaction(full_node_api, wallet_node, response.tx.spend_bundle)
     await time_out_assert(20, env.wallet_2.wallet.get_confirmed_balance, uint64(100000000000))
 
     notification = (await client_2.get_notifications(GetNotifications())).notifications[0]
@@ -2337,29 +2717,33 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
     assert [notification] == (await client_2.get_notifications(GetNotifications(None, None, uint32(1)))).notifications
     assert [] == (await client_2.get_notifications(GetNotifications(None, uint32(1), None))).notifications
     assert [notification] == (await client_2.get_notifications(GetNotifications(None, None, None))).notifications
-    assert await client_2.delete_notifications()
+    await client_2.delete_notifications(DeleteNotifications())
     assert [] == (await client_2.get_notifications(GetNotifications([notification.id]))).notifications
 
     async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        tx = await client.send_notification(
-            await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager),
-            b"hello",
-            uint64(100000000000),
-            fee=uint64(100000000000),
+        response = await client.send_notification(
+            SendNotification(
+                target=(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)),
+                message=b"hello",
+                amount=uint64(100000000000),
+                fee=uint64(100000000000),
+                push=True,
+            ),
+            tx_config=DEFAULT_TX_CONFIG,
         )
 
-    assert tx.spend_bundle is not None
+    assert response.tx.spend_bundle is not None
     await time_out_assert(
         5,
         full_node_api.full_node.mempool_manager.get_spendbundle,
-        tx.spend_bundle,
-        tx.spend_bundle.name(),
+        response.tx.spend_bundle,
+        response.tx.spend_bundle.name(),
     )
-    await farm_transaction(full_node_api, wallet_node, tx.spend_bundle)
+    await farm_transaction(full_node_api, wallet_node, response.tx.spend_bundle)
     await time_out_assert(20, env.wallet_2.wallet.get_confirmed_balance, uint64(200000000000))
 
     notification = (await client_2.get_notifications(GetNotifications())).notifications[0]
-    assert await client_2.delete_notifications([notification.id])
+    await client_2.delete_notifications(DeleteNotifications([notification.id]))
     assert [] == (await client_2.get_notifications(GetNotifications([notification.id]))).notifications
 
 
@@ -2573,7 +2957,7 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
 
     nft_wallet = await wc.create_new_nft_wallet(None)
     nft_wallet_id = nft_wallet["wallet_id"]
-    address = await wc.get_next_address(env.wallet_1.wallet.id(), True)
+    address = (await wc.get_next_address(GetNextAddress(env.wallet_1.wallet.id(), True))).address
     await wc.mint_nft(
         request=NFTMintNFTRequest(
             wallet_id=nft_wallet_id,
@@ -2594,12 +2978,14 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
     # Test Clawback resync
     tx = (
         await wc.send_transaction(
-            wallet_id=1,
-            amount=uint64(500),
-            address=address,
+            SendTransaction(
+                wallet_id=uint32(1),
+                amount=uint64(500),
+                address=address,
+                puzzle_decorator=[ClawbackPuzzleDecoratorOverride(decorator="CLAWBACK", clawback_timelock=uint64(5))],
+                push=True,
+            ),
             tx_config=DEFAULT_TX_CONFIG,
-            fee=uint64(0),
-            puzzle_decorator_override=[{"decorator": "CLAWBACK", "clawback_timelock": 5}],
         )
     ).transaction
     clawback_coin_id = tx.additions[0].name()
@@ -2607,12 +2993,11 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
     await farm_transaction(full_node_api, wallet_node, tx.spend_bundle)
     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"]
-    assert len(resp["transaction_ids"]) == 1
-    await time_out_assert_not_none(
-        10, full_node_api.full_node.mempool_manager.get_spendbundle, bytes32.from_hexstr(resp["transaction_ids"][0])
+    resp = await wc.spend_clawback_coins(
+        SpendClawbackCoins(coin_ids=[clawback_coin_id], fee=uint64(0), push=True), tx_config=DEFAULT_TX_CONFIG
     )
+    assert len(resp.transaction_ids) == 1
+    await time_out_assert_not_none(10, full_node_api.full_node.mempool_manager.get_spendbundle, resp.transaction_ids[0])
     await farm_transaction_block(full_node_api, wallet_node)
     await time_out_assert(20, check_client_synced, True, wc)
     wallet_node_2._close()
@@ -2742,7 +3127,11 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
     )
     tx_amount = uint64(100)
 
-    tx = (await client.send_transaction(1, tx_amount, addr, DEFAULT_TX_CONFIG)).transaction
+    tx = (
+        await client.send_transaction(
+            SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True), DEFAULT_TX_CONFIG
+        )
+    ).transaction
     transaction_id = tx.name
     spend_bundle = tx.spend_bundle
     assert spend_bundle is not None
@@ -2784,11 +3173,16 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
     # Attempt to melt it fully
     tx = (
         await client.cat_spend(
-            cat_wallet_id,
-            amount=uint64(0),
+            CATSpend(
+                wallet_id=cat_wallet_id,
+                amount=uint64(0),
+                inner_address=encode_puzzle_hash(our_ph, "txch"),
+                extra_delta=str(tx_amount * -1),
+                tail_reveal=b"\x80",
+                tail_solution=b"\x80",
+                push=True,
+            ),
             tx_config=DEFAULT_TX_CONFIG,
-            inner_address=encode_puzzle_hash(our_ph, "txch"),
-            cat_discrepancy=(tx_amount * -1, Program.to(None), Program.to(None)),
         )
     ).transaction
     transaction_id = tx.name
@@ -2822,15 +3216,15 @@ async def test_get_balances(wallet_rpc_environment: WalletRpcTestEnvironment) ->
     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, check_client_synced, True, client)
-    bal = await client.get_wallet_balances()
-    assert len(bal) == 3
-    assert bal["1"]["confirmed_wallet_balance"] == 1999999999880
-    assert bal["2"]["confirmed_wallet_balance"] == 100
-    assert bal["3"]["confirmed_wallet_balance"] == 20
-    bal_ids = await client.get_wallet_balances([3, 2])
-    assert len(bal_ids) == 2
-    assert bal["2"]["confirmed_wallet_balance"] == 100
-    assert bal["3"]["confirmed_wallet_balance"] == 20
+    bals_response = await client.get_wallet_balances(GetWalletBalances())
+    assert len(bals_response.wallet_balances) == 3
+    assert bals_response.wallet_balances[uint32(1)].confirmed_wallet_balance == 1999999999880
+    assert bals_response.wallet_balances[uint32(2)].confirmed_wallet_balance == 100
+    assert bals_response.wallet_balances[uint32(3)].confirmed_wallet_balance == 20
+    bals_response = await client.get_wallet_balances(GetWalletBalances([uint32(3), uint32(2)]))
+    assert len(bals_response.wallet_balances) == 2
+    assert bals_response.wallet_balances[uint32(2)].confirmed_wallet_balance == 100
+    assert bals_response.wallet_balances[uint32(3)].confirmed_wallet_balance == 20
 
 
 @pytest.mark.parametrize(