chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/wallet/trading/offer.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, BinaryIO, Optional, Union
+from typing import BinaryIO
 
 from chia_puzzles_py.programs import SETTLEMENT_PAYMENT, SETTLEMENT_PAYMENT_HASH
 from chia_rs import CoinSpend, G2Element
@@ -15,12 +15,13 @@ from chia.types.blockchain_format.program import INFINITE_COST, Program, run_wit
 from chia.types.coin_spend import make_spend
 from chia.util.bech32m import bech32_decode, bech32_encode, convertbits
 from chia.util.errors import Err, ValidationError
-from chia.util.streamable import parse_rust
+from chia.util.streamable import Streamable, parse_rust, streamable
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     AssertPuzzleAnnouncement,
     Condition,
     ConditionValidTimes,
+    ConditionValidTimesAbsolute,
     CreateCoin,
     parse_conditions_non_consensus,
     parse_timelock_info,
@@ -43,7 +44,7 @@ from chia.wallet.util.puzzle_compression import (
 )
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
-OfferSummary = dict[Union[int, bytes32], int]
+OfferSpecification = dict[int | bytes32, int]
 
 OFFER_MOD = Program.from_bytes(SETTLEMENT_PAYMENT)
 OFFER_MOD_HASH = bytes32(SETTLEMENT_PAYMENT_HASH)
@@ -51,7 +52,7 @@ OFFER_MOD_HASH = bytes32(SETTLEMENT_PAYMENT_HASH)
 
 def detect_dependent_coin(
     names: list[bytes32], deps: dict[bytes32, list[bytes32]], announcement_dict: dict[bytes32, list[bytes32]]
-) -> Optional[tuple[bytes32, bytes32]]:
+) -> tuple[bytes32, bytes32] | None:
     # First, we check for any dependencies on coins in the same bundle
     for name in names:
         for dependency in deps[name]:
@@ -76,10 +77,22 @@ class NotarizedPayment(CreateCoin):
         return self.to_program().get_tree_hash()
 
 
+@streamable
+@dataclass(frozen=True)
+class OfferSummary(Streamable):
+    offered: dict[str, str]  # str for negative int support
+    requested: dict[str, str]  # str for negative int support
+    fees: uint64
+    infos: dict[str, PuzzleInfo]
+    additions: list[bytes32]
+    removals: list[bytes32]
+    valid_times: ConditionValidTimesAbsolute
+
+
 @dataclass(frozen=True, eq=False)
 class Offer:
     requested_payments: dict[
-        Optional[bytes32], list[NotarizedPayment]
+        bytes32 | None, list[NotarizedPayment]
     ]  # The key is the asset id of the asset being requested
     _bundle: WalletSpendBundle
     driver_dict: dict[bytes32, PuzzleInfo]  # asset_id -> asset driver
@@ -88,9 +101,9 @@ class Offer:
     # ordered by the coin being spent
     _additions: dict[Coin, list[Coin]] = field(init=False, repr=False)
     _hints: dict[bytes32, bytes32] = field(init=False)
-    _offered_coins: dict[Optional[bytes32], list[Coin]] = field(init=False, repr=False)
-    _final_spend_bundle: Optional[WalletSpendBundle] = field(init=False, repr=False)
-    _conditions: Optional[dict[Coin, list[Condition]]] = field(init=False)
+    _offered_coins: dict[bytes32 | None, list[Coin]] = field(init=False, repr=False)
+    _final_spend_bundle: WalletSpendBundle | None = field(init=False, repr=False)
+    _conditions: dict[Coin, list[Condition]] | None = field(init=False)
 
     @staticmethod
     def ph() -> bytes32:
@@ -98,15 +111,15 @@ class Offer:
 
     @staticmethod
     def notarize_payments(
-        requested_payments: dict[Optional[bytes32], list[CreateCoin]],  # `None` means you are requesting XCH
+        requested_payments: dict[bytes32 | None, list[CreateCoin]],  # `None` means you are requesting XCH
         coins: list[Coin],
-    ) -> dict[Optional[bytes32], list[NotarizedPayment]]:
+    ) -> dict[bytes32 | None, list[NotarizedPayment]]:
         # This sort should be reproducible in CLVM with `>s`
         sorted_coins: list[Coin] = sorted(coins, key=Coin.name)
-        sorted_coin_list: list[list[Union[bytes32, uint64]]] = [coin_as_list(c) for c in sorted_coins]
+        sorted_coin_list: list[list[bytes32 | uint64]] = [coin_as_list(c) for c in sorted_coins]
         nonce: bytes32 = Program.to(sorted_coin_list).get_tree_hash()
 
-        notarized_payments: dict[Optional[bytes32], list[NotarizedPayment]] = {}
+        notarized_payments: dict[bytes32 | None, list[NotarizedPayment]] = {}
         for asset_id, payments in requested_payments.items():
             notarized_payments[asset_id] = []
             for p in payments:
@@ -117,7 +130,7 @@ class Offer:
     # The announcements returned from this function must be asserted in whatever spend bundle is created by the wallet
     @staticmethod
     def calculate_announcements(
-        notarized_payments: dict[Optional[bytes32], list[NotarizedPayment]],
+        notarized_payments: dict[bytes32 | None, list[NotarizedPayment]],
         driver_dict: dict[bytes32, PuzzleInfo],
     ) -> list[AssertPuzzleAnnouncement]:
         announcements: list[AssertPuzzleAnnouncement] = []
@@ -222,8 +235,8 @@ class Offer:
 
     # This method does not get every coin that is being offered, only the `settlement_payment` children
     # It's also a little heuristic, but it should get most things
-    def _get_offered_coins(self) -> dict[Optional[bytes32], list[Coin]]:
-        offered_coins: dict[Optional[bytes32], list[Coin]] = {}
+    def _get_offered_coins(self) -> dict[bytes32 | None, list[Coin]]:
+        offered_coins: dict[bytes32 | None, list[Coin]] = {}
 
         for parent_spend in self._bundle.coin_spends:
             coins_for_this_spend: list[Coin] = []
@@ -235,8 +248,8 @@ class Offer:
             puzzle_driver = match_puzzle(parent_puzzle)
             if puzzle_driver is not None:
                 asset_id = create_asset_id(puzzle_driver)
-                inner_puzzle: Optional[Program] = get_inner_puzzle(puzzle_driver, parent_puzzle, parent_solution)
-                inner_solution: Optional[Program] = get_inner_solution(puzzle_driver, parent_solution)
+                inner_puzzle: Program | None = get_inner_puzzle(puzzle_driver, parent_puzzle, parent_solution)
+                inner_solution: Program | None = get_inner_solution(puzzle_driver, parent_solution)
                 assert inner_puzzle is not None and inner_solution is not None
 
                 # We're going to look at the conditions created by the inner puzzle
@@ -280,7 +293,7 @@ class Offer:
                 offered_coins[asset_id].extend(coins_for_this_spend)
         return offered_coins
 
-    def get_offered_coins(self) -> dict[Optional[bytes32], list[Coin]]:
+    def get_offered_coins(self) -> dict[bytes32 | None, list[Coin]]:
         try:
             if self._offered_coins is not None:
                 return self._offered_coins
@@ -288,58 +301,58 @@ class Offer:
             object.__setattr__(self, "_offered_coins", self._get_offered_coins())
         return self._offered_coins
 
-    def get_offered_amounts(self) -> dict[Optional[bytes32], int]:
-        offered_coins: dict[Optional[bytes32], list[Coin]] = self.get_offered_coins()
-        offered_amounts: dict[Optional[bytes32], int] = {}
+    def get_offered_amounts(self) -> dict[bytes32 | None, int]:
+        offered_coins: dict[bytes32 | None, list[Coin]] = self.get_offered_coins()
+        offered_amounts: dict[bytes32 | None, int] = {}
         for asset_id, coins in offered_coins.items():
             offered_amounts[asset_id] = uint64(sum(c.amount for c in coins))
         return offered_amounts
 
-    def get_requested_payments(self) -> dict[Optional[bytes32], list[NotarizedPayment]]:
+    def get_requested_payments(self) -> dict[bytes32 | None, list[NotarizedPayment]]:
         return self.requested_payments
 
-    def get_requested_amounts(self) -> dict[Optional[bytes32], int]:
-        requested_amounts: dict[Optional[bytes32], int] = {}
+    def get_requested_amounts(self) -> dict[bytes32 | None, int]:
+        requested_amounts: dict[bytes32 | None, int] = {}
         for asset_id, coins in self.get_requested_payments().items():
             requested_amounts[asset_id] = uint64(sum(c.amount for c in coins))
         return requested_amounts
 
-    def arbitrage(self) -> dict[Optional[bytes32], int]:
+    def arbitrage(self) -> dict[bytes32 | None, int]:
         """
         Returns a dictionary of the type of each asset and amount that is involved in the trade
         With the amount being how much their offered amount within the offer
         exceeds/falls short of their requested amount.
         """
-        offered_amounts: dict[Optional[bytes32], int] = self.get_offered_amounts()
-        requested_amounts: dict[Optional[bytes32], int] = self.get_requested_amounts()
+        offered_amounts: dict[bytes32 | None, int] = self.get_offered_amounts()
+        requested_amounts: dict[bytes32 | None, int] = self.get_requested_amounts()
 
-        arbitrage_dict: dict[Optional[bytes32], int] = {}
+        arbitrage_dict: dict[bytes32 | None, int] = {}
         for asset_id in [*requested_amounts.keys(), *offered_amounts.keys()]:
             arbitrage_dict[asset_id] = offered_amounts.get(asset_id, 0) - requested_amounts.get(asset_id, 0)
 
         return arbitrage_dict
 
     # This is a method mostly for the UI that creates a JSON summary of the offer
-    def summary(self) -> tuple[dict[str, int], dict[str, int], dict[str, dict[str, Any]], ConditionValidTimes]:
-        offered_amounts: dict[Optional[bytes32], int] = self.get_offered_amounts()
-        requested_amounts: dict[Optional[bytes32], int] = self.get_requested_amounts()
+    def summary(self) -> tuple[dict[str, str], dict[str, str], dict[str, PuzzleInfo], ConditionValidTimes]:
+        offered_amounts: dict[bytes32 | None, int] = self.get_offered_amounts()
+        requested_amounts: dict[bytes32 | None, int] = self.get_requested_amounts()
 
-        def keys_to_strings(dic: dict[Optional[bytes32], Any]) -> dict[str, Any]:
-            new_dic: dict[str, Any] = {}
+        def keys_and_amounts_to_strings(dic: dict[bytes32 | None, int]) -> dict[str, str]:
+            new_dic: dict[str, str] = {}
             for key, val in dic.items():
                 if key is None:
-                    new_dic["xch"] = val
+                    new_dic["xch"] = str(val)
                 else:
-                    new_dic[key.hex()] = val
+                    new_dic[key.hex()] = str(val)
             return new_dic
 
-        driver_dict: dict[str, Any] = {}
+        driver_dict: dict[str, PuzzleInfo] = {}
         for key, value in self.driver_dict.items():
-            driver_dict[key.hex()] = value.info
+            driver_dict[key.hex()] = value
 
         return (
-            keys_to_strings(offered_amounts),
-            keys_to_strings(requested_amounts),
+            keys_and_amounts_to_strings(offered_amounts),
+            keys_and_amounts_to_strings(requested_amounts),
             driver_dict,
             self.absolute_valid_times_ban_relatives(),
         )
@@ -449,7 +462,7 @@ class Offer:
 
     @classmethod
     def aggregate(cls, offers: list[Offer]) -> Offer:
-        total_requested_payments: dict[Optional[bytes32], list[NotarizedPayment]] = {}
+        total_requested_payments: dict[bytes32 | None, list[NotarizedPayment]] = {}
         total_bundle = WalletSpendBundle([], G2Element())
         total_driver_dict: dict[bytes32, PuzzleInfo] = {}
         for offer in offers:
@@ -481,13 +494,13 @@ class Offer:
 
     # A "valid" spend means that this bundle can be pushed to the network and will succeed
     # This differs from the `to_spend_bundle` method which deliberately creates an invalid SpendBundle
-    def to_valid_spend(self, arbitrage_ph: Optional[bytes32] = None, solver: Solver = Solver({})) -> WalletSpendBundle:
+    def to_valid_spend(self, arbitrage_ph: bytes32 | None = None, solver: Solver = Solver({})) -> WalletSpendBundle:
         if not self.is_valid():
             raise ValueError("Offer is currently incomplete")
 
         completion_spends: list[CoinSpend] = []
-        all_offered_coins: dict[Optional[bytes32], list[Coin]] = self.get_offered_coins()
-        total_arbitrage_amount: dict[Optional[bytes32], int] = self.arbitrage()
+        all_offered_coins: dict[bytes32 | None, list[Coin]] = self.get_offered_coins()
+        total_arbitrage_amount: dict[bytes32 | None, int] = self.arbitrage()
         for asset_id, payments in self.requested_payments.items():
             offered_coins: list[Coin] = all_offered_coins[asset_id]
 
@@ -612,7 +625,7 @@ class Offer:
     @classmethod
     def from_spend_bundle(cls, bundle: WalletSpendBundle) -> Offer:
         # Because of the `to_spend_bundle` method, we need to parse the dummy CoinSpends as `requested_payments`
-        requested_payments: dict[Optional[bytes32], list[NotarizedPayment]] = {}
+        requested_payments: dict[bytes32 | None, list[NotarizedPayment]] = {}
         driver_dict: dict[bytes32, PuzzleInfo] = {}
         leftover_coin_spends: list[CoinSpend] = []
         for coin_spend in bundle.coin_spends:
@@ -648,7 +661,7 @@ class Offer:
             return False  # don't attempt to compare against unrelated types
         return self.name() == other.name()
 
-    def compress(self, version: Optional[int] = None) -> bytes:
+    def compress(self, version: int | None = None) -> bytes:
         as_spend_bundle = self.to_spend_bundle()
         if version is None:
             mods: list[bytes] = [bytes(uncurry(s.puzzle_reveal)[0]) for s in as_spend_bundle.coin_spends]
@@ -667,7 +680,7 @@ class Offer:
             pass
         return cls.from_bytes(offer_bytes)
 
-    def to_bech32(self, prefix: str = "offer", compression_version: Optional[int] = None) -> str:
+    def to_bech32(self, prefix: str = "offer", compression_version: int | None = None) -> str:
         offer_bytes = self.compress(version=compression_version)
         encoded = bech32_encode(prefix, convertbits(list(offer_bytes), 8, 5))
         return encoded

chia/wallet/trading/trade_store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 from time import perf_counter
-from typing import Optional
 
 import aiosqlite
 from chia_rs.sized_bytes import bytes32
@@ -84,7 +83,7 @@ class TradeStore:
 
     @classmethod
     async def create(
-        cls, db_wrapper: DBWrapper2, cache_size: uint32 = uint32(600000), name: Optional[str] = None
+        cls, db_wrapper: DBWrapper2, cache_size: uint32 = uint32(600000), name: str | None = None
     ) -> TradeStore:
         self = cls()
 
@@ -227,7 +226,7 @@ class TradeStore:
         """
         Updates the status of the trade
         """
-        current: Optional[TradeRecord] = await self.get_trade_record(trade_id)
+        current: TradeRecord | None = await self.get_trade_record(trade_id)
         if current is None:
             return
         confirmed_at_index = current.confirmed_at_index
@@ -255,13 +254,13 @@ class TradeStore:
         await self.add_trade_record(tx, offer_name, replace=True)
 
     async def increment_sent(
-        self, id: bytes32, name: str, send_status: MempoolInclusionStatus, err: Optional[Err]
+        self, id: bytes32, name: str, send_status: MempoolInclusionStatus, err: Err | None
     ) -> bool:
         """
         Updates trade sent count (Full Node has received spend_bundle and sent ack).
         """
 
-        current: Optional[TradeRecord] = await self.get_trade_record(id)
+        current: TradeRecord | None = await self.get_trade_record(id)
         if current is None:
             return False
 
@@ -322,7 +321,7 @@ class TradeStore:
 
         return total, my_offers_count, taken_offers_count
 
-    async def get_trade_record(self, trade_id: bytes32) -> Optional[TradeRecord]:
+    async def get_trade_record(self, trade_id: bytes32) -> TradeRecord | None:
         """
         Checks DB for TradeRecord with id: id and returns it.
         """
@@ -377,7 +376,7 @@ class TradeStore:
         start: int,
         end: int,
         *,
-        sort_key: Optional[str] = None,
+        sort_key: str | None = None,
         reverse: bool = False,
         exclude_my_offers: bool = False,
         exclude_taken_offers: bool = False,
@@ -398,8 +397,8 @@ class TradeStore:
 
         offset = start
         limit = end - start
-        where_status_clause: Optional[str] = None
-        order_by_clause: Optional[str] = None
+        where_status_clause: str | None = None
+        order_by_clause: str | None = None
 
         if not include_completed:
             # Construct a WHERE clause that only looks at active/pending statuses

chia/wallet/transaction_record.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 from chia_rs import SpendBundle
 from chia_rs.sized_bytes import bytes32
@@ -29,7 +29,7 @@ class ItemAndTransactionRecords(Generic[T]):
 
 
 @streamable
-@dataclass(frozen=True)
+@dataclass(frozen=True, kw_only=True)
 class TransactionRecordOld(Streamable):
     """
     Used for storing transaction data and status in wallets.
@@ -42,15 +42,15 @@ class TransactionRecordOld(Streamable):
     fee_amount: uint64
     confirmed: bool
     sent: uint32
-    spend_bundle: Optional[WalletSpendBundle]
+    spend_bundle: WalletSpendBundle | None
     additions: list[Coin]
     removals: list[Coin]
     wallet_id: uint32
 
     # Represents the list of peers that we sent the transaction to, whether each one
     # included it in the mempool, and what the error message (if any) was
-    sent_to: list[tuple[str, uint8, Optional[str]]]
-    trade_id: Optional[bytes32]
+    sent_to: list[tuple[str, uint8, str | None]]
+    trade_id: bytes32 | None
     type: uint32  # TransactionType
 
     # name is also called bundle_id and tx_id
@@ -64,7 +64,7 @@ class TransactionRecordOld(Streamable):
                 return True
         return False
 
-    def height_farmed(self, genesis_challenge: bytes32) -> Optional[uint32]:
+    def height_farmed(self, genesis_challenge: bytes32) -> uint32 | None:
         if not self.confirmed:
             return None
         if self.type in {TransactionType.FEE_REWARD, TransactionType.COINBASE_REWARD}:
@@ -100,7 +100,7 @@ class TransactionRecordOld(Streamable):
 
 
 @streamable
-@dataclass(frozen=True)
+@dataclass(frozen=True, kw_only=True)
 class TransactionRecord(TransactionRecordOld):
     valid_times: ConditionValidTimes
     to_address: str
@@ -118,4 +118,4 @@ class LightTransactionRecord(Streamable):
     type: uint32
     additions: list[Coin]
     removals: list[Coin]
-    spend_bundle: Optional[SpendBundle]
+    spend_bundle: SpendBundle | None

chia/wallet/uncurried_puzzle.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Union
 
 from chia.types.blockchain_format.program import Program, uncurry
 from chia.types.blockchain_format.serialized_program import SerializedProgram
@@ -13,5 +12,5 @@ class UncurriedPuzzle:
     args: Program
 
 
-def uncurry_puzzle(puzzle: Union[Program, SerializedProgram]) -> UncurriedPuzzle:
+def uncurry_puzzle(puzzle: Program | SerializedProgram) -> UncurriedPuzzle:
     return UncurriedPuzzle(*uncurry(puzzle))

chia/wallet/util/clvm_streamable.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 import dataclasses
 import functools
+from collections.abc import Callable
 from types import MappingProxyType
-from typing import Any, Callable, Generic, Optional, TypeVar, Union, get_type_hints
+from typing import Any, Generic, TypeGuard, TypeVar, get_type_hints
 
 from hsms.clvm_serde import from_program_for_type, to_program_for_type
-from typing_extensions import TypeGuard
 
 from chia.types.blockchain_format.program import Program
 from chia.util.byte_types import hexstr_to_bytes
@@ -36,7 +36,7 @@ def clvm_streamable(cls: type[Streamable]) -> type[Streamable]:
 
 
 def program_serialize_clvm_streamable(
-    clvm_streamable: Streamable, translation_layer: Optional[TranslationLayer] = None
+    clvm_streamable: Streamable, translation_layer: TranslationLayer | None = None
 ) -> Program:
     if translation_layer is not None:
         mapping = translation_layer.get_mapping(clvm_streamable.__class__)
@@ -47,17 +47,17 @@ def program_serialize_clvm_streamable(
 
 
 def byte_serialize_clvm_streamable(
-    clvm_streamable: Streamable, translation_layer: Optional[TranslationLayer] = None
+    clvm_streamable: Streamable, translation_layer: TranslationLayer | None = None
 ) -> bytes:
     return bytes(program_serialize_clvm_streamable(clvm_streamable, translation_layer=translation_layer))
 
 
 def json_serialize_with_clvm_streamable(
     streamable: object,
-    next_recursion_step: Optional[Callable[..., dict[str, Any]]] = None,
-    translation_layer: Optional[TranslationLayer] = None,
+    next_recursion_step: Callable[..., dict[str, Any]] | None = None,
+    translation_layer: TranslationLayer | None = None,
     **next_recursion_env: Any,
-) -> Union[str, dict[str, Any]]:
+) -> str | dict[str, Any]:
     if next_recursion_step is None:
         next_recursion_step = recurse_jsonify
     if is_clvm_streamable(streamable):
@@ -70,7 +70,7 @@ def json_serialize_with_clvm_streamable(
 
 
 def program_deserialize_clvm_streamable(
-    program: Program, clvm_streamable_type: type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
+    program: Program, clvm_streamable_type: type[_T_Streamable], translation_layer: TranslationLayer | None = None
 ) -> _T_Streamable:
     type_to_deserialize_from: type[Streamable] = clvm_streamable_type
     if translation_layer is not None:
@@ -86,7 +86,7 @@ def program_deserialize_clvm_streamable(
 
 
 def byte_deserialize_clvm_streamable(
-    blob: bytes, clvm_streamable_type: type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
+    blob: bytes, clvm_streamable_type: type[_T_Streamable], translation_layer: TranslationLayer | None = None
 ) -> _T_Streamable:
     return program_deserialize_clvm_streamable(
         Program.from_bytes(blob), clvm_streamable_type, translation_layer=translation_layer
@@ -106,9 +106,9 @@ def is_clvm_streamable(v: object) -> TypeGuard[Streamable]:
 
 
 def json_deserialize_with_clvm_streamable(
-    json_dict: Union[str, dict[str, Any]],
+    json_dict: str | dict[str, Any],
     streamable_type: type[_T_Streamable],
-    translation_layer: Optional[TranslationLayer] = None,
+    translation_layer: TranslationLayer | None = None,
 ) -> _T_Streamable:
     # This function is flawed for compound types because it's highjacking the function_to_convert_one_item func
     # which does not call back to it. More examination is needed.
@@ -164,7 +164,7 @@ class TranslationLayer:
 
     def get_mapping(
         self, _type: type[_T_ClvmStreamable]
-    ) -> Optional[TranslationLayerMapping[_T_ClvmStreamable, Streamable]]:
+    ) -> TranslationLayerMapping[_T_ClvmStreamable, Streamable] | None:
         mappings = [m for m in self.type_mappings if m.from_type == _type]
         if len(mappings) == 1:
             return mappings[0]

chia/wallet/util/compute_hints.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
@@ -18,7 +17,7 @@ from chia.util.errors import Err, ValidationError
 @dataclass(frozen=True)
 class HintedCoin:
     coin: Coin
-    hint: Optional[bytes32]
+    hint: bytes32 | None
 
 
 def compute_spend_hints_and_additions(
@@ -54,12 +53,12 @@ def compute_spend_hints_and_additions(
         assert rf is not None
 
         coin: Coin = Coin(cs.coin.name(), bytes32(rf), uint64(condition.at("rrf").as_int()))
-        hint: Optional[bytes32] = None
+        hint: bytes32 | None = None
         if (
-            condition.at("rrr") != Program.to(None)  # There's more than two arguments
+            condition.at("rrr") != Program.NIL  # There's more than two arguments
             and condition.at("rrrf").atom is None  # The 3rd argument is a cons
         ):
-            potential_hint: Optional[bytes] = condition.at("rrrff").atom
+            potential_hint: bytes | None = condition.at("rrrff").atom
             if potential_hint is not None and len(potential_hint) == 32:
                 hint = bytes32(potential_hint)
         hinted_coins[bytes32(coin.name())] = HintedCoin(coin, hint)

chia/wallet/util/curry_and_treehash.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from hashlib import sha256
-from typing import Callable
 
 from chia_rs.sized_bytes import bytes32
 

chia/wallet/util/merkle_tree.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import math
 from enum import Enum
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 
@@ -57,7 +56,7 @@ class MerkleTree:
 
     def _proof(
         self, puzzle_hashes: list[bytes32], searching_for: bytes32
-    ) -> tuple[Optional[int], Optional[list[bytes32]], bytes32, Optional[int]]:
+    ) -> tuple[int | None, list[bytes32] | None, bytes32, int | None]:
         if len(puzzle_hashes) == 1:
             atom_hash = hash_an_atom(puzzle_hashes[0])
             if puzzle_hashes[0] == searching_for:
@@ -95,6 +94,6 @@ class MerkleTree:
 
             return (final_path, final_list, pair_hash, bit_num + 1 if bit_num is not None else None)
 
-    def generate_proof(self, leaf_reveal: bytes32) -> tuple[Optional[int], list[Optional[list[bytes32]]]]:
+    def generate_proof(self, leaf_reveal: bytes32) -> tuple[int | None, list[list[bytes32] | None]]:
         proof = self._proof(self.nodes, leaf_reveal)
         return (proof[0], [proof[1]])

chia/wallet/util/peer_request_cache.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import CoinState, HeaderBlock
 from chia_rs.sized_bytes import bytes32
@@ -14,7 +14,7 @@ from chia.util.lru_cache import LRUCache
 class PeerRequestCache:
     _blocks: LRUCache[uint32, HeaderBlock]  # height -> HeaderBlock
     _block_requests: LRUCache[tuple[uint32, uint32], asyncio.Task[Any]]  # (start, end) -> Task
-    _states_validated: LRUCache[bytes32, Optional[uint32]]  # coin state hash -> last change height, or None for reorg
+    _states_validated: LRUCache[bytes32, uint32 | None]  # coin state hash -> last change height, or None for reorg
     _timestamps: LRUCache[uint32, uint64]  # block height -> timestamp
     _blocks_validated: LRUCache[bytes32, uint32]  # header_hash -> height
     _block_signatures_validated: LRUCache[bytes32, uint32]  # sig_hash -> height
@@ -33,7 +33,7 @@ class PeerRequestCache:
         self._additions_in_block = LRUCache(200)
         self._race_cache = {}
 
-    def get_block(self, height: uint32) -> Optional[HeaderBlock]:
+    def get_block(self, height: uint32) -> HeaderBlock | None:
         return self._blocks.get(height)
 
     def add_to_blocks(self, header_block: HeaderBlock) -> None:
@@ -43,7 +43,7 @@ class PeerRequestCache:
             if self._timestamps.get(header_block.height) is None:
                 self._timestamps.put(header_block.height, header_block.foliage_transaction_block.timestamp)
 
-    def get_block_request(self, start: uint32, end: uint32) -> Optional[asyncio.Task[Any]]:
+    def get_block_request(self, start: uint32, end: uint32) -> asyncio.Task[Any] | None:
         return self._block_requests.get((start, end))
 
     def add_to_block_requests(self, start: uint32, end: uint32, request: asyncio.Task[Any]) -> None:
@@ -53,14 +53,14 @@ class PeerRequestCache:
         return self._states_validated.get(coin_state_hash) is not None
 
     def add_to_states_validated(self, coin_state: CoinState) -> None:
-        cs_height: Optional[uint32] = None
+        cs_height: uint32 | None = None
         if coin_state.spent_height is not None:
             cs_height = uint32(coin_state.spent_height)
         elif coin_state.created_height is not None:
             cs_height = uint32(coin_state.created_height)
         self._states_validated.put(coin_state.get_hash(), cs_height)
 
-    def get_height_timestamp(self, height: uint32) -> Optional[uint64]:
+    def get_height_timestamp(self, height: uint32) -> uint64 | None:
         return self._timestamps.get(height)
 
     def add_to_blocks_validated(self, reward_chain_hash: bytes32, height: uint32) -> None:
@@ -126,7 +126,7 @@ class PeerRequestCache:
                 new_block_requests.put((start_h, end_h), fetch_task)
         self._block_requests = new_block_requests
 
-        new_states_validated: LRUCache[bytes32, Optional[uint32]] = LRUCache(self._states_validated.capacity)
+        new_states_validated: LRUCache[bytes32, uint32 | None] = LRUCache(self._states_validated.capacity)
         for cs_hash, cs_height in self._states_validated.cache.items():
             if cs_height is not None and cs_height <= height:
                 new_states_validated.put(cs_hash, cs_height)
@@ -158,7 +158,7 @@ class PeerRequestCache:
 
 
 def can_use_peer_request_cache(
-    coin_state: CoinState, peer_request_cache: PeerRequestCache, fork_height: Optional[uint32]
+    coin_state: CoinState, peer_request_cache: PeerRequestCache, fork_height: uint32 | None
 ) -> bool:
     if not peer_request_cache.in_states_validated(coin_state.get_hash()):
         return False