chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -1,26 +1,22 @@
 from __future__ import annotations
 
-import asyncio
 import dataclasses
 import io
 import json
 import logging
-import random
 import re
-from collections.abc import AsyncIterator
 from operator import attrgetter
-from typing import Any, Optional
+from typing import Any
 from unittest.mock import patch
 
 import aiosqlite
 import pytest
-from chia_rs import CoinSpend, G1Element, G2Element
+from chia_rs import CoinRecord, CoinSpend, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64, uint128
 
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
-from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
-from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_not_none
+from chia._tests.util.time_out_assert import time_out_assert
 from chia._tests.wallet.cat_wallet.test_cat_wallet import mint_cat
 from chia._tests.wallet.test_wallet_coin_store import (
     get_coin_records_amount_filter_tests,
@@ -50,29 +46,25 @@ from chia._tests.wallet.test_wallet_coin_store import (
 )
 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.full_node.full_node_rpc_client import FullNodeRpcClient
+from chia.pools.pool_wallet_info import NewPoolWalletInitialTargetState
 from chia.rpc.rpc_client import ResponseFailureError
-from chia.server.server import ChiaServer
 from chia.simulator.full_node_simulator import FullNodeSimulator
-from chia.simulator.simulator_protocol import FarmNewBlockProtocol
 from chia.types.blockchain_format.coin import Coin, coin_as_list
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_record import CoinRecord
 from chia.types.coin_spend import make_spend
-from chia.types.peer_info import PeerInfo
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
 from chia.util.config import load_config, lock_and_load_config, save_config
 from chia.util.db_wrapper import DBWrapper2
 from chia.util.hash import std_hash
-from chia.util.streamable import ConversionError, InvalidTypeError
 from chia.wallet.cat_wallet.cat_constants import DEFAULT_CATS
 from chia.wallet.cat_wallet.cat_utils import CAT_MOD, construct_cat_puzzle
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
 from chia.wallet.cat_wallet.r_cat_wallet import RCATWallet
 from chia.wallet.conditions import (
     ConditionValidTimes,
+    ConditionValidTimesAbsolute,
     CreateCoinAnnouncement,
     CreatePuzzleAnnouncement,
     Remark,
@@ -81,11 +73,11 @@ from chia.wallet.conditions import (
 from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_sk_unhardened
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
-from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
+from chia.wallet.puzzle_drivers import PuzzleInfo
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 from chia.wallet.signer_protocol import UnsignedTransaction
 from chia.wallet.trade_record import TradeRecord
-from chia.wallet.trading.offer import Offer
+from chia.wallet.trading.offer import Offer, OfferSummary
 from chia.wallet.trading.trade_status import TradeStatus
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.transaction_sorting import SortKey
@@ -96,15 +88,18 @@ from chia.wallet.util.clvm_streamable import byte_deserialize_clvm_streamable
 from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.query_filter import AmountFilter, HashFilter, TransactionTypeFilter
 from chia.wallet.util.transaction_type import TransactionType
-from chia.wallet.util.tx_config import DEFAULT_COIN_SELECTION_CONFIG, DEFAULT_TX_CONFIG
+from chia.wallet.util.tx_config import TXConfig
 from chia.wallet.util.wallet_types import CoinType, WalletType
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_coin_record import WalletCoinRecord
 from chia.wallet.wallet_coin_store import GetCoinRecords
-from chia.wallet.wallet_node import WalletNode
+from chia.wallet.wallet_node import WalletNode, get_wallet_db_path
 from chia.wallet.wallet_protocol import WalletProtocol
 from chia.wallet.wallet_request_types import (
+    Addition,
     AddKey,
+    CancelOffer,
+    CancelOffers,
     CATAssetIDToName,
     CATGetAssetID,
     CATGetName,
@@ -114,6 +109,10 @@ from chia.wallet.wallet_request_types import (
     CheckOfferValidity,
     ClawbackPuzzleDecoratorOverride,
     CombineCoins,
+    CreateNewWallet,
+    CreateNewWalletType,
+    CreateOfferForIDs,
+    CreateSignedTransaction,
     DefaultCAT,
     DeleteKey,
     DeleteNotifications,
@@ -126,11 +125,17 @@ from chia.wallet.wallet_request_types import (
     DIDMessageSpend,
     DIDSetWalletName,
     DIDTransferDID,
+    DIDType,
     DIDUpdateMetadata,
     FungibleAsset,
+    GetAllOffers,
     GetCoinRecordsByNames,
+    GetFarmedAmount,
+    GetFarmedAmountResponse,
     GetNextAddress,
     GetNotifications,
+    GetOffer,
+    GetOfferSummary,
     GetPrivateKey,
     GetSpendableCoins,
     GetSyncStatusResponse,
@@ -153,55 +158,29 @@ from chia.wallet.wallet_request_types import (
     SelectCoins,
     SendNotification,
     SendTransaction,
+    SendTransactionMulti,
     SetWalletResyncOnStartup,
+    SignMessageByAddress,
     SpendClawbackCoins,
     SplitCoins,
+    TakeOffer,
+    VCSpend,
     VerifySignature,
     VerifySignatureResponse,
+    WalletCreationMode,
 )
 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__)
 
 
-@dataclasses.dataclass
-class WalletBundle:
-    service: WalletService
-    node: WalletNode
-    rpc_client: WalletRpcClient
-    wallet: Wallet
-
-
-@dataclasses.dataclass
-class FullNodeBundle:
-    server: ChiaServer
-    api: FullNodeSimulator
-    rpc_client: FullNodeRpcClient
-
-
-@dataclasses.dataclass
-class WalletRpcTestEnvironment:
-    wallet_1: WalletBundle
-    wallet_2: WalletBundle
-    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) -> None:
     await full_node_api.farm_blocks_to_puzzlehash(count=1)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
 
-def check_mempool_spend_count(full_node_api: FullNodeSimulator, num_of_spends: int) -> bool:
-    return full_node_api.full_node.mempool_manager.mempool.size() == num_of_spends
-
-
 async def farm_transaction(
     full_node_api: FullNodeSimulator, wallet_node: WalletNode, spend_bundle: WalletSpendBundle
 ) -> None:
@@ -211,124 +190,36 @@ async def farm_transaction(
     assert full_node_api.full_node.mempool_manager.get_spendbundle(spend_bundle_name) is None
 
 
-async def generate_funds(full_node_api: FullNodeSimulator, wallet_bundle: WalletBundle, num_blocks: int = 1) -> int:
-    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))
-        peak_height = full_node_api.full_node.blockchain.get_peak_height()
-        assert peak_height is not None
-        generated_funds += calculate_pool_reward(peak_height) + calculate_base_farmer_reward(peak_height)
-
-    # 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
-    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)
-
-    return generated_funds
-
-
-@pytest.fixture(scope="function", params=[True, False])
-async def wallet_rpc_environment(
-    two_wallet_nodes_services: SimulatorsAndWalletsServices, request: pytest.FixtureRequest, self_hostname: str
-) -> AsyncIterator[WalletRpcTestEnvironment]:
-    full_node, wallets, bt = two_wallet_nodes_services
-    full_node_service = full_node[0]
-    full_node_api = full_node_service._api
-    full_node_server = full_node_api.full_node.server
-    wallet_service = wallets[0]
-    wallet_service_2 = wallets[1]
-    wallet_node = wallet_service._node
-    wallet_node_2 = wallet_service_2._node
-    wallet = wallet_node.wallet_state_manager.main_wallet
-    wallet_2 = wallet_node_2.wallet_state_manager.main_wallet
-
-    config = bt.config
-    hostname = config["self_hostname"]
-
-    if request.param:
-        wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-        wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
-    else:
-        wallet_node.config["trusted_peers"] = {}
-        wallet_node_2.config["trusted_peers"] = {}
-
-    await wallet_node.server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-    await wallet_node_2.server.start_client(PeerInfo(self_hostname, full_node_server.get_port()), None)
-
-    assert wallet_service.rpc_server is not None
-    async with WalletRpcClient.create_as_context(
-        hostname, wallet_service.rpc_server.listen_port, wallet_service.root_path, wallet_service.config
-    ) as client:
-        assert wallet_service_2.rpc_server is not None
-        async with WalletRpcClient.create_as_context(
-            hostname, wallet_service_2.rpc_server.listen_port, wallet_service_2.root_path, wallet_service_2.config
-        ) as client_2:
-            assert full_node_service.rpc_server is not None
-            async with FullNodeRpcClient.create_as_context(
-                hostname,
-                full_node_service.rpc_server.listen_port,
-                full_node_service.root_path,
-                full_node_service.config,
-            ) as client_node:
-                wallet_bundle_1 = WalletBundle(wallet_service, wallet_node, client, wallet)
-                wallet_bundle_2 = WalletBundle(wallet_service_2, wallet_node_2, client_2, wallet_2)
-                node_bundle = FullNodeBundle(full_node_server, full_node_api, client_node)
-
-                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]]:
-    outputs = []
-    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        for args in output_args:
-            output = {
-                "amount": uint64(args[0]),
-                "puzzle_hash": await action_scope.get_puzzle_hash(
-                    wallet.wallet_state_manager, override_reuse_puzhash_with=False
-                ),
-            }
-            if args[1] is not None:
-                assert len(args[1]) > 0
-                output["memos"] = args[1]
-            outputs.append(output)
-    return outputs
-
-
-async def assert_wallet_types(client: WalletRpcClient, expected: dict[WalletType, int]) -> None:
-    for wallet_type in WalletType:
-        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
+async def create_tx_outputs(
+    wallet: Wallet, tx_config: TXConfig, output_args: list[tuple[int, list[str] | None]]
+) -> list[Addition]:
+    async with wallet.wallet_state_manager.new_action_scope(tx_config, push=True) as action_scope:
+        return [
+            Addition(
+                amount=uint64(args[0]),
+                puzzle_hash=await action_scope.get_puzzle_hash(wallet.wallet_state_manager),
+                memos=None if args[1] is None or len(args[1]) == 0 else args[1],
+            )
+            for args in output_args
+        ]
 
 
 def assert_tx_amounts(
     tx: TransactionRecord,
-    outputs: list[dict[str, Any]],
+    outputs: list[Addition],
     *,
     amount_fee: uint64,
     change_expected: bool,
     is_cat: bool = False,
 ) -> None:
     assert tx.fee_amount == amount_fee
-    assert tx.amount == sum(output["amount"] for output in outputs)
+    assert tx.amount == sum(output.amount for output in outputs)
     expected_additions = len(outputs) + 1 if change_expected else len(outputs)
     assert len(tx.additions) == expected_additions
     addition_amounts = [addition.amount for addition in tx.additions]
     removal_amounts = [removal.amount for removal in tx.removals]
     for output in outputs:
-        assert output["amount"] in addition_amounts
+        assert output.amount in addition_amounts
     if is_cat:
         assert (sum(removal_amounts) - sum(addition_amounts)) == 0
     else:
@@ -356,7 +247,7 @@ async def assert_get_balance(rpc_client: WalletRpcClient, wallet_node: WalletNod
     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"] = "0x" + wallet.get_asset_id()
+        expected_balance_dict["asset_id"] = "0x" + wallet.get_asset_id().hex()
     else:
         expected_balance_dict["asset_id"] = None
     assert (
@@ -381,24 +272,34 @@ async def get_unconfirmed_balance(client: WalletRpcClient, wallet_id: int) -> ui
     ).wallet_balance.unconfirmed_wallet_balance
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 2,
+            "blocks_needed": [1, 1],
+        }
+    ],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet_2: Wallet = env.wallet_2.wallet
-    wallet_node: WalletNode = env.wallet_1.node
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-
-    generated_funds = await generate_funds(full_node_api, env.wallet_1)
+async def test_send_transaction(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
+    wallet_2: Wallet = env_2.xch_wallet
+    wallet_node: WalletNode = env.node
+    full_node_api: FullNodeSimulator = wallet_environments.full_node
+    client: WalletRpcClient = env.rpc_client
 
-    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    INITIAL_FUNDS = await env.xch_wallet.get_confirmed_balance()
+    async with wallet_2.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         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(
             SendTransaction(wallet_id=uint32(1), amount=uint64(100000000000000001), address=addr, push=True),
-            DEFAULT_TX_CONFIG,
+            wallet_environments.tx_config,
         )
 
     # Tests sending a basic transaction
@@ -409,7 +310,7 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
             SendTransaction(
                 wallet_id=uint32(1), amount=tx_amount, address=addr, memos=["this is a basic tx"], push=False
             ),
-            tx_config=DEFAULT_TX_CONFIG.override(
+            tx_config=wallet_environments.tx_config.override(
                 excluded_coin_amounts=[uint64(250000000000)],
                 excluded_coin_ids=[non_existent_coin.name()],
                 reuse_puzhash=True,
@@ -449,7 +350,7 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
     assert spend_bundle is not None
 
     await time_out_assert(20, tx_in_mempool, True, client, transaction_id)
-    await time_out_assert(20, get_unconfirmed_balance, generated_funds - tx_amount, client, 1)
+    await time_out_assert(20, get_unconfirmed_balance, INITIAL_FUNDS - tx_amount, client, 1)
 
     await farm_transaction(full_node_api, wallet_node, spend_bundle)
 
@@ -460,38 +361,56 @@ async def test_send_transaction(wallet_rpc_environment: WalletRpcTestEnvironment
     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)
+    await time_out_assert(20, get_confirmed_balance, INITIAL_FUNDS - tx_amount, client, 1)
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 1,
+            "blocks_needed": [2],
+        }
+    ],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_push_transactions(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet: Wallet = env.wallet_1.wallet
-    wallet_node: WalletNode = env.wallet_1.node
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
+async def test_push_transactions(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
 
-    await generate_funds(full_node_api, env.wallet_1, num_blocks=2)
+    wallet: Wallet = env.xch_wallet
+    wallet_node: WalletNode = env.node
+    full_node_api: FullNodeSimulator = wallet_environments.full_node
+    client: WalletRpcClient = env.rpc_client
 
-    outputs = await create_tx_outputs(wallet, [(1234321, None)])
+    outputs = await create_tx_outputs(wallet, wallet_environments.tx_config, [(1234321, None)])
 
     tx = (
         await client.create_signed_transactions(
-            outputs,
-            tx_config=DEFAULT_TX_CONFIG,
-            fee=uint64(100),
+            CreateSignedTransaction(additions=outputs, fee=uint64(100)),
+            tx_config=wallet_environments.tx_config,
         )
     ).signed_tx
 
+    with pytest.raises(ValueError, match="Cannot add conditions to a transaction if no new fee spend is being added"):
+        await client.push_transactions(
+            PushTransactions(transactions=[tx]),
+            tx_config=wallet_environments.tx_config,
+            extra_conditions=(Remark(rest=Program.to("foo")),),
+        )
+
     resp_client = await client.push_transactions(
         PushTransactions(transactions=[tx], fee=uint64(10)),
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
     )
+    await full_node_api.wait_for_wallet_synced(wallet_node)
     resp = await client.fetch("push_transactions", {"transactions": [tx.to_json_dict()], "fee": 10})
     assert resp["success"]
+    await full_node_api.wait_for_wallet_synced(wallet_node)
     resp = await client.fetch("push_transactions", {"transactions": [bytes(tx).hex()], "fee": 10})
     assert resp["success"]
+    await full_node_api.wait_for_wallet_synced(wallet_node)
 
     spend_bundle = WalletSpendBundle.aggregate(
         [tx.spend_bundle for tx in resp_client.transactions if tx.spend_bundle is not None]
@@ -508,15 +427,25 @@ async def test_push_transactions(wallet_rpc_environment: WalletRpcTestEnvironmen
     assert resp["success"]
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 1,
+            "blocks_needed": [1],
+        }
+    ],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_balance(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env = wallet_rpc_environment
-    wallet: Wallet = env.wallet_1.wallet
-    wallet_node: WalletNode = env.wallet_1.node
-    full_node_api: FullNodeSimulator = env.full_node.api
-    wallet_rpc_client = env.wallet_1.rpc_client
-    await full_node_api.farm_blocks_to_wallet(2, wallet)
-    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+async def test_get_balance(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet: Wallet = env.xch_wallet
+    wallet_node: WalletNode = env.node
+    full_node_api: FullNodeSimulator = wallet_environments.full_node
+    wallet_rpc_client = env.rpc_client
+    async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         cat_wallet = await CATWallet.create_new_cat_wallet(
             wallet_node.wallet_state_manager,
             wallet,
@@ -530,44 +459,50 @@ async def test_get_balance(wallet_rpc_environment: WalletRpcTestEnvironment) ->
     await assert_get_balance(wallet_rpc_client, wallet_node, cat_wallet)
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [2], "reuse_puzhash": True, "trusted": True}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_farmed_amount(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env = wallet_rpc_environment
-    wallet: Wallet = env.wallet_1.wallet
-    full_node_api: FullNodeSimulator = env.full_node.api
-    wallet_rpc_client = env.wallet_1.rpc_client
-    await full_node_api.farm_blocks_to_wallet(2, wallet)
-
-    get_farmed_amount_result = await wallet_rpc_client.get_farmed_amount()
+async def test_get_farmed_amount(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet_rpc_client = env.rpc_client
+
+    get_farmed_amount_result = await wallet_rpc_client.get_farmed_amount(GetFarmedAmount())
     get_timestamp_for_height_result = await wallet_rpc_client.get_timestamp_for_height(
         GetTimestampForHeight(uint32(3))
     )  # genesis + 2
 
-    expected_result = {
-        "blocks_won": 2,
-        "farmed_amount": 4_000_000_000_000,
-        "farmer_reward_amount": 500_000_000_000,
-        "fee_amount": 0,
-        "last_height_farmed": 3,
-        "last_time_farmed": get_timestamp_for_height_result.timestamp,
-        "pool_reward_amount": 3_500_000_000_000,
-        "success": True,
-    }
+    expected_result = GetFarmedAmountResponse(
+        blocks_won=uint32(2),
+        farmed_amount=uint64(4_000_000_000_000),
+        farmer_reward_amount=uint64(500_000_000_000),
+        fee_amount=uint64(0),
+        last_height_farmed=uint32(3),
+        last_time_farmed=uint64(get_timestamp_for_height_result.timestamp),
+        pool_reward_amount=uint64(3_500_000_000_000),
+    )
     assert get_farmed_amount_result == expected_result
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [2], "reuse_puzhash": True, "trusted": True}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_farmed_amount_with_fee(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env = wallet_rpc_environment
-    wallet: Wallet = env.wallet_1.wallet
-    full_node_api: FullNodeSimulator = env.full_node.api
-    wallet_rpc_client = env.wallet_1.rpc_client
-    wallet_node: WalletNode = env.wallet_1.node
-
-    await generate_funds(full_node_api, env.wallet_1)
+async def test_get_farmed_amount_with_fee(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet: Wallet = env.xch_wallet
+    full_node_api: FullNodeSimulator = wallet_environments.full_node
+    wallet_rpc_client = env.rpc_client
+    wallet_node: WalletNode = env.node
 
     fee_amount = 100
-    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         await wallet.generate_signed_transaction(
             amounts=[uint64(5)],
             puzzle_hashes=[bytes32.zeros],
@@ -580,18 +515,20 @@ async def test_get_farmed_amount_with_fee(wallet_rpc_environment: WalletRpcTestE
     await full_node_api.farm_blocks_to_puzzlehash(count=2, farm_to=our_ph, guarantee_transaction_blocks=True)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
 
-    result = await wallet_rpc_client.get_farmed_amount()
-    assert result["fee_amount"] == fee_amount
+    result = await wallet_rpc_client.get_farmed_amount(GetFarmedAmount())
+    assert result.fee_amount == fee_amount
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [1], "reuse_puzhash": True, "trusted": True}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_timestamp_for_height(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-
-    await generate_funds(full_node_api, env.wallet_1)
+async def test_get_timestamp_for_height(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    client: WalletRpcClient = env.rpc_client
 
     # This tests that the client returns successfully, rather than raising or returning something unexpected
     await client.get_timestamp_for_height(GetTimestampForHeight(uint32(1)))
@@ -613,44 +550,74 @@ async def test_get_timestamp_for_height(wallet_rpc_environment: WalletRpcTestEnv
         ([(120000000000, None), (120000000000, None)], 10000000000, True, False),
     ],
 )
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [2, 1], "config_overrides": {"automatically_add_unknown_cats": True}}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
 async def test_create_signed_transaction(
-    wallet_rpc_environment: WalletRpcTestEnvironment,
-    output_args: list[tuple[int, Optional[list[str]]]],
+    wallet_environments: WalletTestFramework,
+    output_args: list[tuple[int, list[str] | None]],
     fee: int,
     select_coin: bool,
     is_cat: bool,
 ) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
+    if (
+        len(set(amount for amount, _ in output_args)) != len(output_args)
+        and wallet_environments.tx_config.reuse_puzhash
+    ):
+        pytest.skip("Skipping reuse_puzhash + identical amounts for simplicity sake")
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
+
+    wallet_2: Wallet = env_2.xch_wallet
+    wallet_1_rpc: WalletRpcClient = env.rpc_client
+    full_node_rpc: FullNodeRpcClient = wallet_environments.full_node_rpc_client
 
-    wallet_2: Wallet = env.wallet_2.wallet
-    wallet_1_node: WalletNode = env.wallet_1.node
-    wallet_1_rpc: WalletRpcClient = env.wallet_1.rpc_client
-    full_node_api: FullNodeSimulator = env.full_node.api
-    full_node_rpc: FullNodeRpcClient = env.full_node.rpc_client
+    env.wallet_aliases = {"xch": 1, "cat": 2}
+    env_2.wallet_aliases = {"xch": 1, "cat": 2}
 
-    generated_funds = await generate_funds(full_node_api, env.wallet_1)
+    outputs = await create_tx_outputs(wallet_2, wallet_environments.tx_config, output_args)
+    amount_outputs = sum(output.amount for output in outputs)
+    amount_fee = uint64(fee)
 
     wallet_id = 1
     if is_cat:
-        generated_funds = 10**9
-
-        res = await wallet_1_rpc.create_new_cat_and_wallet(uint64(generated_funds), test=True)
-        assert res["success"]
-        wallet_id = res["wallet_id"]
-
-        await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-        for _ in range(5):
-            if check_mempool_spend_count(full_node_api, 0):
-                break
-            await farm_transaction_block(full_node_api, wallet_1_node)
+        create_cat_res = await wallet_1_rpc.create_new_wallet(
+            CreateNewWallet(
+                wallet_type=CreateNewWalletType.CAT_WALLET,
+                mode=WalletCreationMode.NEW,
+                amount=uint64(amount_outputs + 1),
+                test=True,
+                push=True,
+            ),
+            tx_config=wallet_environments.tx_config,
+        )
+        wallet_id = create_cat_res.wallet_id
 
-    outputs = await create_tx_outputs(wallet_2, output_args)
-    amount_outputs = sum(output["amount"] for output in outputs)
-    amount_fee = uint64(fee)
+        await wallet_environments.process_pending_states(
+            [
+                WalletStateTransition(
+                    pre_block_balance_updates={
+                        "xch": {"set_remainder": True},
+                        "cat": {"init": True, "set_remainder": True},
+                    },
+                    post_block_balance_updates={
+                        "xch": {"set_remainder": True},
+                        "cat": {"set_remainder": True},
+                    },
+                ),
+                WalletStateTransition(
+                    pre_block_balance_updates={},
+                    post_block_balance_updates={},
+                ),
+            ]
+        )
 
     if is_cat:
-        amount_total = amount_outputs
+        amount_total: int = amount_outputs
     else:
         amount_total = amount_outputs + amount_fee
 
@@ -658,7 +625,9 @@ async def test_create_signed_transaction(
     if select_coin:
         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
+                amount=uint64(amount_total),
+                wallet_id=uint32(wallet_id),
+                coin_selection_config=wallet_environments.tx_config.coin_selection_config,
             )
         )
         assert len(select_coins_response.coins) == 1
@@ -666,15 +635,17 @@ async def test_create_signed_transaction(
 
     txs = (
         await wallet_1_rpc.create_signed_transactions(
-            outputs,
-            coins=[selected_coin] if selected_coin is not None else [],
-            fee=amount_fee,
-            wallet_id=wallet_id,
+            CreateSignedTransaction(
+                additions=outputs,
+                coins=[selected_coin] if selected_coin is not None else None,
+                fee=amount_fee,
+                wallet_id=uint32(wallet_id),
+                push=True,
+            ),
             # shouldn't actually block it
-            tx_config=DEFAULT_TX_CONFIG.override(
+            tx_config=wallet_environments.tx_config.override(
                 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.amount - amount_total > 0
@@ -683,8 +654,72 @@ async def test_create_signed_transaction(
     # Farm the transaction and make sure the wallet balance reflects it correct
     spend_bundle = txs[0].spend_bundle
     assert spend_bundle is not None
-    await farm_transaction(full_node_api, wallet_1_node, spend_bundle)
-    await time_out_assert(20, get_confirmed_balance, generated_funds - amount_total, wallet_1_rpc, wallet_id)
+    xch_delta = amount_total if not is_cat else amount_fee
+    cat_delta = amount_total if is_cat else 0
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={  # type: ignore[arg-type]
+                    "xch": {
+                        "unconfirmed_wallet_balance": -xch_delta,
+                        "<=#spendable_balance": -xch_delta,
+                        "<=#max_send_amount": -xch_delta,
+                        ">=#pending_change": 0,
+                        "pending_coin_removal_count": 1,
+                    }
+                }
+                | (
+                    {
+                        "cat": {
+                            "unconfirmed_wallet_balance": -cat_delta,
+                            "<=#spendable_balance": -cat_delta,
+                            "<=#max_send_amount": -cat_delta,
+                            ">=#pending_change": 1 if is_cat else 0,
+                            "pending_coin_removal_count": 1 if is_cat else 0,
+                        }
+                    }
+                    if is_cat
+                    else {}
+                ),
+                post_block_balance_updates={  # type: ignore[arg-type]
+                    "xch": {
+                        "confirmed_wallet_balance": -xch_delta,
+                        ">=#spendable_balance": 0,
+                        ">=#max_send_amount": 0,
+                        "<=#pending_change": 0,
+                        "pending_coin_removal_count": -1,
+                        "<=#unspent_coin_count": 0,
+                    }
+                }
+                | (
+                    {
+                        "cat": {
+                            "confirmed_wallet_balance": -cat_delta,
+                            ">=#spendable_balance": 1 if is_cat else 0,
+                            ">=#max_send_amount": 1 if is_cat else 0,
+                            "<=#pending_change": -1 if is_cat else 0,
+                            "pending_coin_removal_count": -1 if is_cat else 0,
+                        }
+                    }
+                    if is_cat
+                    else {}
+                ),
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={},
+                post_block_balance_updates={
+                    "cat" if is_cat else "xch": {
+                        "init": is_cat,
+                        "confirmed_wallet_balance": amount_outputs,
+                        "unconfirmed_wallet_balance": amount_outputs,
+                        "spendable_balance": amount_outputs,
+                        "max_send_amount": amount_outputs,
+                        "unspent_coin_count": len(outputs),
+                    }
+                },
+            ),
+        ]
+    )
 
     # Assert every coin comes from the same parent
     additions: list[Coin] = spend_bundle.additions()
@@ -692,9 +727,9 @@ async def test_create_signed_transaction(
 
     # Assert you can get the spend for each addition
     for addition in additions:
-        cr: Optional[CoinRecord] = await full_node_rpc.get_coin_record_by_name(addition.name())
+        cr: CoinRecord | None = await full_node_rpc.get_coin_record_by_name(addition.name())
         assert cr is not None
-        spend: Optional[CoinSpend] = await full_node_rpc.get_puzzle_and_solution(
+        spend: CoinSpend | None = await full_node_rpc.get_puzzle_and_solution(
             addition.parent_coin_info, cr.confirmed_block_index
         )
         assert spend is not None
@@ -703,35 +738,37 @@ async def test_create_signed_transaction(
     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:
+        if output.memos is not None:
             found: bool = False
             for addition_id, addition in addition_dict.items():
                 if (
                     is_cat
-                    and addition.amount == output["amount"]
-                    and memo_dictionary[addition_id][0] == output["puzzle_hash"]
-                    and memo_dictionary[addition_id][1:] == [memo.encode() for memo in output["memos"]]
+                    and addition.amount == output.amount
+                    and memo_dictionary[addition_id][0] == output.puzzle_hash
+                    and memo_dictionary[addition_id][1:] == [memo.encode() for memo in output.memos]
                 ) or (
-                    addition.amount == output["amount"]
-                    and addition.puzzle_hash == output["puzzle_hash"]
-                    and memo_dictionary[addition_id] == [memo.encode() for memo in output["memos"]]
+                    addition.amount == output.amount
+                    and addition.puzzle_hash == output.puzzle_hash
+                    and memo_dictionary[addition_id] == [memo.encode() for memo in output.memos]
                 ):
                     found = True
             assert found
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [1, 1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_create_signed_transaction_with_coin_announcement(
-    wallet_rpc_environment: WalletRpcTestEnvironment,
-) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet_2: Wallet = env.wallet_2.wallet
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    client_node: FullNodeRpcClient = env.full_node.rpc_client
+async def test_create_signed_transaction_with_coin_announcement(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
 
-    await generate_funds(full_node_api, env.wallet_1)
+    wallet_2: Wallet = env_2.xch_wallet
+    client: WalletRpcClient = env.rpc_client
+    client_node: FullNodeRpcClient = wallet_environments.full_node_rpc_client
 
     signed_tx_amount = uint64(888000)
     tx_coin_announcements = [
@@ -744,28 +781,32 @@ async def test_create_signed_transaction_with_coin_announcement(
             std_hash(b"coin_id_2"),
         ),
     ]
-    outputs = await create_tx_outputs(wallet_2, [(signed_tx_amount, None)])
+    outputs = await create_tx_outputs(wallet_2, wallet_environments.tx_config, [(signed_tx_amount, None)])
     tx_res: TransactionRecord = (
         await client.create_signed_transactions(
-            outputs, tx_config=DEFAULT_TX_CONFIG, extra_conditions=(*tx_coin_announcements,)
+            CreateSignedTransaction(additions=outputs),
+            tx_config=wallet_environments.tx_config,
+            extra_conditions=(*tx_coin_announcements,),
         )
     ).signed_tx
     assert_tx_amounts(tx_res, outputs, amount_fee=uint64(0), change_expected=True)
     await assert_push_tx_error(client_node, tx_res)
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [1, 1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_create_signed_transaction_with_puzzle_announcement(
-    wallet_rpc_environment: WalletRpcTestEnvironment,
-) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet_2: Wallet = env.wallet_2.wallet
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    client_node: FullNodeRpcClient = env.full_node.rpc_client
+async def test_create_signed_transaction_with_puzzle_announcement(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
 
-    await generate_funds(full_node_api, env.wallet_1)
+    wallet_2: Wallet = env_2.xch_wallet
+    client: WalletRpcClient = env.rpc_client
+    client_node: FullNodeRpcClient = wallet_environments.full_node_rpc_client
 
     signed_tx_amount = uint64(888000)
     tx_puzzle_announcements = [
@@ -778,38 +819,46 @@ async def test_create_signed_transaction_with_puzzle_announcement(
             std_hash(b"puzzle_hash_2"),
         ),
     ]
-    outputs = await create_tx_outputs(wallet_2, [(signed_tx_amount, None)])
+    outputs = await create_tx_outputs(wallet_2, wallet_environments.tx_config, [(signed_tx_amount, None)])
     tx_res = (
         await client.create_signed_transactions(
-            outputs, tx_config=DEFAULT_TX_CONFIG, extra_conditions=(*tx_puzzle_announcements,)
+            CreateSignedTransaction(additions=outputs),
+            tx_config=wallet_environments.tx_config,
+            extra_conditions=(*tx_puzzle_announcements,),
         )
     ).signed_tx
     assert_tx_amounts(tx_res, outputs, amount_fee=uint64(0), change_expected=True)
     await assert_push_tx_error(client_node, tx_res)
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_create_signed_transaction_with_excluded_coins(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    wallet_1: Wallet = env.wallet_1.wallet
-    wallet_1_rpc: WalletRpcClient = env.wallet_1.rpc_client
-    full_node_api: FullNodeSimulator = env.full_node.api
-    full_node_rpc: FullNodeRpcClient = env.full_node.rpc_client
-    await generate_funds(full_node_api, env.wallet_1)
+async def test_create_signed_transaction_with_excluded_coins(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet_1: Wallet = env.xch_wallet
+    wallet_1_rpc: WalletRpcClient = env.rpc_client
+    full_node_rpc: FullNodeRpcClient = wallet_environments.full_node_rpc_client
 
     async def it_does_not_include_the_excluded_coins() -> None:
         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
+                amount=uint64(250000000000),
+                wallet_id=uint32(1),
+                coin_selection_config=wallet_environments.tx_config.coin_selection_config,
             )
         )
         assert len(select_coins_response.coins) == 1
-        outputs = await create_tx_outputs(wallet_1, [(uint64(250000000000), None)])
+        outputs = await create_tx_outputs(wallet_1, wallet_environments.tx_config, [(uint64(250000000000), None)])
 
         tx = (
             await wallet_1_rpc.create_signed_transactions(
-                outputs,
-                DEFAULT_TX_CONFIG.override(
+                CreateSignedTransaction(additions=outputs),
+                wallet_environments.tx_config.override(
                     excluded_coin_ids=[c.name() for c in select_coins_response.coins],
                 ),
             )
@@ -823,16 +872,18 @@ async def test_create_signed_transaction_with_excluded_coins(wallet_rpc_environm
     async def it_throws_an_error_when_all_spendable_coins_are_excluded() -> None:
         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
+                amount=uint64(1750000000000),
+                wallet_id=uint32(1),
+                coin_selection_config=wallet_environments.tx_config.coin_selection_config,
             )
         )
         assert len(select_coins_response.coins) == 1
-        outputs = await create_tx_outputs(wallet_1, [(uint64(1750000000000), None)])
+        outputs = await create_tx_outputs(wallet_1, wallet_environments.tx_config, [(uint64(1750000000000), None)])
 
         with pytest.raises(ValueError):
             await wallet_1_rpc.create_signed_transactions(
-                outputs,
-                DEFAULT_TX_CONFIG.override(
+                CreateSignedTransaction(additions=outputs),
+                wallet_environments.tx_config.override(
                     excluded_coin_ids=[c.name() for c in select_coins_response.coins],
                 ),
             )
@@ -841,159 +892,47 @@ async def test_create_signed_transaction_with_excluded_coins(wallet_rpc_environm
     await it_throws_an_error_when_all_spendable_coins_are_excluded()
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [1, 1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_spend_clawback_coins(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet_1_node: WalletNode = env.wallet_1.node
-    wallet_2_node: WalletNode = env.wallet_2.node
-    wallet_1_rpc: WalletRpcClient = env.wallet_1.rpc_client
-    wallet_2_rpc: WalletRpcClient = env.wallet_2.rpc_client
-    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
-
-    generated_funds = await generate_funds(full_node_api, env.wallet_1, 1)
-    await generate_funds(full_node_api, env.wallet_2, 1)
-    async with wallet_1.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        wallet_1_puzhash = await action_scope.get_puzzle_hash(wallet_1.wallet_state_manager)
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_1_node, timeout=20)
-    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        wallet_2_puzhash = await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)
-    tx = (
-        await wallet_1_rpc.send_transaction(
-            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,
-        )
-    ).transaction
-    clawback_coin_id_1 = tx.additions[0].name()
-    assert tx.spend_bundle is not None
-    await farm_transaction(full_node_api, wallet_1_node, tx.spend_bundle)
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_2_node, timeout=20)
-    tx = (
-        await wallet_2_rpc.send_transaction(
-            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,
-        )
-    ).transaction
-    assert tx.spend_bundle is not None
-    clawback_coin_id_2 = tx.additions[0].name()
-    await farm_transaction(full_node_api, wallet_2_node, tx.spend_bundle)
-    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 coin ID is not a Clawback coin
-    invalid_coin_id = tx.removals[0].name()
-    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(
-        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(
-        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
-    fake_coin = Coin(coin_record.coin.parent_coin_info, wallet_2_puzhash, coin_record.coin.amount)
-    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(
-        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(
-        dataclasses.replace(farmed_tx, name=fake_coin.name())
-    )
-    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(
-        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(
-            enabled=False,
-            tx_fee=uint64(100),
-            min_amount=uint64(0),
-            batch_size=uint16(1),
-        )
-    )
-    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()
-            )
-    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(
-        SpendClawbackCoins(coin_ids=[clawback_coin_id_1], fee=uint64(500), push=True), tx_config=DEFAULT_TX_CONFIG
-    )
-    assert resp.transaction_ids == []
-
-
-@pytest.mark.anyio
-async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
+async def test_send_transaction_multi(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
 
-    wallet_2: Wallet = env.wallet_2.wallet
-    wallet_node: WalletNode = env.wallet_1.node
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
+    wallet_2: Wallet = env_2.xch_wallet
+    wallet_node: WalletNode = env.node
+    full_node_api: FullNodeSimulator = wallet_environments.full_node
+    client: WalletRpcClient = env.rpc_client
 
-    generated_funds = await generate_funds(full_node_api, env.wallet_1)
+    INITIAL_BALANCE = await env.xch_wallet.get_confirmed_balance()
 
     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
+            amount=uint64(1750000000000),
+            wallet_id=uint32(1),
+            coin_selection_config=wallet_environments.tx_config.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)
+    outputs = await create_tx_outputs(
+        wallet_2, wallet_environments.tx_config, [(uint64(1), ["memo_1"]), (uint64(2), ["memo_2"])]
+    )
+    amount_outputs = sum(output.amount for output in outputs)
     amount_fee = uint64(amount_outputs + 1)
 
     send_tx_res: TransactionRecord = (
         await client.send_transaction_multi(
-            1,
-            outputs,
-            DEFAULT_TX_CONFIG,
-            coins=select_coins_response.coins,
-            fee=amount_fee,
+            SendTransactionMulti(
+                wallet_id=uint32(1),
+                additions=outputs,
+                coins=select_coins_response.coins,
+                fee=amount_fee,
+                push=True,
+            ),
+            tx_config=wallet_environments.tx_config,
         )
     ).transaction
     spend_bundle = send_tx_res.spend_bundle
@@ -1005,7 +944,7 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
 
     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)
+    await time_out_assert(20, get_confirmed_balance, INITIAL_BALANCE - amount_outputs - amount_fee, client, 1)
 
     # Checks that the memo can be retrieved
     tx_confirmed = (await client.get_transaction(GetTransaction(send_tx_res.name))).transaction
@@ -1013,30 +952,39 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
     memos = tx_confirmed.memos
     assert len(memos) == len(outputs)
     for output in outputs:
-        assert [output["memos"][0].encode()] in memos.values()
+        assert output.memos is not None
+        assert [output.memos[0].encode()] in memos.values()
     spend_bundle = send_tx_res.spend_bundle
     assert spend_bundle is not None
     for key in memos.keys():
         assert key in [a.name() for a in spend_bundle.additions()]
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [3]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet: Wallet = env.wallet_1.wallet
-    wallet_node: WalletNode = env.wallet_1.node
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
+async def test_get_transactions(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
 
-    await generate_funds(full_node_api, env.wallet_1, 5)
+    wallet: Wallet = env.xch_wallet
+    wallet_node: WalletNode = env.node
+    full_node_api: FullNodeSimulator = wallet_environments.full_node
+    client: WalletRpcClient = env.rpc_client
 
     all_transactions = (await client.get_transactions(GetTransactions(uint32(1)))).transactions
-    assert len(all_transactions) >= 10
+    initially_farmed_blocks = 3
+    # We expect 2 transactions per farmed block
+    expected_initial_txs_count = initially_farmed_blocks * 2
+    unconfirmed_txs_count = 0
+    assert len(all_transactions) == expected_initial_txs_count
     # Test transaction pagination
-    some_transactions = (await client.get_transactions(GetTransactions(uint32(1), uint16(0), uint16(5)))).transactions
+    some_transactions = (await client.get_transactions(GetTransactions(uint32(1), uint32(0), uint32(5)))).transactions
     some_transactions_2 = (
-        await client.get_transactions(GetTransactions(uint32(1), uint16(5), uint16(10)))
+        await client.get_transactions(GetTransactions(uint32(1), uint32(5), uint32(10)))
     ).transactions
     assert some_transactions == all_transactions[0:5]
     assert some_transactions_2 == all_transactions[5:10]
@@ -1048,13 +996,14 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
     assert all_transactions == sorted(all_transactions, key=attrgetter("confirmed_at_height"), reverse=True)
 
     # Test RELEVANCE
-    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         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(
         SendTransaction(wallet_id=uint32(1), amount=uint64(1), address=encode_puzzle_hash(puzhash, "txch"), push=True),
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
     )  # Create a pending tx
+    unconfirmed_txs_count += 1
 
     with pytest.raises(ValueError, match="There is no known sort foo"):
         await client.get_transactions(GetTransactions(uint32(1), sort_key="foo"))
@@ -1076,20 +1025,25 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
     assert all_transactions == sorted_transactions
 
     # Test get_transactions to address
-    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with wallet.wallet_state_manager.new_action_scope(wallet_environments.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(
         SendTransaction(
             wallet_id=uint32(1), amount=uint64(1), address=encode_puzzle_hash(ph_by_addr, "txch"), push=True
         ),
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
     )
+    unconfirmed_txs_count += 1
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
     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 (
+        len(tx_for_address) == expected_initial_txs_count + unconfirmed_txs_count
+        if wallet_environments.tx_config.reuse_puzhash
+        else 1
+    )
     assert tx_for_address[0].to_puzzle_hash == ph_by_addr
 
     # Test type filter
@@ -1098,14 +1052,15 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
             GetTransactions(uint32(1), type_filter=TransactionTypeFilter.include([TransactionType.COINBASE_REWARD]))
         )
     ).transactions
-    assert len(all_transactions) == 5
+    # Each farmed block creates one COINBASE_REWARD transaction
+    assert len(all_transactions) == initially_farmed_blocks
     assert all(transaction.type == TransactionType.COINBASE_REWARD.value for transaction in all_transactions)
     # Test confirmed filter
     all_transactions = (await client.get_transactions(GetTransactions(uint32(1), confirmed=True))).transactions
-    assert len(all_transactions) == 10
+    assert len(all_transactions) == expected_initial_txs_count
     assert all(transaction.confirmed for transaction in all_transactions)
     all_transactions = (await client.get_transactions(GetTransactions(uint32(1), confirmed=False))).transactions
-    assert len(all_transactions) == 2
+    assert len(all_transactions) == unconfirmed_txs_count
     assert all(not transaction.confirmed for transaction in all_transactions)
 
     # Test bypass broken txs
@@ -1124,14 +1079,16 @@ async def test_get_transactions(wallet_rpc_environment: WalletRpcTestEnvironment
     assert len(all_transactions) == 1
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_transaction_count(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-
-    await generate_funds(full_node_api, env.wallet_1)
+async def test_get_transaction_count(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    client: WalletRpcClient = env.rpc_client
 
     all_transactions = (await client.get_transactions(GetTransactions(uint32(1)))).transactions
     assert len(all_transactions) > 0
@@ -1213,7 +1170,7 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     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())
+    ).name == wallet_type.default_wallet_name_for_unknown_cat(asset_id)
     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))
@@ -1229,10 +1186,17 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     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)
-    assert res["success"]
-    cat_1_id = res["wallet_id"]
-    cat_1_asset_id = bytes.fromhex(res["asset_id"])
+    create_wallet_res = await env_1.rpc_client.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.CAT_WALLET,
+            mode=WalletCreationMode.EXISTING,
+            asset_id=asset_id,
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
+    cat_1_id = create_wallet_res.wallet_id
+    cat_1_asset_id = create_wallet_res.asset_id
     assert cat_1_asset_id == asset_id
 
     await wallet_environments.process_pending_states(
@@ -1525,12 +1489,21 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     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 env_2.rpc_client.create_wallet_for_existing_cat(cat_asset_id)
+    await env_2.rpc_client.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.CAT_WALLET,
+            mode=WalletCreationMode.EXISTING,
+            asset_id=cat_asset_id,
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
     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"]}]
+    adds = [Addition(puzzle_hash=decode_puzzle_hash(wallet_2_address), amount=uint64(4), memos=["the cat memo"])]
     tx_res = (
         await env_1.rpc_client.send_transaction_multi(
-            cat_wallet_id, additions=adds, tx_config=wallet_environments.tx_config, fee=uint64(0)
+            SendTransactionMulti(wallet_id=uint32(cat_wallet_id), additions=adds, fee=uint64(0), push=True),
+            tx_config=wallet_environments.tx_config,
         )
     ).transaction
     spend_bundle = tx_res.spend_bundle
@@ -1586,56 +1559,54 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
         )
     # Create an offer of 5 chia for one CAT
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1}, wallet_environments.tx_config, validate_only=True
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, validate_only=True),
+        tx_config=wallet_environments.tx_config,
     )
-    all_offers = await env_1.rpc_client.get_all_offers()
+    all_offers = (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
     assert len(all_offers) == 0
 
-    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()}}
-            ),
-        }
+    driver_dict = {
+        cat_asset_id: PuzzleInfo(
+            {
+                "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 env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
-        fee=uint64(1),
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict, fee=uint64(1)),
+        tx_config=wallet_environments.tx_config,
     )
     offer = create_res.offer
 
-    id, summary = await env_1.rpc_client.get_offer_summary(offer)
-    assert id == offer.name()
-    id, advanced_summary = await env_1.rpc_client.get_offer_summary(offer, advanced=True)
-    assert id == offer.name()
-    assert summary == {
-        "offered": {"xch": 5},
-        "requested": {cat_asset_id.hex(): 1},
-        "infos": driver_dict,
-        "fees": 1,
-        "additions": [c.name().hex() for c in offer.additions()],
-        "removals": [c.name().hex() for c in offer.removals()],
-        "valid_times": {
-            "max_height": None,
-            "max_time": None,
-            "min_height": None,
-            "min_time": None,
-        },
-    }
-    assert advanced_summary == summary
+    offer_summary_response = await env_1.rpc_client.get_offer_summary(GetOfferSummary(offer.to_bech32()))
+    assert offer_summary_response.id == offer.name()
+    offer_summary_response_advanced = await env_1.rpc_client.get_offer_summary(
+        GetOfferSummary(offer.to_bech32(), advanced=True)
+    )
+    assert offer_summary_response_advanced.id == offer.name()
+    assert offer_summary_response_advanced.summary == OfferSummary(
+        offered={"xch": "5"},
+        requested={cat_asset_id.hex(): "1"},
+        infos={key.hex(): info for key, info in driver_dict.items()},
+        fees=uint64(1),
+        additions=[c.name() for c in offer.additions()],
+        removals=[c.name() for c in offer.removals()],
+        valid_times=ConditionValidTimesAbsolute(),
+    )
+    assert offer_summary_response_advanced.summary == offer_summary_response.summary
 
     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 env_1.rpc_client.get_all_offers(file_contents=True)
+    all_offers = (await env_1.rpc_client.get_all_offers(GetAllOffers(file_contents=True))).trade_records
     assert len(all_offers) == 1
     assert TradeStatus(all_offers[0].status) == TradeStatus.PENDING_ACCEPT
     assert all_offers[0].offer == bytes(offer)
@@ -1645,26 +1616,44 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     assert offer_count.my_offers_count == 1
     assert offer_count.taken_offers_count == 0
 
-    trade_record = (await env_2.rpc_client.take_offer(offer, wallet_environments.tx_config, fee=uint64(1))).trade_record
+    trade_record = (
+        await env_2.rpc_client.take_offer(
+            TakeOffer(
+                offer=offer.to_bech32(),
+                fee=uint64(1),
+                push=True,
+            ),
+            wallet_environments.tx_config,
+        )
+    ).trade_record
     assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CONFIRM
 
-    await env_1.rpc_client.cancel_offer(offer.name(), wallet_environments.tx_config, secure=False)
-
-    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 env_1.rpc_client.cancel_offer(
+        CancelOffer(
+            trade_id=offer.name(),
+            secure=False,
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
+
+    trade_record = (await env_1.rpc_client.get_offer(GetOffer(offer.name(), file_contents=True))).trade_record
+    assert trade_record.offer == bytes(offer)
+    assert TradeStatus(trade_record.status) == TradeStatus.CANCELLED
 
     failed_cancel_res = await env_1.rpc_client.cancel_offer(
-        offer.name(), wallet_environments.tx_config, fee=uint64(1), secure=True
+        CancelOffer(trade_id=offer.name(), fee=uint64(1), secure=True, push=True),
+        tx_config=wallet_environments.tx_config,
     )
 
-    trade_record = await env_1.rpc_client.get_offer(offer.name())
+    trade_record = (await env_1.rpc_client.get_offer(GetOffer(offer.name()))).trade_record
     assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CANCEL
 
     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)
+        CreateOfferForIDs(offer={str(1): "-5", str(cat_wallet_id): "1"}, fee=uint64(1)),
+        tx_config=wallet_environments.tx_config,
     )
-    all_offers = await env_1.rpc_client.get_all_offers()
+    all_offers = (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
     assert len(all_offers) == 2
     offer_count = await env_1.rpc_client.get_offers_count()
     assert offer_count.total == 2
@@ -1744,7 +1733,7 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     )
 
     async def is_trade_confirmed(client: WalletRpcClient, offer: Offer) -> bool:
-        trade_record = await client.get_offer(offer.name())
+        trade_record = (await client.get_offer(GetOffer(offer.name()))).trade_record
         return TradeStatus(trade_record.status) == TradeStatus.CONFIRMED
 
     await time_out_assert(15, is_trade_confirmed, True, env_1.rpc_client, offer)
@@ -1753,39 +1742,64 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
         return [t.trade_id for t in trades]
 
-    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
+    trade_record = (await env_1.rpc_client.get_offer(GetOffer(offer.name()))).trade_record
+    all_offers = (  # confirmed at index descending
+        await env_1.rpc_client.get_all_offers(GetAllOffers(include_completed=True))
+    ).trade_records
     assert len(all_offers) == 2
     assert only_ids(all_offers) == only_ids([trade_record, new_trade_record])
-    all_offers = await env_1.rpc_client.get_all_offers(
-        include_completed=True, reverse=True
-    )  # confirmed at index ascending
+    all_offers = (  # confirmed at index ascending
+        await env_1.rpc_client.get_all_offers(GetAllOffers(include_completed=True, reverse=True))
+    ).trade_records
     assert only_ids(all_offers) == only_ids([new_trade_record, trade_record])
-    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True, sort_key="RELEVANCE")  # most relevant
+    all_offers = (  # most relevant
+        await env_1.rpc_client.get_all_offers(GetAllOffers(include_completed=True, sort_key="RELEVANCE"))
+    ).trade_records
     assert only_ids(all_offers) == only_ids([new_trade_record, trade_record])
-    all_offers = await env_1.rpc_client.get_all_offers(
-        include_completed=True, sort_key="RELEVANCE", reverse=True
-    )  # least relevant
+    all_offers = (  # least relevant
+        await env_1.rpc_client.get_all_offers(GetAllOffers(include_completed=True, sort_key="RELEVANCE", reverse=True))
+    ).trade_records
     assert only_ids(all_offers) == only_ids([trade_record, new_trade_record])
     # Test pagination
-    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True, start=0, end=1)
+    all_offers = (
+        await env_1.rpc_client.get_all_offers(GetAllOffers(include_completed=True, start=uint16(0), end=uint16(1)))
+    ).trade_records
     assert len(all_offers) == 1
-    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True, start=50)
+    all_offers = (
+        await env_1.rpc_client.get_all_offers(GetAllOffers(include_completed=True, start=uint16(10)))
+    ).trade_records
     assert len(all_offers) == 0
-    all_offers = await env_1.rpc_client.get_all_offers(include_completed=True, start=0, end=50)
+    all_offers = (
+        await env_1.rpc_client.get_all_offers(GetAllOffers(include_completed=True, start=uint16(0), end=uint16(50)))
+    ).trade_records
     assert len(all_offers) == 2
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
-        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
+        len(
+            [
+                o
+                for o in (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
+                if o.status == TradeStatus.PENDING_ACCEPT.value
+            ]
+        )
+        == 2
+    )
+    await env_1.rpc_client.cancel_offers(
+        CancelOffers(secure=True, batch_size=uint16(1), push=True), tx_config=wallet_environments.tx_config
     )
-    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
+        len(
+            [
+                o
+                for o in (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
+                if o.status == TradeStatus.PENDING_ACCEPT.value
+            ]
+        )
+        == 0
     )
     await wallet_environments.process_pending_states(
         [
@@ -1814,21 +1828,35 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     )
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): 5, cat_asset_id.hex(): -1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "5", cat_asset_id.hex(): "-1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
-        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
+        len(
+            [
+                o
+                for o in (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
+                if o.status == TradeStatus.PENDING_ACCEPT.value
+            ]
+        )
+        == 2
+    )
+    await env_1.rpc_client.cancel_offers(
+        CancelOffers(secure=True, cancel_all=True, push=True), tx_config=wallet_environments.tx_config
     )
-    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
+        len(
+            [
+                o
+                for o in (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
+                if o.status == TradeStatus.PENDING_ACCEPT.value
+            ]
+        )
+        == 0
     )
 
     await wallet_environments.process_pending_states(
@@ -1868,51 +1896,81 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     )
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): 5, cat_asset_id.hex(): -1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "5", cat_asset_id.hex(): "-1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
-        len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 1
+        len(
+            [
+                o
+                for o in (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
+                if o.status == TradeStatus.PENDING_ACCEPT.value
+            ]
+        )
+        == 1
+    )
+    await env_1.rpc_client.cancel_offers(
+        CancelOffers(secure=True, asset_id=bytes32.zeros.hex(), push=True), tx_config=wallet_environments.tx_config
     )
-    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
+        len(
+            [
+                o
+                for o in (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
+                if o.status == TradeStatus.PENDING_ACCEPT.value
+            ]
+        )
+        == 1
+    )
+    await env_1.rpc_client.cancel_offers(
+        CancelOffers(secure=True, asset_id=cat_asset_id.hex(), push=True), tx_config=wallet_environments.tx_config
     )
-    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
+        len(
+            [
+                o
+                for o in (await env_1.rpc_client.get_all_offers(GetAllOffers())).trade_records
+                if o.status == TradeStatus.PENDING_ACCEPT.value
+            ]
+        )
+        == 0
     )
 
     with pytest.raises(ValueError, match="not currently supported"):
         await env_1.rpc_client.create_offer_for_ids(
-            {uint32(1): -5, cat_asset_id.hex(): 1},
+            CreateOfferForIDs(
+                offer={str(1): "-5", cat_asset_id.hex(): "1"},
+                driver_dict=driver_dict,
+            ),
             wallet_environments.tx_config,
-            driver_dict=driver_dict,
             timelock_info=ConditionValidTimes(min_secs_since_created=uint64(1)),
         )
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [5]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    wallet_node: WalletNode = env.wallet_1.node
-    client: WalletRpcClient = env.wallet_1.rpc_client
+async def test_get_coin_records_by_names(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet_node: WalletNode = env.node
+    client: WalletRpcClient = env.rpc_client
     store = wallet_node.wallet_state_manager.coin_store
-    full_node_api = env.full_node.api
-    # Generate some funds
-    generated_funds = await generate_funds(full_node_api, env.wallet_1, 5)
-    async with env.wallet_1.wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        address = encode_puzzle_hash(
-            await action_scope.get_puzzle_hash(env.wallet_1.wallet.wallet_state_manager), "txch"
-        )
+    full_node_api = wallet_environments.full_node
+
+    INITIAL_BALANCE = await env.xch_wallet.get_confirmed_balance()
+    async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+        address = encode_puzzle_hash(await action_scope.get_puzzle_hash(env.wallet_state_manager), "txch")
     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(
-            SendTransaction(wallet_id=uint32(1), amount=uint64(generated_funds / 2), address=address, push=True),
-            DEFAULT_TX_CONFIG,
+            SendTransaction(wallet_id=uint32(1), amount=uint64(INITIAL_BALANCE / 2), address=address, push=True),
+            wallet_environments.tx_config,
         )
     ).transaction
     assert tx.spend_bundle is not None
@@ -1958,31 +2016,55 @@ async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEn
         await client.get_coin_records_by_names(GetCoinRecordsByNames(coin_ids, include_spent_coins=False))
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [1, 1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet_1: Wallet = env.wallet_1.wallet
-    wallet_2: Wallet = env.wallet_2.wallet
-    wallet_1_node: WalletNode = env.wallet_1.node
-    wallet_2_node: WalletNode = env.wallet_2.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
-    wallet_1_id = wallet_1.id()
+async def test_did_endpoints(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
+
+    env.wallet_aliases = {
+        "xch": 1,
+        "did": 2,
+        "nft": 3,
+    }
+    env_2.wallet_aliases = {
+        "xch": 1,
+        "did": 2,
+    }
 
-    await generate_funds(env.full_node.api, env.wallet_1, 5)
+    wallet_1: Wallet = env.xch_wallet
+    wallet_2: Wallet = env_2.xch_wallet
+    wallet_1_node: WalletNode = env.node
+    wallet_2_node: WalletNode = env_2.node
+    wallet_1_rpc: WalletRpcClient = env.rpc_client
+    wallet_2_rpc: WalletRpcClient = env_2.rpc_client
+    wallet_1_id = wallet_1.id()
 
     # Create a DID wallet
-    res = await wallet_1_rpc.create_new_did_wallet(amount=1, tx_config=DEFAULT_TX_CONFIG, name="Profile 1")
-    assert res["success"]
-    did_wallet_id_0 = res["wallet_id"]
-    did_id_0 = res["my_did"]
+    create_new_res = await wallet_1_rpc.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.DID_WALLET,
+            did_type=DIDType.NEW,
+            amount=uint64(1),
+            wallet_name="Profile 1",
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
+    did_wallet_id_0 = create_new_res.wallet_id
+    did_id_0 = create_new_res.my_did
+    await env.change_balances({"did": {"init": True, "set_remainder": True}})
+    await env.change_balances({"nft": {"init": True, "set_remainder": True}})
 
     # Get wallet name
     get_name_res = await wallet_1_rpc.did_get_wallet_name(DIDGetWalletName(did_wallet_id_0))
     assert get_name_res.name == "Profile 1"
-    nft_wallet = wallet_1_node.wallet_state_manager.wallets[did_wallet_id_0 + 1]
+    nft_wallet = wallet_1_node.wallet_state_manager.wallets[uint32(did_wallet_id_0 + 1)]
     assert isinstance(nft_wallet, NFTWallet)
     assert nft_wallet.get_name() == "Profile 1 NFT Wallet"
 
@@ -2000,36 +2082,80 @@ 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)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
 
     # Update metadata
     with pytest.raises(ValueError, match="wallet id 1 is of type Wallet but type DIDWallet is required"):
         await wallet_1_rpc.update_did_metadata(
-            DIDUpdateMetadata(wallet_id=wallet_1_id, metadata={"Twitter": "Https://test"}, push=True), DEFAULT_TX_CONFIG
+            DIDUpdateMetadata(wallet_id=wallet_1_id, metadata={"Twitter": "Https://test"}, push=True),
+            wallet_environments.tx_config,
         )
     await wallet_1_rpc.update_did_metadata(
-        DIDUpdateMetadata(wallet_id=did_wallet_id_0, metadata={"Twitter": "Https://test"}, push=True), DEFAULT_TX_CONFIG
+        DIDUpdateMetadata(wallet_id=did_wallet_id_0, metadata={"Twitter": "Https://test"}, push=True),
+        wallet_environments.tx_config,
     )
 
     get_metadata_res = await wallet_1_rpc.get_did_metadata(DIDGetMetadata(did_wallet_id_0))
     assert get_metadata_res.metadata["Twitter"] == "Https://test"
 
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-    await farm_transaction_block(full_node_api, wallet_1_node)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
 
     # Transfer DID
-    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with wallet_2.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
     await wallet_1_rpc.did_transfer_did(
         DIDTransferDID(
             wallet_id=did_wallet_id_0, inner_address=addr, fee=uint64(0), with_recovery_info=True, push=True
         ),
-        DEFAULT_TX_CONFIG,
+        wallet_environments.tx_config,
     )
 
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-    await farm_transaction_block(full_node_api, wallet_1_node)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(
+                post_block_balance_updates={
+                    "did": {"init": True, "set_remainder": True},
+                }
+            ),
+        ]
+    )
 
     async def num_wallets() -> int:
         return len(await wallet_2_node.wallet_state_manager.get_all_wallet_info_entries())
@@ -2052,23 +2178,52 @@ async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -
     assert metadata["Twitter"] == "Https://test"
 
     last_did_coin = await did_wallet_2.get_coin()
-    await wallet_2_rpc.did_message_spend(DIDMessageSpend(wallet_id=did_wallet_2.id(), push=True), DEFAULT_TX_CONFIG)
+    await wallet_2_rpc.did_message_spend(
+        DIDMessageSpend(wallet_id=did_wallet_2.id(), push=True), wallet_environments.tx_config
+    )
     await wallet_2_node.wallet_state_manager.add_interested_coin_ids([last_did_coin.name()])
 
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-    await farm_transaction_block(full_node_api, wallet_2_node)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+            ),
+        ]
+    )
 
     next_did_coin = await did_wallet_2.get_coin()
     assert next_did_coin.parent_coin_info == last_did_coin.name()
     last_did_coin = next_did_coin
 
     await wallet_2_rpc.did_message_spend(
-        DIDMessageSpend(wallet_id=did_wallet_2.id(), push=True), DEFAULT_TX_CONFIG.override(reuse_puzhash=True)
+        DIDMessageSpend(wallet_id=did_wallet_2.id(), push=True),
+        wallet_environments.tx_config.override(reuse_puzhash=True),
     )
     await wallet_2_node.wallet_state_manager.add_interested_coin_ids([last_did_coin.name()])
 
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-    await farm_transaction_block(full_node_api, wallet_2_node)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                },
+            ),
+        ]
+    )
 
     next_did_coin = await did_wallet_2.get_coin()
     assert next_did_coin.parent_coin_info == last_did_coin.name()
@@ -2079,21 +2234,37 @@ async def test_did_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -
     assert isinstance(pubkey_res.pubkey, G1Element)
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [1, 1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_nft_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    wallet_1_node: WalletNode = env.wallet_1.node
-    wallet_1_rpc: WalletRpcClient = env.wallet_1.rpc_client
-    wallet_2: Wallet = env.wallet_2.wallet
-    wallet_2_node: WalletNode = env.wallet_2.node
-    wallet_2_rpc: WalletRpcClient = env.wallet_2.rpc_client
-    full_node_api: FullNodeSimulator = env.full_node.api
-
-    await generate_funds(env.full_node.api, env.wallet_1, 5)
-
-    res = await wallet_1_rpc.create_new_nft_wallet(None)
-    nft_wallet_id = res["wallet_id"]
-    mint_res = await wallet_1_rpc.mint_nft(
+async def test_nft_endpoints(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
+    wallet_1_node: WalletNode = env.node
+    wallet_1_rpc: WalletRpcClient = env.rpc_client
+    wallet_2: Wallet = env_2.xch_wallet
+    wallet_2_node: WalletNode = env_2.node
+    wallet_2_rpc: WalletRpcClient = env_2.rpc_client
+
+    env.wallet_aliases = {
+        "xch": 1,
+        "nft": 2,
+    }
+    env_2.wallet_aliases = {
+        "xch": 1,
+        "nft": 2,
+    }
+
+    create_wallet_res = await wallet_1_rpc.create_new_wallet(
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, did_id=None, push=True),
+        wallet_environments.tx_config,
+    )
+    nft_wallet_id = create_wallet_res.wallet_id
+    await wallet_1_rpc.mint_nft(
         request=NFTMintNFTRequest(
             wallet_id=nft_wallet_id,
             royalty_address=None,
@@ -2102,14 +2273,24 @@ async def test_nft_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -
             uris=["https://www.chia.net/img/branding/chia-logo.svg"],
             push=True,
         ),
-        tx_config=DEFAULT_TX_CONFIG,
+        tx_config=wallet_environments.tx_config,
     )
 
-    spend_bundle = mint_res.spend_bundle
-
-    await farm_transaction(full_node_api, wallet_1_node, spend_bundle)
-
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_1_node, timeout=15)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "nft": {"init": True, "set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "nft": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
 
     nft_wallet = wallet_1_node.wallet_state_manager.wallets[nft_wallet_id]
     assert isinstance(nft_wallet, NFTWallet)
@@ -2132,17 +2313,34 @@ async def test_nft_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -
     nft_info = (await wallet_1_rpc.get_nft_info(NFTGetInfo(hmr_nft_id))).nft_info
     assert nft_info.nft_coin_id == (await nft_wallet.get_current_nfts())[0].coin.name()
 
-    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with wallet_2.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
     await wallet_1_rpc.transfer_nft(
-        NFTTransferNFT(wallet_id=nft_wallet_id, nft_coin_id=nft_id, target_address=addr, push=True), DEFAULT_TX_CONFIG
+        NFTTransferNFT(wallet_id=nft_wallet_id, nft_coin_id=nft_id, target_address=addr, push=True),
+        wallet_environments.tx_config,
     )
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 1)
-    await farm_transaction_block(full_node_api, wallet_1_node)
-    await time_out_assert(5, check_mempool_spend_count, True, full_node_api, 0)
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_1_node, timeout=5)
 
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_2_node, timeout=5)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "nft": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "nft": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={},
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "nft": {"init": True, "set_remainder": True},
+                },
+            ),
+        ]
+    )
 
     nft_wallet_id_1 = (
         await wallet_2_node.wallet_state_manager.get_all_wallet_info_entries(wallet_type=WalletType.NFT)
@@ -2261,13 +2459,19 @@ async def _check_delete_key(
     assert resp.used_for_pool_rewards is False
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
+async def test_key_and_address_endpoints(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
 
-    wallet: Wallet = env.wallet_1.wallet
-    wallet_node: WalletNode = env.wallet_1.node
-    client: WalletRpcClient = env.wallet_1.rpc_client
+    wallet: Wallet = env.xch_wallet
+    wallet_node: WalletNode = env.node
+    client: WalletRpcClient = env.rpc_client
 
     address = (await client.get_next_address(GetNextAddress(uint32(1), True))).address
     assert len(address) > 10
@@ -2275,18 +2479,17 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
     pks = (await client.get_public_keys()).pk_fingerprints
     assert len(pks) == 1
 
-    await generate_funds(env.full_node.api, env.wallet_1)
-
     assert (await client.get_height_info()).height > 0
 
-    async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+    async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
         ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
+    await wallet_environments.full_node.wait_for_wallet_synced(wallet_node)
     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(
-            SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True), DEFAULT_TX_CONFIG
+            SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True),
+            wallet_environments.tx_config,
         )
     ).transaction
 
@@ -2340,7 +2543,9 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
     assert delete_key_resp.used_for_farmer_rewards is False
     assert delete_key_resp.used_for_pool_rewards is False
 
+    assert get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(pks[0])).exists()
     await client.delete_key(DeleteKey(pks[0]))
+    assert not get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(pks[0])).exists()
     await client.log_in(LogIn(uint32(pks[1])))
     assert len((await client.get_public_keys()).pk_fingerprints) == 1
 
@@ -2353,28 +2558,46 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
     with pytest.raises(ValueError):
         await client.send_transaction(
             SendTransaction(wallet_id=uint32(wallets[0].id), amount=uint64(100), address=addr, push=True),
-            DEFAULT_TX_CONFIG,
+            wallet_environments.tx_config,
         )
 
     # Delete all keys
+    resp = await client.generate_mnemonic()
+    add_key_resp = await client.add_key(AddKey(resp.mnemonic))
+    assert get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(pks[1])).exists()
+    assert get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(add_key_resp.fingerprint)).exists()
     await client.delete_all_keys()
+    assert not get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(pks[1])).exists()
+    assert not get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(add_key_resp.fingerprint)).exists()
     assert len((await client.get_public_keys()).pk_fingerprints) == 0
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [1, 0]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
+async def test_select_coins_rpc(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
 
-    wallet_2: Wallet = env.wallet_2.wallet
-    wallet_node: WalletNode = env.wallet_1.node
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    client_2: WalletRpcClient = env.wallet_2.rpc_client
+    env.wallet_aliases = {"xch": 1}
+    env_2.wallet_aliases = {"xch": 1}
 
-    funds = await generate_funds(full_node_api, env.wallet_1)
+    wallet_2: Wallet = env_2.xch_wallet
+    client: WalletRpcClient = env.rpc_client
+    client_2: WalletRpcClient = env_2.rpc_client
 
-    async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
+    funds: int = await env.xch_wallet.get_confirmed_balance()
+
+    # since this wallet farms no blocks, this first request will always make a new puzzle hash
+    with wallet_environments.new_puzzle_hashes_allowed():
+        async with wallet_2.wallet_state_manager.new_action_scope(
+            wallet_environments.tx_config, push=True
+        ) as action_scope:
+            addr = encode_puzzle_hash(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager), "txch")
     coin_300: list[Coin]
     tx_amounts: list[uint64] = [uint64(1000), uint64(300), uint64(1000), uint64(1000), uint64(10000)]
     for tx_amount in tx_amounts:
@@ -2382,7 +2605,8 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         # create coins for tests
         tx = (
             await client.send_transaction(
-                SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True), DEFAULT_TX_CONFIG
+                SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True),
+                wallet_environments.tx_config,
             )
         ).transaction
         spend_bundle = tx.spend_bundle
@@ -2391,16 +2615,27 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
             if coin.amount == uint64(300):
                 coin_300 = [coin]
 
-        await time_out_assert(20, tx_in_mempool, True, client, tx.name)
-        await farm_transaction(full_node_api, wallet_node, spend_bundle)
-        await time_out_assert(20, get_confirmed_balance, funds, client, 1)
+        await wallet_environments.process_pending_states(
+            [
+                WalletStateTransition(
+                    pre_block_balance_updates={"xch": {"set_remainder": True}},
+                    post_block_balance_updates={"xch": {"set_remainder": True}},
+                ),
+                WalletStateTransition(
+                    pre_block_balance_updates={},
+                    post_block_balance_updates={"xch": {"set_remainder": True}},
+                ),
+            ]
+        )
 
     # test min coin amount
     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)),
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
+                min_coin_amount=uint64(1001)
+            ),
         )
     )
     assert len(min_coins_response.coins) == 1
@@ -2411,7 +2646,7 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         SelectCoins.from_coin_selection_config(
             amount=uint64(2000),
             wallet_id=uint32(1),
-            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
                 min_coin_amount=uint64(999), max_coin_amount=uint64(9999)
             ),
         )
@@ -2425,7 +2660,9 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         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)]),
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
+                excluded_coin_amounts=[uint64(1000)]
+            ),
         )
     )
     assert len(excluded_amt_coins_response.coins) == len([a for a in tx_amounts if a != 1000])
@@ -2437,7 +2674,7 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
             SelectCoins.from_coin_selection_config(
                 amount=uint64(5000),
                 wallet_id=uint32(1),
-                coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+                coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
                     excluded_coin_ids=[c.name() for c in min_coins_response.coins]
                 ),
             )
@@ -2446,7 +2683,7 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         SelectCoins.from_coin_selection_config(
             amount=uint64(1300),
             wallet_id=uint32(1),
-            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
                 excluded_coin_ids=[c.name() for c in coin_300]
             ),
         )
@@ -2474,7 +2711,7 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
     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(
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
                 excluded_coin_ids=[c.name() for c in excluded_amt_coins_response.coins]
             ),
         ),
@@ -2488,14 +2725,18 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
     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)]),
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
+                excluded_coin_amounts=[uint64(1000)]
+            ),
         )
     )
     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)),
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
+                max_coin_amount=uint64(999)
+            ),
         )
     )
     assert spendable_coins_response.confirmed_records[0].coin == coin_300[0]
@@ -2503,16 +2744,24 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         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=[b"a"]),
+                coin_selection_config=wallet_environments.tx_config.coin_selection_config.override(
+                    excluded_coin_ids=[b"a"]
+                ),
             )
         )
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [0], "reuse_puzhash": True, "trusted": True}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_coin_records_rpc(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    wallet_node: WalletNode = env.wallet_1.node
-    client: WalletRpcClient = env.wallet_1.rpc_client
+async def test_get_coin_records_rpc(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet_node: WalletNode = env.node
+    client: WalletRpcClient = env.rpc_client
     store = wallet_node.wallet_state_manager.coin_store
 
     for record in [record_1, record_2, record_3, record_4, record_5, record_6, record_7, record_8, record_9]:
@@ -2521,7 +2770,7 @@ async def test_get_coin_records_rpc(wallet_rpc_environment: WalletRpcTestEnviron
     async def run_test_case(
         test_case: str,
         test_request: GetCoinRecords,
-        test_total_count: Optional[int],
+        test_total_count: int | None,
         test_records: list[WalletCoinRecord],
     ) -> None:
         response = await client.get_coin_records(test_request)
@@ -2554,28 +2803,28 @@ async def test_get_coin_records_rpc(wallet_rpc_environment: WalletRpcTestEnviron
             await run_test_case(f"{name}-{i}", request, expected_total_count, expected_records)
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [0], "reuse_puzhash": True, "trusted": True}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_coin_records_rpc_limits(
-    wallet_rpc_environment: WalletRpcTestEnvironment,
-    seeded_random: random.Random,
-) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    wallet_node: WalletNode = env.wallet_1.node
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
-    assert rpc_server is not None
-    api: WalletRpcApi = rpc_server.rpc_api
+async def test_get_coin_records_rpc_limits(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet_node: WalletNode = env.node
+    client: WalletRpcClient = env.rpc_client
     store = wallet_node.wallet_state_manager.coin_store
 
     # Adjust the limits for faster testing
     WalletRpcApi.max_get_coin_records_limit = uint32(5)
     WalletRpcApi.max_get_coin_records_filter_items = uint32(5)
 
-    max_coins = api.max_get_coin_records_limit * 10
+    max_coins = WalletRpcApi.max_get_coin_records_limit * 10
     coin_records = [
         WalletCoinRecord(
-            Coin(bytes32.random(seeded_random), bytes32.random(seeded_random), uint64(seeded_random.randrange(2**64))),
-            uint32(seeded_random.randrange(2**32)),
+            Coin(bytes32(bytes([i] * 32)), bytes32(bytes([i] * 32)), uint64(i)),
+            uint32(i),
             uint32(0),
             False,
             False,
@@ -2584,15 +2833,15 @@ async def test_get_coin_records_rpc_limits(
             CoinType.NORMAL,
             None,
         )
-        for _ in range(max_coins)
+        for i in range(max_coins)
     ]
     for record in coin_records:
         await store.add_coin_record(record)
 
-    limit = api.max_get_coin_records_limit
+    limit = WalletRpcApi.max_get_coin_records_limit
     response_records = []
-    for i in range(int(max_coins / api.max_get_coin_records_limit)):
-        offset = uint32(api.max_get_coin_records_limit * i)
+    for i in range(int(max_coins / WalletRpcApi.max_get_coin_records_limit)):
+        offset = uint32(WalletRpcApi.max_get_coin_records_limit * i)
         response = await client.get_coin_records(GetCoinRecords(limit=limit, offset=offset, include_total_count=True))
         response_records.extend(list(response["coin_records"]))
 
@@ -2603,7 +2852,7 @@ async def test_get_coin_records_rpc_limits(
         assert expected_record in response_records
 
     # Request coins with the max number of filter items
-    max_filter_items = api.max_get_coin_records_filter_items
+    max_filter_items = WalletRpcApi.max_get_coin_records_filter_items
     filter_records = coin_records[:max_filter_items]
     coin_id_filter = HashFilter.include([coin.name() for coin in filter_records])
     puzzle_hash_filter = HashFilter.include([coin.coin.puzzle_hash for coin in filter_records])
@@ -2627,24 +2876,22 @@ async def test_get_coin_records_rpc_limits(
             assert expected_record in response["coin_records"]
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [0], "reuse_puzhash": True, "trusted": True}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_coin_records_rpc_failures(
-    wallet_rpc_environment: WalletRpcTestEnvironment,
-    seeded_random: random.Random,
-) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
-    assert rpc_server is not None
-    api = rpc_server.rpc_api
-
-    too_many_hashes = [bytes32.random(seeded_random) for _ in range(api.max_get_coin_records_filter_items + 1)]
-    too_many_amounts = [
-        uint64(uint64(seeded_random.randrange(2**64))) for _ in range(api.max_get_coin_records_filter_items + 1)
-    ]
+async def test_get_coin_records_rpc_failures(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    client: WalletRpcClient = env.rpc_client
+
+    too_many_hashes = [bytes32.secret() for i in range(WalletRpcApi.max_get_coin_records_filter_items + 1)]
+    too_many_amounts = [uint64(i) for i in range(WalletRpcApi.max_get_coin_records_filter_items + 1)]
     # Run requests which exceeds the allowed limit and contain too much filter items
     for name, request in {
-        "limit": GetCoinRecords(limit=uint32(api.max_get_coin_records_limit + 1)),
+        "limit": GetCoinRecords(limit=uint32(WalletRpcApi.max_get_coin_records_limit + 1)),
         "coin_id_filter": GetCoinRecords(coin_id_filter=HashFilter.include(too_many_hashes)),
         "puzzle_hash_filter": GetCoinRecords(puzzle_hash_filter=HashFilter.include(too_many_hashes)),
         "parent_coin_id_filter": GetCoinRecords(parent_coin_id_filter=HashFilter.include(too_many_hashes)),
@@ -2653,44 +2900,33 @@ 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.
-    for field, value in {
-        "offset": "invalid",
-        "limit": "invalid",
-        "wallet_id": "invalid",
-        "wallet_type": 100,
-        "coin_type": 100,
-        "coin_id_filter": "invalid",
-        "puzzle_hash_filter": "invalid",
-        "parent_coin_id_filter": "invalid",
-        "amount_filter": "invalid",
-        "amount_range": "invalid",
-        "confirmed_range": "invalid",
-        "spent_range": "invalid",
-        "order": 8,
-    }.items():
-        with pytest.raises((ConversionError, InvalidTypeError, ValueError)):
-            json_dict = GetCoinRecords().to_json_dict()
-            json_dict[field] = value
-            await api.get_coin_records(json_dict)
-
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 2,
+            "blocks_needed": [1, 1],
+            "config_overrides": {"enable_notifications": True, "required_notification_amount": 100000000000},
+        }
+    ],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    wallet_2: Wallet = env.wallet_2.wallet
-    wallet_node: WalletNode = env.wallet_1.node
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    client_2: WalletRpcClient = env.wallet_2.rpc_client
+async def test_notification_rpcs(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
 
-    await generate_funds(full_node_api, env.wallet_1)
+    env.wallet_aliases = {"xch": 1}
+    env_2.wallet_aliases = {"xch": 1}
 
-    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:
-        response = await client.send_notification(
+    wallet_2: Wallet = env_2.xch_wallet
+    client: WalletRpcClient = env.rpc_client
+    client_2: WalletRpcClient = env_2.rpc_client
+
+    async with wallet_2.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+        await client.send_notification(
             SendNotification(
                 target=(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)),
                 message=b"hello",
@@ -2698,18 +2934,29 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
                 fee=uint64(100000000000),
                 push=True,
             ),
-            tx_config=DEFAULT_TX_CONFIG,
+            tx_config=wallet_environments.tx_config,
         )
 
-    assert response.tx.spend_bundle is not None
-    await time_out_assert(
-        5,
-        full_node_api.full_node.mempool_manager.get_spendbundle,
-        response.tx.spend_bundle,
-        response.tx.spend_bundle.name(),
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+            ),
+        ]
     )
-    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]
     assert [notification] == (await client_2.get_notifications(GetNotifications([notification.id]))).notifications
@@ -2720,8 +2967,8 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
     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:
-        response = await client.send_notification(
+    async with wallet_2.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+        await client.send_notification(
             SendNotification(
                 target=(await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)),
                 message=b"hello",
@@ -2729,18 +2976,29 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
                 fee=uint64(100000000000),
                 push=True,
             ),
-            tx_config=DEFAULT_TX_CONFIG,
+            tx_config=wallet_environments.tx_config,
         )
 
-    assert response.tx.spend_bundle is not None
-    await time_out_assert(
-        5,
-        full_node_api.full_node.mempool_manager.get_spendbundle,
-        response.tx.spend_bundle,
-        response.tx.spend_bundle.name(),
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+            ),
+        ]
     )
-    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]
     await client_2.delete_notifications(DeleteNotifications([notification.id]))
@@ -2882,82 +3140,120 @@ async def test_notification_rpcs(wallet_rpc_environment: WalletRpcTestEnvironmen
     ],
 )
 @pytest.mark.parametrize("prefix_hex_strings", [True, False], ids=["with 0x", "no 0x"])
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 1,
+            "blocks_needed": [1],
+            "reuse_puzhash": True,
+            "trusted": True,
+        }
+    ],
+    indirect=True,
+)
 @pytest.mark.anyio
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
 async def test_verify_signature(
-    wallet_rpc_environment: WalletRpcTestEnvironment,
+    wallet_environments: WalletTestFramework,
     rpc_request: dict[str, Any],
     rpc_response: VerifySignatureResponse,
     prefix_hex_strings: bool,
 ) -> None:
-    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
-    assert rpc_server is not None
     updated_request = rpc_request.copy()
     updated_request["pubkey"] = ("0x" if prefix_hex_strings else "") + updated_request["pubkey"]
     updated_request["signature"] = ("0x" if prefix_hex_strings else "") + updated_request["signature"]
-    res = await wallet_rpc_environment.wallet_1.rpc_client.verify_signature(
+    res = await wallet_environments.environments[0].rpc_client.verify_signature(
         VerifySignature.from_json_dict(updated_request)
     )
     assert res == rpc_response
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [
+        {
+            "num_environments": 1,
+            "blocks_needed": [1],
+            "reuse_puzhash": True,
+            "trusted": True,
+        }
+    ],
+    indirect=True,
+)
 @pytest.mark.anyio
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
-async def test_set_auto_claim(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    full_node_api: FullNodeSimulator = env.full_node.api
-    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
-    await generate_funds(full_node_api, env.wallet_1)
-    assert rpc_server is not None
-    api: WalletRpcApi = rpc_server.rpc_api
-    req = {"enabled": False, "tx_fee": -1, "min_amount": 100}
-    has_exception = False
-    try:
-        # Manually using API to test error condition
-        await api.set_auto_claim(req)
-    except ConversionError:
-        has_exception = True
-    assert has_exception
-    req = {"enabled": False, "batch_size": 0, "min_amount": 100}
-    res = await env.wallet_1.rpc_client.set_auto_claim(
-        AutoClaimSettings(enabled=False, batch_size=uint16(0), min_amount=uint64(100))
+async def test_sign_message_by_address(wallet_environments: WalletTestFramework) -> None:
+    client: WalletRpcClient = wallet_environments.environments[0].rpc_client
+
+    message = "foo"
+    address = await client.get_next_address(GetNextAddress(uint32(1)))
+    signed_message = await client.sign_message_by_address(SignMessageByAddress(address.address, message))
+
+    await wallet_environments.environments[0].rpc_client.verify_signature(
+        VerifySignature(
+            message=message,
+            pubkey=signed_message.pubkey,
+            signature=signed_message.signature,
+            signing_mode=signed_message.signing_mode,
+        )
     )
-    assert not res.enabled
-    assert res.tx_fee == 0
-    assert res.min_amount == 100
-    assert res.batch_size == 50
 
 
-@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [1, 0]}],
+    indirect=True,
+)
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
-async def test_get_auto_claim(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    full_node_api: FullNodeSimulator = env.full_node.api
-    rpc_server = wallet_rpc_environment.wallet_1.service.rpc_server
-    await generate_funds(full_node_api, env.wallet_1)
-    assert rpc_server is not None
-    res = await env.wallet_1.rpc_client.get_auto_claim()
-    assert not res.enabled
-    assert res.tx_fee == 0
-    assert res.min_amount == 0
-    assert res.batch_size == 50
+@pytest.mark.anyio
+async def test_set_wallet_resync_on_startup(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
+    client: WalletRpcClient = env.rpc_client
+    wc = env.rpc_client
 
+    env.wallet_aliases = {
+        "xch": 1,
+        "did": 2,
+        "nft1": 3,
+        "nft0": 4,
+    }
 
-@pytest.mark.anyio
-async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    await generate_funds(full_node_api, env.wallet_1)
-    wc = env.wallet_1.rpc_client
-    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, check_client_synced, True, wc)
-
-    nft_wallet = await wc.create_new_nft_wallet(None)
-    nft_wallet_id = nft_wallet["wallet_id"]
-    address = (await wc.get_next_address(GetNextAddress(env.wallet_1.wallet.id(), True))).address
+    await wc.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.DID_WALLET,
+            did_type=DIDType.NEW,
+            amount=uint64(1),
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"init": True, "set_remainder": True},
+                    "nft1": {"init": True, "set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                    "nft1": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
+
+    nft_wallet_res = await wc.create_new_wallet(
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, did_id=None, push=True),
+        wallet_environments.tx_config,
+    )
+    nft_wallet_id = nft_wallet_res.wallet_id
+    address = (await wc.get_next_address(GetNextAddress(env.xch_wallet.id(), True))).address
     await wc.mint_nft(
         request=NFTMintNFTRequest(
             wallet_id=nft_wallet_id,
@@ -2967,14 +3263,31 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
             uris=["http://test.nft"],
             push=True,
         ),
-        tx_config=DEFAULT_TX_CONFIG,
+        tx_config=wallet_environments.tx_config,
     )
-    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, check_client_synced, True, wc)
 
-    wallet_node: WalletNode = env.wallet_1.node
-    wallet_node_2: WalletNode = env.wallet_2.node
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                    "nft1": {"set_remainder": True},
+                    "nft0": {"init": True, "set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                    "nft1": {"set_remainder": True},
+                    "nft0": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
+
+    wallet_node: WalletNode = env.node
+    wallet_node_2: WalletNode = env_2.node
     # Test Clawback resync
     tx = (
         await wc.send_transaction(
@@ -2985,21 +3298,57 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
                 puzzle_decorator=[ClawbackPuzzleDecoratorOverride(decorator="CLAWBACK", clawback_timelock=uint64(5))],
                 push=True,
             ),
-            tx_config=DEFAULT_TX_CONFIG,
+            tx_config=wallet_environments.tx_config,
         )
     ).transaction
     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, check_client_synced, True, wc)
-    await asyncio.sleep(10)
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                    "nft1": {"set_remainder": True},
+                    "nft0": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                    "nft1": {"set_remainder": True},
+                    "nft0": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
+
     resp = await wc.spend_clawback_coins(
-        SpendClawbackCoins(coin_ids=[clawback_coin_id], fee=uint64(0), push=True), tx_config=DEFAULT_TX_CONFIG
+        SpendClawbackCoins(coin_ids=[clawback_coin_id], fee=uint64(0), push=True),
+        tx_config=wallet_environments.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)
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                    "nft1": {"set_remainder": True},
+                    "nft0": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "did": {"set_remainder": True},
+                    "nft1": {"set_remainder": True},
+                    "nft0": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
+
     wallet_node_2._close()
     await wallet_node_2._await_closed()
     # set flag to reset wallet sync data on start
@@ -3044,14 +3393,19 @@ async def test_set_wallet_resync_on_startup(wallet_rpc_environment: WalletRpcTes
     await wallet_node_2._await_closed()
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 2, "blocks_needed": [1, 0]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_set_wallet_resync_on_startup_disable(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    full_node_api: FullNodeSimulator = env.full_node.api
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    await generate_funds(full_node_api, env.wallet_1)
-    wallet_node: WalletNode = env.wallet_1.node
-    wallet_node_2: WalletNode = env.wallet_2.node
+async def test_set_wallet_resync_on_startup_disable(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    env_2 = wallet_environments.environments[1]
+    client: WalletRpcClient = env.rpc_client
+    wallet_node: WalletNode = env.node
+    wallet_node_2: WalletNode = env_2.node
     wallet_node_2._close()
     await wallet_node_2._await_closed()
     # set flag to reset wallet sync data on start
@@ -3083,13 +3437,16 @@ async def test_set_wallet_resync_on_startup_disable(wallet_rpc_environment: Wall
     await wallet_node_2._await_closed()
 
 
-@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [0]}],
+    indirect=True,
+)
 @pytest.mark.limit_consensus_modes(reason="irrelevant")
-async def test_set_wallet_resync_schema(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-    full_node_api: FullNodeSimulator = env.full_node.api
-    await generate_funds(full_node_api, env.wallet_1)
-    wallet_node: WalletNode = env.wallet_1.node
+@pytest.mark.anyio
+async def test_set_wallet_resync_schema(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet_node: WalletNode = env.node
     fingerprint = wallet_node.logged_in_fingerprint
     assert fingerprint is not None
     db_path = wallet_node.wallet_state_manager.db_path
@@ -3106,21 +3463,30 @@ async def test_set_wallet_resync_schema(wallet_rpc_environment: WalletRpcTestEnv
     )
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
+async def test_cat_spend_run_tail(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
 
-    wallet_node: WalletNode = env.wallet_1.node
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    full_node_api: FullNodeSimulator = env.full_node.api
-    full_node_rpc: FullNodeRpcClient = env.full_node.rpc_client
+    wallet_node: WalletNode = env.node
+    client: WalletRpcClient = env.rpc_client
+    full_node_api: FullNodeSimulator = wallet_environments.full_node
+    full_node_rpc: FullNodeRpcClient = wallet_environments.full_node_rpc_client
 
-    await generate_funds(full_node_api, env.wallet_1, 1)
+    env.wallet_aliases = {
+        "xch": 1,
+        "cat": 2,
+    }
 
     # Send to a CAT with an anyone can spend TAIL
-    async with env.wallet_1.wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        our_ph = await action_scope.get_puzzle_hash(env.wallet_1.wallet.wallet_state_manager)
-    cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), Program.to(1))
+    async with env.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+        our_ph = await action_scope.get_puzzle_hash(env.wallet_state_manager)
+    cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, Program.NIL.get_tree_hash(), Program.to(1))
     addr = encode_puzzle_hash(
         cat_puzzle.get_tree_hash(),
         "txch",
@@ -3129,15 +3495,25 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
 
     tx = (
         await client.send_transaction(
-            SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True), DEFAULT_TX_CONFIG
+            SendTransaction(wallet_id=uint32(1), amount=tx_amount, address=addr, push=True),
+            wallet_environments.tx_config,
         )
     ).transaction
-    transaction_id = tx.name
     spend_bundle = tx.spend_bundle
     assert spend_bundle is not None
 
-    await time_out_assert(20, tx_in_mempool, True, client, transaction_id)
-    await farm_transaction(full_node_api, wallet_node, spend_bundle)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                },
+            )
+        ]
+    )
 
     # Do the eve spend back to our wallet
     cat_coin = next(c for c in spend_bundle.additions() if c.amount == tx_amount)
@@ -3165,10 +3541,26 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
     await farm_transaction(full_node_api, wallet_node, eve_spend)
 
     # Make sure we have the CAT
-    res = await client.create_wallet_for_existing_cat(Program.to(None).get_tree_hash())
-    assert res["success"]
-    cat_wallet_id = res["wallet_id"]
-    await time_out_assert(20, get_confirmed_balance, tx_amount, client, cat_wallet_id)
+    create_wallet_res = await client.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.CAT_WALLET,
+            mode=WalletCreationMode.EXISTING,
+            asset_id=Program.to(None).get_tree_hash(),
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
+    cat_wallet_id = create_wallet_res.wallet_id
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "cat": {"init": True, "set_remainder": True},
+                },
+                post_block_balance_updates={},
+            )
+        ]
+    )
 
     # Attempt to melt it fully
     tx = (
@@ -3182,40 +3574,89 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
                 tail_solution=b"\x80",
                 push=True,
             ),
-            tx_config=DEFAULT_TX_CONFIG,
+            tx_config=wallet_environments.tx_config,
         )
     ).transaction
-    transaction_id = tx.name
-    spend_bundle = tx.spend_bundle
-    assert spend_bundle is not None
-
-    await time_out_assert(20, tx_in_mempool, True, client, transaction_id)
-    await farm_transaction(full_node_api, wallet_node, spend_bundle)
 
-    await time_out_assert(20, get_confirmed_balance, 0, client, cat_wallet_id)
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {},
+                    "cat": {
+                        "unconfirmed_wallet_balance": -tx_amount,
+                        "spendable_balance": -tx_amount,
+                        "max_send_amount": -tx_amount,
+                        "pending_coin_removal_count": 1,
+                    },
+                },
+                post_block_balance_updates={
+                    "xch": {},
+                    "cat": {
+                        "confirmed_wallet_balance": -tx_amount,
+                        "pending_coin_removal_count": -1,
+                    },
+                },
+            )
+        ]
+    )
 
 
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [1]}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
 @pytest.mark.anyio
-async def test_get_balances(wallet_rpc_environment: WalletRpcTestEnvironment) -> None:
-    env: WalletRpcTestEnvironment = wallet_rpc_environment
-
-    client: WalletRpcClient = env.wallet_1.rpc_client
-    wallet_node: WalletNode = env.wallet_1.node
-
-    full_node_api: FullNodeSimulator = env.full_node.api
+async def test_get_balances(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    client: WalletRpcClient = env.rpc_client
 
-    await generate_funds(full_node_api, env.wallet_1, 1)
+    env.wallet_aliases = {
+        "xch": 1,
+        "cat": 2,
+        "cat2": 3,
+    }
 
-    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, 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, check_client_synced, True, client)
+    await client.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.CAT_WALLET,
+            mode=WalletCreationMode.NEW,
+            amount=uint64(100),
+            test=True,
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
+    await client.create_new_wallet(
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.CAT_WALLET,
+            mode=WalletCreationMode.NEW,
+            amount=uint64(20),
+            test=True,
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "cat": {"init": True, "set_remainder": True},
+                    "cat2": {"init": True, "set_remainder": True},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},
+                    "cat": {"set_remainder": True},
+                    "cat2": {"set_remainder": True},
+                },
+            ),
+            WalletStateTransition(),
+        ]
+    )
     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
@@ -3265,9 +3706,12 @@ async def test_split_coins(wallet_environments: WalletTestFramework, capsys: pyt
         }
     )
 
-    with pytest.raises(ResponseFailureError, match="501 coins is greater then the maximum limit of 500 coins"):
+    with pytest.raises(ValueError, match="501 coins is greater then the maximum limit of 500 coins"):
         await dataclasses.replace(xch_request, number_of_coins=501).run()
 
+    with pytest.raises(ValueError, match="Cannot split into 0 new coins"):
+        await dataclasses.replace(xch_request, number_of_coins=0).run()
+
     with pytest.raises(ResponseFailureError, match="Could not find coin with ID 00000000000000000"):
         await dataclasses.replace(xch_request, target_coin_id=bytes32.zeros).run()
 
@@ -3298,10 +3742,6 @@ async def test_split_coins(wallet_environments: WalletTestFramework, capsys: pyt
 
     del env.wallet_state_manager.wallets[uint32(42)]
 
-    await dataclasses.replace(xch_request, number_of_coins=0).run()
-    output = (capsys.readouterr()).out
-    assert "Transaction sent" not in output
-
     with wallet_environments.new_puzzle_hashes_allowed():
         await xch_request.run()
 
@@ -3461,13 +3901,13 @@ async def test_combine_coins(wallet_environments: WalletTestFramework, capsys: p
     )
 
     # Test some error cases first
-    with pytest.raises(ResponseFailureError, match="greater then the maximum limit"):
+    with pytest.raises(ValueError, match="greater then the maximum limit"):
         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"):
+    with pytest.raises(ValueError, match="You need at least two coins to combine"):
         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"):
+    with pytest.raises(ValueError, match="More coin IDs specified than desired number of coins to combine"):
         await dataclasses.replace(xch_combine_request, input_coins=(bytes32.zeros,) * 100).run()
 
     # We catch this one
@@ -3718,3 +4158,339 @@ async def test_fee_bigger_than_selection_coin_combining(wallet_environments: Wal
             )
         ]
     )
+
+
+def test_send_transaction_multi_post_init() -> None:
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Specified "morph_bytes" for a CAT-type wallet. Maybe you meant to specify an XCH wallet?'),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            morph_bytes=b"",
+        ).convert_to_proxy(CATSpend)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape(
+            'Specified "coin/puzzle_announcements" for a CAT-type wallet.Maybe you meant to specify an XCH wallet?'
+        ),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            coin_announcements=[],
+        ).convert_to_proxy(CATSpend)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape(
+            'Specified "coin/puzzle_announcements" for a CAT-type wallet.Maybe you meant to specify an XCH wallet?'
+        ),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            puzzle_announcements=[],
+        ).convert_to_proxy(CATSpend)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Specified "amount" for an XCH wallet. Maybe you meant to specify a CAT-type wallet?'),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            amount=uint64(100),
+        ).convert_to_proxy(CreateSignedTransaction)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Specified "inner_address" for an XCH wallet. Maybe you meant to specify a CAT-type wallet?'),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            inner_address="foo",
+        ).convert_to_proxy(CreateSignedTransaction)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Specified "memos" for an XCH wallet. Maybe you meant to specify a CAT-type wallet?'),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            memos=["foo"],
+        ).convert_to_proxy(CreateSignedTransaction)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape(
+            'Specified "extra_delta", "tail_reveal", or "tail_solution" for an XCH wallet.'
+            "Maybe you meant to specify a CAT-type wallet?"
+        ),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            extra_delta="1",
+        ).convert_to_proxy(CreateSignedTransaction)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape(
+            'Specified "extra_delta", "tail_reveal", or "tail_solution" for an XCH wallet.'
+            "Maybe you meant to specify a CAT-type wallet?"
+        ),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            tail_reveal=b"",
+        ).convert_to_proxy(CreateSignedTransaction)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape(
+            'Specified "extra_delta", "tail_reveal", or "tail_solution" for an XCH wallet.'
+            "Maybe you meant to specify a CAT-type wallet?"
+        ),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+            tail_solution=b"",
+        ).convert_to_proxy(CreateSignedTransaction)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"additions" are required for XCH wallets.'),
+    ):
+        SendTransactionMulti(
+            wallet_id=uint32(1),
+        ).convert_to_proxy(CreateSignedTransaction)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("An unsupported wallet type was selected for `send_transaction_multi`"),
+    ):
+        SendTransactionMulti(  # type: ignore[type-var]
+            wallet_id=uint32(1),
+        ).convert_to_proxy(VCSpend)
+
+
+def test_create_new_wallet_post_init() -> None:
+    with pytest.raises(
+        ValueError,
+        match=re.escape("Invalid pool wallet initial state: FOO"),
+    ):
+        NewPoolWalletInitialTargetState(state="FOO")
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("target_puzzle_hash must be set when state is FARMING_TO_POOL"),
+    ):
+        NewPoolWalletInitialTargetState(state="FARMING_TO_POOL")
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("pool_url must be set when state is FARMING_TO_POOL"),
+    ):
+        NewPoolWalletInitialTargetState(state="FARMING_TO_POOL", target_puzzle_hash=bytes32.zeros)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("relative_lock_height must be set when state is FARMING_TO_POOL"),
+    ):
+        NewPoolWalletInitialTargetState(state="FARMING_TO_POOL", target_puzzle_hash=bytes32.zeros, pool_url="")
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("target_puzzle_hash is only valid for FARMING_TO_POOL"),
+    ):
+        NewPoolWalletInitialTargetState(state="SELF_POOLING", target_puzzle_hash=bytes32.zeros)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("pool_url is only valid for FARMING_TO_POOL"),
+    ):
+        NewPoolWalletInitialTargetState(state="SELF_POOLING", pool_url="")
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("relative_lock_height is only valid for FARMING_TO_POOL"),
+    ):
+        NewPoolWalletInitialTargetState(state="SELF_POOLING", relative_lock_height=uint32(0))
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Must specify a "mode" when creating a new CAT wallet'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.CAT_WALLET)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("Support for this RPC mode has been dropped."),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.CAT_WALLET, mode=WalletCreationMode.NEW)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Must specify an "amount" of CATs to generate'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.CAT_WALLET, mode=WalletCreationMode.NEW, test=True)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"asset_id" is not an argument for new CAT wallets. Maybe you meant existing?'),
+    ):
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.CAT_WALLET,
+            mode=WalletCreationMode.NEW,
+            test=True,
+            amount=uint64(0),
+            asset_id=bytes32.zeros,
+        )
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Must specify an "asset_id" when creating an existing CAT wallet'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.CAT_WALLET, mode=WalletCreationMode.EXISTING)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"amount" is not an argument for existing CAT wallets'),
+    ):
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.CAT_WALLET,
+            mode=WalletCreationMode.EXISTING,
+            asset_id=bytes32.zeros,
+            amount=uint64(0),
+        )
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"test" mode is not supported except for new CAT wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET, test=True)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"asset_id" is not a valid argument. Maybe you meant to create an existing CAT wallet?'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET, asset_id=bytes32.zeros)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"mode": "existing" is only valid for CAT wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET, mode=WalletCreationMode.EXISTING)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Must specify "did_type": "new/recovery"'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Must specify an "amount" when creating a new DID'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET, did_type=DIDType.NEW)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Recovery options are no longer supported. "backup_dids" cannot be set.'),
+    ):
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.DID_WALLET, did_type=DIDType.NEW, amount=uint64(0), backup_dids=["foo"]
+        )
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"backup_data" is only an option in "did_type": "recovery"'),
+    ):
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.DID_WALLET, did_type=DIDType.NEW, amount=uint64(0), backup_data="foo"
+        )
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Cannot specify an "amount" when recovering a DID'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET, did_type=DIDType.RECOVERY, amount=uint64(0))
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Cannot specify "backup_dids" when recovering a DID'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET, did_type=DIDType.RECOVERY, backup_dids=["foo"])
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Cannot specify "metadata" when recovering a DID'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET, did_type=DIDType.RECOVERY, metadata={"foo": "bar"})
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('Must specify "backup_data" when recovering a DID'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.DID_WALLET, did_type=DIDType.RECOVERY)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"did_type" is only a valid argument for DID wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, did_type=DIDType.NEW)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"backup_dids" is only a valid argument for DID wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, backup_dids=["foo"])
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"metadata" is only a valid argument for DID wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, metadata={"foo": "bar"})
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"wallet_name" is only a valid argument for DID wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, wallet_name="foo")
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"backup_data" is only a valid argument for DID wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, backup_data="foo")
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"did_id" is only a valid argument for NFT wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.POOL_WALLET, did_id="foo")
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"initial_target_state" is required for new pool wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.POOL_WALLET)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"initial_target_state" is only a valid argument for pool wallets'),
+    ):
+        CreateNewWallet(
+            wallet_type=CreateNewWalletType.NFT_WALLET,
+            initial_target_state=NewPoolWalletInitialTargetState("SELF_POOLING"),
+        )
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"p2_singleton_delayed_ph" is only a valid argument for pool wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, p2_singleton_delayed_ph=bytes32.zeros)
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape('"p2_singleton_delay_time" is only a valid argument for pool wallets'),
+    ):
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, p2_singleton_delay_time=uint64(0))