chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/_tests/cmds/test_show.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Optional
 
 from chia._tests.cmds.cmd_test_utils import TestFullNodeRpcClient, TestRpcClients, run_cli_command_and_assert
 from chia._tests.cmds.testing_classes import hash_to_height, height_hash
@@ -16,9 +16,9 @@ from chia.util.ints import uint32, uint64
 
 @dataclass
 class ShowFullNodeRpcClient(TestFullNodeRpcClient):
-    async def get_fee_estimate(self, target_times: Optional[List[int]], cost: Optional[int]) -> Dict[str, Any]:
+    async def get_fee_estimate(self, target_times: Optional[list[int]], cost: Optional[int]) -> dict[str, Any]:
         self.add_to_log("get_fee_estimate", (target_times, cost))
-        response: Dict[str, Any] = {
+        response: dict[str, Any] = {
             "current_fee_rate": 0,
             "estimates": [0, 0, 0],
             "fee_rate_last_block": 30769.681426718744,
@@ -79,10 +79,10 @@ class ShowFullNodeRpcClient(TestFullNodeRpcClient):
         return full_block
 
 
-RPC_CLIENT_TO_USE = ShowFullNodeRpcClient()  # pylint: disable=no-value-for-parameter
+RPC_CLIENT_TO_USE = ShowFullNodeRpcClient()
 
 
-def test_chia_show(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_chia_show(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
     # set RPC Client
     test_rpc_clients.full_node_rpc_client = RPC_CLIENT_TO_USE
@@ -106,7 +106,7 @@ def test_chia_show(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, P
         "Is a Transaction Block?True",
     ]
     run_cli_command_and_assert(capsys, root_dir, command_args, assert_list)
-    expected_calls: dict[str, Optional[List[tuple[Any, ...]]]] = {  # name of rpc: (args)
+    expected_calls: dict[str, Optional[list[tuple[Any, ...]]]] = {  # name of rpc: (args)
         "get_blockchain_state": None,
         "get_block_record": [(height_hash(height),) for height in [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 11, 10]],
         "get_block_record_by_height": [(10,)],

chia/_tests/cmds/test_tx_config_args.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
 from pathlib import Path
-from typing import Optional, Sequence
+from typing import Optional
 
 import click
 from click.testing import CliRunner

chia/_tests/cmds/wallet/test_dao.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import time
 from pathlib import Path
 from secrets import token_bytes
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 import pytest
 from typing_extensions import override
@@ -32,7 +32,7 @@ from chia.wallet.util.wallet_types import WalletType
 # DAO Commands
 
 
-def test_dao_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_dao_create(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -41,7 +41,7 @@ def test_dao_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
             self,
             mode: str,
             tx_config: TXConfig,
-            dao_rules: Optional[Dict[str, uint64]] = None,
+            dao_rules: Optional[dict[str, uint64]] = None,
             amount_of_cats: Optional[uint64] = None,
             treasury_id: Optional[bytes32] = None,
             filter_amount: uint64 = uint64(1),
@@ -66,7 +66,7 @@ def test_dao_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
                 }
             )
 
-    inst_rpc_client = DAOCreateRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DAOCreateRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     command_args = [
         "dao",
@@ -118,17 +118,17 @@ def test_dao_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
     run_cli_command_and_assert(capsys, root_dir, add_command_args, assert_list)
 
 
-def test_dao_treasury(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_dao_treasury(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     class DAOCreateRpcClient(TestWalletRpcClient):
         async def dao_get_treasury_id(
             self,
             wallet_id: int,
-        ) -> Dict[str, str]:
+        ) -> dict[str, str]:
             return {"treasury_id": "0xCAFEF00D"}
 
-        async def dao_get_treasury_balance(self, wallet_id: int) -> Dict[str, Union[str, bool, Dict[str, int]]]:
+        async def dao_get_treasury_balance(self, wallet_id: int) -> dict[str, Union[str, bool, dict[str, int]]]:
             if wallet_id == 2:
                 return {"success": True, "balances": {"xch": 1000000000000, "0xCAFEF00D": 10000000}}
             else:
@@ -150,7 +150,7 @@ def test_dao_treasury(capsys: object, get_test_cli_clients: Tuple[TestRpcClients
         async def dao_get_rules(
             self,
             wallet_id: int,
-        ) -> Dict[str, Dict[str, int]]:
+        ) -> dict[str, dict[str, int]]:
             return {"rules": {"proposal_minimum": 100}}
 
         @override
@@ -175,7 +175,7 @@ def test_dao_treasury(capsys: object, get_test_cli_clients: Tuple[TestRpcClients
                 valid_times=parse_timelock_info(tuple()),
             )
 
-    inst_rpc_client = DAOCreateRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DAOCreateRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
 
     get_id_args = ["dao", "get_id", FINGERPRINT_ARG, "-i 2"]
@@ -201,7 +201,7 @@ def test_dao_treasury(capsys: object, get_test_cli_clients: Tuple[TestRpcClients
     run_cli_command_and_assert(capsys, root_dir, rules_args, rules_asserts)
 
 
-def test_dao_proposals(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_dao_proposals(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -210,7 +210,7 @@ def test_dao_proposals(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
             self,
             wallet_id: int,
             include_closed: bool = True,
-        ) -> Dict[str, Union[bool, int, List[Any]]]:
+        ) -> dict[str, Union[bool, int, list[Any]]]:
             proposal = {
                 "proposal_id": "0xCAFEF00D",
                 "amount_voted": uint64(10),
@@ -236,11 +236,11 @@ def test_dao_proposals(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
             self,
             wallet_id: int,
             proposal_id: str,
-        ) -> Dict[str, Union[bool, Dict[str, Any]]]:
+        ) -> dict[str, Union[bool, dict[str, Any]]]:
             if proposal_id == "0xCAFEF00D":
                 puzhash = bytes32(b"1" * 32).hex()
                 asset_id = bytes32(b"2" * 32).hex()
-                proposal_details: Dict[str, Any] = {
+                proposal_details: dict[str, Any] = {
                     "proposal_type": "s",
                     "xch_conditions": [{"puzzle_hash": puzhash, "amount": 100}],
                     "asset_conditions": [
@@ -305,21 +305,21 @@ def test_dao_proposals(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
             wallet_id: int,
             proposal_type: str,
             tx_config: TXConfig,
-            additions: Optional[List[Dict[str, Any]]] = None,
+            additions: Optional[list[dict[str, Any]]] = None,
             amount: Optional[uint64] = None,
             inner_address: Optional[str] = None,
             asset_id: Optional[str] = None,
             cat_target_address: Optional[str] = None,
             vote_amount: Optional[int] = None,
-            new_dao_rules: Optional[Dict[str, uint64]] = None,
+            new_dao_rules: Optional[dict[str, uint64]] = None,
             fee: uint64 = uint64(0),
             reuse_puzhash: Optional[bool] = None,
             push: bool = True,
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> DAOCreateProposalResponse:
-            return DAOCreateProposalResponse([STD_UTX], [STD_TX], bytes32([0] * 32), STD_TX.name, STD_TX)
+            return DAOCreateProposalResponse([STD_UTX], [STD_TX], bytes32.zeros, STD_TX.name, STD_TX)
 
-        async def get_wallets(self, wallet_type: Optional[WalletType] = None) -> List[Dict[str, Union[str, int]]]:
+        async def get_wallets(self, wallet_type: Optional[WalletType] = None) -> list[dict[str, Union[str, int]]]:
             return [{"id": 1, "type": 0}, {"id": 2, "type": 14}]
 
         @override
@@ -345,7 +345,7 @@ def test_dao_proposals(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
             )
 
     # List all proposals
-    inst_rpc_client = DAOCreateRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DAOCreateRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     list_args = ["dao", "list_proposals", FINGERPRINT_ARG, "-i 2"]
     # these are various things that should be in the output
@@ -429,7 +429,7 @@ def test_dao_proposals(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
         "-m 0.1",
         "--reuse",
     ]
-    proposal_asserts = ["Successfully created proposal", f"Proposal ID: {bytes32([0] * 32).hex()}"]
+    proposal_asserts = ["Successfully created proposal", f"Proposal ID: {bytes32.zeros.hex()}"]
     run_cli_command_and_assert(capsys, root_dir, spend_args, proposal_asserts)
 
     bad_spend_args = [
@@ -447,7 +447,7 @@ def test_dao_proposals(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
         "-m 0.1",
         "--reuse",
     ]
-    proposal_asserts = ["Successfully created proposal", f"Proposal ID: {bytes32([0] * 32).hex()}"]
+    proposal_asserts = ["Successfully created proposal", f"Proposal ID: {bytes32.zeros.hex()}"]
     with pytest.raises(ValueError) as e_info:
         run_cli_command_and_assert(capsys, root_dir, bad_spend_args, proposal_asserts)
     assert e_info.value.args[0] == "Must include a json specification or an address / amount pair."
@@ -487,7 +487,7 @@ def test_dao_proposals(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
     run_cli_command_and_assert(capsys, root_dir, mint_args, proposal_asserts)
 
 
-def test_dao_cats(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_dao_cats(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -519,7 +519,7 @@ def test_dao_cats(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Pa
             self,
             wallet_id: int,
             tx_config: TXConfig,
-            coins: Optional[List[Dict[str, Union[str, int]]]] = None,
+            coins: Optional[list[dict[str, Union[str, int]]]] = None,
             fee: uint64 = uint64(0),
             reuse_puzhash: Optional[bool] = None,
             push: bool = True,
@@ -549,7 +549,7 @@ def test_dao_cats(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Pa
                 valid_times=parse_timelock_info(tuple()),
             )
 
-    inst_rpc_client = DAOCreateRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DAOCreateRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     lockup_args = ["dao", "lockup_coins", FINGERPRINT_ARG, "-i 2", "-a", "1000", "-m 0.1", "--reuse"]
     lockup_asserts = ["Transaction submitted to nodes"]

chia/_tests/cmds/wallet/test_did.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 from chia_rs import G2Element
 
@@ -22,7 +22,7 @@ test_condition_valid_times: ConditionValidTimes = ConditionValidTimes(min_time=u
 # DID Commands
 
 
-def test_did_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_create(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -33,11 +33,11 @@ def test_did_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
             tx_config: TXConfig,
             fee: int = 0,
             name: Optional[str] = "DID Wallet",
-            backup_ids: Optional[List[str]] = None,
+            backup_ids: Optional[list[str]] = None,
             required_num: int = 0,
             push: bool = True,
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
-        ) -> Dict[str, Union[str, int]]:
+        ) -> dict[str, Union[str, int]]:
             if backup_ids is None:
                 backup_ids = []
             self.add_to_log(
@@ -45,7 +45,7 @@ def test_did_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
             )
             return {"wallet_id": 3, "my_did": "did:chia:testdid123456"}
 
-    inst_rpc_client = DidCreateRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DidCreateRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     command_args = [
         "wallet",
@@ -74,11 +74,11 @@ def test_did_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_did_sign_message(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_sign_message(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
-    inst_rpc_client = TestWalletRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = TestWalletRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     did_id = encode_puzzle_hash(get_bytes32(1), "did:chia:")
     message = b"hello did world!!"
@@ -90,23 +90,23 @@ def test_did_sign_message(capsys: object, get_test_cli_clients: Tuple[TestRpcCli
         f"Signature: {bytes([7] * 576).hex()}",
         f"Signing Mode: {SigningMode.CHIP_0002.value}",
     ]
-    run_cli_command_and_assert(capsys, root_dir, command_args + [f"-i{did_id}"], assert_list)
+    run_cli_command_and_assert(capsys, root_dir, [*command_args, f"-i{did_id}"], assert_list)
     expected_calls: logType = {
         "sign_message_by_id": [(did_id, message.hex())],  # xch std
     }
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_did_set_name(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_set_name(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
     class DidSetNameRpcClient(TestWalletRpcClient):
-        async def did_set_wallet_name(self, wallet_id: int, name: str) -> Dict[str, Union[str, int]]:
+        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 {}
 
-    inst_rpc_client = DidSetNameRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DidSetNameRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     w_id = 3
     did_name = "testdid"
@@ -120,16 +120,16 @@ def test_did_set_name(capsys: object, get_test_cli_clients: Tuple[TestRpcClients
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_did_get_did(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_get_did(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
     class DidGetDidRpcClient(TestWalletRpcClient):
-        async def get_did_id(self, wallet_id: int) -> Dict[str, str]:
+        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()}
 
-    inst_rpc_client = DidGetDidRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DidGetDidRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     w_id = 3
     expected_did = encode_puzzle_hash(get_bytes32(1), "did:chia:")
@@ -143,12 +143,12 @@ def test_did_get_did(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_did_get_details(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_get_details(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
     class DidGetDetailsRpcClient(TestWalletRpcClient):
-        async def get_did_info(self, coin_id: str, latest: bool) -> Dict[str, object]:
+        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:"),
@@ -165,7 +165,7 @@ def test_did_get_details(capsys: object, get_test_cli_clients: Tuple[TestRpcClie
             }
             return response
 
-    inst_rpc_client = DidGetDetailsRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DidGetDetailsRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     did_coin_id_hex = get_bytes32(1).hex()
     command_args = ["wallet", "did", "get_details", FINGERPRINT_ARG, "--coin_id", did_coin_id_hex]
@@ -191,7 +191,7 @@ def test_did_get_details(capsys: object, get_test_cli_clients: Tuple[TestRpcClie
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_did_update_metadata(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_update_metadata(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -199,7 +199,7 @@ def test_did_update_metadata(capsys: object, get_test_cli_clients: Tuple[TestRpc
         async def update_did_metadata(
             self,
             wallet_id: int,
-            metadata: Dict[str, object],
+            metadata: dict[str, object],
             tx_config: TXConfig,
             push: bool = True,
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
@@ -207,7 +207,7 @@ def test_did_update_metadata(capsys: object, get_test_cli_clients: Tuple[TestRpc
             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))
 
-    inst_rpc_client = DidUpdateMetadataRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DidUpdateMetadataRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     w_id = 3
     json_mdata = '{"test": true}'
@@ -237,7 +237,7 @@ def test_did_update_metadata(capsys: object, get_test_cli_clients: Tuple[TestRpc
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_did_find_lost(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_find_lost(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -246,13 +246,13 @@ def test_did_find_lost(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
             self,
             coin_id: str,
             recovery_list_hash: Optional[str],
-            metadata: Optional[Dict[str, object]],
+            metadata: Optional[dict[str, object]],
             num_verification: Optional[int],
-        ) -> Dict[str, Union[bool, str]]:
+        ) -> 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()}
 
-    inst_rpc_client = DidFindLostRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DidFindLostRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     c_id = get_bytes32(1)
     json_mdata = '{"test": true}'
@@ -275,7 +275,7 @@ def test_did_find_lost(capsys: object, get_test_cli_clients: Tuple[TestRpcClient
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_did_message_spend(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_message_spend(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -284,14 +284,14 @@ def test_did_message_spend(capsys: object, get_test_cli_clients: Tuple[TestRpcCl
             self,
             wallet_id: int,
             tx_config: TXConfig,
-            extra_conditions: Tuple[Condition, ...],
+            extra_conditions: tuple[Condition, ...],
             push: bool,
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> DIDMessageSpendResponse:
             self.add_to_log("did_message_spend", (wallet_id, tx_config, extra_conditions, push, timelock_info))
             return DIDMessageSpendResponse([STD_UTX], [STD_TX], WalletSpendBundle([], G2Element()))
 
-    inst_rpc_client = DidMessageSpendRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DidMessageSpendRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     w_id = 3
     c_announcements = [get_bytes32(1), get_bytes32(2)]
@@ -332,7 +332,7 @@ def test_did_message_spend(capsys: object, get_test_cli_clients: Tuple[TestRpcCl
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_did_transfer(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_did_transfer(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -357,7 +357,7 @@ def test_did_transfer(capsys: object, get_test_cli_clients: Tuple[TestRpcClients
                 STD_TX.name,
             )
 
-    inst_rpc_client = DidTransferRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = DidTransferRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     w_id = 3
     t_address = encode_puzzle_hash(get_bytes32(1), "xch")

chia/_tests/cmds/wallet/test_nft.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, List, Optional, Tuple
+from typing import Any, Optional
 
 from chia_rs import G2Element
 
@@ -27,7 +27,7 @@ test_condition_valid_times: ConditionValidTimes = ConditionValidTimes(min_time=u
 # NFT Commands
 
 
-def test_nft_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_nft_create(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -36,7 +36,7 @@ def test_nft_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
             self.add_to_log("create_new_nft_wallet", (did_id, name))
             return {"wallet_id": 4}
 
-    inst_rpc_client = NFTCreateRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = NFTCreateRpcClient()
     did_id = encode_puzzle_hash(get_bytes32(2), "did:chia:")
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     command_args = ["wallet", "nft", "create", FINGERPRINT_ARG, "-ntest", "--did-id", did_id]
@@ -49,12 +49,12 @@ def test_nft_create(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_nft_sign_message(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_nft_sign_message(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
 
-    inst_rpc_client = TestWalletRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = TestWalletRpcClient()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     did_id = encode_puzzle_hash(get_bytes32(1), "nft")
     message = b"hello nft world!!"
@@ -66,14 +66,14 @@ def test_nft_sign_message(capsys: object, get_test_cli_clients: Tuple[TestRpcCli
         f"Signature: {bytes([7] * 576).hex()}",
         f"Signing Mode: {SigningMode.CHIP_0002.value}",
     ]
-    run_cli_command_and_assert(capsys, root_dir, command_args + [f"-i{did_id}"], assert_list)
+    run_cli_command_and_assert(capsys, root_dir, [*command_args, f"-i{did_id}"], assert_list)
     expected_calls: logType = {
         "sign_message_by_id": [(did_id, message.hex())],  # xch std
     }
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_nft_mint(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_nft_mint(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -88,11 +88,11 @@ def test_nft_mint(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Pa
             royalty_address: Optional[str],
             target_address: Optional[str],
             hash: str,
-            uris: List[str],
+            uris: list[str],
             meta_hash: str = "",
-            meta_uris: Optional[List[str]] = None,
+            meta_uris: Optional[list[str]] = None,
             license_hash: str = "",
-            license_uris: Optional[List[str]] = None,
+            license_uris: Optional[list[str]] = None,
             edition_total: uint8 = uint8(1),
             edition_number: uint8 = uint8(1),
             fee: uint64 = uint64(0),
@@ -129,10 +129,10 @@ def test_nft_mint(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Pa
                 [STD_TX],
                 uint32(wallet_id),
                 WalletSpendBundle([], G2Element()),
-                bytes32([0] * 32).hex(),
+                bytes32.zeros.hex(),
             )
 
-    inst_rpc_client = NFTCreateRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = NFTCreateRpcClient()
     target_addr = encode_puzzle_hash(get_bytes32(2), "xch")
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     command_args = [
@@ -190,7 +190,7 @@ def test_nft_mint(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Pa
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_nft_add_uri(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_nft_add_uri(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -209,7 +209,7 @@ def test_nft_add_uri(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
             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()))
 
-    inst_rpc_client = NFTAddUriRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = NFTAddUriRpcClient()
     nft_coin_id = get_bytes32(2).hex()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     command_args = [
@@ -250,7 +250,7 @@ def test_nft_add_uri(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_nft_transfer(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_nft_transfer(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -275,7 +275,7 @@ def test_nft_transfer(capsys: object, get_test_cli_clients: Tuple[TestRpcClients
                 WalletSpendBundle([], G2Element()),
             )
 
-    inst_rpc_client = NFTTransferRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = NFTTransferRpcClient()
     nft_coin_id = get_bytes32(2).hex()
     target_address = encode_puzzle_hash(get_bytes32(2), "xch")
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
@@ -316,7 +316,7 @@ def test_nft_transfer(capsys: object, get_test_cli_clients: Tuple[TestRpcClients
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_nft_list(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_nft_list(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -352,7 +352,7 @@ def test_nft_list(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Pa
                 )
             return {"nft_list": nft_list}
 
-    inst_rpc_client = NFTListRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = NFTListRpcClient()
     launcher_ids = [bytes32([i] * 32).hex() for i in range(50, 60)]
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     command_args = [
@@ -370,7 +370,8 @@ def test_nft_list(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Pa
     assert_list = [
         "https://example.com/data",
         "did:chia:1qgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpq4msw0c",
-    ] + launcher_ids
+        *launcher_ids,
+    ]
     run_cli_command_and_assert(capsys, root_dir, command_args, assert_list)
     expected_calls: logType = {
         "list_nfts": [(4, 10, 50)],
@@ -378,7 +379,7 @@ def test_nft_list(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Pa
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_nft_set_did(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_nft_set_did(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
@@ -401,7 +402,7 @@ def test_nft_set_did(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
                 WalletSpendBundle([], G2Element()),
             )
 
-    inst_rpc_client = NFTSetDidRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = NFTSetDidRpcClient()
     nft_coin_id = get_bytes32(2).hex()
     did_id = encode_puzzle_hash(get_bytes32(3), "did:chia:")
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
@@ -442,12 +443,12 @@ def test_nft_set_did(capsys: object, get_test_cli_clients: Tuple[TestRpcClients,
     test_rpc_clients.wallet_rpc_client.check_log(expected_calls)
 
 
-def test_nft_get_info(capsys: object, get_test_cli_clients: Tuple[TestRpcClients, Path]) -> None:
+def test_nft_get_info(capsys: object, get_test_cli_clients: tuple[TestRpcClients, Path]) -> None:
     test_rpc_clients, root_dir = get_test_cli_clients
 
     # set RPC Client
 
-    inst_rpc_client = TestWalletRpcClient()  # pylint: disable=no-value-for-parameter
+    inst_rpc_client = TestWalletRpcClient()
     nft_coin_id = get_bytes32(2).hex()
     test_rpc_clients.wallet_rpc_client = inst_rpc_client
     command_args = [