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

chia/wallet/nft_wallet/nft_puzzle_utils.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint64
@@ -82,7 +82,7 @@ async def get_nft_info_from_puzzle(nft_coin_info: NFTCoinInfo, config: dict[str,
     :param ignore_size_limit Ignore the off-chain metadata loading size limit
     :return: NFTInfo
     """
-    uncurried_nft: Optional[UncurriedNFT] = UncurriedNFT.uncurry(*nft_coin_info.full_puzzle.uncurry())
+    uncurried_nft: UncurriedNFT | None = UncurriedNFT.uncurry(*nft_coin_info.full_puzzle.uncurry())
     assert uncurried_nft is not None
     data_uris: list[str] = []
 
@@ -94,7 +94,7 @@ async def get_nft_info_from_puzzle(nft_coin_info: NFTCoinInfo, config: dict[str,
     license_uris: list[str] = []
     for uri in uncurried_nft.license_uris.as_python():
         license_uris.append(str(uri, "utf-8"))
-    off_chain_metadata: Optional[str] = None
+    off_chain_metadata: str | None = None
     nft_info = NFTInfo(
         encode_puzzle_hash(uncurried_nft.singleton_launcher_id, prefix=AddressType.NFT.hrp(config=config)),
         uncurried_nft.singleton_launcher_id,
@@ -177,7 +177,7 @@ def update_metadata(metadata: Program, update_condition: Program) -> Program:
 
 
 def construct_ownership_layer(
-    current_owner: Optional[bytes32],
+    current_owner: bytes32 | None,
     transfer_program: Program,
     inner_puzzle: Program,
 ) -> Program:
@@ -189,7 +189,7 @@ def create_ownership_layer_puzzle(
     did_id: bytes,
     p2_puzzle: Program,
     percentage: uint16,
-    royalty_puzzle_hash: Optional[bytes32] = None,
+    royalty_puzzle_hash: bytes32 | None = None,
 ) -> Program:
     log.debug(
         "Creating ownership layer puzzle with NFT_ID: %s DID_ID: %s Royalty_Percentage: %d P2_puzzle: %s",
@@ -230,7 +230,7 @@ def create_ownership_layer_transfer_solution(
 def get_metadata_and_phs(unft: UncurriedNFT, solution: SerializedProgram) -> tuple[Program, bytes32]:
     conditions = unft.p2_puzzle.run(unft.get_innermost_solution(Program.from_serialized(solution)))
     metadata = unft.metadata
-    puzhash_for_derivation: Optional[bytes32] = None
+    puzhash_for_derivation: bytes32 | None = None
     for condition in conditions.as_iter():
         if condition.list_len() < 2:
             # invalid condition
@@ -279,9 +279,9 @@ def recurry_nft_puzzle(unft: UncurriedNFT, solution: Program, new_inner_puzzle:
     return new_ownership_puzzle
 
 
-def get_new_owner_did(unft: UncurriedNFT, solution: Program) -> Union[Literal[b""], bytes32, None]:
+def get_new_owner_did(unft: UncurriedNFT, solution: Program) -> Literal[b""] | bytes32 | None:
     conditions = unft.p2_puzzle.run(unft.get_innermost_solution(solution))
-    new_did_id: Union[Literal[b""], bytes32, None] = None
+    new_did_id: Literal[b""] | bytes32 | None = None
     for condition in conditions.as_iter():
         if condition.first().as_int() == -10:
             # this is the change owner magic condition

chia/wallet/nft_wallet/nft_wallet.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 import json
 import logging
 import math
-import time
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar, cast
 
 from chia_rs import AugSchemeMPL, CoinSpend, CoinState, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
@@ -15,7 +14,6 @@ from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
-from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
 from chia.util.casts import int_from_bytes, int_to_bytes
 from chia.util.hash import std_hash
 from chia.wallet.conditions import (
@@ -26,7 +24,6 @@ from chia.wallet.conditions import (
     CreateCoinAnnouncement,
     CreatePuzzleAnnouncement,
     UnknownCondition,
-    parse_timelock_info,
 )
 from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.did_wallet import did_wallet_puzzles
@@ -40,8 +37,6 @@ from chia.wallet.nft_wallet.uncurry_nft import NFTCoinData, UncurriedNFT
 from chia.wallet.outer_puzzles import AssetType, construct_puzzle, match_puzzle, solve_puzzle
 from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
-    DEFAULT_HIDDEN_PUZZLE_HASH,
-    calculate_synthetic_secret_key,
     puzzle_for_pk,
 )
 from chia.wallet.singleton import SINGLETON_LAUNCHER_PUZZLE, SINGLETON_LAUNCHER_PUZZLE_HASH, create_singleton_puzzle
@@ -49,8 +44,6 @@ from chia.wallet.trading.offer import OFFER_MOD, OFFER_MOD_HASH, NotarizedPaymen
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.uncurried_puzzle import uncurry_puzzle
 from chia.wallet.util.compute_additions import compute_additions
-from chia.wallet.util.compute_memos import compute_memos
-from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_action_scope import WalletActionScope
@@ -76,7 +69,7 @@ class NFTWallet:
     nft_store: WalletNftStore
 
     @property
-    def did_id(self) -> Optional[bytes32]:
+    def did_id(self) -> bytes32 | None:
         return self.nft_wallet_info.did_id
 
     @classmethod
@@ -84,8 +77,8 @@ class NFTWallet:
         cls: type[_T_NFTWallet],
         wallet_state_manager: Any,
         wallet: Wallet,
-        did_id: Optional[bytes32] = None,
-        name: Optional[str] = None,
+        did_id: bytes32 | None = None,
+        name: str | None = None,
     ) -> _T_NFTWallet:
         """
         This must be called under the wallet state manager lock
@@ -115,7 +108,7 @@ class NFTWallet:
         wallet_state_manager: Any,
         wallet: Wallet,
         wallet_info: WalletInfo,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> _T_NFTWallet:
         self = cls()
         self.log = logging.getLogger(name if name else __name__)
@@ -135,25 +128,25 @@ class NFTWallet:
     def id(self) -> uint32:
         return self.wallet_info.id
 
-    def get_did(self) -> Optional[bytes32]:
+    def get_did(self) -> bytes32 | None:
         return self.did_id
 
-    async def get_confirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_confirmed_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128:
         """The NFT wallet doesn't really have a balance."""
         return uint128(0)
 
-    async def get_unconfirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_unconfirmed_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128:
         """The NFT wallet doesn't really have a balance."""
         return uint128(0)
 
-    async def get_spendable_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_spendable_balance(self, unspent_records: set[WalletCoinRecord] | None = None) -> uint128:
         """The NFT wallet doesn't really have a balance."""
         return uint128(0)
 
     async def get_pending_change_balance(self) -> uint64:
         return uint64(0)
 
-    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_max_send_amount(self, records: set[WalletCoinRecord] | None = None) -> uint128:
         """This is the confirmed balance, which we set to 0 as the NFT wallet doesn't have one."""
         return uint128(0)
 
@@ -164,7 +157,7 @@ class NFTWallet:
         return nft_coin
 
     async def coin_added(
-        self, coin: Coin, height: uint32, peer: WSChiaConnection, parent_coin_data: Optional[NFTCoinData]
+        self, coin: Coin, height: uint32, peer: WSChiaConnection, parent_coin_data: NFTCoinData | None
     ) -> None:
         """Notification from wallet state manager that wallet has been received."""
         self.log.info(f"NFT wallet %s has been notified that {coin} was added", self.get_name())
@@ -191,9 +184,9 @@ class NFTWallet:
         metadata, p2_puzzle_hash = get_metadata_and_phs(uncurried_nft, data.parent_coin_spend.solution)
         self.log.debug("Got back puzhash from solution: %s", p2_puzzle_hash)
         self.log.debug("Got back updated metadata: %s", metadata)
-        derivation_record: Optional[
-            DerivationRecord
-        ] = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(p2_puzzle_hash)
+        derivation_record: (
+            DerivationRecord | None
+        ) = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(p2_puzzle_hash)
         self.log.debug("Record for %s is: %s", p2_puzzle_hash, derivation_record)
         if derivation_record is None:
             self.log.debug("Not our NFT, pointing to %s, skipping", p2_puzzle_hash)
@@ -267,7 +260,7 @@ class NFTWallet:
         puzzle: Program,
         lineage_proof: LineageProof,
         mint_height: uint32,
-        minter_did: Optional[bytes32],
+        minter_did: bytes32 | None,
         confirmed_height: uint32,
     ) -> None:
         new_nft = NFTCoinInfo(nft_id, coin, lineage_proof, puzzle, mint_height, minter_did, confirmed_height)
@@ -300,7 +293,7 @@ class NFTWallet:
         self,
         nft_ids: list[bytes32],
         action_scope: WalletActionScope,
-        did_id: Optional[bytes32] = None,
+        did_id: bytes32 | None = None,
     ) -> bytes32:
         """Get DID spend with announcement created we need to transfer NFT with did with current inner hash of DID
 
@@ -329,10 +322,10 @@ class NFTWallet:
         self,
         metadata: Program,
         action_scope: WalletActionScope,
-        target_puzzle_hash: Optional[bytes32] = None,
-        royalty_puzzle_hash: Optional[bytes32] = None,
+        target_puzzle_hash: bytes32 | None = None,
+        royalty_puzzle_hash: bytes32 | None = None,
         percentage: uint16 = uint16(0),
-        did_id: Optional[bytes] = None,
+        did_id: bytes | None = None,
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> bytes32:
@@ -488,36 +481,24 @@ class NFTWallet:
     async def convert_puzzle_hash(self, puzhash: bytes32) -> bytes32:
         return puzhash
 
-    async def get_nft(self, launcher_id: bytes32) -> Optional[NFTCoinInfo]:
+    async def get_nft(self, launcher_id: bytes32) -> NFTCoinInfo | None:
         return await self.nft_store.get_nft_by_id(launcher_id)
 
     async def get_puzzle_info(self, nft_id: bytes32) -> PuzzleInfo:
-        nft_coin: Optional[NFTCoinInfo] = await self.get_nft(nft_id)
+        nft_coin: NFTCoinInfo | None = await self.get_nft(nft_id)
         if nft_coin is None:
             raise ValueError("An asset ID was specified that this wallet doesn't track")
-        puzzle_info: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(nft_coin.full_puzzle))
+        puzzle_info: PuzzleInfo | None = match_puzzle(uncurry_puzzle(nft_coin.full_puzzle))
         if puzzle_info is None:
             raise ValueError("Internal Error: NFT wallet is tracking a non NFT coin")
         else:
             return puzzle_info
 
-    async def sign_message(self, message: str, nft: NFTCoinInfo, mode: SigningMode) -> tuple[G1Element, G2Element]:
+    async def current_p2_puzzle_hash(self, nft: NFTCoinInfo) -> bytes32:
         uncurried_nft = UncurriedNFT.uncurry(*nft.full_puzzle.uncurry())
         if uncurried_nft is not None:
             p2_puzzle = uncurried_nft.p2_puzzle
-            puzzle_hash = p2_puzzle.get_tree_hash()
-            private = await self.wallet_state_manager.get_private_key(puzzle_hash)
-            synthetic_secret_key = calculate_synthetic_secret_key(private, DEFAULT_HIDDEN_PUZZLE_HASH)
-            synthetic_pk = synthetic_secret_key.get_g1()
-            if mode == SigningMode.CHIP_0002_HEX_INPUT:
-                hex_message: bytes = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, bytes.fromhex(message))).get_tree_hash()
-            elif mode == SigningMode.BLS_MESSAGE_AUGMENTATION_UTF8_INPUT:
-                hex_message = bytes(message, "utf-8")
-            elif mode == SigningMode.BLS_MESSAGE_AUGMENTATION_HEX_INPUT:
-                hex_message = bytes.fromhex(message)
-            else:
-                hex_message = Program.to((CHIP_0002_SIGN_MESSAGE_PREFIX, message)).get_tree_hash()
-            return synthetic_pk, AugSchemeMPL.sign(synthetic_secret_key, hex_message)
+            return p2_puzzle.get_tree_hash()
         else:
             raise ValueError("Invalid NFT puzzle.")
 
@@ -527,7 +508,7 @@ class NFTWallet:
         *args: Any,
         **kwargs: Any,
     ) -> set[Coin]:
-        nft_coin: Optional[NFTCoinInfo] = await self.get_nft(nft_id)
+        nft_coin: NFTCoinInfo | None = await self.get_nft(nft_id)
         if nft_coin is None:
             raise ValueError("An asset ID was specified that this wallet doesn't track")
         return {nft_coin.coin}
@@ -547,7 +528,7 @@ class NFTWallet:
         wallet_state_manager: Any,
         wallet: Wallet,
         puzzle_driver: PuzzleInfo,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> Any:
         # Off the bat we don't support multiple profile but when we do this will have to change
         for wsm_wallet in wallet_state_manager.wallets.values():
@@ -568,17 +549,17 @@ class NFTWallet:
         puzzle_hashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[set[Coin]] = None,
-        memos: Optional[list[list[bytes]]] = None,
+        coins: set[Coin] | None = None,
+        memos: list[list[bytes]] | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None:
-        nft_coin: Optional[NFTCoinInfo] = kwargs.get("nft_coin", None)
-        new_owner: Optional[bytes] = kwargs.get("new_owner", None)
-        new_did_inner_hash: Optional[bytes] = kwargs.get("new_did_inner_hash", None)
-        trade_prices_list: Optional[Program] = kwargs.get("trade_prices_list", None)
+        nft_coin: NFTCoinInfo | None = kwargs.get("nft_coin", None)
+        new_owner: bytes | None = kwargs.get("new_owner", None)
+        new_did_inner_hash: bytes | None = kwargs.get("new_did_inner_hash", None)
+        trade_prices_list: Program | None = kwargs.get("trade_prices_list", None)
         additional_bundles: list[WalletSpendBundle] = kwargs.get("additional_bundles", [])
-        metadata_update: Optional[tuple[str, str]] = kwargs.get("metadata_update", None)
+        metadata_update: tuple[str, str] | None = kwargs.get("metadata_update", None)
         if memos is None:
             memos = [[] for _ in range(len(puzzle_hashes))]
 
@@ -613,25 +594,16 @@ class NFTWallet:
             other_tx_additions: set[Coin] = {
                 addition for tx in interface.side_effects.transactions for addition in tx.additions
             }
-            tx = TransactionRecord(
-                confirmed_at_height=uint32(0),
-                created_at_time=uint64(time.time()),
-                to_puzzle_hash=puzzle_hashes[0],
-                to_address=self.wallet_state_manager.encode_puzzle_hash(puzzle_hashes[0]),
+            tx = self.wallet_state_manager.new_outgoing_transaction(
+                wallet_id=self.id(),
+                puzzle_hash=puzzle_hashes[0],
                 amount=uint64(payment_sum),
-                fee_amount=fee,
-                confirmed=False,
-                sent=uint32(0),
+                fee=fee,
                 spend_bundle=spend_bundle,
                 additions=list(set(spend_bundle.additions()) - other_tx_additions),
                 removals=list(set(spend_bundle.removals()) - other_tx_removals),
-                wallet_id=self.id(),
-                sent_to=[],
-                trade_id=None,
-                type=uint32(TransactionType.OUTGOING_TX.value),
                 name=spend_bundle.name(),
-                memos=compute_memos(spend_bundle),
-                valid_times=parse_timelock_info(extra_conditions),
+                extra_conditions=extra_conditions,
             )
 
             interface.side_effects.transactions.append(tx)
@@ -641,12 +613,12 @@ class NFTWallet:
         payments: list[CreateCoin],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[set[Coin]] = None,
-        new_owner: Optional[bytes] = None,
-        new_did_inner_hash: Optional[bytes] = None,
-        trade_prices_list: Optional[Program] = None,
-        metadata_update: Optional[tuple[str, str]] = None,
-        nft_coin: Optional[NFTCoinInfo] = None,
+        coins: set[Coin] | None = None,
+        new_owner: bytes | None = None,
+        new_did_inner_hash: bytes | None = None,
+        trade_prices_list: Program | None = None,
+        metadata_update: tuple[str, str] | None = None,
+        nft_coin: NFTCoinInfo | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> WalletSpendBundle:
         if nft_coin is None:
@@ -671,9 +643,9 @@ class NFTWallet:
         if unft.supports_did:
             if new_owner is None:
                 # If no new owner was specified and we're sending this to ourselves, let's not reset the DID
-                derivation_record: Optional[
-                    DerivationRecord
-                ] = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
+                derivation_record: (
+                    DerivationRecord | None
+                ) = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
                     payments[0].puzzle_hash
                 )
                 if derivation_record is not None:
@@ -741,7 +713,7 @@ class NFTWallet:
     @staticmethod
     async def make_nft1_offer(
         wallet_state_manager: Any,
-        offer_dict: dict[Optional[bytes32], int],
+        offer_dict: dict[bytes32 | None, int],
         driver_dict: dict[bytes32, PuzzleInfo],
         action_scope: WalletActionScope,
         fee: uint64,
@@ -761,7 +733,7 @@ class NFTWallet:
                 royalty_nft_asset_dict[asset] = amount
 
         # Then, all of the things that trigger royalties
-        fungible_asset_dict: dict[Optional[bytes32], int] = {}
+        fungible_asset_dict: dict[bytes32 | None, int] = {}
         for asset, amount in offer_dict.items():
             if asset is None or driver_dict[asset].type() != AssetType.SINGLETON.value:
                 fungible_asset_dict[asset] = amount
@@ -806,7 +778,7 @@ class NFTWallet:
             else:
                 offered_royalty_percentages[asset] = uint16(royalty_percentage)
 
-        royalty_payments: dict[Optional[bytes32], list[tuple[bytes32, CreateCoin]]] = {}
+        royalty_payments: dict[bytes32 | None, list[tuple[bytes32, CreateCoin]]] = {}
         for asset, amount in fungible_asset_dict.items():  # offered fungible items
             if amount < 0 and request_side_royalty_split > 0:
                 payment_list: list[tuple[bytes32, CreateCoin]] = []
@@ -821,20 +793,20 @@ class NFTWallet:
 
         # Generate the requested_payments to be notarized
         p2_ph = await action_scope.get_puzzle_hash(wallet_state_manager)
-        requested_payments: dict[Optional[bytes32], list[CreateCoin]] = {}
+        requested_payments: dict[bytes32 | None, list[CreateCoin]] = {}
         for asset, amount in offer_dict.items():
             if amount > 0:
                 requested_payments[asset] = [CreateCoin(p2_ph, uint64(amount), [p2_ph] if asset is not None else [])]
 
         # Find all the coins we're offering
-        offered_coins_by_asset: dict[Optional[bytes32], set[Coin]] = {}
+        offered_coins_by_asset: dict[bytes32 | None, set[Coin]] = {}
         all_offered_coins: set[Coin] = set()
         for asset, amount in offer_dict.items():
             if amount < 0:
                 if asset is None:
                     wallet = wallet_state_manager.main_wallet
                 else:
-                    wallet = await wallet_state_manager.get_wallet_for_asset_id(asset.hex())
+                    wallet = await wallet_state_manager.get_wallet_for_asset_id(asset)
                 if asset in royalty_payments:
                     royalty_amount: int = sum(p.amount for _, p in royalty_payments[asset])
                 else:
@@ -850,7 +822,7 @@ class NFTWallet:
                 all_offered_coins.update(offered_coins)
 
         # Notarize the payments and get the announcements for the bundle
-        notarized_payments: dict[Optional[bytes32], list[NotarizedPayment]] = Offer.notarize_payments(
+        notarized_payments: dict[bytes32 | None, list[NotarizedPayment]] = Offer.notarize_payments(
             requested_payments, list(all_offered_coins)
         )
         announcements_to_assert: list[AssertPuzzleAnnouncement] = Offer.calculate_announcements(
@@ -885,7 +857,7 @@ class NFTWallet:
                 if asset is None:
                     wallet = wallet_state_manager.main_wallet
                 else:
-                    wallet = await wallet_state_manager.get_wallet_for_asset_id(asset.hex())
+                    wallet = await wallet_state_manager.get_wallet_for_asset_id(asset)
 
                 # First, sending all the coins to the OFFER_MOD
                 async with wallet_state_manager.new_action_scope(
@@ -934,8 +906,8 @@ class NFTWallet:
                     # We cannot create coins with the same puzzle hash and amount
                     # So if there's multiple NFTs with the same royalty puzhash/percentage, we must create multiple
                     # generations of offer coins
-                    royalty_coin: Optional[Coin] = None
-                    parent_spend: Optional[CoinSpend] = None
+                    royalty_coin: Coin | None = None
+                    parent_spend: CoinSpend | None = None
                     while True:
                         duplicate_payments: list[tuple[bytes32, CreateCoin]] = []
                         deduped_payment_list: list[tuple[bytes32, CreateCoin]] = []
@@ -1142,15 +1114,15 @@ class NFTWallet:
         self,
         metadata_list: list[dict[str, Any]],
         action_scope: WalletActionScope,
-        target_list: Optional[list[bytes32]] = [],
-        mint_number_start: Optional[int] = 1,
-        mint_total: Optional[int] = None,
-        xch_coins: Optional[set[Coin]] = None,
-        xch_change_ph: Optional[bytes32] = None,
-        new_innerpuzhash: Optional[bytes32] = None,
-        new_p2_puzhash: Optional[bytes32] = None,
-        did_coin: Optional[Coin] = None,
-        did_lineage_parent: Optional[bytes32] = None,
+        target_list: list[bytes32] | None = [],
+        mint_number_start: int | None = 1,
+        mint_total: int | None = None,
+        xch_coins: set[Coin] | None = None,
+        xch_change_ph: bytes32 | None = None,
+        new_innerpuzhash: bytes32 | None = None,
+        new_p2_puzhash: bytes32 | None = None,
+        did_coin: Coin | None = None,
+        did_lineage_parent: bytes32 | None = None,
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:
@@ -1375,7 +1347,7 @@ class NFTWallet:
         )
         # The DID lineage parent won't not exist if we're bulk minting from a future DID coin
         if did_lineage_parent:
-            did_parent_info: Optional[LineageProof] = LineageProof(
+            did_parent_info: LineageProof | None = LineageProof(
                 parent_name=did_lineage_parent,
                 inner_puzzle_hash=innerpuz.get_tree_hash(),
                 amount=uint64(did_coin.amount),
@@ -1403,25 +1375,16 @@ class NFTWallet:
 
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
-                TransactionRecord(
-                    confirmed_at_height=uint32(0),
-                    created_at_time=uint64(time.time()),
-                    to_puzzle_hash=innerpuz.get_tree_hash(),
-                    to_address=self.wallet_state_manager.encode_puzzle_hash(innerpuz.get_tree_hash()),
+                self.wallet_state_manager.new_outgoing_transaction(
+                    wallet_id=did_wallet.id(),
+                    puzzle_hash=innerpuz.get_tree_hash(),
                     amount=uint64(1),
-                    fee_amount=fee,
-                    confirmed=False,
-                    sent=uint32(0),
+                    fee=fee,
                     spend_bundle=unsigned_spend_bundle,
-                    additions=list(unsigned_spend_bundle.additions()),
-                    removals=list(unsigned_spend_bundle.removals()),
-                    wallet_id=did_wallet.id(),
-                    sent_to=[],
-                    trade_id=None,
-                    type=uint32(TransactionType.OUTGOING_TX.value),
+                    additions=unsigned_spend_bundle.additions(),
+                    removals=unsigned_spend_bundle.removals(),
                     name=unsigned_spend_bundle.name(),
-                    memos=compute_memos(unsigned_spend_bundle),
-                    valid_times=parse_timelock_info(extra_conditions),
+                    extra_conditions=extra_conditions,
                 )
             )
 
@@ -1429,11 +1392,11 @@ class NFTWallet:
         self,
         metadata_list: list[dict[str, Any]],
         action_scope: WalletActionScope,
-        target_list: Optional[list[bytes32]] = [],
-        mint_number_start: Optional[int] = 1,
-        mint_total: Optional[int] = None,
-        xch_coins: Optional[set[Coin]] = None,
-        xch_change_ph: Optional[bytes32] = None,
+        target_list: list[bytes32] | None = [],
+        mint_number_start: int | None = 1,
+        mint_total: int | None = None,
+        xch_coins: set[Coin] | None = None,
+        xch_change_ph: bytes32 | None = None,
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> None:

chia/wallet/nft_wallet/ownership_outer_puzzle.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, Optional, Union
 
 from chia_rs.sized_bytes import bytes32
 from clvm_tools.binutils import disassemble
@@ -19,7 +19,7 @@ def match_ownership_layer_puzzle(puzzle: UncurriedPuzzle) -> tuple[bool, list[Pr
 
 
 def puzzle_for_ownership_layer(
-    current_owner: Union[Program, bytes], transfer_program: Program, inner_puzzle: Program
+    current_owner: Program | bytes, transfer_program: Program, inner_puzzle: Program
 ) -> Program:
     return NFT_OWNERSHIP_LAYER.curry(NFT_OWNERSHIP_LAYER.get_tree_hash(), current_owner, transfer_program, inner_puzzle)
 
@@ -30,18 +30,18 @@ def solution_for_ownership_layer(inner_solution: Program) -> Program:
 
 @dataclass(frozen=True)
 class OwnershipOuterPuzzle:
-    _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
+    _match: Callable[[UncurriedPuzzle], PuzzleInfo | None]
     _construct: Callable[[PuzzleInfo, Program], Program]
     _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
-    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle, Optional[Program]], Optional[Program]]
-    _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle, Program | None], Program | None]
+    _get_inner_solution: Callable[[PuzzleInfo, Program], Program | None]
 
-    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+    def match(self, puzzle: UncurriedPuzzle) -> PuzzleInfo | None:
         matched, curried_args = match_ownership_layer_puzzle(puzzle)
         if matched:
             _, current_owner, transfer_program, inner_puzzle = curried_args
             owner_bytes: bytes = current_owner.as_python()
-            tp_match: Optional[PuzzleInfo] = self._match(uncurry_puzzle(transfer_program))
+            tp_match: PuzzleInfo | None = self._match(uncurry_puzzle(transfer_program))
             constructor_dict = {
                 "type": "ownership",
                 "owner": "()" if owner_bytes == b"" else "0x" + owner_bytes.hex(),
@@ -54,14 +54,14 @@ class OwnershipOuterPuzzle:
         else:
             return None
 
-    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+    def asset_id(self, constructor: PuzzleInfo) -> bytes32 | None:
         return None
 
     def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
         also = constructor.also()
         if also is not None:
             inner_puzzle = self._construct(also, inner_puzzle)
-        transfer_program_info: Union[PuzzleInfo, Program] = constructor["transfer_program"]
+        transfer_program_info: PuzzleInfo | Program = constructor["transfer_program"]
         if isinstance(transfer_program_info, Program):
             transfer_program: Program = transfer_program_info
         else:
@@ -69,25 +69,25 @@ class OwnershipOuterPuzzle:
         return puzzle_for_ownership_layer(constructor["owner"], transfer_program, inner_puzzle)
 
     def get_inner_puzzle(
-        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Optional[Program] = None
-    ) -> Optional[Program]:
+        self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Program | None = None
+    ) -> Program | None:
         matched, curried_args = match_ownership_layer_puzzle(puzzle_reveal)
         if matched:
             _, _, _, inner_puzzle = curried_args
             also = constructor.also()
             if also is not None:
-                deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle), None)
+                deep_inner_puzzle: Program | None = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle), None)
                 return deep_inner_puzzle
             else:
                 return inner_puzzle
         else:
             raise ValueError("This driver is not for the specified puzzle reveal")
 
-    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Program | None:
         my_inner_solution: Program = solution.first()
         also = constructor.also()
         if also:
-            deep_inner_solution: Optional[Program] = self._get_inner_solution(also, my_inner_solution)
+            deep_inner_solution: Program | None = self._get_inner_solution(also, my_inner_solution)
             return deep_inner_solution
         else:
             return my_inner_solution