chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/wallet/nft_wallet/test_nft_1_offers.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 import asyncio
 import logging
 import random
-from typing import Any, Callable, Coroutine, Optional, Tuple
+from collections.abc import Coroutine
+from typing import Any, Callable, Optional
 
 import pytest
 
@@ -173,7 +174,7 @@ async def test_nft_offer_sell_nft(
     assert not mempool_not_empty(full_node_api)
     peer = wallet_node_taker.get_full_node_peer()
 
-    [maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -313,7 +314,7 @@ async def test_nft_offer_request_nft(
     taker_fee = 1
 
     peer = wallet_node_taker.get_full_node_peer()
-    [maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -411,7 +412,7 @@ async def test_nft_offer_sell_did_to_did(
                 20, full_node_api.full_node.mempool_manager.get_spendbundle, tx.spend_bundle.name()
             )
 
-    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32([0] * 32)))
+    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32.zeros))
     await full_node_api.wait_for_wallets_synced(wallet_nodes=[wallet_node_maker, wallet_node_taker], timeout=20)
 
     await time_out_assert(20, get_nft_count, 1, nft_wallet_maker)
@@ -458,7 +459,7 @@ async def test_nft_offer_sell_did_to_did(
     taker_fee = 1
 
     peer = wallet_node_taker.get_full_node_peer()
-    [maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -642,7 +643,7 @@ async def test_nft_offer_sell_nft_for_cat(
     taker_fee = 1
 
     peer = wallet_node_taker.get_full_node_peer()
-    [maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -831,7 +832,7 @@ async def test_nft_offer_request_nft_for_cat(
     taker_fee = 1
 
     peer = wallet_node_taker.get_full_node_peer()
-    [maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_maker.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -954,7 +955,7 @@ async def test_nft_offer_sell_cancel(
     offer_did_nft_for_xch = {nft_to_offer_asset_id: -1, wallet_maker.id(): xch_requested}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
-        success, trade_make, error = await trade_manager_maker.create_offer_for_ids(
+        _success, trade_make, _error = await trade_manager_maker.create_offer_for_ids(
             offer_did_nft_for_xch, action_scope, {}, fee=maker_fee
         )
 
@@ -1067,7 +1068,7 @@ async def test_nft_offer_sell_cancel_in_batch(
     offer_did_nft_for_xch = {nft_to_offer_asset_id: -1, wallet_maker.id(): xch_requested}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
-        success, trade_make, error = await trade_manager_maker.create_offer_for_ids(
+        _success, trade_make, _error = await trade_manager_maker.create_offer_for_ids(
             offer_did_nft_for_xch, action_scope, {}, fee=maker_fee
         )
 
@@ -1083,7 +1084,7 @@ async def test_nft_offer_sell_cancel_in_batch(
     await full_node_api.process_transaction_records(records=action_scope.side_effects.transactions)
 
     for i in range(1, num_blocks):
-        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32([0] * 32)))
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(bytes32.zeros))
 
     await time_out_assert(15, get_trade_and_status, TradeStatus.CANCELLED, trade_manager_maker, trade_make)
 
@@ -1104,7 +1105,7 @@ async def test_complex_nft_offer(
     self_hostname: str,
     two_wallet_nodes: Any,
     trusted: Any,
-    royalty_pts: Tuple[int, int, int],
+    royalty_pts: tuple[int, int, int],
     seeded_random: random.Random,
 ) -> None:
     """

chia/_tests/wallet/nft_wallet/test_nft_bulk_mint.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import random
 from typing import Any
 
@@ -203,42 +204,49 @@ async def test_nft_mint_from_did_rpc(
     assert wallet_services[0].rpc_server is not None
     assert full_node_service.rpc_server is not None
 
-    client = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[0].rpc_server.listen_port,
-        wallet_services[0].root_path,
-        wallet_services[0].config,
-    )
-    client_node = await FullNodeRpcClient.create(
-        self_hostname, full_node_service.rpc_server.listen_port, full_node_service.root_path, full_node_service.config
-    )
-
-    async with wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        did_wallet_maker: DIDWallet = await DIDWallet.create_new_did_wallet(
-            wallet_node_maker.wallet_state_manager, wallet_maker, uint64(1), action_scope
+    async with contextlib.AsyncExitStack() as exit_stack:
+        client = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[0].rpc_server.listen_port,
+                wallet_services[0].root_path,
+                wallet_services[0].config,
+            )
+        )
+        client_node = await exit_stack.enter_async_context(
+            FullNodeRpcClient.create_as_context(
+                self_hostname,
+                full_node_service.rpc_server.listen_port,
+                full_node_service.root_path,
+                full_node_service.config,
+            )
         )
-    await full_node_api.process_transaction_records(action_scope.side_effects.transactions)
 
-    await time_out_assert(30, wallet_maker.get_pending_change_balance, 0)
-    await time_out_assert(30, wallet_maker.get_unconfirmed_balance, funds - 1)
-    await time_out_assert(30, wallet_maker.get_confirmed_balance, funds - 1)
+        async with wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            did_wallet_maker: DIDWallet = await DIDWallet.create_new_did_wallet(
+                wallet_node_maker.wallet_state_manager, wallet_maker, uint64(1), action_scope
+            )
+        await full_node_api.process_transaction_records(action_scope.side_effects.transactions)
 
-    hex_did_id = did_wallet_maker.get_my_DID()
-    hmr_did_id = encode_puzzle_hash(bytes32.from_hexstr(hex_did_id), AddressType.DID.hrp(config))
+        await time_out_assert(30, wallet_maker.get_pending_change_balance, 0)
+        await time_out_assert(30, wallet_maker.get_unconfirmed_balance, funds - 1)
+        await time_out_assert(30, wallet_maker.get_confirmed_balance, funds - 1)
 
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_maker, timeout=20)
+        hex_did_id = did_wallet_maker.get_my_DID()
+        hmr_did_id = encode_puzzle_hash(bytes32.from_hexstr(hex_did_id), AddressType.DID.hrp(config))
 
-    nft_wallet_maker = await api_maker.create_new_wallet(
-        dict(wallet_type="nft_wallet", name="NFT WALLET 1", did_id=hmr_did_id)
-    )
-    assert isinstance(nft_wallet_maker, dict)
-    assert nft_wallet_maker.get("success")
+        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_maker, timeout=20)
 
-    nft_wallet_taker = await api_taker.create_new_wallet(dict(wallet_type="nft_wallet", name="NFT WALLET 2"))
+        nft_wallet_maker = await api_maker.create_new_wallet(
+            dict(wallet_type="nft_wallet", name="NFT WALLET 1", did_id=hmr_did_id)
+        )
+        assert isinstance(nft_wallet_maker, dict)
+        assert nft_wallet_maker.get("success")
 
-    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_token))
+        nft_wallet_taker = await api_taker.create_new_wallet(dict(wallet_type="nft_wallet", name="NFT WALLET 2"))
+
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_token))
 
-    try:
         n = 10
         metadata_list = [
             {
@@ -291,8 +299,10 @@ async def test_nft_mint_from_did_rpc(
                 tx_config=DEFAULT_TX_CONFIG,
             )
             sb = resp.spend_bundle
-            did_lineage_parent = [cn for cn in sb.removals() if cn.name() == did_coin.name()][0].parent_coin_info.hex()
-            did_coin = [cn for cn in sb.additions() if (cn.parent_coin_info == did_coin.name()) and (cn.amount == 1)][0]
+            did_lineage_parent = next(cn for cn in sb.removals() if cn.name() == did_coin.name()).parent_coin_info.hex()
+            did_coin = next(
+                cn for cn in sb.additions() if (cn.parent_coin_info == did_coin.name()) and (cn.amount == 1)
+            )
             spends.append(sb)
             xch_adds = [c for c in sb.additions() if c.puzzle_hash == funding_coin.puzzle_hash]
             assert len(xch_adds) == 1
@@ -327,11 +337,6 @@ async def test_nft_mint_from_did_rpc(
             assert meta_dict["edition_number"] == nft.edition_number
             assert meta_dict["edition_total"] == nft.edition_total
             assert nft.launcher_id in nft_ids
-    finally:
-        client.close()
-        client_node.close()
-        await client.await_closed()
-        await client_node.await_closed()
 
 
 @pytest.mark.parametrize(
@@ -391,41 +396,49 @@ async def test_nft_mint_from_did_rpc_no_royalties(
     assert wallet_services[0].rpc_server is not None
     assert full_node_service.rpc_server is not None
 
-    client = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[0].rpc_server.listen_port,
-        wallet_services[0].root_path,
-        wallet_services[0].config,
-    )
-    client_node = await FullNodeRpcClient.create(
-        self_hostname, full_node_service.rpc_server.listen_port, full_node_service.root_path, full_node_service.config
-    )
-
-    async with wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        did_wallet_maker: DIDWallet = await DIDWallet.create_new_did_wallet(
-            wallet_node_maker.wallet_state_manager, wallet_maker, uint64(1), action_scope
+    async with contextlib.AsyncExitStack() as exit_stack:
+        client = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[0].rpc_server.listen_port,
+                wallet_services[0].root_path,
+                wallet_services[0].config,
+            )
+        )
+        client_node = await exit_stack.enter_async_context(
+            FullNodeRpcClient.create_as_context(
+                self_hostname,
+                full_node_service.rpc_server.listen_port,
+                full_node_service.root_path,
+                full_node_service.config,
+            )
         )
-    await full_node_api.process_transaction_records(action_scope.side_effects.transactions)
 
-    await time_out_assert(30, wallet_maker.get_pending_change_balance, 0)
-    await time_out_assert(30, wallet_maker.get_unconfirmed_balance, funds - 1)
-    await time_out_assert(30, wallet_maker.get_confirmed_balance, funds - 1)
+        async with wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            did_wallet_maker: DIDWallet = await DIDWallet.create_new_did_wallet(
+                wallet_node_maker.wallet_state_manager, wallet_maker, uint64(1), action_scope
+            )
+        await full_node_api.process_transaction_records(action_scope.side_effects.transactions)
 
-    hex_did_id = did_wallet_maker.get_my_DID()
-    hmr_did_id = encode_puzzle_hash(bytes32.from_hexstr(hex_did_id), AddressType.DID.hrp(config))
+        await time_out_assert(30, wallet_maker.get_pending_change_balance, 0)
+        await time_out_assert(30, wallet_maker.get_unconfirmed_balance, funds - 1)
+        await time_out_assert(30, wallet_maker.get_confirmed_balance, funds - 1)
 
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_maker, timeout=20)
+        hex_did_id = did_wallet_maker.get_my_DID()
+        hmr_did_id = encode_puzzle_hash(bytes32.from_hexstr(hex_did_id), AddressType.DID.hrp(config))
 
-    nft_wallet_maker = await api_maker.create_new_wallet(
-        dict(wallet_type="nft_wallet", name="NFT WALLET 1", did_id=hmr_did_id)
-    )
-    assert isinstance(nft_wallet_maker, dict)
-    assert nft_wallet_maker.get("success")
+        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_maker, timeout=20)
 
-    nft_wallet_taker = await api_taker.create_new_wallet(dict(wallet_type="nft_wallet", name="NFT WALLET 2"))
+        nft_wallet_maker = await api_maker.create_new_wallet(
+            dict(wallet_type="nft_wallet", name="NFT WALLET 1", did_id=hmr_did_id)
+        )
+        assert isinstance(nft_wallet_maker, dict)
+        assert nft_wallet_maker.get("success")
+
+        nft_wallet_taker = await api_taker.create_new_wallet(dict(wallet_type="nft_wallet", name="NFT WALLET 2"))
+
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_token))
 
-    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_token))
-    try:
         n = 10
         metadata_list = [
             {
@@ -476,8 +489,10 @@ async def test_nft_mint_from_did_rpc_no_royalties(
                 tx_config=DEFAULT_TX_CONFIG,
             )
             sb = resp.spend_bundle
-            did_lineage_parent = [cn for cn in sb.removals() if cn.name() == did_coin.name()][0].parent_coin_info.hex()
-            did_coin = [cn for cn in sb.additions() if (cn.parent_coin_info == did_coin.name()) and (cn.amount == 1)][0]
+            did_lineage_parent = next(cn for cn in sb.removals() if cn.name() == did_coin.name()).parent_coin_info.hex()
+            did_coin = next(
+                cn for cn in sb.additions() if (cn.parent_coin_info == did_coin.name()) and (cn.amount == 1)
+            )
             spends.append(sb)
             xch_adds = [c for c in sb.additions() if c.puzzle_hash == funding_coin.puzzle_hash]
             assert len(xch_adds) == 1
@@ -495,12 +510,6 @@ async def test_nft_mint_from_did_rpc_no_royalties(
 
         await time_out_assert(60, get_taker_nfts, n)
 
-    finally:
-        client.close()
-        client_node.close()
-        await client.await_closed()
-        await client_node.await_closed()
-
 
 @pytest.mark.parametrize(
     "trusted",
@@ -783,42 +792,49 @@ async def test_nft_mint_from_xch_rpc(
     assert wallet_services[0].rpc_server is not None
     assert full_node_service.rpc_server is not None
 
-    client = await WalletRpcClient.create(
-        self_hostname,
-        wallet_services[0].rpc_server.listen_port,
-        wallet_services[0].root_path,
-        wallet_services[0].config,
-    )
-    client_node = await FullNodeRpcClient.create(
-        self_hostname, full_node_service.rpc_server.listen_port, full_node_service.root_path, full_node_service.config
-    )
-
-    async with wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
-        did_wallet_maker: DIDWallet = await DIDWallet.create_new_did_wallet(
-            wallet_node_maker.wallet_state_manager, wallet_maker, uint64(1), action_scope
+    async with contextlib.AsyncExitStack() as exit_stack:
+        client = await exit_stack.enter_async_context(
+            WalletRpcClient.create_as_context(
+                self_hostname,
+                wallet_services[0].rpc_server.listen_port,
+                wallet_services[0].root_path,
+                wallet_services[0].config,
+            )
+        )
+        client_node = await exit_stack.enter_async_context(
+            FullNodeRpcClient.create_as_context(
+                self_hostname,
+                full_node_service.rpc_server.listen_port,
+                full_node_service.root_path,
+                full_node_service.config,
+            )
         )
-    await full_node_api.process_transaction_records(action_scope.side_effects.transactions)
 
-    await time_out_assert(30, wallet_maker.get_pending_change_balance, 0)
-    await time_out_assert(30, wallet_maker.get_unconfirmed_balance, funds - 1)
-    await time_out_assert(30, wallet_maker.get_confirmed_balance, funds - 1)
+        async with wallet_maker.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            did_wallet_maker: DIDWallet = await DIDWallet.create_new_did_wallet(
+                wallet_node_maker.wallet_state_manager, wallet_maker, uint64(1), action_scope
+            )
+        await full_node_api.process_transaction_records(action_scope.side_effects.transactions)
 
-    hex_did_id = did_wallet_maker.get_my_DID()
-    hmr_did_id = encode_puzzle_hash(bytes32.from_hexstr(hex_did_id), AddressType.DID.hrp(config))
+        await time_out_assert(30, wallet_maker.get_pending_change_balance, 0)
+        await time_out_assert(30, wallet_maker.get_unconfirmed_balance, funds - 1)
+        await time_out_assert(30, wallet_maker.get_confirmed_balance, funds - 1)
 
-    await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_maker, timeout=20)
+        hex_did_id = did_wallet_maker.get_my_DID()
+        hmr_did_id = encode_puzzle_hash(bytes32.from_hexstr(hex_did_id), AddressType.DID.hrp(config))
 
-    nft_wallet_maker = await api_maker.create_new_wallet(
-        dict(wallet_type="nft_wallet", name="NFT WALLET 1", did_id=hmr_did_id)
-    )
-    assert isinstance(nft_wallet_maker, dict)
-    assert nft_wallet_maker.get("success")
+        await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_maker, timeout=20)
 
-    nft_wallet_taker = await api_taker.create_new_wallet(dict(wallet_type="nft_wallet", name="NFT WALLET 2"))
+        nft_wallet_maker = await api_maker.create_new_wallet(
+            dict(wallet_type="nft_wallet", name="NFT WALLET 1", did_id=hmr_did_id)
+        )
+        assert isinstance(nft_wallet_maker, dict)
+        assert nft_wallet_maker.get("success")
 
-    await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_token))
+        nft_wallet_taker = await api_taker.create_new_wallet(dict(wallet_type="nft_wallet", name="NFT WALLET 2"))
+
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_token))
 
-    try:
         n = 10
         metadata_list = [
             {
@@ -898,12 +914,6 @@ async def test_nft_mint_from_xch_rpc(
             assert meta_dict["edition_number"] == nft.edition_number
             assert meta_dict["edition_total"] == nft.edition_total
 
-    finally:
-        client.close()
-        client_node.close()
-        await client.await_closed()
-        await client_node.await_closed()
-
 
 @pytest.mark.parametrize(
     "trusted",

chia/_tests/wallet/nft_wallet/test_nft_lifecycle.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 import itertools
-from typing import List
 
 import pytest
 from chia_rs import G2Element
 
-from chia.clvm.spend_sim import CostLogger, sim_and_client
+from chia._tests.util.spend_sim import CostLogger, sim_and_client
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_spend import make_spend
@@ -68,13 +67,13 @@ async def test_state_layer(cost_logger: CostLogger, metadata_updater: str) -> No
         await sim.farm_block()
 
         if metadata_updater == "default":
-            metadata_updater_solutions: List[Program] = [
+            metadata_updater_solutions: list[Program] = [
                 Program.to((b"u", "update")),
                 Program.to((b"lu", "update")),
                 Program.to((b"mu", "update")),
                 Program.to((b"foo", "update")),
             ]
-            expected_metadatas: List[Program] = [
+            expected_metadatas: list[Program] = [
                 metadata_to_program(
                     {
                         b"u": ["update", "hey hey"],
@@ -140,7 +139,7 @@ async def test_state_layer(cost_logger: CostLogger, metadata_updater: str) -> No
 @pytest.mark.anyio
 async def test_ownership_layer(cost_logger: CostLogger) -> None:
     async with sim_and_client() as (sim, sim_client):
-        TARGET_OWNER = bytes32([0] * 32)
+        TARGET_OWNER = bytes32.zeros
         TARGET_TP = Program.to([8])  # (x)
         # (a (i 11 (q 4 19 (c 43 (q ()))) (q 8)) 1) or
         # (mod (_ _ solution) (if solution (list (f solution) (f (r solution)) ()) (x)))
@@ -192,7 +191,7 @@ async def test_ownership_layer(cost_logger: CostLogger) -> None:
                     [
                         [51, ACS_PH, 1],
                         [-10, TARGET_OWNER, TARGET_TP],
-                        [62, b"\xad\x4c" + bytes32([0] * 32)],
+                        [62, b"\xad\x4c" + bytes32.zeros],
                     ]
                 ]
             ),
@@ -252,7 +251,7 @@ async def test_default_transfer_program(cost_logger: CostLogger) -> None:
         # Now make the ownership coin
         FAKE_SINGLETON_MOD = Program.to([2, 5, 11])  # (a 5 11) | (mod (_ INNER_PUZ inner_sol) (a INNER_PUZ inner_sol))
         FAKE_CAT_MOD = Program.to([2, 11, 23])  # (a 11 23) or (mod (_ _ INNER_PUZ inner_sol) (a INNER_PUZ inner_sol))
-        FAKE_LAUNCHER_ID = bytes32([0] * 32)
+        FAKE_LAUNCHER_ID = bytes32.zeros
         FAKE_TAIL = bytes32([2] * 32)
         FAKE_SINGLETON_STRUCT = Program.to((FAKE_SINGLETON_MOD.get_tree_hash(), (FAKE_LAUNCHER_ID, FAKE_LAUNCHER_ID)))
         FAKE_SINGLETON = FAKE_SINGLETON_MOD.curry(FAKE_SINGLETON_STRUCT, ACS)

chia/_tests/wallet/nft_wallet/test_nft_offers.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import random
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import pytest
 
@@ -123,7 +123,7 @@ async def test_nft_offer_with_fee(
     nft_to_offer = coins_maker[0]
     nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     nft_asset_id: bytes32 = create_asset_id(nft_info)  # type: ignore
-    driver_dict: Dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
+    driver_dict: dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
 
     xch_request = 100
     maker_fee = uint64(10)
@@ -145,7 +145,7 @@ async def test_nft_offer_with_fee(
 
     taker_fee = uint64(1)
 
-    [maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     peer = wallet_node_1.get_full_node_peer()
@@ -205,7 +205,7 @@ async def test_nft_offer_with_fee(
     nft_to_buy = coins_taker[0]
     nft_to_buy_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
     nft_to_buy_asset_id: bytes32 = create_asset_id(nft_to_buy_info)  # type: ignore
-    driver_dict_to_buy: Dict[bytes32, Optional[PuzzleInfo]] = {nft_to_buy_asset_id: nft_to_buy_info}
+    driver_dict_to_buy: dict[bytes32, Optional[PuzzleInfo]] = {nft_to_buy_asset_id: nft_to_buy_info}
 
     xch_offered = 1000
     maker_fee = uint64(10)
@@ -221,7 +221,7 @@ async def test_nft_offer_with_fee(
 
     taker_fee = uint64(1)
 
-    [maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -327,7 +327,7 @@ async def test_nft_offer_cancellations(
     nft_to_offer = coins_maker[0]
     nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     nft_asset_id: bytes32 = create_asset_id(nft_info)  # type: ignore
-    driver_dict: Dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
+    driver_dict: dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
 
     xch_request = 100
     maker_fee = uint64(10)
@@ -472,7 +472,7 @@ async def test_nft_offer_with_metadata_update(
     nft_to_offer = coins_maker[0]
     nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     nft_asset_id: bytes32 = create_asset_id(nft_info)  # type: ignore
-    driver_dict: Dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
+    driver_dict: dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
 
     xch_request = 100
     maker_fee = uint64(10)
@@ -488,7 +488,7 @@ async def test_nft_offer_with_metadata_update(
 
     taker_fee = uint64(1)
 
-    [maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     peer = wallet_node_1.get_full_node_peer()
@@ -643,7 +643,7 @@ async def test_nft_offer_nft_for_cat(
     nft_to_offer = coins_maker[0]
     nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     nft_asset_id: bytes32 = create_asset_id(nft_info)  # type: ignore
-    driver_dict: Dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
+    driver_dict: dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
 
     maker_fee = uint64(10)
     taker_cat_offered = 2500
@@ -665,7 +665,7 @@ async def test_nft_offer_nft_for_cat(
 
     taker_fee = uint64(1)
 
-    [maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     peer = wallet_node_1.get_full_node_peer()
@@ -732,7 +732,7 @@ async def test_nft_offer_nft_for_cat(
     nft_to_buy_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
     nft_to_buy_asset_id: bytes32 = create_asset_id(nft_to_buy_info)  # type: ignore
 
-    driver_dict_to_buy: Dict[bytes32, Optional[PuzzleInfo]] = {
+    driver_dict_to_buy: dict[bytes32, Optional[PuzzleInfo]] = {
         nft_to_buy_asset_id: nft_to_buy_info,
     }
 
@@ -753,7 +753,7 @@ async def test_nft_offer_nft_for_cat(
 
     taker_fee = uint64(1)
 
-    [maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     async with trade_manager_taker.wallet_state_manager.new_action_scope(
@@ -889,7 +889,7 @@ async def test_nft_offer_nft_for_nft(
     nft_to_take_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_take.full_puzzle))
     nft_to_take_asset_id: bytes32 = create_asset_id(nft_to_take_info)  # type: ignore
 
-    driver_dict: Dict[bytes32, Optional[PuzzleInfo]] = {
+    driver_dict: dict[bytes32, Optional[PuzzleInfo]] = {
         nft_to_offer_asset_id: nft_to_offer_info,
         nft_to_take_asset_id: nft_to_take_info,
     }
@@ -907,7 +907,7 @@ async def test_nft_offer_nft_for_nft(
 
     taker_fee = uint64(1)
 
-    [maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
+    [_maker_offer], signing_response = await wallet_node_0.wallet_state_manager.sign_offers(
         [Offer.from_bytes(trade_make.offer)]
     )
     peer = wallet_node_1.get_full_node_peer()
@@ -1064,7 +1064,7 @@ async def test_nft_offer_nft0_and_xch_for_cat(
     nft_to_offer = coins_maker[0]
     nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     nft_asset_id: bytes32 = create_asset_id(nft_info)  # type: ignore
-    driver_dict: Dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
+    driver_dict: dict[bytes32, Optional[PuzzleInfo]] = {nft_asset_id: nft_info}
 
     maker_fee = uint64(10)
     maker_xch_offered = 1000
@@ -1160,7 +1160,7 @@ async def test_nft_offer_nft0_and_xch_for_cat(
     nft_to_buy_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
     nft_to_buy_asset_id: bytes32 = create_asset_id(nft_to_buy_info)  # type: ignore
 
-    driver_dict_to_buy: Dict[bytes32, Optional[PuzzleInfo]] = {
+    driver_dict_to_buy: dict[bytes32, Optional[PuzzleInfo]] = {
         nft_to_buy_asset_id: nft_to_buy_info,
     }
 

chia/_tests/wallet/nft_wallet/test_nft_puzzles.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import random
-from typing import Optional, Tuple
+from typing import Optional
 
 from chia._tests.core.make_block_generator import int_to_public_key
 from chia.types.blockchain_format.program import Program
@@ -104,7 +104,7 @@ def test_nft_transfer_puzzle_hashes(seeded_random: random.Random) -> None:
     assert expected_ph == calculated_ph
 
 
-def make_a_new_solution() -> Tuple[Program, Program]:
+def make_a_new_solution() -> tuple[Program, Program]:
     destination = int_to_public_key(2)
     p2_puzzle = puzzle_for_pk(destination)
     puzhash = p2_puzzle.get_tree_hash()
@@ -116,7 +116,7 @@ def make_a_new_solution() -> Tuple[Program, Program]:
     return p2_puzzle, solution
 
 
-def make_a_new_ownership_layer_puzzle() -> Tuple[Program, Program]:
+def make_a_new_ownership_layer_puzzle() -> tuple[Program, Program]:
     pubkey = int_to_public_key(1)
     innerpuz = puzzle_for_pk(pubkey)
     old_did = Program.to("test_2").get_tree_hash()