chia-blockchain 2.5.4rc1__py3-none-any.whl → 2.5.5__py3-none-any.whl

chia/_tests/cmds/wallet/test_did.py

@@ -3,25 +3,56 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Optional, Union
 
+import pytest
 from chia_rs import G2Element
-from chia_rs.sized_bytes import bytes48
-from chia_rs.sized_ints import uint32, uint64
+from chia_rs.sized_bytes import bytes32, bytes48
+from chia_rs.sized_ints import uint16, uint32, uint64
 
 from chia._tests.cmds.cmd_test_utils import TestRpcClients, TestWalletRpcClient, logType, run_cli_command_and_assert
 from chia._tests.cmds.wallet.test_consts import FINGERPRINT_ARG, STD_TX, STD_UTX, get_bytes32
-from chia.rpc.wallet_request_types import DIDMessageSpendResponse, DIDTransferDIDResponse, DIDUpdateMetadataResponse
+from chia.types.blockchain_format.program import NIL, Program
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.config import load_config
 from chia.wallet.conditions import Condition, ConditionValidTimes, CreateCoinAnnouncement, CreatePuzzleAnnouncement
+from chia.wallet.did_wallet.did_info import did_recovery_is_nil
+from chia.wallet.util.curry_and_treehash import NIL_TREEHASH
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
+from chia.wallet.wallet_request_types import (
+    DIDFindLostDID,
+    DIDFindLostDIDResponse,
+    DIDGetDID,
+    DIDGetDIDResponse,
+    DIDGetInfo,
+    DIDGetInfoResponse,
+    DIDMessageSpend,
+    DIDMessageSpendResponse,
+    DIDSetWalletName,
+    DIDSetWalletNameResponse,
+    DIDTransferDID,
+    DIDTransferDIDResponse,
+    DIDUpdateMetadata,
+    DIDUpdateMetadataResponse,
+)
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 test_condition_valid_times: ConditionValidTimes = ConditionValidTimes(min_time=uint64(100), max_time=uint64(150))
 
-# DID Commands
+
+@pytest.mark.parametrize(
+    argnames=["program", "result"],
+    argvalues=[
+        (Program.to(NIL_TREEHASH), True),
+        (NIL, True),
+        (Program.to(bytes32([1] * 32)), False),
+    ],
+)
+def test_did_recovery_is_nil(program: Program, result: bool) -> None:
+    # test that the alternate wallet nil recovery list bytes are used
+    assert did_recovery_is_nil(program) is result
 
 
+# DID Commands
 def test_did_create(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
@@ -102,9 +133,9 @@ def test_did_set_name(capsys: object, get_test_cli_clients: tuple[TestRpcClients
 
     # set RPC Client
     class DidSetNameRpcClient(TestWalletRpcClient):
-        async def did_set_wallet_name(self, wallet_id: int, name: str) -> dict[str, Union[str, int]]:
-            self.add_to_log("did_set_wallet_name", (wallet_id, name))
-            return {}
+        async def did_set_wallet_name(self, request: DIDSetWalletName) -> DIDSetWalletNameResponse:
+            self.add_to_log("did_set_wallet_name", (request.wallet_id, request.name))
+            return DIDSetWalletNameResponse(request.wallet_id)
 
     inst_rpc_client = DidSetNameRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
@@ -125,9 +156,13 @@ def test_did_get_did(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
 
     # set RPC Client
     class DidGetDidRpcClient(TestWalletRpcClient):
-        async def get_did_id(self, wallet_id: int) -> dict[str, str]:
-            self.add_to_log("get_did_id", (wallet_id,))
-            return {"my_did": encode_puzzle_hash(get_bytes32(1), "did:chia:"), "coin_id": get_bytes32(2).hex()}
+        async def get_did_id(self, request: DIDGetDID) -> DIDGetDIDResponse:
+            self.add_to_log("get_did_id", (request.wallet_id,))
+            return DIDGetDIDResponse(
+                wallet_id=request.wallet_id,
+                my_did=encode_puzzle_hash(get_bytes32(1), "did:chia:"),
+                coin_id=get_bytes32(2),
+            )
 
     inst_rpc_client = DidGetDidRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
@@ -148,21 +183,21 @@ def test_did_get_details(capsys: object, get_test_cli_clients: tuple[TestRpcClie
 
     # set RPC Client
     class DidGetDetailsRpcClient(TestWalletRpcClient):
-        async def get_did_info(self, coin_id: str, latest: bool) -> dict[str, object]:
-            self.add_to_log("get_did_info", (coin_id, latest))
-            response = {
-                "did_id": encode_puzzle_hash(get_bytes32(2), "did:chia:"),
-                "latest_coin": get_bytes32(3).hex(),
-                "p2_address": encode_puzzle_hash(get_bytes32(4), "xch"),
-                "public_key": bytes48([5] * 48).hex(),
-                "launcher_id": get_bytes32(6).hex(),
-                "metadata": "did metadata",
-                "recovery_list_hash": get_bytes32(7).hex(),
-                "num_verification": 8,
-                "full_puzzle": get_bytes32(9).hex(),
-                "solution": get_bytes32(10).hex(),
-                "hints": [get_bytes32(11).hex(), get_bytes32(12).hex()],
-            }
+        async def get_did_info(self, request: DIDGetInfo) -> DIDGetInfoResponse:
+            self.add_to_log("get_did_info", (request.coin_id, request.latest))
+            response = DIDGetInfoResponse(
+                did_id=encode_puzzle_hash(get_bytes32(2), "did:chia:"),
+                latest_coin=get_bytes32(3),
+                p2_address=encode_puzzle_hash(get_bytes32(4), "xch"),
+                public_key=bytes48([5] * 48),
+                launcher_id=get_bytes32(6),
+                metadata={"did metadata": "yes"},
+                recovery_list_hash=get_bytes32(7),
+                num_verification=uint16(8),
+                full_puzzle=Program.to(9),
+                solution=Program.to(10),
+                hints=[get_bytes32(11), get_bytes32(12)],
+            )
             return response
 
     inst_rpc_client = DidGetDetailsRpcClient()
@@ -176,11 +211,11 @@ def test_did_get_details(capsys: object, get_test_cli_clients: tuple[TestRpcClie
         "Inner P2 Address:       xch1qszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqkxck8d",
         f"Public Key:             {bytes48([5] * 48).hex()}",
         f"Launcher ID:            {get_bytes32(6).hex()}",
-        "DID Metadata:           did metadata",
+        "DID Metadata:           {'did metadata': 'yes'}",
         f"Recovery List Hash:     {get_bytes32(7).hex()}",
         "Recovery Required Verifications: 8",
-        f"Last Spend Puzzle:      {get_bytes32(9).hex()}",
-        "Last Spend Solution:    0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a",
+        "Last Spend Puzzle:      09",
+        "Last Spend Solution:    0a",
         "Last Spend Hints:       ['0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b', "
         "'0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c']",
     ]
@@ -198,19 +233,23 @@ def test_did_update_metadata(capsys: object, get_test_cli_clients: tuple[TestRpc
     class DidUpdateMetadataRpcClient(TestWalletRpcClient):
         async def update_did_metadata(
             self,
-            wallet_id: int,
-            metadata: dict[str, object],
+            request: DIDUpdateMetadata,
             tx_config: TXConfig,
-            push: bool = True,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> DIDUpdateMetadataResponse:
-            self.add_to_log("update_did_metadata", (wallet_id, metadata, tx_config, push, timelock_info))
-            return DIDUpdateMetadataResponse([STD_UTX], [STD_TX], WalletSpendBundle([], G2Element()), uint32(wallet_id))
+            self.add_to_log(
+                "update_did_metadata",
+                (request.wallet_id, request.metadata, tx_config, request.push, extra_conditions, timelock_info),
+            )
+            return DIDUpdateMetadataResponse(
+                [STD_UTX], [STD_TX], WalletSpendBundle([], G2Element()), uint32(request.wallet_id)
+            )
 
     inst_rpc_client = DidUpdateMetadataRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     w_id = 3
-    json_mdata = '{"test": true}'
+    json_mdata = '{"foo": "bar"}'
     command_args = [
         "wallet",
         "did",
@@ -231,7 +270,7 @@ def test_did_update_metadata(capsys: object, get_test_cli_clients: tuple[TestRpc
     run_cli_command_and_assert(capsys, root_dir, command_args, assert_list)
     expected_calls: logType = {
         "update_did_metadata": [
-            (w_id, {"test": True}, DEFAULT_TX_CONFIG.override(reuse_puzhash=True), True, test_condition_valid_times)
+            (w_id, {"foo": "bar"}, DEFAULT_TX_CONFIG.override(reuse_puzhash=True), True, (), test_condition_valid_times)
         ],
     }
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
@@ -242,20 +281,17 @@ def test_did_find_lost(capsys: object, get_test_cli_clients: tuple[TestRpcClient
 
     # set RPC Client
     class DidFindLostRpcClient(TestWalletRpcClient):
-        async def find_lost_did(
-            self,
-            coin_id: str,
-            recovery_list_hash: Optional[str],
-            metadata: Optional[dict[str, object]],
-            num_verification: Optional[int],
-        ) -> dict[str, Union[bool, str]]:
-            self.add_to_log("find_lost_did", (coin_id, recovery_list_hash, metadata, num_verification))
-            return {"success": True, "latest_coin_id": get_bytes32(2).hex()}
+        async def find_lost_did(self, request: DIDFindLostDID) -> DIDFindLostDIDResponse:
+            self.add_to_log(
+                "find_lost_did",
+                (request.coin_id, request.recovery_list_hash, request.metadata, request.num_verification),
+            )
+            return DIDFindLostDIDResponse(get_bytes32(2))
 
     inst_rpc_client = DidFindLostRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     c_id = get_bytes32(1)
-    json_mdata = '{"test": true}'
+    json_mdata = '{"foo": "bar"}'
     command_args = [
         "wallet",
         "did",
@@ -270,7 +306,7 @@ def test_did_find_lost(capsys: object, get_test_cli_clients: tuple[TestRpcClient
     assert_list = [f"Successfully found lost DID {c_id.hex()}, latest coin ID: {get_bytes32(2).hex()}"]
     run_cli_command_and_assert(capsys, root_dir, command_args, assert_list)
     expected_calls: logType = {
-        "find_lost_did": [(c_id.hex(), None, json_mdata, None)],
+        "find_lost_did": [(c_id.hex(), None, {"foo": "bar"}, None)],
     }
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
@@ -282,13 +318,14 @@ def test_did_message_spend(capsys: object, get_test_cli_clients: tuple[TestRpcCl
     class DidMessageSpendRpcClient(TestWalletRpcClient):
         async def did_message_spend(
             self,
-            wallet_id: int,
+            request: DIDMessageSpend,
             tx_config: TXConfig,
-            extra_conditions: tuple[Condition, ...],
-            push: bool,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> DIDMessageSpendResponse:
-            self.add_to_log("did_message_spend", (wallet_id, tx_config, extra_conditions, push, timelock_info))
+            self.add_to_log(
+                "did_message_spend", (request.wallet_id, tx_config, extra_conditions, request.push, timelock_info)
+            )
             return DIDMessageSpendResponse([STD_UTX], [STD_TX], WalletSpendBundle([], G2Element()))
 
     inst_rpc_client = DidMessageSpendRpcClient()
@@ -339,16 +376,23 @@ def test_did_transfer(capsys: object, get_test_cli_clients: tuple[TestRpcClients
     class DidTransferRpcClient(TestWalletRpcClient):
         async def did_transfer_did(
             self,
-            wallet_id: int,
-            address: str,
-            fee: int,
-            with_recovery: bool,
+            request: DIDTransferDID,
             tx_config: TXConfig,
-            push: bool,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> DIDTransferDIDResponse:
             self.add_to_log(
-                "did_transfer_did", (wallet_id, address, fee, with_recovery, tx_config, push, timelock_info)
+                "did_transfer_did",
+                (
+                    request.wallet_id,
+                    request.inner_address,
+                    request.fee,
+                    request.with_recovery_info,
+                    tx_config,
+                    request.push,
+                    extra_conditions,
+                    timelock_info,
+                ),
             )
             return DIDTransferDIDResponse(
                 [STD_UTX],
@@ -396,6 +440,7 @@ def test_did_transfer(capsys: object, get_test_cli_clients: tuple[TestRpcClients
                 True,
                 DEFAULT_TX_CONFIG.override(reuse_puzhash=True),
                 True,
+                (),
                 test_condition_valid_times,
             )
         ],

chia/_tests/cmds/wallet/test_nft.py

@@ -5,21 +5,29 @@ from typing import Any, Optional
 
 from chia_rs import G2Element
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint16, uint32, uint64
+from chia_rs.sized_ints import uint16, uint32, uint64
 
 from chia._tests.cmds.cmd_test_utils import TestRpcClients, TestWalletRpcClient, logType, run_cli_command_and_assert
 from chia._tests.cmds.wallet.test_consts import FINGERPRINT, FINGERPRINT_ARG, STD_TX, STD_UTX, get_bytes32
-from chia.rpc.wallet_request_types import (
+from chia.types.signing_mode import SigningMode
+from chia.util.bech32m import encode_puzzle_hash
+from chia.wallet.conditions import Condition, ConditionValidTimes
+from chia.wallet.nft_wallet.nft_info import NFTInfo
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
+from chia.wallet.wallet_request_types import (
+    NFTAddURI,
     NFTAddURIResponse,
+    NFTGetNFTs,
+    NFTGetNFTsResponse,
+    NFTGetWalletDID,
+    NFTGetWalletDIDResponse,
+    NFTMintNFTRequest,
     NFTMintNFTResponse,
+    NFTSetNFTDID,
     NFTSetNFTDIDResponse,
+    NFTTransferNFT,
     NFTTransferNFTResponse,
 )
-from chia.types.signing_mode import SigningMode
-from chia.util.bech32m import encode_puzzle_hash
-from chia.wallet.conditions import ConditionValidTimes
-from chia.wallet.nft_wallet.nft_info import NFTInfo
-from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 test_condition_valid_times: ConditionValidTimes = ConditionValidTimes(min_time=uint64(100), max_time=uint64(150))
@@ -78,56 +86,44 @@ def test_nft_mint(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Pa
 
     # set RPC Client
     class NFTCreateRpcClient(TestWalletRpcClient):
-        async def get_nft_wallet_did(self, wallet_id: uint8) -> dict[str, Optional[str]]:
-            self.add_to_log("get_nft_wallet_did", (wallet_id,))
-            return {"did_id": "0xcee228b8638c67cb66a55085be99fa3b457ae5b56915896f581990f600b2c652"}
+        async def get_nft_wallet_did(self, request: NFTGetWalletDID) -> NFTGetWalletDIDResponse:
+            self.add_to_log("get_nft_wallet_did", (request.wallet_id,))
+            return NFTGetWalletDIDResponse("did:chia:1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpq4msw0c")
 
         async def mint_nft(
             self,
-            wallet_id: int,
-            royalty_address: Optional[str],
-            target_address: Optional[str],
-            hash: str,
-            uris: list[str],
-            meta_hash: str = "",
-            meta_uris: Optional[list[str]] = None,
-            license_hash: str = "",
-            license_uris: Optional[list[str]] = None,
-            edition_total: uint8 = uint8(1),
-            edition_number: uint8 = uint8(1),
-            fee: uint64 = uint64(0),
-            royalty_percentage: int = 0,
-            did_id: Optional[str] = None,
-            reuse_puzhash: Optional[bool] = None,
-            push: bool = True,
+            request: NFTMintNFTRequest,
+            tx_config: TXConfig,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> NFTMintNFTResponse:
             self.add_to_log(
                 "mint_nft",
                 (
-                    wallet_id,
-                    royalty_address,
-                    target_address,
-                    hash,
-                    uris,
-                    meta_hash,
-                    meta_uris,
-                    license_hash,
-                    license_uris,
-                    edition_total,
-                    edition_number,
-                    fee,
-                    royalty_percentage,
-                    did_id,
-                    reuse_puzhash,
-                    push,
+                    request.wallet_id,
+                    request.royalty_address,
+                    request.target_address,
+                    request.hash,
+                    request.uris,
+                    request.meta_hash,
+                    request.meta_uris,
+                    request.license_hash,
+                    request.license_uris,
+                    request.edition_total,
+                    request.edition_number,
+                    request.fee,
+                    request.royalty_amount,
+                    request.did_id,
+                    request.push,
+                    tx_config,
                     timelock_info,
+                    extra_conditions,
                 ),
             )
             return NFTMintNFTResponse(
                 [STD_UTX],
                 [STD_TX],
-                uint32(wallet_id),
+                uint32(request.wallet_id),
                 WalletSpendBundle([], G2Element()),
                 bytes32.zeros.hex(),
             )
@@ -142,7 +138,7 @@ def test_nft_mint(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Pa
         FINGERPRINT_ARG,
         "-i4",
         "--hash",
-        "0x1234",
+        bytes32.zeros.hex(),
         "--uris",
         "https://example.com",
         "--target-address",
@@ -164,26 +160,27 @@ def test_nft_mint(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Pa
                 4,
                 None,
                 "xch1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqzc0j4g",
-                "0x1234",
+                bytes32.zeros,
                 ["https://example.com"],
-                TXConfig(
-                    min_coin_amount=uint64(0),
-                    max_coin_amount=uint64(18446744073709551615),
-                    excluded_coin_amounts=[],
-                    excluded_coin_ids=[],
-                    reuse_puzhash=True,
-                ),
-                "",
+                None,
                 [],
-                "",
+                None,
                 [],
                 1,
                 1,
                 500000000000,
                 0,
-                "0xcee228b8638c67cb66a55085be99fa3b457ae5b56915896f581990f600b2c652",
+                "did:chia:1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpq4msw0c",
                 True,
+                TXConfig(
+                    min_coin_amount=uint64(0),
+                    max_coin_amount=uint64(18446744073709551615),
+                    excluded_coin_amounts=[],
+                    excluded_coin_ids=[],
+                    reuse_puzhash=True,
+                ),
                 test_condition_valid_times,
+                (),
             )
         ],
     }
@@ -197,17 +194,26 @@ def test_nft_add_uri(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
     class NFTAddUriRpcClient(TestWalletRpcClient):
         async def add_uri_to_nft(
             self,
-            wallet_id: int,
-            nft_coin_id: str,
-            key: str,
-            uri: str,
-            fee: int,
+            request: NFTAddURI,
             tx_config: TXConfig,
-            push: bool,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> NFTAddURIResponse:
-            self.add_to_log("add_uri_to_nft", (wallet_id, nft_coin_id, key, uri, fee, tx_config, push, timelock_info))
-            return NFTAddURIResponse([STD_UTX], [STD_TX], uint32(wallet_id), WalletSpendBundle([], G2Element()))
+            self.add_to_log(
+                "add_uri_to_nft",
+                (
+                    request.wallet_id,
+                    request.nft_coin_id,
+                    request.key,
+                    request.uri,
+                    request.fee,
+                    tx_config,
+                    request.push,
+                    timelock_info,
+                    extra_conditions,
+                ),
+            )
+            return NFTAddURIResponse([STD_UTX], [STD_TX], request.wallet_id, WalletSpendBundle([], G2Element()))
 
     inst_rpc_client = NFTAddUriRpcClient()
     nft_coin_id = get_bytes32(2).hex()
@@ -244,6 +250,7 @@ def test_nft_add_uri(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
                 DEFAULT_TX_CONFIG.override(reuse_puzhash=True),
                 True,
                 test_condition_valid_times,
+                (),
             )
         ],
     }
@@ -257,21 +264,28 @@ def test_nft_transfer(capsys: object, get_test_cli_clients: tuple[TestRpcClients
     class NFTTransferRpcClient(TestWalletRpcClient):
         async def transfer_nft(
             self,
-            wallet_id: int,
-            nft_coin_id: str,
-            target_address: str,
-            fee: int,
+            request: NFTTransferNFT,
             tx_config: TXConfig,
-            push: bool,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> NFTTransferNFTResponse:
             self.add_to_log(
-                "transfer_nft", (wallet_id, nft_coin_id, target_address, fee, tx_config, push, timelock_info)
+                "transfer_nft",
+                (
+                    request.wallet_id,
+                    request.nft_coin_id,
+                    request.target_address,
+                    request.fee,
+                    tx_config,
+                    request.push,
+                    timelock_info,
+                    extra_conditions,
+                ),
             )
             return NFTTransferNFTResponse(
                 [STD_UTX],
                 [STD_TX],
-                uint32(wallet_id),
+                request.wallet_id,
                 WalletSpendBundle([], G2Element()),
             )
 
@@ -310,6 +324,7 @@ def test_nft_transfer(capsys: object, get_test_cli_clients: tuple[TestRpcClients
                 DEFAULT_TX_CONFIG.override(reuse_puzhash=True),
                 True,
                 test_condition_valid_times,
+                (),
             )
         ],
     }
@@ -321,10 +336,10 @@ def test_nft_list(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Pa
 
     # set RPC Client
     class NFTListRpcClient(TestWalletRpcClient):
-        async def list_nfts(self, wallet_id: int, num: int = 50, start_index: int = 0) -> dict[str, object]:
-            self.add_to_log("list_nfts", (wallet_id, num, start_index))
+        async def list_nfts(self, request: NFTGetNFTs) -> NFTGetNFTsResponse:
+            self.add_to_log("list_nfts", (request.wallet_id, request.num, request.start_index))
             nft_list = []
-            for i in range(start_index, start_index + num):
+            for i in range(request.start_index, request.start_index + request.num):
                 index_bytes = bytes32([i] * 32)
                 nft_list.append(
                     NFTInfo(
@@ -348,9 +363,9 @@ def test_nft_list(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Pa
                         mint_height=uint32(1),
                         supports_did=True,
                         p2_address=get_bytes32(8),
-                    ).to_json_dict()
+                    )
                 )
-            return {"nft_list": nft_list}
+            return NFTGetNFTsResponse(request.wallet_id, nft_list)
 
     inst_rpc_client = NFTListRpcClient()
     launcher_ids = [bytes32([i] * 32).hex() for i in range(50, 60)]
@@ -386,24 +401,33 @@ def test_nft_set_did(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
     class NFTSetDidRpcClient(TestWalletRpcClient):
         async def set_nft_did(
             self,
-            wallet_id: int,
-            did_id: str,
-            nft_coin_id: str,
-            fee: int,
+            request: NFTSetNFTDID,
             tx_config: TXConfig,
-            push: bool,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> NFTSetNFTDIDResponse:
-            self.add_to_log("set_nft_did", (wallet_id, did_id, nft_coin_id, fee, tx_config, push, timelock_info))
+            self.add_to_log(
+                "set_nft_did",
+                (
+                    request.wallet_id,
+                    request.did_id,
+                    request.nft_coin_id,
+                    request.fee,
+                    tx_config,
+                    request.push,
+                    timelock_info,
+                    extra_conditions,
+                ),
+            )
             return NFTSetNFTDIDResponse(
                 [STD_UTX],
                 [STD_TX],
-                uint32(wallet_id),
+                request.wallet_id,
                 WalletSpendBundle([], G2Element()),
             )
 
     inst_rpc_client = NFTSetDidRpcClient()
-    nft_coin_id = get_bytes32(2).hex()
+    nft_coin_id = get_bytes32(2)
     did_id = encode_puzzle_hash(get_bytes32(3), "did:chia:")
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     command_args = [
@@ -413,7 +437,7 @@ def test_nft_set_did(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
         FINGERPRINT_ARG,
         "-i4",
         "--nft-coin-id",
-        nft_coin_id,
+        nft_coin_id.hex(),
         "--did-id",
         did_id,
         "-m0.5",
@@ -437,6 +461,7 @@ def test_nft_set_did(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
                 DEFAULT_TX_CONFIG.override(reuse_puzhash=True),
                 True,
                 test_condition_valid_times,
+                (),
             )
         ],
     }

chia/_tests/cmds/wallet/test_notifications.py

@@ -8,11 +8,11 @@ from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.cmds.cmd_test_utils import TestRpcClients, TestWalletRpcClient, logType, run_cli_command_and_assert
 from chia._tests.cmds.wallet.test_consts import FINGERPRINT, FINGERPRINT_ARG, get_bytes32
-from chia.rpc.wallet_request_types import GetNotifications, GetNotificationsResponse
 from chia.util.bech32m import encode_puzzle_hash
 from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.notification_store import Notification
 from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.wallet_request_types import GetNotifications, GetNotificationsResponse
 
 test_condition_valid_times: ConditionValidTimes = ConditionValidTimes(min_time=uint64(100), max_time=uint64(150))
 

chia/_tests/cmds/wallet/test_offer.toffer

@@ -1 +1 @@
-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

chia/_tests/cmds/wallet/test_vcs.py

@@ -8,7 +8,14 @@ from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.cmds.cmd_test_utils import TestRpcClients, TestWalletRpcClient, logType, run_cli_command_and_assert
 from chia._tests.cmds.wallet.test_consts import FINGERPRINT_ARG, STD_TX, STD_UTX, get_bytes32
-from chia.rpc.wallet_request_types import (
+from chia.util.bech32m import encode_puzzle_hash
+from chia.wallet.conditions import ConditionValidTimes
+from chia.wallet.lineage_proof import LineageProof
+from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
+from chia.wallet.vc_wallet.vc_drivers import VCLineageProof, VerifiedCredential
+from chia.wallet.vc_wallet.vc_store import VCRecord
+from chia.wallet.wallet_request_types import (
     VCAddProofs,
     VCGet,
     VCGetList,
@@ -26,13 +33,6 @@ from chia.rpc.wallet_request_types import (
     VCSpend,
     VCSpendResponse,
 )
-from chia.util.bech32m import encode_puzzle_hash
-from chia.wallet.conditions import ConditionValidTimes
-from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.transaction_record import TransactionRecord
-from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
-from chia.wallet.vc_wallet.vc_drivers import VCLineageProof, VerifiedCredential
-from chia.wallet.vc_wallet.vc_store import VCRecord
 
 test_condition_valid_times: ConditionValidTimes = ConditionValidTimes(min_time=uint64(100), max_time=uint64(150))
 # VC Commands