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

chia/wallet/wallet.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 import logging
-import time
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs import AugSchemeMPL, CoinSpend, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
@@ -13,16 +12,13 @@ from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.coin_spend import make_spend
-from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
 from chia.util.hash import std_hash
-from chia.util.streamable import Streamable
 from chia.wallet.coin_selection import select_coins
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     Condition,
     CreateCoin,
     CreateCoinAnnouncement,
-    parse_timelock_info,
 )
 from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.derive_keys import (
@@ -53,9 +49,8 @@ from chia.wallet.signer_protocol import (
     TransactionInfo,
 )
 from chia.wallet.transaction_record import TransactionRecord
-from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.puzzle_decorator import PuzzleDecoratorManager
-from chia.wallet.util.transaction_type import CLAWBACK_INCOMING_TRANSACTION_TYPES, TransactionType
+from chia.wallet.util.transaction_type import CLAWBACK_INCOMING_TRANSACTION_TYPES
 from chia.wallet.util.wallet_types import WalletIdentifier, WalletType
 from chia.wallet.wallet_action_scope import WalletActionScope
 from chia.wallet.wallet_coin_record import WalletCoinRecord
@@ -99,15 +94,15 @@ class Wallet:
         # avoid full block TXs
         return int(self.wallet_state_manager.constants.MAX_BLOCK_COST_CLVM / 5 / self.cost_of_single_tx)
 
-    async def get_max_spendable_coins(self, records: Optional[set[WalletCoinRecord]] = None) -> set[WalletCoinRecord]:
-        spendable: list[WalletCoinRecord] = list(
-            await self.wallet_state_manager.get_spendable_coins_for_wallet(self.id(), records)
+    async def get_max_send_amount(self, records: set[WalletCoinRecord] | None = None) -> uint128:
+        return uint128(
+            sum(
+                cr.coin.amount
+                for cr in await self.wallet_state_manager.get_spendable_coins_for_wallet(
+                    self.id(), records, in_one_block=True
+                )
+            )
         )
-        spendable.sort(reverse=True, key=lambda record: record.coin.amount)
-        return set(spendable[0 : min(len(spendable), self.max_send_quantity)])
-
-    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128:
-        return uint128(sum(cr.coin.amount for cr in await self.get_max_spendable_coins()))
 
     @classmethod
     def type(cls) -> WalletType:
@@ -116,13 +111,16 @@ class Wallet:
     def id(self) -> uint32:
         return self.wallet_id
 
-    async def get_confirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    def convert_secret_key_to_synthetic(self, secret_key: PrivateKey) -> PrivateKey:
+        return calculate_synthetic_secret_key(secret_key, DEFAULT_HIDDEN_PUZZLE_HASH)
+
+    async def get_confirmed_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128:
         return await self.wallet_state_manager.get_confirmed_balance_for_wallet(self.id(), record_list)
 
-    async def get_unconfirmed_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_unconfirmed_balance(self, unspent_records: set[WalletCoinRecord] | None = None) -> uint128:
         return await self.wallet_state_manager.get_unconfirmed_balance(self.id(), unspent_records)
 
-    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:
         spendable = await self.wallet_state_manager.get_confirmed_spendable_balance_for_wallet(
             self.id(), unspent_records
         )
@@ -208,7 +206,9 @@ class Wallet:
         Note: Must be called under wallet state manager lock
         """
         spendable_amount: uint128 = await self.get_spendable_balance()
-        spendable_coins: list[WalletCoinRecord] = list(await self.get_max_spendable_coins())
+        spendable_coins: list[WalletCoinRecord] = list(
+            await self.wallet_state_manager.get_spendable_coins_for_wallet(self.id(), in_one_block=True)
+        )
 
         # Try to use coins from the store, if there isn't enough of "unused"
         # coins use change coins that are not confirmed yet
@@ -234,14 +234,14 @@ class Wallet:
         newpuzzlehashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        origin_id: Optional[bytes32] = None,
-        coins: Optional[set[Coin]] = None,
-        memos: Optional[list[list[bytes]]] = None,
+        origin_id: bytes32 | None = None,
+        coins: set[Coin] | None = None,
+        memos: list[list[bytes]] | None = None,
         negative_change_allowed: bool = False,
-        puzzle_decorator_override: Optional[list[dict[str, Any]]] = None,
+        puzzle_decorator_override: list[dict[str, Any]] | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
-        reserve_fee: Optional[uint64] = None,
-        preferred_change_puzzle_hash: Optional[bytes32] = None,
+        reserve_fee: uint64 | None = None,
+        preferred_change_puzzle_hash: bytes32 | None = None,
     ) -> list[CoinSpend]:
         """
         Generates a unsigned transaction in form of List(Puzzle, Solutions)
@@ -274,7 +274,7 @@ class Wallet:
         assert change >= 0
 
         spends: list[CoinSpend] = []
-        primary_announcement: Optional[AssertCoinAnnouncement] = None
+        primary_announcement: AssertCoinAnnouncement | None = None
 
         # Check for duplicates
         all_primaries_list = list(zip(amounts, newpuzzlehashes))
@@ -363,38 +363,22 @@ class Wallet:
         self.log.debug(f"Spends is {spends}")
         return spends
 
-    async def sign_message(self, message: str, puzzle_hash: bytes32, mode: SigningMode) -> tuple[G1Element, G2Element]:
-        # CHIP-0002 message signing as documented at:
-        # https://github.com/Chia-Network/chips/blob/80e4611fe52b174bf1a0382b9dff73805b18b8c6/CHIPs/chip-0002.md#signmessage
-        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)
-
     async def generate_signed_transaction(
         self,
         amounts: list[uint64],
         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:
-        origin_id: Optional[bytes32] = kwargs.get("origin_id", None)
+        origin_id: bytes32 | None = kwargs.get("origin_id", None)
         negative_change_allowed: bool = kwargs.get("negative_change_allowed", False)
-        puzzle_decorator_override: Optional[list[dict[str, Any]]] = kwargs.get("puzzle_decorator_override", None)
-        reserve_fee: Optional[uint64] = kwargs.get("reserve_fee", None)
-        preferred_change_puzzle_hash: Optional[bytes32] = kwargs.get("preferred_change_puzzle_hash", None)
+        puzzle_decorator_override: list[dict[str, Any]] | None = kwargs.get("puzzle_decorator_override", None)
+        reserve_fee: uint64 | None = kwargs.get("reserve_fee", None)
+        preferred_change_puzzle_hash: bytes32 | None = kwargs.get("preferred_change_puzzle_hash", None)
         """
         Use this to generate transaction.
         Note: this must be called under a wallet state manager lock
@@ -402,7 +386,7 @@ class Wallet:
         """
         non_change_amount = uint64(sum(amounts))
 
-        self.log.debug("Generating transaction for: %s %s %s", puzzle_hashes, amounts, repr(coins))
+        self.log.debug("Generating transaction for: %s %s %r", puzzle_hashes, amounts, coins)
         transaction = await self._generate_unsigned_transaction(
             amounts,
             puzzle_hashes,
@@ -420,7 +404,6 @@ class Wallet:
         assert len(transaction) > 0
         spend_bundle = WalletSpendBundle(transaction, G2Element())
 
-        now = uint64(time.time())
         add_list: list[Coin] = list(spend_bundle.additions())
         rem_list: list[Coin] = list(spend_bundle.removals())
 
@@ -434,25 +417,16 @@ class Wallet:
         to_ph = add_list[0].puzzle_hash if len(add_list) > 0 else bytes32.zeros
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
-                TransactionRecord(
-                    confirmed_at_height=uint32(0),
-                    created_at_time=now,
-                    to_puzzle_hash=to_ph,
-                    to_address=self.wallet_state_manager.encode_puzzle_hash(to_ph),
+                self.wallet_state_manager.new_outgoing_transaction(
+                    wallet_id=self.id(),
+                    puzzle_hash=to_ph,
                     amount=uint64(non_change_amount),
-                    fee_amount=uint64(fee),
-                    confirmed=False,
-                    sent=uint32(0),
+                    fee=fee,
                     spend_bundle=spend_bundle,
                     additions=add_list,
                     removals=rem_list,
-                    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,
                 )
             )
 
@@ -460,10 +434,10 @@ class Wallet:
         self,
         fee: uint64,
         action_scope: WalletActionScope,
-        coins: Optional[set[Coin]] = None,
+        coins: set[Coin] | None = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
-        reserve_fee: Optional[uint64] = None,
-        preferred_change_puzzle_hash: Optional[bytes32] = None,
+        reserve_fee: uint64 | None = None,
+        preferred_change_puzzle_hash: bytes32 | None = None,
     ) -> None:
         if coins is None:
             coins = await self.select_coins(fee, action_scope)
@@ -480,7 +454,7 @@ class Wallet:
 
     async def get_coins_to_offer(
         self,
-        asset_id: Optional[bytes32],
+        asset_id: bytes32 | None,
         amount: uint64,
         action_scope: WalletActionScope,
     ) -> set[Coin]:
@@ -494,9 +468,7 @@ class Wallet:
             return await self.select_coins(amount, sandbox)
 
     # WSChiaConnection is only imported for type checking
-    async def coin_added(
-        self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[Streamable]
-    ) -> None:
+    async def coin_added(self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: object | None) -> None:
         pass
 
     def get_name(self) -> str:
@@ -504,9 +476,9 @@ class Wallet:
 
     async def match_hinted_coin(self, coin: Coin, hint: bytes32) -> bool:
         if hint == coin.puzzle_hash:
-            wallet_identifier: Optional[
-                WalletIdentifier
-            ] = await self.wallet_state_manager.puzzle_store.get_wallet_identifier_for_puzzle_hash(coin.puzzle_hash)
+            wallet_identifier: (
+                WalletIdentifier | None
+            ) = await self.wallet_state_manager.puzzle_store.get_wallet_identifier_for_puzzle_hash(coin.puzzle_hash)
             if wallet_identifier is not None and wallet_identifier.id == self.id():
                 return True
         return False
@@ -514,9 +486,9 @@ class Wallet:
     def hardened_pubkey_for_path(self, path: list[int]) -> G1Element:
         return _derive_path(self.wallet_state_manager.get_master_private_key(), path).get_g1()
 
-    async def sum_hint_for_pubkey(self, pk: bytes) -> Optional[SumHint]:
+    async def sum_hint_for_pubkey(self, pk: bytes) -> SumHint | None:
         pk_parsed: G1Element = G1Element.from_bytes(pk)
-        dr: Optional[DerivationRecord] = await self.wallet_state_manager.puzzle_store.record_for_puzzle_hash(
+        dr: DerivationRecord | None = await self.wallet_state_manager.puzzle_store.record_for_puzzle_hash(
             puzzle_hash_for_synthetic_public_key(pk_parsed)
         )
         if dr is None:
@@ -527,9 +499,9 @@ class Wallet:
             pk,
         )
 
-    async def path_hint_for_pubkey(self, pk: bytes) -> Optional[PathHint]:
+    async def path_hint_for_pubkey(self, pk: bytes) -> PathHint | None:
         pk_parsed: G1Element = G1Element.from_bytes(pk)
-        index: Optional[uint32] = await self.wallet_state_manager.puzzle_store.index_for_pubkey(pk_parsed)
+        index: uint32 | None = await self.wallet_state_manager.puzzle_store.index_for_pubkey(pk_parsed)
         if index is None:
             index = await self.wallet_state_manager.puzzle_store.index_for_puzzle_hash(
                 puzzle_hash_for_synthetic_public_key(pk_parsed)

chia/wallet/wallet_action_scope.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import contextlib
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 from dataclasses import dataclass, field, replace
-from typing import TYPE_CHECKING, Callable, Optional, cast, final
+from typing import TYPE_CHECKING, cast, final
 
 from chia_rs.chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
@@ -33,7 +33,7 @@ class _StreamableWalletSideEffects(Streamable):
     extra_spends: list[WalletSpendBundle]
     selected_coins: list[Coin]
     singleton_records: list[SingletonRecord]
-    get_unused_derivation_record_result: Optional[StreambleGetUnusedDerivationRecordResult]
+    get_unused_derivation_record_result: StreambleGetUnusedDerivationRecordResult | None
 
 
 @dataclass
@@ -43,7 +43,7 @@ class WalletSideEffects:
     extra_spends: list[WalletSpendBundle] = field(default_factory=list)
     selected_coins: list[Coin] = field(default_factory=list)
     singleton_records: list[SingletonRecord] = field(default_factory=list)
-    get_unused_derivation_record_result: Optional[StreambleGetUnusedDerivationRecordResult] = None
+    get_unused_derivation_record_result: StreambleGetUnusedDerivationRecordResult | None = None
 
     def __bytes__(self) -> bytes:
         return bytes(_StreamableWalletSideEffects(**self.__dict__))
@@ -58,7 +58,7 @@ class WalletSideEffects:
 class WalletActionConfig:
     push: bool
     merge_spends: bool
-    sign: Optional[bool]
+    sign: bool | None
     additional_signing_responses: list[SigningResponse]
     extra_spends: list[WalletSpendBundle]
     tx_config: TXConfig
@@ -98,12 +98,12 @@ class WalletActionScope(ActionScope[WalletSideEffects, WalletActionConfig]):
         return (await self._get_unused_derivation_path(wallet_state_manager)).record.puzzle_hash
 
     async def get_puzzle(
-        self, wallet_state_manager: WalletStateManager, override_reuse_puzhash_with: Optional[bool] = None
+        self, wallet_state_manager: WalletStateManager, override_reuse_puzhash_with: bool | None = None
     ) -> Program:
         if (
             self.config.tx_config.reuse_puzhash or override_reuse_puzhash_with is True
         ) and override_reuse_puzhash_with is not False:
-            record: Optional[DerivationRecord] = await wallet_state_manager.get_current_derivation_record_for_wallet(
+            record: DerivationRecord | None = await wallet_state_manager.get_current_derivation_record_for_wallet(
                 wallet_state_manager.main_wallet.id()
             )
             if record is None:
@@ -114,12 +114,12 @@ class WalletActionScope(ActionScope[WalletSideEffects, WalletActionConfig]):
             return await self._get_new_puzzle(wallet_state_manager)
 
     async def get_puzzle_hash(
-        self, wallet_state_manager: WalletStateManager, override_reuse_puzhash_with: Optional[bool] = None
+        self, wallet_state_manager: WalletStateManager, override_reuse_puzhash_with: bool | None = None
     ) -> bytes32:
         if (
             self.config.tx_config.reuse_puzhash or override_reuse_puzhash_with is True
         ) and override_reuse_puzhash_with is not False:
-            record: Optional[DerivationRecord] = await wallet_state_manager.get_current_derivation_record_for_wallet(
+            record: DerivationRecord | None = await wallet_state_manager.get_current_derivation_record_for_wallet(
                 wallet_state_manager.main_wallet.id()
             )
             if record is None:
@@ -135,10 +135,10 @@ async def new_wallet_action_scope(
     tx_config: TXConfig,
     push: bool = False,
     merge_spends: bool = True,
-    sign: Optional[bool] = None,
+    sign: bool | None = None,
     additional_signing_responses: list[SigningResponse] = [],
     extra_spends: list[WalletSpendBundle] = [],
-    puzzle_for_pk: Optional[Callable[[G1Element], Program]] = None,
+    puzzle_for_pk: Callable[[G1Element], Program] | None = None,
 ) -> AsyncIterator[WalletActionScope]:
     if puzzle_for_pk is None:
         puzzle_for_pk = wallet_state_manager.main_wallet.puzzle_for_pk

chia/wallet/wallet_blockchain.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from chia_rs import BlockRecord, ConsensusConstants, HeaderBlock
 from chia_rs.sized_bytes import bytes32
@@ -31,10 +31,10 @@ class WalletBlockchain:
     _basic_store: KeyValStore
     _weight_proof_handler: WalletWeightProofHandler
 
-    synced_weight_proof: Optional[WeightProof]
+    synced_weight_proof: WeightProof | None
     _finished_sync_up_to: uint32
 
-    _peak: Optional[HeaderBlock]
+    _peak: HeaderBlock | None
     _height_to_hash: dict[uint32, bytes32]
     _block_records: dict[bytes32, BlockRecord]
     _latest_timestamp: uint64
@@ -70,7 +70,7 @@ class WalletBlockchain:
         return self
 
     async def new_valid_weight_proof(self, weight_proof: WeightProof, records: list[BlockRecord]) -> None:
-        peak: Optional[HeaderBlock] = await self.get_peak_block()
+        peak: HeaderBlock | None = await self.get_peak_block()
 
         if peak is not None and weight_proof.recent_chain_data[-1].weight <= peak.weight:
             # No update, don't change anything
@@ -93,7 +93,7 @@ class WalletBlockchain:
             await self.set_peak_block(weight_proof.recent_chain_data[-1], latest_timestamp)
             await self.clean_block_records()
 
-    async def add_block(self, block: HeaderBlock) -> tuple[AddBlockResult, Optional[Err]]:
+    async def add_block(self, block: HeaderBlock) -> tuple[AddBlockResult, Err | None]:
         if self.contains_block(block.header_hash):
             return AddBlockResult.ALREADY_HAVE_BLOCK, None
         if not self.contains_block(block.prev_header_hash) and block.height > 0:
@@ -159,7 +159,7 @@ class WalletBlockchain:
 
         await self._basic_store.remove_object("PEAK_BLOCK")
 
-    async def set_peak_block(self, block: HeaderBlock, timestamp: Optional[uint64] = None) -> None:
+    async def set_peak_block(self, block: HeaderBlock, timestamp: uint64 | None = None) -> None:
         await self._basic_store.set_object("PEAK_BLOCK", block)
         self._peak = block
         if timestamp is not None:
@@ -168,7 +168,7 @@ class WalletBlockchain:
             self._latest_timestamp = block.foliage_transaction_block.timestamp
         log.info(f"Peak set to: {self._peak.height} timestamp: {self._latest_timestamp}")
 
-    async def get_peak_block(self) -> Optional[HeaderBlock]:
+    async def get_peak_block(self) -> HeaderBlock | None:
         if self._peak is not None:
             return self._peak
         header_block = await self._basic_store.get_object("PEAK_BLOCK", HeaderBlock)
@@ -183,7 +183,7 @@ class WalletBlockchain:
             await self.clean_block_records()
 
     async def get_finished_sync_up_to(self) -> uint32:
-        h: Optional[uint32] = await self._basic_store.get_object("FINISHED_SYNC_UP_TO", uint32)
+        h: uint32 | None = await self._basic_store.get_object("FINISHED_SYNC_UP_TO", uint32)
         if h is None:
             return uint32(0)
         return h
@@ -191,7 +191,7 @@ class WalletBlockchain:
     def get_latest_timestamp(self) -> uint64:
         return self._latest_timestamp
 
-    def contains_block(self, header_hash: bytes32, height: Optional[uint32] = None) -> bool:
+    def contains_block(self, header_hash: bytes32, height: uint32 | None = None) -> bool:
         """
         True if we have already added this block to the chain. This may return false for orphan blocks
         that we have added but no longer keep in memory.
@@ -204,18 +204,18 @@ class WalletBlockchain:
     def height_to_hash(self, height: uint32) -> bytes32:
         return self._height_to_hash[height]
 
-    def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
+    def try_block_record(self, header_hash: bytes32) -> BlockRecord | None:
         return self._block_records.get(header_hash)
 
     def height_to_block_record(self, height: uint32) -> BlockRecord:
-        header_hash: Optional[bytes32] = self.height_to_hash(height)
+        header_hash: bytes32 | None = self.height_to_hash(height)
         assert header_hash is not None
         return self._block_records[header_hash]
 
     def block_record(self, header_hash: bytes32) -> BlockRecord:
         return self._block_records[header_hash]
 
-    async def get_block_record_from_db(self, header_hash: bytes32) -> Optional[BlockRecord]:
+    async def get_block_record_from_db(self, header_hash: bytes32) -> BlockRecord | None:
         # the wallet doesn't have the blockchain DB, this implements the
         # blockchain_interface
         return self._block_records.get(header_hash)

chia/wallet/wallet_coin_record.py

@@ -1,19 +1,23 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Optional, Union
+from typing import Any
 
+from chia_rs import CoinRecord
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.coin_record import CoinRecord
 from chia.util.streamable import VersionedBlob
 from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata, ClawbackVersion
 from chia.wallet.util.wallet_types import CoinType, StreamableWalletIdentifier, WalletType
 from chia.wallet.vc_wallet.cr_cat_drivers import CRCATMetadata, CRCATVersion
 
-MetadataTypes = Union[ClawbackMetadata, CRCATMetadata]
+MetadataTypes = ClawbackMetadata | CRCATMetadata
+
+
+class WalletCoinRecordMetadataParsingError(Exception):
+    pass
 
 
 @dataclass(frozen=True)
@@ -34,14 +38,14 @@ class WalletCoinRecord:
     # The launcher coin ID will change and will break all hardcode offer tests in CAT/NFT/DL, etc.
     # TODO Change hardcode offer in unit tests
     coin_type: CoinType = field(default=CoinType.NORMAL, hash=False)
-    metadata: Optional[VersionedBlob] = field(default=None, hash=False)
+    metadata: VersionedBlob | None = field(default=None, hash=False)
 
     def wallet_identifier(self) -> StreamableWalletIdentifier:
         return StreamableWalletIdentifier(uint32(self.wallet_id), uint8(self.wallet_type))
 
     def parsed_metadata(self) -> MetadataTypes:
         if self.metadata is None:
-            raise ValueError("Can't parse None metadata")
+            raise WalletCoinRecordMetadataParsingError("Can't parse None metadata")
         if self.coin_type == CoinType.CLAWBACK and self.metadata.version == ClawbackVersion.V1.value:
             return ClawbackMetadata.from_bytes(self.metadata.blob)
         if (
@@ -49,7 +53,9 @@ class WalletCoinRecord:
             and self.metadata.version == CRCATVersion.V1.value
         ):
             return CRCATMetadata.from_bytes(self.metadata.blob)
-        raise ValueError(f"Unknown metadata {self.metadata} for coin_type {self.coin_type}")
+        raise WalletCoinRecordMetadataParsingError(
+            f"Unknown metadata {self.metadata} for coin_id {self.coin.name()} of type {self.coin_type}"
+        )
 
     def name(self) -> bytes32:
         return self.coin.name()

chia/wallet/wallet_coin_store.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import sqlite3
 from dataclasses import dataclass
 from enum import IntEnum
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
@@ -31,16 +30,16 @@ class CoinRecordOrder(IntEnum):
 class GetCoinRecords(Streamable):
     offset: uint32 = uint32(0)
     limit: uint32 = uint32.MAXIMUM
-    wallet_id: Optional[uint32] = None
-    wallet_type: Optional[uint8] = None  # WalletType
-    coin_type: Optional[uint8] = None  # CoinType
-    coin_id_filter: Optional[HashFilter] = None
-    puzzle_hash_filter: Optional[HashFilter] = None
-    parent_coin_id_filter: Optional[HashFilter] = None
-    amount_filter: Optional[AmountFilter] = None
-    amount_range: Optional[UInt64Range] = None
-    confirmed_range: Optional[UInt32Range] = None
-    spent_range: Optional[UInt32Range] = None
+    wallet_id: uint32 | None = None
+    wallet_type: uint8 | None = None  # WalletType
+    coin_type: uint8 | None = None  # CoinType
+    coin_id_filter: HashFilter | None = None
+    puzzle_hash_filter: HashFilter | None = None
+    parent_coin_id_filter: HashFilter | None = None
+    amount_filter: AmountFilter | None = None
+    amount_range: UInt64Range | None = None
+    confirmed_range: UInt32Range | None = None
+    spent_range: UInt32Range | None = None
     order: uint8 = uint8(CoinRecordOrder.confirmed_height)
     reverse: bool = False
     include_total_count: bool = False  # Include the total number of entries for the query without applying offset/limit
@@ -50,7 +49,7 @@ class GetCoinRecords(Streamable):
 class GetCoinRecordsResult:
     records: list[WalletCoinRecord]
     coin_id_to_record: dict[bytes32, WalletCoinRecord]
-    total_count: Optional[uint32]
+    total_count: uint32 | None
 
 
 class WalletCoinStore:
@@ -115,7 +114,7 @@ class WalletCoinStore:
             return int(0 if row is None else row[0])
 
     # Store CoinRecord in DB and ram cache
-    async def add_coin_record(self, record: WalletCoinRecord, name: Optional[bytes32] = None) -> None:
+    async def add_coin_record(self, record: WalletCoinRecord, name: bytes32 | None = None) -> None:
         if name is None:
             name = record.name()
         assert record.spent == (record.spent_block_height != 0)
@@ -174,7 +173,7 @@ class WalletCoinStore:
             None if row[11] is None else VersionedBlob.from_bytes(row[11]),
         )
 
-    async def get_coin_record(self, coin_name: bytes32) -> Optional[WalletCoinRecord]:
+    async def get_coin_record(self, coin_name: bytes32) -> WalletCoinRecord | None:
         """Returns CoinRecord with specified coin id."""
         async with self.db_wrapper.reader_no_transaction() as conn:
             rows = list(await conn.execute_fetchall("SELECT * from coin_record WHERE coin_name=?", (coin_name.hex(),)))
@@ -188,16 +187,16 @@ class WalletCoinStore:
         *,
         offset: uint32 = uint32(0),
         limit: uint32 = uint32.MAXIMUM,
-        wallet_id: Optional[uint32] = None,
-        wallet_type: Optional[WalletType] = None,
-        coin_type: Optional[CoinType] = None,
-        coin_id_filter: Optional[HashFilter] = None,
-        puzzle_hash_filter: Optional[HashFilter] = None,
-        parent_coin_id_filter: Optional[HashFilter] = None,
-        amount_filter: Optional[AmountFilter] = None,
-        amount_range: Optional[UInt64Range] = None,
-        confirmed_range: Optional[UInt32Range] = None,
-        spent_range: Optional[UInt32Range] = None,
+        wallet_id: uint32 | None = None,
+        wallet_type: WalletType | None = None,
+        coin_type: CoinType | None = None,
+        coin_id_filter: HashFilter | None = None,
+        puzzle_hash_filter: HashFilter | None = None,
+        parent_coin_id_filter: HashFilter | None = None,
+        amount_filter: AmountFilter | None = None,
+        amount_range: UInt64Range | None = None,
+        confirmed_range: UInt32Range | None = None,
+        spent_range: UInt32Range | None = None,
         order: CoinRecordOrder = CoinRecordOrder.confirmed_height,
         reverse: bool = False,
         include_total_count: bool = False,
@@ -282,7 +281,7 @@ class WalletCoinStore:
             )
         return [self.coin_record_from_row(row) for row in rows]
 
-    async def get_first_coin_height(self) -> Optional[uint32]:
+    async def get_first_coin_height(self) -> uint32 | None:
         """Returns height of first confirmed coin"""
         async with self.db_wrapper.reader_no_transaction() as conn:
             rows = list(await conn.execute_fetchall("SELECT MIN(confirmed_height) FROM coin_record"))

chia/wallet/wallet_interested_store.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from chia_rs import CoinState
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
@@ -61,7 +59,7 @@ class WalletInterestedStore:
             rows_hex = await cursor.fetchall()
         return [(bytes32(bytes.fromhex(row[0])), row[1]) for row in rows_hex]
 
-    async def get_interested_puzzle_hash_wallet_id(self, puzzle_hash: bytes32) -> Optional[int]:
+    async def get_interested_puzzle_hash_wallet_id(self, puzzle_hash: bytes32) -> int | None:
         async with self.db_wrapper.reader_no_transaction() as conn:
             cursor = await conn.execute(
                 "SELECT wallet_id FROM interested_puzzle_hashes WHERE puzzle_hash=?", (puzzle_hash.hex(),)
@@ -89,7 +87,7 @@ class WalletInterestedStore:
         self,
         asset_id: bytes32,
         name: str,
-        first_seen_height: Optional[uint32],
+        first_seen_height: uint32 | None,
         sender_puzzle_hash: bytes32,
     ) -> None:
         """
@@ -131,7 +129,7 @@ class WalletInterestedStore:
         self,
         asset_id: bytes32,
         coin_state: CoinState,
-        fork_height: Optional[uint32],
+        fork_height: uint32 | None,
     ) -> None:
         """
         Add an unacknowledged coin state of a CAT to the database. It will be inserted into the retry store when the