chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/_tests/wallet/nft_wallet/test_nft_1_offers.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs.sized_bytes import bytes32
@@ -17,7 +17,7 @@ from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
 from chia.wallet.outer_puzzles import create_asset_id, match_puzzle
 from chia.wallet.puzzle_drivers import PuzzleInfo
-from chia.wallet.trading.offer import Offer, OfferSummary
+from chia.wallet.trading.offer import Offer, OfferSpecification
 from chia.wallet.trading.trade_status import TradeStatus
 from chia.wallet.uncurried_puzzle import uncurry_puzzle
 
@@ -158,12 +158,12 @@ async def test_nft_offer_sell_nft(wallet_environments: WalletTestFramework, zero
     assert await nft_wallet_taker.get_nft_count() == 0
 
     nft_to_offer = coins_maker[0]
-    nft_to_offer_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_to_offer_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     nft_to_offer_asset_id: bytes32 = create_asset_id(nft_to_offer_info)  # type: ignore
     xch_requested = 1000
     maker_fee = uint64(433)
 
-    offer_did_nft_for_xch: OfferSummary = {nft_to_offer_asset_id: -1, wallet_maker.id(): xch_requested}
+    offer_did_nft_for_xch: OfferSpecification = {nft_to_offer_asset_id: -1, wallet_maker.id(): xch_requested}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -386,7 +386,7 @@ async def test_nft_offer_request_nft(wallet_environments: WalletTestFramework, z
 
     assert await nft_wallet_maker.get_nft_count() == 0
     nft_to_request = coins_taker[0]
-    nft_to_request_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_request.full_puzzle))
+    nft_to_request_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_request.full_puzzle))
 
     assert isinstance(nft_to_request_info, PuzzleInfo)
     nft_to_request_asset_id = create_asset_id(nft_to_request_info)
@@ -395,7 +395,7 @@ async def test_nft_offer_request_nft(wallet_environments: WalletTestFramework, z
     maker_fee = uint64(10)
     driver_dict = {nft_to_request_asset_id: nft_to_request_info}
 
-    offer_dict: OfferSummary = {nft_to_request_asset_id: 1, wallet_maker.id(): -xch_offered}
+    offer_dict: OfferSpecification = {nft_to_request_asset_id: 1, wallet_maker.id(): -xch_offered}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -680,12 +680,12 @@ async def test_nft_offer_sell_did_to_did(wallet_environments: WalletTestFramewor
     assert len(coins_maker) == 1
     assert await nft_wallet_taker.get_nft_count() == 0
     nft_to_offer = coins_maker[0]
-    nft_to_offer_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_to_offer_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     nft_to_offer_asset_id: bytes32 = create_asset_id(nft_to_offer_info)  # type: ignore
     xch_requested = 1000
     maker_fee = uint64(433)
 
-    offer_did_nft_for_xch: OfferSummary = {nft_to_offer_asset_id: -1, wallet_maker.id(): xch_requested}
+    offer_did_nft_for_xch: OfferSpecification = {nft_to_offer_asset_id: -1, wallet_maker.id(): xch_requested}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -985,12 +985,12 @@ async def test_nft_offer_sell_nft_for_cat(
     await time_out_assert(20, cat_wallet_maker.get_confirmed_balance, maker_cat_balance)
     await time_out_assert(20, cat_wallet_taker.get_confirmed_balance, taker_cat_balance)
     nft_to_offer = coins_maker[0]
-    nft_to_offer_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_to_offer_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     nft_to_offer_asset_id: bytes32 = create_asset_id(nft_to_offer_info)  # type: ignore
     cats_requested = 1000
     maker_fee = uint64(433)
 
-    offer_did_nft_for_xch: OfferSummary = {nft_to_offer_asset_id: -1, cat_wallet_maker.id(): cats_requested}
+    offer_did_nft_for_xch: OfferSpecification = {nft_to_offer_asset_id: -1, cat_wallet_maker.id(): cats_requested}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -1347,7 +1347,7 @@ async def test_nft_offer_request_nft_for_cat(
     maker_fee = uint64(433)
     driver_dict = {nft_to_request_asset_id: nft_to_request_info}
 
-    offer_dict: OfferSummary = {nft_to_request_asset_id: 1, cat_wallet_maker.id(): -cats_requested}
+    offer_dict: OfferSpecification = {nft_to_request_asset_id: 1, cat_wallet_maker.id(): -cats_requested}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -1583,7 +1583,7 @@ async def test_nft_offer_sell_cancel(wallet_environments: WalletTestFramework) -
     xch_requested = 1000
     maker_fee = uint64(433)
 
-    offer_did_nft_for_xch: OfferSummary = {nft_to_offer_asset_id: -1, wallet_maker.id(): xch_requested}
+    offer_did_nft_for_xch: OfferSpecification = {nft_to_offer_asset_id: -1, wallet_maker.id(): xch_requested}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -1976,13 +1976,13 @@ async def test_complex_nft_offer(
         CAT_REQUESTED = 100000
         FEE = uint64(2000000000000)
 
-    complex_nft_offer: OfferSummary = {
+    complex_nft_offer: OfferSpecification = {
         nft_to_offer_asset_id_maker: -1,
         cat_wallet_maker.id(): CAT_REQUESTED * -1,
         1: XCH_REQUESTED,
         nft_to_offer_asset_id_taker_1: 1,
         nft_to_offer_asset_id_taker_2: 1,
-        bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): CAT_REQUESTED,
+        cat_wallet_taker.get_asset_id(): CAT_REQUESTED,
     }
 
     nft_taker_1_info = match_puzzle(uncurry_puzzle(taker_nfts[0].full_puzzle))
@@ -1992,10 +1992,10 @@ async def test_complex_nft_offer(
     driver_dict = {
         nft_to_offer_asset_id_taker_1: nft_taker_1_info,
         nft_to_offer_asset_id_taker_2: nft_taker_2_info,
-        bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): PuzzleInfo(
+        cat_wallet_taker.get_asset_id(): PuzzleInfo(
             {
                 "type": "CAT",
-                "tail": "0x" + cat_wallet_taker.get_asset_id(),
+                "tail": "0x" + cat_wallet_taker.get_asset_id().hex(),
                 **(
                     {}
                     if wallet_type is CATWallet
@@ -2047,7 +2047,7 @@ async def test_complex_nft_offer(
         },
         {
             None: uint64(XCH_REQUESTED),
-            bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): uint64(CAT_REQUESTED),
+            cat_wallet_taker.get_asset_id(): uint64(CAT_REQUESTED),
         },
     )
     taker_royalty_summary = NFTWallet.royalty_calculation(
@@ -2056,7 +2056,7 @@ async def test_complex_nft_offer(
             nft_to_offer_asset_id_taker_2: (royalty_puzhash_taker, royalty_basis_pts_taker_2),
         },
         {
-            bytes32.from_hexstr(cat_wallet_maker.get_asset_id()): uint64(CAT_REQUESTED),
+            cat_wallet_maker.get_asset_id(): uint64(CAT_REQUESTED),
         },
     )
     maker_xch_royalties_expected = maker_royalty_summary[nft_to_offer_asset_id_maker][0]["amount"]
@@ -2198,7 +2198,7 @@ async def test_complex_nft_offer(
     complex_nft_offer = {
         cat_wallet_maker.id(): CAT_REQUESTED * -1,
         1: HALF_XCH_REQUESTED,
-        bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): CAT_REQUESTED,
+        cat_wallet_taker.get_asset_id(): CAT_REQUESTED,
         nft_to_offer_asset_id_maker: 1,
     }
 
@@ -2206,10 +2206,10 @@ async def test_complex_nft_offer(
     assert maker_nft_info is not None
     driver_dict = {
         nft_to_offer_asset_id_maker: maker_nft_info,
-        bytes32.from_hexstr(cat_wallet_taker.get_asset_id()): PuzzleInfo(
+        cat_wallet_taker.get_asset_id(): PuzzleInfo(
             {
                 "type": "CAT",
-                "tail": "0x" + cat_wallet_taker.get_asset_id(),
+                "tail": "0x" + cat_wallet_taker.get_asset_id().hex(),
             }
         ),
     }

chia/_tests/wallet/nft_wallet/test_nft_bulk_mint.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Optional, cast
+from typing import cast
 
 import pytest
 from chia_rs.sized_bytes import bytes32
@@ -15,7 +15,15 @@ from chia.wallet.nft_wallet.nft_wallet import NFTWallet
 from chia.wallet.nft_wallet.uncurry_nft import UncurriedNFT
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.address_type import AddressType
-from chia.wallet.wallet_request_types import NFTGetNFTs, NFTMintBulk, NFTMintMetadata, PushTransactions, SelectCoins
+from chia.wallet.wallet_request_types import (
+    CreateNewWallet,
+    CreateNewWalletType,
+    NFTGetNFTs,
+    NFTMintBulk,
+    NFTMintMetadata,
+    PushTransactions,
+    SelectCoins,
+)
 
 
 async def nft_count(wallet: NFTWallet) -> int:
@@ -263,9 +271,15 @@ async def test_nft_mint_rpc(wallet_environments: WalletTestFramework, zero_royal
     hex_did_id = did_wallet_maker.get_my_DID()
     hmr_did_id = encode_puzzle_hash(bytes32.from_hexstr(hex_did_id), AddressType.DID.hrp(env_0.node.config))
 
-    nft_wallet_maker = await env_0.rpc_client.create_new_nft_wallet(name="NFT WALLET 1", did_id=hmr_did_id)
+    create_wallet_res = await env_0.rpc_client.create_new_wallet(
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, name="NFT WALLET 1", did_id=hmr_did_id, push=True),
+        wallet_environments.tx_config,
+    )
 
-    await env_1.rpc_client.create_new_nft_wallet(name="NFT WALLET 2", did_id=None)
+    await env_1.rpc_client.create_new_wallet(
+        CreateNewWallet(wallet_type=CreateNewWalletType.NFT_WALLET, name="NFT WALLET 2", did_id=None, push=True),
+        wallet_environments.tx_config,
+    )
 
     await env_0.change_balances({"nft": {"init": True}})
     await env_1.change_balances({"nft": {"init": True}})
@@ -310,13 +324,13 @@ async def test_nft_mint_rpc(wallet_environments: WalletTestFramework, zero_royal
             )
         )
     ).coins[0]
-    did_lineage_parent: Optional[bytes32] = None
+    did_lineage_parent: bytes32 | None = None
     txs: list[TransactionRecord] = []
     nft_ids = set()
     for i in range(0, n, chunk):
         resp = await env_0.rpc_client.nft_mint_bulk(
             NFTMintBulk(
-                wallet_id=nft_wallet_maker["wallet_id"],
+                wallet_id=create_wallet_res.wallet_id,
                 metadata_list=[NFTMintMetadata.from_json_dict(metadata) for metadata in metadata_list[i : i + chunk]],
                 target_list=target_list[i : i + chunk],
                 royalty_percentage=uint16.construct_optional(royalty_percentage),

chia/_tests/wallet/nft_wallet/test_nft_offers.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional, Union
-
 import pytest
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
@@ -116,7 +114,7 @@ async def test_nft_offer_with_fee(wallet_environments: WalletTestFramework) -> N
     # MAKE FIRST TRADE: 1 NFT for 100 xch
 
     nft_to_offer = coins_maker[0]
-    nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     assert nft_info is not None
     nft_asset_id = create_asset_id(nft_info)
     assert nft_asset_id is not None
@@ -124,7 +122,7 @@ async def test_nft_offer_with_fee(wallet_environments: WalletTestFramework) -> N
 
     xch_request = 100
     maker_fee = uint64(10)
-    offer_nft_for_xch: dict[Union[int, bytes32], int] = {wallet_maker.id(): xch_request, nft_asset_id: -1}
+    offer_nft_for_xch: dict[int | bytes32, int] = {wallet_maker.id(): xch_request, nft_asset_id: -1}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -215,7 +213,7 @@ async def test_nft_offer_with_fee(wallet_environments: WalletTestFramework) -> N
     # MAKE SECOND TRADE: 100 xch for 1 NFT
 
     nft_to_buy = coins_taker[0]
-    nft_to_buy_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
+    nft_to_buy_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
     assert nft_to_buy_info is not None
     nft_to_buy_asset_id = create_asset_id(nft_to_buy_info)
     assert nft_to_buy_asset_id is not None
@@ -223,7 +221,7 @@ async def test_nft_offer_with_fee(wallet_environments: WalletTestFramework) -> N
 
     xch_offered = 1000
     maker_fee = uint64(10)
-    offer_xch_for_nft: dict[Union[int, bytes32], int] = {wallet_maker.id(): -xch_offered, nft_to_buy_asset_id: 1}
+    offer_xch_for_nft: dict[int | bytes32, int] = {wallet_maker.id(): -xch_offered, nft_to_buy_asset_id: 1}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -385,7 +383,7 @@ async def test_nft_offer_cancellations(wallet_environments: WalletTestFramework)
 
     # maker creates offer and cancels
     nft_to_offer = coins_maker[0]
-    nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     assert nft_info is not None
     nft_asset_id = create_asset_id(nft_info)
     assert nft_asset_id is not None
@@ -393,7 +391,7 @@ async def test_nft_offer_cancellations(wallet_environments: WalletTestFramework)
 
     xch_request = 100
     maker_fee = uint64(10)
-    offer_nft_for_xch: dict[Union[bytes32, int], int] = {wallet_maker.id(): xch_request, nft_asset_id: -1}
+    offer_nft_for_xch: dict[bytes32 | int, int] = {wallet_maker.id(): xch_request, nft_asset_id: -1}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -602,7 +600,7 @@ async def test_nft_offer_with_metadata_update(wallet_environments: WalletTestFra
 
     # MAKE FIRST TRADE: 1 NFT for 100 xch
     nft_to_offer = coins_maker[0]
-    nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     assert nft_info is not None
     nft_asset_id = create_asset_id(nft_info)
     assert nft_asset_id is not None
@@ -610,7 +608,7 @@ async def test_nft_offer_with_metadata_update(wallet_environments: WalletTestFra
 
     xch_request = 100
     maker_fee = uint64(10)
-    offer_nft_for_xch: dict[Union[bytes32, int], int] = {wallet_maker.id(): xch_request, nft_asset_id: -1}
+    offer_nft_for_xch: dict[bytes32 | int, int] = {wallet_maker.id(): xch_request, nft_asset_id: -1}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -827,7 +825,7 @@ async def test_nft_offer_nft_for_cat(wallet_environments: WalletTestFramework, w
 
     # MAKE FIRST TRADE: 1 NFT for 10 taker cats
     nft_to_offer = coins_maker[0]
-    nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     assert nft_info is not None
     nft_asset_id = create_asset_id(nft_info)
     assert nft_asset_id is not None
@@ -835,7 +833,7 @@ async def test_nft_offer_nft_for_cat(wallet_environments: WalletTestFramework, w
 
     maker_fee = uint64(10)
     taker_cat_offered = 2500
-    offer_nft_for_cat: dict[Union[bytes32, int], int] = {
+    offer_nft_for_cat: dict[bytes32 | int, int] = {
         nft_asset_id: -1,
         wallet_maker_for_taker_cat.id(): taker_cat_offered,
     }
@@ -955,7 +953,7 @@ async def test_nft_offer_nft_for_cat(wallet_environments: WalletTestFramework, w
     taker_cat_amount = 500
 
     nft_to_buy = coins_taker[0]
-    nft_to_buy_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
+    nft_to_buy_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
     assert nft_to_buy_info is not None
     nft_to_buy_asset_id = create_asset_id(nft_to_buy_info)
     assert nft_to_buy_asset_id is not None
@@ -964,7 +962,7 @@ async def test_nft_offer_nft_for_cat(wallet_environments: WalletTestFramework, w
     }
 
     maker_fee = uint64(10)
-    offer_multi_cats_for_nft: dict[Union[bytes32, int], int] = {
+    offer_multi_cats_for_nft: dict[bytes32 | int, int] = {
         nft_to_buy_asset_id: 1,
         wallet_maker_for_taker_cat.id(): -taker_cat_amount,
         cat_wallet_maker.id(): -maker_cat_amount,
@@ -1230,13 +1228,13 @@ async def test_nft_offer_nft_for_nft(wallet_environments: WalletTestFramework) -
     assert len(coins_taker) == 1
 
     nft_to_offer = coins_maker[0]
-    nft_to_offer_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_to_offer_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     assert nft_to_offer_info is not None
     nft_to_offer_asset_id = create_asset_id(nft_to_offer_info)
     assert nft_to_offer_asset_id is not None
 
     nft_to_take = coins_taker[0]
-    nft_to_take_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_take.full_puzzle))
+    nft_to_take_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_take.full_puzzle))
     assert nft_to_take_info is not None
     nft_to_take_asset_id = create_asset_id(nft_to_take_info)
     assert nft_to_take_asset_id is not None
@@ -1247,7 +1245,7 @@ async def test_nft_offer_nft_for_nft(wallet_environments: WalletTestFramework) -
     }
 
     maker_fee = uint64(10)
-    offer_nft_for_nft: dict[Union[bytes32, int], int] = {nft_to_take_asset_id: 1, nft_to_offer_asset_id: -1}
+    offer_nft_for_nft: dict[bytes32 | int, int] = {nft_to_take_asset_id: 1, nft_to_offer_asset_id: -1}
 
     async with trade_manager_maker.wallet_state_manager.new_action_scope(
         wallet_environments.tx_config, push=False
@@ -1466,7 +1464,7 @@ async def test_nft_offer_nft0_and_xch_for_cat(
 
     # MAKE FIRST TRADE: 1 NFT for 10 taker cats
     nft_to_offer = coins_maker[0]
-    nft_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
+    nft_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_offer.full_puzzle))
     assert nft_info is not None
     nft_asset_id = create_asset_id(nft_info)
     assert nft_asset_id is not None
@@ -1476,7 +1474,7 @@ async def test_nft_offer_nft0_and_xch_for_cat(
     maker_xch_offered = 1000
     taker_cat_offered = 2500
     wallet_maker_id = wallet_maker.id()
-    offer_nft_for_cat: dict[Union[bytes32, int], int] = {
+    offer_nft_for_cat: dict[bytes32 | int, int] = {
         wallet_maker_id: -maker_xch_offered,
         nft_asset_id: -1,
         wallet_maker_for_taker_cat.id(): taker_cat_offered,
@@ -1595,7 +1593,7 @@ async def test_nft_offer_nft0_and_xch_for_cat(
     taker_cat_amount = 500
 
     nft_to_buy = coins_taker[0]
-    nft_to_buy_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
+    nft_to_buy_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_to_buy.full_puzzle))
     assert nft_to_buy_info is not None
     nft_to_buy_asset_id = create_asset_id(nft_to_buy_info)
     assert nft_to_buy_asset_id is not None
@@ -1605,7 +1603,7 @@ async def test_nft_offer_nft0_and_xch_for_cat(
     }
 
     maker_fee = uint64(10)
-    offer_multi_cats_for_nft: dict[Union[bytes32, int], int] = {
+    offer_multi_cats_for_nft: dict[bytes32 | int, int] = {
         nft_to_buy_asset_id: 1,
         wallet_maker_for_taker_cat.id(): -taker_cat_amount,
         cat_wallet_maker.id(): -maker_cat_amount,

chia/_tests/wallet/nft_wallet/test_nft_puzzles.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import random
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 
@@ -85,7 +84,7 @@ def test_nft_transfer_puzzle_hashes(seeded_random: random.Random) -> None:
 
     conds = nft_puz.run(nft_sol)
 
-    expected_ph: Optional[bytes32] = None
+    expected_ph: bytes32 | None = None
     # get the new NFT puzhash
     for cond in conds.as_iter():
         if cond.first().as_int() == 51:

chia/_tests/wallet/nft_wallet/test_nft_wallet.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import asyncio
 import time
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import pytest
 from chia_rs import AugSchemeMPL
@@ -660,10 +661,128 @@ async def test_nft_wallet_rpc_creation_and_list(wallet_environments: WalletTestF
     # test counts
     assert (await env.rpc_client.count_nfts(NFTCountNFTs(uint32(env.wallet_aliases["nft"])))).count == 2
     assert (await env.rpc_client.count_nfts(NFTCountNFTs())).count == 2
-    with pytest.raises(ResponseFailureError, match="Wallet 50 not found"):
+    with pytest.raises(ResponseFailureError, match="Wallet with id 50 does not exist"):
         await env.rpc_client.count_nfts(NFTCountNFTs(uint32(50)))
 
 
+@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
+@pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [1]}], indirect=True)
+@pytest.mark.anyio
+async def test_sign_message_by_nft_id(wallet_environments: WalletTestFramework) -> None:
+    env = wallet_environments.environments[0]
+    wallet_node = env.node
+    wallet = env.xch_wallet
+
+    env.wallet_aliases = {
+        "xch": 1,
+        "nft": 2,
+    }
+
+    nft_wallet_0 = await env.rpc_client.fetch("create_new_wallet", dict(wallet_type="nft_wallet", name="NFT WALLET 1"))
+    assert isinstance(nft_wallet_0, dict)
+    assert nft_wallet_0.get("success")
+    assert env.wallet_aliases["nft"] == nft_wallet_0["wallet_id"]
+
+    async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+        wallet_ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
+    await env.rpc_client.mint_nft(
+        request=NFTMintNFTRequest(
+            wallet_id=uint32(env.wallet_aliases["nft"]),
+            royalty_address=encode_puzzle_hash(wallet_ph, AddressType.NFT.hrp(wallet_node.config)),
+            target_address=None,
+            hash=bytes32.from_hexstr("0xD4584AD463139FA8C0D9F68F4B59F185D4584AD463139FA8C0D9F68F4B59F185"),
+            uris=["https://www.chia.net/img/branding/chia-logo.svg"],
+            push=True,
+        ),
+        tx_config=wallet_environments.tx_config,
+    )
+
+    await wallet_environments.process_pending_states(
+        [
+            WalletStateTransition(
+                pre_block_balance_updates={
+                    "xch": {"set_remainder": True},  # tested above
+                    "nft": {"init": True, "pending_coin_removal_count": 1},
+                },
+                post_block_balance_updates={
+                    "xch": {"set_remainder": True},  # tested above
+                    "nft": {
+                        "pending_coin_removal_count": -1,
+                        "unspent_coin_count": 1,
+                    },
+                },
+            )
+        ]
+    )
+
+    nft_list = await env.rpc_client.list_nfts(NFTGetNFTs(uint32(env.wallet_aliases["nft"])))
+    nft_id = nft_list.nft_list[0].nft_id
+
+    # Test general string
+    message = "Hello World"
+    response = await env.rpc_client.sign_message_by_id(
+        SignMessageByID(
+            id=nft_id,
+            message=message,
+        )
+    )
+    puzzle: Program = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, message))
+    assert AugSchemeMPL.verify(
+        response.pubkey,
+        puzzle.get_tree_hash(),
+        response.signature,
+    )
+    # Test hex string
+    message = "0123456789ABCDEF"
+    response = await env.rpc_client.sign_message_by_id(
+        SignMessageByID(
+            id=nft_id,
+            message=message,
+            is_hex=True,
+        )
+    )
+    puzzle = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, bytes.fromhex(message)))
+
+    assert AugSchemeMPL.verify(
+        response.pubkey,
+        puzzle.get_tree_hash(),
+        response.signature,
+    )
+
+    # Test BLS sign string
+    message = "Hello World"
+    response = await env.rpc_client.sign_message_by_id(
+        SignMessageByID(
+            id=nft_id,
+            message=message,
+            is_hex=False,
+            safe_mode=False,
+        )
+    )
+
+    assert AugSchemeMPL.verify(
+        response.pubkey,
+        bytes(message, "utf-8"),
+        response.signature,
+    )
+    # Test BLS sign hex
+    message = "0123456789ABCDEF"
+    response = await env.rpc_client.sign_message_by_id(
+        SignMessageByID(
+            id=nft_id,
+            message=message,
+            is_hex=True,
+            safe_mode=False,
+        )
+    )
+
+    assert AugSchemeMPL.verify(
+        response.pubkey,
+        hexstr_to_bytes(message),
+        response.signature,
+    )
+
+
 @pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.PLAIN], reason="irrelevant")
 @pytest.mark.parametrize("wallet_environments", [{"num_environments": 1, "blocks_needed": [1]}], indirect=True)
 @pytest.mark.anyio

chia/_tests/wallet/nft_wallet/test_ownership_outer_puzzle.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16
 from clvm_tools.binutils import assemble
@@ -16,7 +14,6 @@ from chia.wallet.uncurried_puzzle import uncurry_puzzle
 
 def test_ownership_outer_puzzle() -> None:
     ACS = Program.to(1)
-    NIL = Program.to([])
     owner = bytes32.zeros
     # (mod (current_owner conditions solution)
     #     (list current_owner () conditions)
@@ -28,12 +25,12 @@ def test_ownership_outer_puzzle() -> None:
     )
     transfer_program_default: Program = puzzle_for_transfer_program(bytes32([1] * 32), bytes32([2] * 32), uint16(5000))
     ownership_puzzle: Program = puzzle_for_ownership_layer(owner, Program.to(transfer_program), ACS)
-    ownership_puzzle_empty: Program = puzzle_for_ownership_layer(NIL, Program.to(transfer_program), ACS)
+    ownership_puzzle_empty: Program = puzzle_for_ownership_layer(Program.NIL, Program.to(transfer_program), ACS)
     ownership_puzzle_default: Program = puzzle_for_ownership_layer(owner, transfer_program_default, ACS)
-    ownership_driver: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(ownership_puzzle))
-    ownership_driver_empty: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(ownership_puzzle_empty))
-    ownership_driver_default: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(ownership_puzzle_default))
-    transfer_program_driver: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(transfer_program_default))
+    ownership_driver: PuzzleInfo | None = match_puzzle(uncurry_puzzle(ownership_puzzle))
+    ownership_driver_empty: PuzzleInfo | None = match_puzzle(uncurry_puzzle(ownership_puzzle_empty))
+    ownership_driver_default: PuzzleInfo | None = match_puzzle(uncurry_puzzle(ownership_puzzle_default))
+    transfer_program_driver: PuzzleInfo | None = match_puzzle(uncurry_puzzle(transfer_program_default))
 
     assert ownership_driver is not None
     assert ownership_driver_empty is not None
@@ -41,7 +38,7 @@ def test_ownership_outer_puzzle() -> None:
     assert transfer_program_driver is not None
     assert ownership_driver.type() == "ownership"
     assert ownership_driver["owner"] == owner
-    assert ownership_driver_empty["owner"] == NIL
+    assert ownership_driver_empty["owner"] == Program.NIL
     assert ownership_driver["transfer_program"] == transfer_program
     assert ownership_driver_default["transfer_program"] == transfer_program_driver
     assert transfer_program_driver.type() == "royalty transfer program"