Port get_spendable_coins

Author: Quexington

chia/_tests/cmds/cmd_test_utils.py

@@ -22,7 +22,6 @@
 from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.rpc.rpc_client import RpcClient
 from chia.simulator.simulator_full_node_rpc_client import SimulatorFullNodeRpcClient
-from chia.types.coin_record import CoinRecord
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.config import load_config
@@ -31,7 +30,7 @@
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.transaction_type import TransactionType
-from chia.wallet.util.tx_config import CoinSelectionConfig, TXConfig
+from chia.wallet.util.tx_config import TXConfig
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet_request_types import (
     GetSyncStatusResponse,
@@ -232,46 +231,6 @@ async def nft_calculate_royalties(
             )
         )
 
-    async def get_spendable_coins(
-        self,
-        wallet_id: int,
-        coin_selection_config: CoinSelectionConfig,
-    ) -> tuple[list[CoinRecord], list[CoinRecord], list[Coin]]:
-        """
-        We return a tuple containing: (confirmed records, unconfirmed removals, unconfirmed additions)
-        """
-        self.add_to_log(
-            "get_spendable_coins",
-            (wallet_id, coin_selection_config),
-        )
-        confirmed_records = [
-            CoinRecord(
-                Coin(bytes32([1] * 32), bytes32([2] * 32), uint64(1234560000)),
-                uint32(123456),
-                uint32(0),
-                False,
-                uint64(0),
-            ),
-            CoinRecord(
-                Coin(bytes32([3] * 32), bytes32([4] * 32), uint64(1234560000)),
-                uint32(123456),
-                uint32(0),
-                False,
-                uint64(0),
-            ),
-        ]
-        unconfirmed_removals = [
-            CoinRecord(
-                Coin(bytes32([5] * 32), bytes32([6] * 32), uint64(1234570000)),
-                uint32(123457),
-                uint32(0),
-                True,
-                uint64(0),
-            )
-        ]
-        unconfirmed_additions = [Coin(bytes32([7] * 32), bytes32([8] * 32), uint64(1234580000))]
-        return confirmed_records, unconfirmed_removals, unconfirmed_additions
-
     async def send_transaction_multi(
         self,
         wallet_id: int,

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -124,6 +124,7 @@
     GetNextAddress,
     GetNotifications,
     GetPrivateKey,
+    GetSpendableCoins,
     GetSyncStatusResponse,
     GetTimestampForHeight,
     GetTransaction,
@@ -2392,27 +2393,40 @@ async def test_select_coins_rpc(wallet_rpc_environment: WalletRpcTestEnvironment
         assert coin != coin_300[0]
 
     # test get coins
-    all_coins, _, _ = await client_2.get_spendable_coins(
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
-            excluded_coin_ids=[c.name() for c in excluded_amt_coins_response.coins]
+    spendable_coins_response = await client_2.get_spendable_coins(
+        GetSpendableCoins.from_coin_selection_config(
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(
+                excluded_coin_ids=[c.name() for c in excluded_amt_coins_response.coins]
+            ),
         ),
     )
-    assert set(excluded_amt_coins_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)]),
+    assert (
+        set(excluded_amt_coins_response.coins).intersection(
+            {rec.coin for rec in spendable_coins_response.confirmed_records}
+        )
+        == set()
     )
-    assert len([rec for rec in all_coins if rec.coin.amount == 1000]) == 0
-    all_coins_2, _, _ = await client_2.get_spendable_coins(
-        wallet_id=1,
-        coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(max_coin_amount=uint64(999)),
+    spendable_coins_response = await client_2.get_spendable_coins(
+        GetSpendableCoins.from_coin_selection_config(
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_amounts=[uint64(1000)]),
+        )
+    )
+    assert len([rec for rec in spendable_coins_response.confirmed_records if rec.coin.amount == 1000]) == 0
+    spendable_coins_response = await client_2.get_spendable_coins(
+        GetSpendableCoins.from_coin_selection_config(
+            wallet_id=uint32(1),
+            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(max_coin_amount=uint64(999)),
+        )
     )
-    assert all_coins_2[0].coin == coin_300[0]
+    assert spendable_coins_response.confirmed_records[0].coin == coin_300[0]
     with pytest.raises(ValueError):  # validate fail on invalid coin id.
         await client_2.get_spendable_coins(
-            wallet_id=1,
-            coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_ids=[b"a"]),
+            GetSpendableCoins.from_coin_selection_config(
+                wallet_id=uint32(1),
+                coin_selection_config=DEFAULT_COIN_SELECTION_CONFIG.override(excluded_coin_ids=[b"a"]),
+            )
         )
 
 

chia/cmds/coin_funcs.py

@@ -18,7 +18,7 @@
 from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.wallet_types import WalletType
-from chia.wallet.wallet_request_types import CombineCoins, SplitCoins
+from chia.wallet.wallet_request_types import CombineCoins, GetSpendableCoins, SplitCoins
 
 
 async def async_list(
@@ -44,23 +44,28 @@ async def async_list(
     if not (await client_info.client.get_sync_status()).synced:
         print("Wallet not synced. Please wait.")
         return
-    conf_coins, unconfirmed_removals, unconfirmed_additions = await client_info.client.get_spendable_coins(
-        wallet_id=wallet_id,
-        coin_selection_config=CMDCoinSelectionConfigLoader(
-            max_coin_amount=max_coin_amount,
-            min_coin_amount=min_coin_amount,
-            excluded_coin_amounts=list(excluded_amounts),
-            excluded_coin_ids=list(excluded_coin_ids),
-        ).to_coin_selection_config(mojo_per_unit),
+    response = await client_info.client.get_spendable_coins(
+        GetSpendableCoins.from_coin_selection_config(
+            wallet_id=uint32(wallet_id),
+            coin_selection_config=CMDCoinSelectionConfigLoader(
+                max_coin_amount=max_coin_amount,
+                min_coin_amount=min_coin_amount,
+                excluded_coin_amounts=list(excluded_amounts),
+                excluded_coin_ids=list(excluded_coin_ids),
+            ).to_coin_selection_config(mojo_per_unit),
+        )
+    )
+    print(
+        f"There are a total of {len(response.confirmed_records) + len(response.unconfirmed_additions)}"
+        f" coins in wallet {wallet_id}."
     )
-    print(f"There are a total of {len(conf_coins) + len(unconfirmed_additions)} coins in wallet {wallet_id}.")
-    print(f"{len(conf_coins)} confirmed coins.")
-    print(f"{len(unconfirmed_additions)} unconfirmed additions.")
-    print(f"{len(unconfirmed_removals)} unconfirmed removals.")
+    print(f"{len(response.confirmed_records)} confirmed coins.")
+    print(f"{len(response.unconfirmed_additions)} unconfirmed additions.")
+    print(f"{len(response.unconfirmed_removals)} unconfirmed removals.")
     print("Confirmed coins:")
     print_coins(
         "\tAddress: {} Amount: {}, Confirmed in block: {}\n",
-        [(cr.coin, str(cr.confirmed_block_index)) for cr in conf_coins],
+        [(cr.coin, str(cr.confirmed_block_index)) for cr in response.confirmed_records],
         mojo_per_unit,
         addr_prefix,
         paginate,
@@ -69,15 +74,15 @@ async def async_list(
         print("\nUnconfirmed Removals:")
         print_coins(
             "\tPrevious Address: {} Amount: {}, Confirmed in block: {}\n",
-            [(cr.coin, str(cr.confirmed_block_index)) for cr in unconfirmed_removals],
+            [(cr.coin, str(cr.confirmed_block_index)) for cr in response.unconfirmed_removals],
             mojo_per_unit,
             addr_prefix,
             paginate,
         )
         print("\nUnconfirmed Additions:")
         print_coins(
             "\tNew Address: {} Amount: {}, Not yet confirmed in a block.{}\n",
-            [(coin, "") for coin in unconfirmed_additions],
+            [(coin, "") for coin in response.unconfirmed_additions],
             mojo_per_unit,
             addr_prefix,
             paginate,

chia/wallet/wallet_request_types.py

@@ -13,6 +13,7 @@
 from chia.data_layer.singleton_record import SingletonRecord
 from chia.pools.pool_wallet_info import PoolWalletInfo
 from chia.types.blockchain_format.program import Program
+from chia.types.coin_record import CoinRecord
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.conditions import Condition, ConditionValidTimes, conditions_to_json_dicts
@@ -514,6 +515,30 @@ class SelectCoinsResponse(Streamable):
     coins: list[Coin]
 
 
+@streamable
+@dataclass(frozen=True)
+class GetSpendableCoins(CoinSelectionConfigLoader):
+    wallet_id: uint32 = field(default_factory=default_raise)
+
+    @classmethod
+    def from_coin_selection_config(cls, wallet_id: uint32, coin_selection_config: CoinSelectionConfig) -> Self:
+        return cls(
+            wallet_id=wallet_id,
+            min_coin_amount=coin_selection_config.min_coin_amount,
+            max_coin_amount=coin_selection_config.max_coin_amount,
+            excluded_coin_amounts=coin_selection_config.excluded_coin_amounts,
+            excluded_coin_ids=coin_selection_config.excluded_coin_ids,
+        )
+
+
+@streamable
+@dataclass(frozen=True)
+class GetSpendableCoinsResponse(Streamable):
+    confirmed_records: list[CoinRecord]
+    unconfirmed_removals: list[CoinRecord]
+    unconfirmed_additions: list[Coin]
+
+
 @streamable
 @dataclass(frozen=True)
 class GetCurrentDerivationIndexResponse(Streamable):

chia/wallet/wallet_rpc_api.py

@@ -183,6 +183,8 @@
     GetPrivateKeyFormat,
     GetPrivateKeyResponse,
     GetPublicKeysResponse,
+    GetSpendableCoins,
+    GetSpendableCoinsResponse,
     GetSyncStatusResponse,
     GetTimestampForHeight,
     GetTimestampForHeightResponse,
@@ -1763,43 +1765,26 @@ async def select_coins(
 
         return SelectCoinsResponse(coins=list(selected_coins))
 
-    async def get_spendable_coins(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_spendable_coins(self, request: GetSpendableCoins) -> GetSpendableCoinsResponse:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before getting all coins")
 
-        wallet_id = uint32(request["wallet_id"])
-        min_coin_amount = uint64(request.get("min_coin_amount", 0))
-        max_coin_amount: uint64 = uint64(request.get("max_coin_amount", 0))
-        if max_coin_amount == 0:
-            max_coin_amount = uint64(self.service.wallet_state_manager.constants.MAX_COIN_AMOUNT)
-        excluded_coin_amounts: Optional[list[uint64]] = request.get("excluded_coin_amounts")
-        if excluded_coin_amounts is not None:
-            excluded_coin_amounts = [uint64(a) for a in excluded_coin_amounts]
-        else:
-            excluded_coin_amounts = []
-        excluded_coins_input: Optional[dict[str, dict[str, Any]]] = request.get("excluded_coins")
-        if excluded_coins_input is not None:
-            excluded_coins = [Coin.from_json_dict(json_coin) for json_coin in excluded_coins_input.values()]
-        else:
-            excluded_coins = []
-        excluded_coin_ids_input: Optional[list[str]] = request.get("excluded_coin_ids")
-        if excluded_coin_ids_input is not None:
-            excluded_coin_ids = [bytes32.from_hexstr(hex_id) for hex_id in excluded_coin_ids_input]
-        else:
-            excluded_coin_ids = []
         state_mgr = self.service.wallet_state_manager
-        wallet = state_mgr.wallets[wallet_id]
+        wallet = state_mgr.wallets[request.wallet_id]
         async with state_mgr.lock:
-            all_coin_records = await state_mgr.coin_store.get_unspent_coins_for_wallet(wallet_id)
+            all_coin_records = await state_mgr.coin_store.get_unspent_coins_for_wallet(request.wallet_id)
             if wallet.type() in {WalletType.CAT, WalletType.CRCAT, WalletType.RCAT}:
                 assert isinstance(wallet, CATWallet)
                 spendable_coins: list[WalletCoinRecord] = await wallet.get_cat_spendable_coins(all_coin_records)
             else:
-                spendable_coins = list(await state_mgr.get_spendable_coins_for_wallet(wallet_id, all_coin_records))
+                spendable_coins = list(
+                    await state_mgr.get_spendable_coins_for_wallet(request.wallet_id, all_coin_records)
+                )
 
             # Now we get the unconfirmed transactions and manually derive the additions and removals.
             unconfirmed_transactions: list[TransactionRecord] = await state_mgr.tx_store.get_unconfirmed_for_wallet(
-                wallet_id
+                request.wallet_id
             )
             unconfirmed_removal_ids: dict[bytes32, uint64] = {
                 coin.name(): transaction.created_at_time
@@ -1810,7 +1795,7 @@ async def get_spendable_coins(self, request: dict[str, Any]) -> EndpointResult:
                 coin
                 for transaction in unconfirmed_transactions
                 for coin in transaction.additions
-                if await state_mgr.does_coin_belong_to_wallet(coin, wallet_id)
+                if await state_mgr.does_coin_belong_to_wallet(coin, request.wallet_id)
             ]
             valid_spendable_cr: list[CoinRecord] = []
             unconfirmed_removals: list[CoinRecord] = []
@@ -1820,23 +1805,26 @@ async def get_spendable_coins(self, request: dict[str, Any]) -> EndpointResult:
             for coin_record in spendable_coins:  # remove all the unconfirmed coins, exclude coins and dust.
                 if coin_record.name() in unconfirmed_removal_ids:
                     continue
-                if coin_record.coin in excluded_coins:
-                    continue
-                if coin_record.name() in excluded_coin_ids:
+                if request.excluded_coin_ids is not None and coin_record.coin.name() in request.excluded_coin_ids:
                     continue
-                if coin_record.coin.amount < min_coin_amount or coin_record.coin.amount > max_coin_amount:
+                if (request.min_coin_amount is not None and coin_record.coin.amount < request.min_coin_amount) or (
+                    request.max_coin_amount is not None and coin_record.coin.amount > request.max_coin_amount
+                ):
                     continue
-                if coin_record.coin.amount in excluded_coin_amounts:
+                if (
+                    request.excluded_coin_amounts is not None
+                    and coin_record.coin.amount in request.excluded_coin_amounts
+                ):
                     continue
                 c_r = await state_mgr.get_coin_record_by_wallet_record(coin_record)
                 assert c_r is not None and c_r.coin == coin_record.coin  # this should never happen
                 valid_spendable_cr.append(c_r)
 
-        return {
-            "confirmed_records": [cr.to_json_dict() for cr in valid_spendable_cr],
-            "unconfirmed_removals": [cr.to_json_dict() for cr in unconfirmed_removals],
-            "unconfirmed_additions": [coin.to_json_dict() for coin in unconfirmed_additions],
-        }
+        return GetSpendableCoinsResponse(
+            confirmed_records=valid_spendable_cr,
+            unconfirmed_removals=unconfirmed_removals,
+            unconfirmed_additions=unconfirmed_additions,
+        )
 
     async def get_coin_records_by_names(self, request: dict[str, Any]) -> EndpointResult:
         if await self.service.wallet_state_manager.synced() is False:

chia/wallet/wallet_rpc_client.py

@@ -16,7 +16,7 @@
 from chia.wallet.trading.offer import Offer
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.clvm_streamable import json_deserialize_with_clvm_streamable
-from chia.wallet.util.tx_config import CoinSelectionConfig, TXConfig
+from chia.wallet.util.tx_config import TXConfig
 from chia.wallet.wallet_coin_store import GetCoinRecords
 from chia.wallet.wallet_request_types import (
     AddKey,
@@ -99,6 +99,8 @@
     GetPrivateKey,
     GetPrivateKeyResponse,
     GetPublicKeysResponse,
+    GetSpendableCoins,
+    GetSpendableCoinsResponse,
     GetSyncStatusResponse,
     GetTimestampForHeight,
     GetTimestampForHeightResponse,
@@ -413,18 +415,8 @@ async def select_coins(self, request: SelectCoins) -> SelectCoinsResponse:
     async def get_coin_records(self, request: GetCoinRecords) -> dict[str, Any]:
         return await self.fetch("get_coin_records", request.to_json_dict())
 
-    async def get_spendable_coins(
-        self, wallet_id: int, coin_selection_config: CoinSelectionConfig
-    ) -> tuple[list[CoinRecord], list[CoinRecord], list[Coin]]:
-        """
-        We return a tuple containing: (confirmed records, unconfirmed removals, unconfirmed additions)
-        """
-        request = {"wallet_id": wallet_id, **coin_selection_config.to_json_dict()}
-        response = await self.fetch("get_spendable_coins", request)
-        confirmed_wrs = [CoinRecord.from_json_dict(coin) for coin in response["confirmed_records"]]
-        unconfirmed_removals = [CoinRecord.from_json_dict(coin) for coin in response["unconfirmed_removals"]]
-        unconfirmed_additions = [Coin.from_json_dict(coin) for coin in response["unconfirmed_additions"]]
-        return confirmed_wrs, unconfirmed_removals, unconfirmed_additions
+    async def get_spendable_coins(self, request: GetSpendableCoins) -> GetSpendableCoinsResponse:
+        return GetSpendableCoinsResponse.from_json_dict(await self.fetch("get_spendable_coins", request.to_json_dict()))
 
     async def get_coin_records_by_names(
         self,