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

chia/wallet/nft_wallet/singleton_outer_puzzle.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, Callable, Optional
+from typing import Any
 
 from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
@@ -22,13 +23,13 @@ from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
 
 @dataclass(frozen=True)
 class SingletonOuterPuzzle:
-    _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_singleton_puzzle(puzzle)
         if matched:
             singleton_struct, inner_puzzle = curried_args
@@ -52,7 +53,7 @@ class SingletonOuterPuzzle:
         else:
             return None
 
-    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+    def asset_id(self, constructor: PuzzleInfo) -> bytes32 | None:
         return bytes32(constructor["launcher_id"])
 
     def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
@@ -63,25 +64,25 @@ class SingletonOuterPuzzle:
         return puzzle_for_singleton(constructor["launcher_id"], inner_puzzle, launcher_hash)
 
     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_singleton_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.at("rrf")
         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

chia/wallet/nft_wallet/transfer_program_puzzle.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, Optional
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16
@@ -30,7 +30,7 @@ def puzzle_for_transfer_program(launcher_id: bytes32, royalty_puzzle_hash: bytes
 
 def solution_for_transfer_program(
     conditions: Program,
-    current_owner: Optional[bytes32],
+    current_owner: bytes32 | None,
     new_did: bytes32,
     new_did_inner_hash: bytes32,
     trade_prices_list: Program,
@@ -40,13 +40,13 @@ def solution_for_transfer_program(
 
 @dataclass(frozen=True)
 class TransferProgramPuzzle:
-    _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_transfer_program_puzzle(puzzle)
         if matched:
             singleton_struct, royalty_puzzle_hash, percentage = curried_args
@@ -60,7 +60,7 @@ class TransferProgramPuzzle:
         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:
@@ -69,12 +69,12 @@ class TransferProgramPuzzle:
         )
 
     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:
         return None
 
-    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Program | None:
         return None
 
     def solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
-        return Program.to(None)
+        return Program.NIL

chia/wallet/nft_wallet/uncurry_nft.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import Optional
 
 from chia_rs import CoinSpend, CoinState
 from chia_rs.sized_bytes import bytes32
@@ -66,28 +65,28 @@ class UncurriedNFT(Streamable):
     """p2 puzzle of the owner, either for ownership layer or standard"""
 
     # ownership layer fields
-    owner_did: Optional[bytes32]
+    owner_did: bytes32 | None
     """Owner's DID"""
 
     supports_did: bool
     """If the inner puzzle support the DID"""
 
-    nft_inner_puzzle_hash: Optional[bytes32]
+    nft_inner_puzzle_hash: bytes32 | None
     """Puzzle hash of the ownership layer inner puzzle """
 
-    transfer_program: Optional[Program]
+    transfer_program: Program | None
     """Puzzle hash of the transfer program"""
 
-    transfer_program_curry_params: Optional[Program]
+    transfer_program_curry_params: Program | None
     """
     Curried parameters of the transfer program
     [royalty_address, trade_price_percentage, settlement_mod_hash, cat_mod_hash]
     """
-    royalty_address: Optional[bytes32]
-    trade_price_percentage: Optional[uint16]
+    royalty_address: bytes32 | None
+    trade_price_percentage: uint16 | None
 
     @classmethod
-    def uncurry(cls, mod: Program, curried_args: Program) -> Optional[Self]:
+    def uncurry(cls, mod: Program, curried_args: Program) -> Self | None:
         """
         Try to uncurry a NFT puzzle
         :param cls UncurriedNFT class
@@ -140,11 +139,11 @@ class UncurriedNFT(Streamable):
                     edition_number = kv_pair.rest()
                 if kv_pair.first().as_atom() == b"st":
                     edition_total = kv_pair.rest()
-            current_did: Optional[bytes32] = None
+            current_did: bytes32 | None = None
             transfer_program = None
             transfer_program_args = None
-            royalty_address: Optional[bytes32] = None
-            royalty_percentage: Optional[uint16] = None
+            royalty_address: bytes32 | None = None
+            royalty_percentage: uint16 | None = None
             nft_inner_puzzle_mod = None
             mod, ol_args = inner_puzzle.uncurry()
             supports_did = False

chia/wallet/notification_manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import CoinSpend, CoinState, G2Element
 from chia_rs.sized_bytes import bytes32
@@ -29,7 +29,7 @@ class NotificationManager:
     async def create(
         wallet_state_manager: Any,
         db_wrapper: DBWrapper2,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> NotificationManager:
         self = NotificationManager()
         if name:
@@ -96,7 +96,7 @@ class NotificationManager:
         notification_spend = make_spend(
             notification_coin,
             notification_puzzle,
-            Program.to(None),
+            Program.NIL,
         )
         extra_spend_bundle = WalletSpendBundle([notification_spend], G2Element())
         await self.wallet_state_manager.main_wallet.generate_signed_transaction(

chia/wallet/notification_store.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import dataclasses
 import logging
 import sqlite3
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
@@ -32,7 +31,7 @@ class NotificationStore:
 
     @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
     ) -> NotificationStore:
         self = cls()
 
@@ -85,58 +84,42 @@ class NotificationStore:
             )
             await cursor.close()
 
-    async def get_notifications(self, coin_ids: list[bytes32]) -> list[Notification]:
-        """
-        Checks DB for Notification with id: id and returns it.
-        """
-        coin_ids_str_list = "("
-        for _ in coin_ids:
-            coin_ids_str_list += "?"
-            coin_ids_str_list += ","
-        coin_ids_str_list = coin_ids_str_list[:-1] if len(coin_ids_str_list) > 1 else "("
-        coin_ids_str_list += ")"
-
-        async with self.db_wrapper.reader_no_transaction() as conn:
-            rows = await conn.execute_fetchall(
-                f"SELECT * from notifications WHERE coin_id IN {coin_ids_str_list} ORDER BY amount DESC", coin_ids
-            )
-
-        return [
-            Notification(
-                bytes32(row[0]),
-                bytes(row[1]),
-                uint64.from_bytes(row[2]),
-                uint32(row[3]),
-            )
-            for row in rows
-        ]
-
-    async def get_all_notifications(
-        self, pagination: Optional[tuple[Optional[int], Optional[int]]] = None
+    async def get_notifications(
+        self,
+        *,
+        coin_ids: list[bytes32] | None = None,
+        pagination: tuple[int | None, int | None] = (None, None),
     ) -> list[Notification]:
-        """
-        Checks DB for Notification with id: id and returns it.
-        """
-        if pagination is not None:
-            if pagination[1] is not None and pagination[0] is not None:
-                pagination_str = " LIMIT ?, ?"
-                pagination_params: tuple[int, ...] = (pagination[0], pagination[1] - pagination[0])
-            elif pagination[1] is None and pagination[0] is not None:
-                pagination_str = " LIMIT ?, (SELECT COUNT(*) from notifications)"
-                pagination_params = (pagination[0],)
-            elif pagination[1] is not None and pagination[0] is None:
-                pagination_str = " LIMIT ?"
-                pagination_params = (pagination[1],)
-            else:
-                pagination_str = ""
-                pagination_params = tuple()
+        if coin_ids is not None:
+            coin_ids_str_list = "("
+            for _ in coin_ids:
+                coin_ids_str_list += "?"
+                coin_ids_str_list += ","
+            coin_ids_str_list = coin_ids_str_list[:-1] if len(coin_ids_str_list) > 1 else "("
+            coin_ids_str_list += ")"
+            coin_id_filter = f"WHERE coin_id IN {coin_ids_str_list} "
+            coin_id_params = coin_ids
+        else:
+            coin_id_filter = ""
+            coin_id_params = list()
+
+        if pagination[1] is not None and pagination[0] is not None:
+            pagination_str = " LIMIT ?, ?"
+            pagination_params: tuple[int, ...] = (pagination[0], pagination[1] - pagination[0])
+        elif pagination[1] is None and pagination[0] is not None:
+            pagination_str = " LIMIT ?, (SELECT COUNT(*) from notifications)"
+            pagination_params = (pagination[0],)
+        elif pagination[1] is not None and pagination[0] is None:
+            pagination_str = " LIMIT ?"
+            pagination_params = (pagination[1],)
         else:
             pagination_str = ""
             pagination_params = tuple()
 
         async with self.db_wrapper.reader_no_transaction() as conn:
             rows = await conn.execute_fetchall(
-                f"SELECT * from notifications ORDER BY amount DESC{pagination_str}", pagination_params
+                f"SELECT * from notifications {coin_id_filter}ORDER BY amount DESC{pagination_str}",
+                (*coin_id_params, *pagination_params),
             )
 
         return [
@@ -149,23 +132,23 @@ class NotificationStore:
             for row in rows
         ]
 
-    async def delete_notifications(self, coin_ids: list[bytes32]) -> None:
-        coin_ids_str_list = "("
-        for _ in coin_ids:
-            coin_ids_str_list += "?"
-            coin_ids_str_list += ","
-        coin_ids_str_list = coin_ids_str_list[:-1] if len(coin_ids_str_list) > 1 else "("
-        coin_ids_str_list += ")"
-
-        async with self.db_wrapper.writer_maybe_transaction() as conn:
-            # Delete from storage
-            cursor = await conn.execute(f"DELETE FROM notifications WHERE coin_id IN {coin_ids_str_list}", coin_ids)
-            await cursor.close()
+    async def delete_notifications(self, *, coin_ids: list[bytes32] | None = None) -> None:
+        if coin_ids is not None:
+            coin_ids_str_list = "("
+            for _ in coin_ids:
+                coin_ids_str_list += "?"
+                coin_ids_str_list += ","
+            coin_ids_str_list = coin_ids_str_list[:-1] if len(coin_ids_str_list) > 1 else "("
+            coin_ids_str_list += ")"
+            coin_id_filter = f"WHERE coin_id IN {coin_ids_str_list} "
+            coin_id_params = coin_ids
+        else:
+            coin_id_filter = ""
+            coin_id_params = list()
 
-    async def delete_all_notifications(self) -> None:
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             # Delete from storage
-            cursor = await conn.execute("DELETE FROM notifications")
+            cursor = await conn.execute(f"DELETE FROM notifications {coin_id_filter}", coin_id_params)
             await cursor.close()
 
     async def notification_exists(self, id: bytes32) -> bool:

chia/wallet/outer_puzzles.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
 
@@ -47,9 +46,9 @@ class AssetType(Enum):
     REVOCATION_LAYER = "revocation layer"
 
 
-def match_puzzle(puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+def match_puzzle(puzzle: UncurriedPuzzle) -> PuzzleInfo | None:
     for driver in driver_lookup.values():
-        potential_info: Optional[PuzzleInfo] = driver.match(puzzle)
+        potential_info: PuzzleInfo | None = driver.match(puzzle)
         if potential_info is not None:
             return potential_info
     return None
@@ -64,16 +63,16 @@ def solve_puzzle(constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program,
 
 
 def get_inner_puzzle(
-    constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Optional[Program] = None
-) -> Optional[Program]:
+    constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle, solution: Program | None = None
+) -> Program | None:
     return driver_lookup[AssetType(constructor.type())].get_inner_puzzle(constructor, puzzle_reveal, solution)
 
 
-def get_inner_solution(constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+def get_inner_solution(constructor: PuzzleInfo, solution: Program) -> Program | None:
     return driver_lookup[AssetType(constructor.type())].get_inner_solution(constructor, solution)
 
 
-def create_asset_id(constructor: PuzzleInfo) -> Optional[bytes32]:
+def create_asset_id(constructor: PuzzleInfo) -> bytes32 | None:
     return driver_lookup[AssetType(constructor.type())].asset_id(constructor)
 
 

chia/wallet/puzzle_drivers.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any
 
 from clvm.SExp import SExp
 from clvm_tools.binutils import assemble, type_for_atom
 from ir.Type import Type
+from typing_extensions import Self
 
 from chia.types.blockchain_format.program import Program
 from chia.util.casts import int_from_bytes
@@ -17,7 +17,6 @@ When you access a value in the dictionary, it will be deserialized to a str, int
 """
 
 
-@dataclass(frozen=True)
 class PuzzleInfo:
     """
     There are two 'magic' keys in a PuzzleInfo object:
@@ -27,6 +26,10 @@ class PuzzleInfo:
 
     info: dict[str, Any]
 
+    def __init__(self, info: dict[str, Any]) -> None:
+        self.info = info
+        self.__post_init__()
+
     def __post_init__(self) -> None:
         if "type" not in self.info:
             raise ValueError("A type is required to initialize a puzzle driver")
@@ -53,7 +56,7 @@ class PuzzleInfo:
     def type(self) -> str:
         return str(self.info["type"])
 
-    def also(self) -> Optional[PuzzleInfo]:
+    def also(self) -> PuzzleInfo | None:
         if "also" in self.info:
             return PuzzleInfo(self.info["also"])
         else:
@@ -74,11 +77,25 @@ class PuzzleInfo:
         else:
             return False
 
+    # Methods to make this a valid Streamable member
+    # Should not be being serialized as bytes
+    stream = None
+    parse = None
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return self.info
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        return cls(json_dict)
+
 
-@dataclass(frozen=True)
 class Solver:
     info: dict[str, Any]
 
+    def __init__(self, info: dict[str, Any]) -> None:
+        self.info = info
+
     def __getitem__(self, item: str) -> Any:
         value = self.info[item]
         return decode_info_value(Solver, value)
@@ -92,6 +109,17 @@ class Solver:
                 return False
         return True
 
+    # Methods to make this a valid Streamable member
+    stream = None
+    parse = None
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return self.info
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        return cls(json_dict)
+
 
 def decode_info_value(cls: Any, value: Any) -> Any:
     if isinstance(value, dict):
@@ -101,7 +129,7 @@ def decode_info_value(cls: Any, value: Any) -> Any:
     elif isinstance(value, Program) and value.atom is None:
         return value
     else:
-        if value == "()":  # special case
+        if value in {"()", ""}:  # special case
             return Program.to([])
         expression: SExp = assemble(value)
         if expression.atom is None:

chia/wallet/puzzles/clawback/drivers.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Optional, Union
+from typing import Any
 
 from chia_puzzles_py.programs import (
     AUGMENTED_CONDITION as AUGMENTED_CONDITION_BYTES,
@@ -43,7 +43,7 @@ AUGMENTED_CONDITION_HASH = bytes32(AUGMENTED_CONDITION_HASH_BYTES)
 log = logging.getLogger(__name__)
 
 
-def create_augmented_cond_puzzle(condition: list[Union[int, uint64]], puzzle: Program) -> Program:
+def create_augmented_cond_puzzle(condition: list[int | uint64], puzzle: Program) -> Program:
     return AUGMENTED_CONDITION.curry(condition, puzzle)
 
 
@@ -137,9 +137,9 @@ def create_merkle_solution(
 
 def match_clawback_puzzle(
     uncurried: UncurriedPuzzle,
-    inner_puzzle: Union[Program, SerializedProgram],
-    inner_solution: Union[Program, SerializedProgram],
-) -> Optional[ClawbackMetadata]:
+    inner_puzzle: Program | SerializedProgram,
+    inner_solution: Program | SerializedProgram,
+) -> ClawbackMetadata | None:
     # Check if the inner puzzle is a P2 puzzle
     if MOD != uncurried.mod:
         return None
@@ -153,7 +153,7 @@ def match_clawback_puzzle(
         inner_solution,
         DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM // 8,
     )
-    metadata: Optional[ClawbackMetadata] = None
+    metadata: ClawbackMetadata | None = None
     new_puzhash: set[bytes32] = set()
     if conditions is not None:
         for condition in conditions:

chia/wallet/puzzles/deployed_puzzle_hashes.json

@@ -1,57 +1,4 @@
 {
-  "augmented_condition": "d303eafa617bedf0bc05850dd014e10fbddf622187dc07891a2aacba9d8a93f6",
-  "block_program_zero": "f0a38c8efe58895ae527c65c37f700a4238504691b83990e5dd91bd8b3c30eae",
-  "cat_v2": "37bef360ee858133b69d595a906dc45d01af50379dad515eb9518abb7c1d2a7a",
-  "chialisp_deserialisation": "94ec19077f9a34e0b11ad2456af0170f4cc03f11230ca42e3f82e6e644ac4f5d",
-  "conditions_w_fee_announce": "1a169582dc619f2542f8eb79f02823e1595ba0aca53820f503eda5ff20b47856",
-  "covenant_layer": "b982796850336aabf9ab17c3f21e299f0c633444117ab5e9ebeafadf1860d9fc",
-  "create_nft_launcher_from_did": "7a32d2d9571d3436791c0ad3d7fcfdb9c43ace2b0f0ff13f98d29f0cc093f445",
-  "credential_restriction": "2fdfc1f058cfd65e7ec4e253bfeb394da163ecd0036f508df8629b0a2b8fde96",
-  "decompress_coin_spend_entry": "9d98ed08770d31be4bd1bde4705dab388db5e7e9c349f5a76fc3c347aa3a0b79",
-  "decompress_coin_spend_entry_with_prefix": "92aa4bc8060a8836355a1884075141b4791ce1b67ae6092bb166b2845954bc89",
-  "decompress_puzzle": "fe94c58f1117afe315e0450daca1c62460ec1a1c439cd4018d79967a5d7d1370",
-  "delegated_tail": "999c3696e167f8a79d938adc11feba3a3dcb39ccff69a426d570706e7b8ec399",
-  "did_innerpuz": "33143d2bef64f14036742673afd158126b94284b4530a28c354fac202b0c910e",
-  "eml_covenant_morpher": "6a87946257f555ae82aca6a11b5205058b844f634ecb6c7dc6b0c54eb2996308",
-  "eml_transfer_program_covenant_adapter": "4218fbebbb6f3c0907ebe8a672fa5d1e4bc655645a3a0073601e6c9b50b07c47",
-  "eml_update_metadata_with_DID": "d3a9a1fc20f247d009b4b0e941707d50b91885c99d0b27ef882e1294e771139d",
-  "everything_with_signature": "1720d13250a7c16988eaf530331cefa9dd57a76b2c82236bec8bbbff91499b89",
-  "exigent_metadata_layer": "d5fd32e069fda83e230ccd8f6a7c4f652231aed5c755514b3d996cbeff4182b8",
-  "flag_proofs_checker": "fe2e3c631562fbb9be095297f762bf573705a0197164e9361ad5d50e045ba241",
-  "genesis_by_coin_id": "493afb89eed93ab86741b2aa61b8f5de495d33ff9b781dfc8919e602b2afa150",
-  "genesis_by_coin_id_or_singleton": "40170305e3a71c3e7523f37fbcfc3188f9f949da0818a6331f28251e76e8c56f",
-  "genesis_by_puzzle_hash": "de5a6e06d41518be97ff6365694f4f89475dda773dede267caa33da63b434e36",
-  "graftroot_dl_offers": "0893e36a88c064fddfa6f8abdb42c044584a98cb4273b80cccc83b4867b701a1",
-  "nft_intermediate_launcher": "7a32d2d9571d3436791c0ad3d7fcfdb9c43ace2b0f0ff13f98d29f0cc093f445",
-  "nft_metadata_updater_default": "fe8a4b4e27a2e29a4d3fc7ce9d527adbcaccbab6ada3903ccf3ba9a769d2d78b",
-  "nft_metadata_updater_updateable": "0b1ffba1601777c06b78ab38636e9624f2f8da73be9b36e0ce17c8d8ef3bad9f",
-  "nft_ownership_layer": "c5abea79afaa001b5427dfa0c8cf42ca6f38f5841b78f9b3c252733eb2de2726",
-  "nft_ownership_transfer_program_one_way_claim_with_royalties": "025dee0fb1e9fa110302a7e9bfb6e381ca09618e2778b0184fa5c6b275cfce1f",
-  "nft_state_layer": "a04d9f57764f54a43e4030befb4d80026e870519aaa66334aef8304f5d0393c2",
-  "notification": "b8b9d8ffca6d5cba5422ead7f477ecfc8f6aaaa1c024b8c3aeb1956b24a0ab1e",
-  "p2_1_of_n": "46b29fd87fbeb6737600c4543931222a6c1ed3db6fa5601a3ca284a9f4efe780",
-  "p2_announced_delegated_puzzle": "c4d24c3c5349376f3e8f3aba202972091713b4ec4915f0f26192ae4ace0bd04d",
-  "p2_conditions": "1c77d7d5efde60a7a1d2d27db6d746bc8e568aea1ef8586ca967a0d60b83cc36",
-  "p2_delegated_conditions": "0ff94726f1a8dea5c3f70d3121945190778d3b2b3fcda3735a1f290977e98341",
-  "p2_delegated_puzzle": "542cde70d1102cd1b763220990873efc8ab15625ded7eae22cc11e21ef2e2f7c",
-  "p2_delegated_puzzle_or_hidden_puzzle": "e9aaa49f45bad5c889b86ee3341550c155cfdd10c3a6757de618d20612fffd52",
-  "p2_m_of_n_delegate_direct": "0f199d5263ac1a62b077c159404a71abd3f9691cc57520bf1d4c5cb501504457",
-  "p2_parent": "b10ce2d0b18dcf8c21ddfaf55d9b9f0adcbf1e0beb55b1a8b9cad9bbff4e5f22",
-  "p2_puzzle_hash": "13e29a62b42cd2ef72a79e4bacdc59733ca6310d65af83d349360d36ec622363",
-  "p2_singleton": "40f828d8dd55603f4ff9fbf6b73271e904e69406982f4fbefae2c8dcceaf9834",
-  "p2_singleton_aggregator": "f79a31fcfe3736cc75720617b4cdcb4376b4b8f8f71108617710612b909a4924",
-  "p2_singleton_or_delayed_puzhash": "adb656e0211e2ab4f42069a4c5efc80dc907e7062be08bf1628c8e5b6d94d25b",
-  "p2_singleton_via_delegated_puzzle": "9590eaa169e45b655a31d3c06bbd355a3e2b2e3e410d3829748ce08ab249c39e",
-  "pool_member_innerpuz": "a8490702e333ddd831a3ac9c22d0fa26d2bfeaf2d33608deb22f0e0123eb0494",
-  "pool_waitingroom_innerpuz": "a317541a765bf8375e1c6e7c13503d0d2cbf56cacad5182befe947e78e2c0307",
-  "rom_bootstrap_generator": "161bade1f822dcd62ab712ebaf30f3922a301e48a639e4295c5685f8bece7bd9",
-  "settlement_payments": "cfbfdeed5c4ca2de3d0bf520b9cb4bb7743a359bd2e6a188d19ce7dffc21d3e7",
-  "singleton_launcher": "eff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9",
-  "singleton_top_layer": "24e044101e57b3d8c908b8a38ad57848afd29d3eecc439dba45f4412df4954fd",
-  "singleton_top_layer_v1_1": "7faa3253bfddd1e0decb0906b2dc6247bbc4cf608f58345d173adb63e8b47c9f",
-  "standard_vc_backdoor_puzzle": "fbce76408ebaf9b3d0b8cd90cc68607755eeca67cd7432d5eea85f3f498cc002",
-  "std_parent_morpher": "8c3f1dc2e46c0d7ec4c2cbd007e23c0368ff8f80c5bc0101647a5c27626ebce6",
   "test_generator_deserialize": "52add794fc76e89512e4a063c383418bda084c8a78c74055abe80179e4a7832c",
-  "test_multiple_generator_input_arguments": "156dafbddc3e1d3bfe1f2a84e48e5e46b287b8358bf65c3c091c93e855fbfc5b",
-  "viral_backdoor": "00848115554ea674131f89f311707a959ad3f4647482648f3fe91ba289131f51"
+  "test_multiple_generator_input_arguments": "156dafbddc3e1d3bfe1f2a84e48e5e46b287b8358bf65c3c091c93e855fbfc5b"
 }

chia/wallet/puzzles/load_clvm.py

@@ -8,7 +8,7 @@ import sys
 import tempfile
 
 import importlib_resources
-from clvm_tools_rs import compile_clvm as compile_clvm_rust
+from chialisp import compile_clvm as compile_clvm_rust
 
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram

chia/wallet/puzzles/p2_delegated_puzzle_or_hidden_puzzle.py

@@ -60,7 +60,6 @@ from __future__ import annotations
 
 import hashlib
 from functools import lru_cache
-from typing import Union
 
 from chia_puzzles_py.programs import P2_DELEGATED_PUZZLE_OR_HIDDEN_PUZZLE
 from chia_rs import G1Element, PrivateKey
@@ -79,7 +78,7 @@ MOD = Program.from_bytes(P2_DELEGATED_PUZZLE_OR_HIDDEN_PUZZLE)
 
 QUOTED_MOD_HASH = calculate_hash_of_quoted_mod_hash(MOD.get_tree_hash())
 
-PublicKeyProgram = Union[bytes, Program]
+PublicKeyProgram = bytes | Program
 
 GROUP_ORDER = 0x73EDA753299D7D483339D80809A1D80553BDA402FFFE5BFEFFFFFFFF00000001
 

chia/wallet/puzzles/singleton_top_layer.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from typing import Optional
 
 from chia_puzzles_py.programs import (
     P2_SINGLETON,
@@ -287,8 +286,8 @@ def claim_p2_singleton(
     p2_singleton_coin: Coin,
     singleton_inner_puzhash: bytes32,
     launcher_id: bytes32,
-    delay_time: Optional[uint64] = None,
-    delay_ph: Optional[bytes32] = None,
+    delay_time: uint64 | None = None,
+    delay_ph: bytes32 | None = None,
 ) -> tuple[Program, Program, CoinSpend]:
     assertion = Program.to([ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, std_hash(p2_singleton_coin.name() + b"$")])
     announcement = Program.to([ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT, p2_singleton_coin.name()])