Port select_coins to @marshal

Author: Quexington

chia/_tests/wallet/nft_wallet/test_nft_bulk_mint.py

@@ -15,7 +15,7 @@
 from chia.wallet.nft_wallet.uncurry_nft import UncurriedNFT
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.address_type import AddressType
-from chia.wallet.wallet_request_types import NFTGetNFTs, NFTMintBulk, NFTMintMetadata, PushTransactions
+from chia.wallet.wallet_request_types import NFTGetNFTs, NFTMintBulk, NFTMintMetadata, PushTransactions, SelectCoins
 
 
 async def nft_count(wallet: NFTWallet) -> int:
@@ -291,22 +291,25 @@ async def test_nft_mint_rpc(wallet_environments: WalletTestFramework, zero_royal
     fee = 100
     num_chunks = int(n / chunk) + (1 if n % chunk > 0 else 0)
     required_amount = n + (fee * num_chunks)
-    xch_coins = await env_0.rpc_client.select_coins(
-        amount=required_amount,
-        coin_selection_config=wallet_environments.tx_config.coin_selection_config,
-        wallet_id=wallet_0.id(),
+    select_coins_response = await env_0.rpc_client.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(required_amount),
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config,
+            wallet_id=wallet_0.id(),
+        )
     )
-    funding_coin = xch_coins[0]
+    funding_coin = select_coins_response.coins[0]
     assert funding_coin.amount >= required_amount
-    funding_coin_dict = xch_coins[0].to_json_dict()
     next_coin = funding_coin
     did_coin = (
         await env_0.rpc_client.select_coins(
-            amount=1,
-            coin_selection_config=wallet_environments.tx_config.coin_selection_config,
-            wallet_id=env_0.wallet_aliases["did"],
+            SelectCoins.from_coin_selection_config(
+                amount=uint64(1),
+                coin_selection_config=wallet_environments.tx_config.coin_selection_config,
+                wallet_id=uint32(env_0.wallet_aliases["did"]),
+            )
         )
-    )[0]
+    ).coins[0]
     did_lineage_parent: Optional[bytes32] = None
     txs: list[TransactionRecord] = []
     nft_ids = set()
@@ -321,7 +324,7 @@ async def test_nft_mint_rpc(wallet_environments: WalletTestFramework, zero_royal
                 mint_number_start=uint16(i + 1),
                 mint_total=uint16(n),
                 xch_coins=[next_coin],
-                xch_change_target=funding_coin_dict["puzzle_hash"],
+                xch_change_target=funding_coin.puzzle_hash.hex(),
                 did_coin=did_coin if with_did else None,
                 did_lineage_parent=did_lineage_parent if with_did else None,
                 mint_from_did=with_did,

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -141,6 +141,7 @@
     PushTransactions,
     PushTX,
     RoyaltyAsset,
+    SelectCoins,
     SendTransaction,
     SetWalletResyncOnStartup,
     SpendClawbackCoins,
@@ -645,10 +646,12 @@ async def test_create_signed_transaction(
 
     selected_coin = None
     if select_coin:
-        selected_coin = await wallet_1_rpc.select_coins(
-            amount=amount_total, wallet_id=wallet_id, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+        select_coins_response = await wallet_1_rpc.select_coins(
+            SelectCoins.from_coin_selection_config(
+                amount=amount_total, wallet_id=uint32(wallet_id), coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+            )
         )
-        assert len(selected_coin) == 1
+        assert len(select_coins_response.coins) == 1
 
     txs = (
         await wallet_1_rpc.create_signed_transactions(
@@ -784,38 +787,42 @@ async def test_create_signed_transaction_with_excluded_coins(wallet_rpc_environm
     await generate_funds(full_node_api, env.wallet_1)
 
     async def it_does_not_include_the_excluded_coins() -> None:
-        selected_coins = await wallet_1_rpc.select_coins(
-            amount=250000000000, wallet_id=1, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+        select_coins_response = await wallet_1_rpc.select_coins(
+            SelectCoins.from_coin_selection_config(
+                amount=uint64(250000000000), wallet_id=uint32(1), coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+            )
         )
-        assert len(selected_coins) == 1
+        assert len(select_coins_response.coins) == 1
         outputs = await create_tx_outputs(wallet_1, [(uint64(250000000000), None)])
 
         tx = (
             await wallet_1_rpc.create_signed_transactions(
                 outputs,
                 DEFAULT_TX_CONFIG.override(
-                    excluded_coin_ids=[c.name() for c in selected_coins],
+                    excluded_coin_ids=[c.name() for c in select_coins_response.coins],
                 ),
             )
         ).signed_tx
 
         assert len(tx.removals) == 1
-        assert tx.removals[0] != selected_coins[0]
+        assert tx.removals[0] != select_coins_response.coins[0]
         assert tx.removals[0].amount == uint64(1750000000000)
         await assert_push_tx_error(full_node_rpc, tx)
 
     async def it_throws_an_error_when_all_spendable_coins_are_excluded() -> None:
-        selected_coins = await wallet_1_rpc.select_coins(
-            amount=1750000000000, wallet_id=1, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+        select_coins_response = await wallet_1_rpc.select_coins(
+            SelectCoins.from_coin_selection_config(
+                amount=uint64(1750000000000), wallet_id=uint32(1), coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+            )
         )
-        assert len(selected_coins) == 1
+        assert len(select_coins_response.coins) == 1
         outputs = await create_tx_outputs(wallet_1, [(uint64(1750000000000), None)])
 
         with pytest.raises(ValueError):
             await wallet_1_rpc.create_signed_transactions(
                 outputs,
                 DEFAULT_TX_CONFIG.override(
-                    excluded_coin_ids=[c.name() for c in selected_coins],
+                    excluded_coin_ids=[c.name() for c in select_coins_response.coins],
                 ),
             )
 
@@ -960,8 +967,10 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
 
     generated_funds = await generate_funds(full_node_api, env.wallet_1)
 
-    removals = await client.select_coins(
-        1750000000000, wallet_id=1, coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+    select_coins_response = await client.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(1750000000000), wallet_id=uint32(1), coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG
+        )
     )  # we want a coin that won't be selected by default
     outputs = await create_tx_outputs(wallet_2, [(uint64(1), ["memo_1"]), (uint64(2), ["memo_2"])])
     amount_outputs = sum(output["amount"] for output in outputs)
@@ -972,7 +981,7 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
             1,
             outputs,
             DEFAULT_TX_CONFIG,
-            coins=removals,
+            coins=select_coins_response.coins,
             fee=amount_fee,
         )
     ).transaction
@@ -981,7 +990,7 @@ async def test_send_transaction_multi(wallet_rpc_environment: WalletRpcTestEnvir
     assert send_tx_res is not None
 
     assert_tx_amounts(send_tx_res, outputs, amount_fee=amount_fee, change_expected=True)
-    assert send_tx_res.removals == removals
+    assert send_tx_res.removals == select_coins_response.coins
 
     await farm_transaction(full_node_api, wallet_node, spend_bundle)
 
@@ -1355,8 +1364,12 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     await wallet_environments.process_pending_states(cat_spend_changes)
 
     # Test CAT spend with a fee and pre-specified removals / coins
-    removals = await env_0.rpc_client.select_coins(
-        amount=uint64(2), wallet_id=cat_0_id, coin_selection_config=wallet_environments.tx_config.coin_selection_config
+    select_coins_response = await env_0.rpc_client.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(2),
+            wallet_id=cat_0_id,
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config,
+        )
     )
     tx_res = await env_0.rpc_client.cat_spend(
         cat_0_id,
@@ -1365,12 +1378,12 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
         addr_1,
         uint64(5_000_000),
         ["the cat memo"],
-        removals=removals,
+        removals=select_coins_response.coins,
     )
 
     spend_bundle = tx_res.transaction.spend_bundle
     assert spend_bundle is not None
-    assert removals[0] in {removal for tx in tx_res.transactions for removal in tx.removals}
+    assert select_coins_response.coins[0] in {removal for tx in tx_res.transactions for removal in tx.removals}
 
     await wallet_environments.process_pending_states(cat_spend_changes)
 
@@ -1382,10 +1395,14 @@ async def test_cat_endpoints(wallet_environments: WalletTestFramework, wallet_ty
     assert len(cats) == 1
 
     # Test CAT coin selection
-    selected_coins = await env_0.rpc_client.select_coins(
-        amount=1, wallet_id=cat_0_id, coin_selection_config=wallet_environments.tx_config.coin_selection_config
+    select_coins_response = await env_0.rpc_client.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(1),
+            wallet_id=cat_0_id,
+            coin_selection_config=wallet_environments.tx_config.coin_selection_config,
+        )
     )
-    assert len(selected_coins) > 0
+    assert len(select_coins_response.coins) > 0
 
     # Test get_cat_list
     cat_list = (await env_0.rpc_client.get_cat_list()).cat_list
@@ -2299,51 +2316,63 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         await time_out_assert(20, get_confirmed_balance, funds, client, 1)
 
     # test min coin amount
-    min_coins: list[Coin] = await client_2.select_coins(
-        amount=1000,
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(min_coin_amount=uint64(1001)),
+    min_coins_response = await client_2.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(1000),
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(min_coin_amount=uint64(1001)),
+        )
     )
-    assert len(min_coins) == 1
-    assert min_coins[0].amount == uint64(10_000)
+    assert len(min_coins_response.coins) == 1
+    assert min_coins_response.coins[0].amount == uint64(10_000)
 
     # test max coin amount
-    max_coins: list[Coin] = await client_2.select_coins(
-        amount=2000,
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
-            min_coin_amount=uint64(999), max_coin_amount=uint64(9999)
-        ),
+    max_coins_reponse = await client_2.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(2000),
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+                min_coin_amount=uint64(999), max_coin_amount=uint64(9999)
+            ),
+        )
     )
-    assert len(max_coins) == 2
-    assert max_coins[0].amount == uint64(1000)
+    assert len(max_coins_reponse.coins) == 2
+    assert max_coins_reponse.coins[0].amount == uint64(1000)
 
     # test excluded coin amounts
     non_1000_amt: int = sum(a for a in tx_amounts if a != 1000)
-    excluded_amt_coins: list[Coin] = await client_2.select_coins(
-        amount=non_1000_amt,
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),
+    excluded_amt_coins_response = await client_2.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(non_1000_amt),
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),
+        )
     )
-    assert len(excluded_amt_coins) == len([a for a in tx_amounts if a != 1000])
-    assert sum(c.amount for c in excluded_amt_coins) == non_1000_amt
+    assert len(excluded_amt_coins_response.coins) == len([a for a in tx_amounts if a != 1000])
+    assert sum(c.amount for c in excluded_amt_coins_response.coins) == non_1000_amt
 
     # test excluded coins
     with pytest.raises(ValueError):
         await client_2.select_coins(
-            amount=5000,
-            wallet_id=1,
+            SelectCoins.from_coin_selection_config(
+                amount=uint64(5000),
+                wallet_id=uint32(1),
+                coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+                    excluded_coin_ids=[c.name() for c in min_coins_response.coins]
+                ),
+            )
+        )
+    excluded_test_response = await client_2.select_coins(
+        SelectCoins.from_coin_selection_config(
+            amount=uint64(1300),
+            wallet_id=uint32(1),
             coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
-                excluded_coin_ids=[c.name() for c in min_coins]
+                excluded_coin_ids=[c.name() for c in coin_300]
             ),
         )
-    excluded_test = await client_2.select_coins(
-        amount=1300,
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_ids=[c.name() for c in coin_300]),
     )
-    assert len(excluded_test) == 2
-    for coin in excluded_test:
+    assert len(excluded_test_response.coins) == 2
+    for coin in excluded_test_response.coins:
         assert coin != coin_300[0]
 
     # test backwards compatibility in the RPC
@@ -2365,10 +2394,10 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
     all_coins, _, _ = await client_2.get_spendable_coins(
         wallet_id=1,
         coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
-            excluded_coin_ids=[c.name() for c in excluded_amt_coins]
+            excluded_coin_ids=[c.name() for c in excluded_amt_coins_response.coins]
         ),
     )
-    assert set(excluded_amt_coins).intersection({rec.coin for rec in all_coins}) == set()
+    assert set(excluded_amt_coins_response.coins).intersection({rec.coin for rec in all_coins}) == set()
     all_coins, _, _ = await client_2.get_spendable_coins(
         wallet_id=1,
         coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),

chia/wallet/util/tx_config.py

@@ -6,7 +6,7 @@
 from chia_rs import ConsensusConstants
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
-from typing_extensions import NotRequired, Self, TypedDict, Unpack
+from typing_extensions import NotRequired, Self, TypedDict, TypeVar, Unpack
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.coin import Coin
@@ -98,10 +98,14 @@ def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
         return super().from_json_dict(json_dict)
 
     # This function is purely for ergonomics
-    def override(self, **kwargs: Any) -> CoinSelectionConfigLoader:
+    # But creates a small linting complication
+    def override(self: _T_CoinSelectionConfigLoader, **kwargs: Any) -> _T_CoinSelectionConfigLoader:  # noqa: PYI019
         return dataclasses.replace(self, **kwargs)
 
 
+_T_CoinSelectionConfigLoader = TypeVar("_T_CoinSelectionConfigLoader", bound=CoinSelectionConfigLoader)
+
+
 @streamable
 @dataclasses.dataclass(frozen=True)
 class TXConfigLoader(CoinSelectionConfigLoader):
@@ -138,10 +142,6 @@ def autofill(
             reuse_puzhash,
         )
 
-    # This function is purely for ergonomics
-    def override(self, **kwargs: Any) -> TXConfigLoader:
-        return dataclasses.replace(self, **kwargs)
-
 
 DEFAULT_COIN_SELECTION_CONFIG = CoinSelectionConfig(uint64(0), uint64(DEFAULT_CONSTANTS.MAX_COIN_AMOUNT), [], [])
 DEFAULT_TX_CONFIG = TXConfig(