Port get_coin_records_by_names

Author: Quexington

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -121,6 +121,7 @@
     DIDTransferDID,
     DIDUpdateMetadata,
     FungibleAsset,
+    GetCoinRecordsByNames,
     GetNextAddress,
     GetNotifications,
     GetPrivateKey,
@@ -1504,13 +1505,17 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
         ]
     )
 
-    test_crs: list[CoinRecord] = await env_1.rpc_client.get_coin_records_by_names(
-        [a.name() for a in spend_bundle.additions() if a.amount != 4]
-    )
+    test_crs: list[CoinRecord] = (
+        await env_1.rpc_client.get_coin_records_by_names(
+            GetCoinRecordsByNames([a.name() for a in spend_bundle.additions() if a.amount != 4])
+        )
+    ).coin_records
     for cr in test_crs:
         assert cr.coin in spend_bundle.additions()
     with pytest.raises(ValueError):
-        await env_1.rpc_client.get_coin_records_by_names([a.name() for a in spend_bundle.additions() if a.amount == 4])
+        await env_1.rpc_client.get_coin_records_by_names(
+            GetCoinRecordsByNames([a.name() for a in spend_bundle.additions() if a.amount == 4])
+        )
     # Create an offer of 5 chia for one CAT
     await env_1.rpc_client.create_offer_for_ids(
         {uint32(1): -5, cat_asset_id.hex(): 1}, wallet_environments.tx_config, validate_only=True
@@ -1855,16 +1860,18 @@ async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEn
     assert len(coin_ids_unspent) > 0
     # Do some queries to trigger all parameters
     # 1. Empty coin_ids
-    assert await client.get_coin_records_by_names([]) == []
+    assert (await client.get_coin_records_by_names(GetCoinRecordsByNames([]))).coin_records == []
     # 2. All coins
-    rpc_result = await client.get_coin_records_by_names(coin_ids + coin_ids_unspent)
-    assert {record.coin for record in rpc_result} == {*coins, *coins_unspent}
+    rpc_result = await client.get_coin_records_by_names(GetCoinRecordsByNames(coin_ids + coin_ids_unspent))
+    assert {record.coin for record in rpc_result.coin_records} == {*coins, *coins_unspent}
     # 3. All spent coins
-    rpc_result = await client.get_coin_records_by_names(coin_ids, include_spent_coins=True)
-    assert {record.coin for record in rpc_result} == coins
+    rpc_result = await client.get_coin_records_by_names(GetCoinRecordsByNames(coin_ids, include_spent_coins=True))
+    assert {record.coin for record in rpc_result.coin_records} == coins
     # 4. All unspent coins
-    rpc_result = await client.get_coin_records_by_names(coin_ids_unspent, include_spent_coins=False)
-    assert {record.coin for record in rpc_result} == coins_unspent
+    rpc_result = await client.get_coin_records_by_names(
+        GetCoinRecordsByNames(coin_ids_unspent, include_spent_coins=False)
+    )
+    assert {record.coin for record in rpc_result.coin_records} == coins_unspent
     # 5. Filter start/end height
     filter_records = result.records[:10]
     assert len(filter_records) == 10
@@ -1873,11 +1880,13 @@ async def test_get_coin_records_by_names(wallet_rpc_environment: WalletRpcTestEn
     min_height = min(record.confirmed_block_height for record in filter_records)
     max_height = max(record.confirmed_block_height for record in filter_records)
     assert min_height != max_height
-    rpc_result = await client.get_coin_records_by_names(filter_coin_ids, start_height=min_height, end_height=max_height)
-    assert {record.coin for record in rpc_result} == filter_coins
+    rpc_result = await client.get_coin_records_by_names(
+        GetCoinRecordsByNames(filter_coin_ids, start_height=min_height, end_height=max_height)
+    )
+    assert {record.coin for record in rpc_result.coin_records} == filter_coins
     # 8. Test the failure case
     with pytest.raises(ValueError, match="not found"):
-        await client.get_coin_records_by_names(coin_ids, include_spent_coins=False)
+        await client.get_coin_records_by_names(GetCoinRecordsByNames(coin_ids, include_spent_coins=False))
 
 
 @pytest.mark.anyio

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, GetSpendableCoins, SplitCoins
+from chia.wallet.wallet_request_types import CombineCoins, GetCoinRecordsByNames, GetSpendableCoins, SplitCoins
 
 
 async def async_list(
@@ -222,19 +222,19 @@ async def async_split(
         return []
 
     if number_of_coins is None:
-        coins = await client_info.client.get_coin_records_by_names([target_coin_id])
-        if len(coins) == 0:
+        response = await client_info.client.get_coin_records_by_names(GetCoinRecordsByNames([target_coin_id]))
+        if len(response.coin_records) == 0:
             print("Could not find target coin.")
             return []
         assert amount_per_coin is not None
-        number_of_coins = int(coins[0].coin.amount // amount_per_coin.convert_amount(mojo_per_unit))
+        number_of_coins = int(response.coin_records[0].coin.amount // amount_per_coin.convert_amount(mojo_per_unit))
     elif amount_per_coin is None:
-        coins = await client_info.client.get_coin_records_by_names([target_coin_id])
-        if len(coins) == 0:
+        response = await client_info.client.get_coin_records_by_names(GetCoinRecordsByNames([target_coin_id]))
+        if len(response.coin_records) == 0:
             print("Could not find target coin.")
             return []
         assert number_of_coins is not None
-        amount_per_coin = CliAmount(True, uint64(coins[0].coin.amount // number_of_coins))
+        amount_per_coin = CliAmount(True, uint64(response.coin_records[0].coin.amount // number_of_coins))
 
     final_amount_per_coin = amount_per_coin.convert_amount(mojo_per_unit)
 

chia/wallet/wallet_request_types.py

@@ -539,6 +539,21 @@ class GetSpendableCoinsResponse(Streamable):
     unconfirmed_additions: list[Coin]
 
 
+@streamable
+@dataclass(frozen=True)
+class GetCoinRecordsByNames(Streamable):
+    names: list[bytes32]
+    start_height: Optional[uint32] = None
+    end_height: Optional[uint32] = None
+    include_spent_coins: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class GetCoinRecordsByNamesResponse(Streamable):
+    coin_records: list[CoinRecord]
+
+
 @streamable
 @dataclass(frozen=True)
 class GetCurrentDerivationIndexResponse(Streamable):

chia/wallet/wallet_rpc_api.py

@@ -27,7 +27,7 @@
 from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
 from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
 from chia.util.byte_types import hexstr_to_bytes
-from chia.util.config import load_config, str2bool
+from chia.util.config import load_config
 from chia.util.errors import KeychainIsLocked
 from chia.util.hash import std_hash
 from chia.util.keychain import bytes_to_mnemonic, generate_mnemonic
@@ -172,6 +172,8 @@
     GatherSigningInfo,
     GatherSigningInfoResponse,
     GenerateMnemonicResponse,
+    GetCoinRecordsByNames,
+    GetCoinRecordsByNamesResponse,
     GetCurrentDerivationIndexResponse,
     GetHeightInfoResponse,
     GetLoggedInFingerprintResponse,
@@ -1826,39 +1828,37 @@ async def get_spendable_coins(self, request: GetSpendableCoins) -> GetSpendableC
             unconfirmed_additions=unconfirmed_additions,
         )
 
-    async def get_coin_records_by_names(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_coin_records_by_names(self, request: GetCoinRecordsByNames) -> GetCoinRecordsByNamesResponse:
         if await self.service.wallet_state_manager.synced() is False:
             raise ValueError("Wallet needs to be fully synced before finding coin information")
 
-        if "names" not in request:
-            raise ValueError("Names not in request")
-        coin_ids = [bytes32.from_hexstr(name) for name in request["names"]]
         kwargs: dict[str, Any] = {
-            "coin_id_filter": HashFilter.include(coin_ids),
+            "coin_id_filter": HashFilter.include(request.names),
         }
 
         confirmed_range = UInt32Range()
-        if "start_height" in request:
-            confirmed_range = dataclasses.replace(confirmed_range, start=uint32(request["start_height"]))
-        if "end_height" in request:
-            confirmed_range = dataclasses.replace(confirmed_range, stop=uint32(request["end_height"]))
+        if request.start_height is not None:
+            confirmed_range = dataclasses.replace(confirmed_range, start=request.start_height)
+        if request.end_height is not None:
+            confirmed_range = dataclasses.replace(confirmed_range, stop=request.end_height)
         if confirmed_range != UInt32Range():
             kwargs["confirmed_range"] = confirmed_range
 
-        if "include_spent_coins" in request and not str2bool(request["include_spent_coins"]):
+        if request.include_spent_coins:
             kwargs["spent_range"] = unspent_range
 
         async with self.service.wallet_state_manager.lock:
             coin_records: list[CoinRecord] = await self.service.wallet_state_manager.get_coin_records_by_coin_ids(
                 **kwargs
             )
             missed_coins: list[str] = [
-                "0x" + c_id.hex() for c_id in coin_ids if c_id not in [cr.name for cr in coin_records]
+                "0x" + c_id.hex() for c_id in request.names if c_id not in [cr.name for cr in coin_records]
             ]
             if missed_coins:
                 raise ValueError(f"Coin ID's: {missed_coins} not found.")
 
-        return {"coin_records": [cr.to_json_dict() for cr in coin_records]}
+        return GetCoinRecordsByNamesResponse(coin_records)
 
     @marshal
     async def get_current_derivation_index(self, request: Empty) -> GetCurrentDerivationIndexResponse:

chia/wallet/wallet_rpc_client.py

@@ -9,7 +9,6 @@
 from chia.rpc.rpc_client import RpcClient
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_record import CoinRecord
 from chia.wallet.conditions import Condition, ConditionValidTimes, conditions_to_json_dicts
 from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
 from chia.wallet.trade_record import TradeRecord
@@ -88,6 +87,8 @@
     GatherSigningInfoResponse,
     GenerateMnemonicResponse,
     GetCATListResponse,
+    GetCoinRecordsByNames,
+    GetCoinRecordsByNamesResponse,
     GetCurrentDerivationIndexResponse,
     GetHeightInfoResponse,
     GetLoggedInFingerprintResponse,
@@ -418,22 +419,10 @@ async def get_coin_records(self, request: GetCoinRecords) -> dict[str, Any]:
     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,
-        names: list[bytes32],
-        include_spent_coins: bool = True,
-        start_height: Optional[int] = None,
-        end_height: Optional[int] = None,
-    ) -> list[CoinRecord]:
-        names_hex = [name.hex() for name in names]
-        request = {"names": names_hex, "include_spent_coins": include_spent_coins}
-        if start_height is not None:
-            request["start_height"] = start_height
-        if end_height is not None:
-            request["end_height"] = end_height
-
-        response = await self.fetch("get_coin_records_by_names", request)
-        return [CoinRecord.from_json_dict(cr) for cr in response["coin_records"]]
+    async def get_coin_records_by_names(self, request: GetCoinRecordsByNames) -> GetCoinRecordsByNamesResponse:
+        return GetCoinRecordsByNamesResponse.from_json_dict(
+            await self.fetch("get_coin_records_by_names", request.to_json_dict())
+        )
 
     # DID wallet
     async def create_new_did_wallet(