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

chia/wallet/puzzles/singleton_top_layer_v1_1.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,
@@ -238,7 +237,7 @@ def launch_conditions_and_coinsol(
 def lineage_proof_for_coinsol(coin_spend: CoinSpend) -> LineageProof:
     parent_name: bytes32 = coin_spend.coin.parent_coin_info
 
-    inner_puzzle_hash: Optional[bytes32] = None
+    inner_puzzle_hash: bytes32 | None = None
     if coin_spend.coin.puzzle_hash != SINGLETON_LAUNCHER_HASH:
         full_puzzle = Program.from_bytes(bytes(coin_spend.puzzle_reveal))
         r = full_puzzle.uncurry()
@@ -321,8 +320,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()])

chia/wallet/puzzles/tails.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 from chia_puzzles_py.programs import (
     DELEGATED_TAIL,
@@ -98,7 +98,7 @@ class GenesisById(LimitationsProgram):
         tail: Program = cls.construct([Program.to(origin_id)])
 
         wallet.lineage_store = await CATLineageStore.create(
-            wallet.wallet_state_manager.db_wrapper, tail.get_tree_hash().hex()
+            wallet.wallet_state_manager.db_wrapper, tail.get_tree_hash()
         )
         await wallet.add_lineage(origin_id, LineageProof())
 
@@ -229,7 +229,7 @@ ALL_LIMITATIONS_PROGRAMS: dict[str, Any] = {
 }
 
 
-def match_limitations_program(limitations_program: Program) -> tuple[Optional[LimitationsProgram], list[Program]]:
+def match_limitations_program(limitations_program: Program) -> tuple[LimitationsProgram | None, list[Program]]:
     uncurried_mod, curried_args = limitations_program.uncurry()
     for key, lp in ALL_LIMITATIONS_PROGRAMS.items():
         matched, args = lp.match(uncurried_mod, curried_args)

chia/wallet/singleton.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional, Union
-
 from chia_puzzles_py.programs import (
     SINGLETON_LAUNCHER,
     SINGLETON_LAUNCHER_HASH,
@@ -31,7 +29,7 @@ SINGLETON_LAUNCHER_PUZZLE_HASH = bytes32(SINGLETON_LAUNCHER_HASH)
 SINGLETON_LAUNCHER_PUZZLE_HASH_TREE_HASH = shatree_atom(SINGLETON_LAUNCHER_PUZZLE_HASH)
 
 
-def get_inner_puzzle_from_singleton(puzzle: Union[Program, SerializedProgram]) -> Optional[Program]:
+def get_inner_puzzle_from_singleton(puzzle: Program | SerializedProgram) -> Program | None:
     """
     Extract the inner puzzle of a singleton
     :param puzzle: Singleton puzzle
@@ -47,7 +45,7 @@ def get_inner_puzzle_from_singleton(puzzle: Union[Program, SerializedProgram]) -
     return Program(INNER_PUZZLE)
 
 
-def get_singleton_id_from_puzzle(puzzle: Union[Program, SerializedProgram]) -> Optional[bytes32]:
+def get_singleton_id_from_puzzle(puzzle: Program | SerializedProgram) -> bytes32 | None:
     """
     Extract the singleton ID from a singleton puzzle
     :param puzzle: Singleton puzzle
@@ -63,7 +61,7 @@ def get_singleton_id_from_puzzle(puzzle: Union[Program, SerializedProgram]) -> O
     return bytes32(Program(SINGLETON_STRUCT).rest().first().as_atom())
 
 
-def is_singleton(inner_f: Union[Program, SerializedProgram]) -> bool:
+def is_singleton(inner_f: Program | SerializedProgram) -> bool:
     """
     Check if a puzzle is a singleton mod
     :param inner_f: puzzle
@@ -88,7 +86,7 @@ def create_singleton_puzzle_hash(innerpuz_hash: bytes32, launcher_id: bytes32) -
     return curry_and_treehash(SINGLETON_TOP_LAYER_MOD_HASH_QUOTED, singleton_struct, innerpuz_hash)
 
 
-def create_singleton_puzzle(innerpuz: Union[Program, SerializedProgram], launcher_id: bytes32) -> Program:
+def create_singleton_puzzle(innerpuz: Program | SerializedProgram, launcher_id: bytes32) -> Program:
     """
     Create a full Singleton puzzle
     :param innerpuz: Singleton inner puzzle
@@ -100,7 +98,7 @@ def create_singleton_puzzle(innerpuz: Union[Program, SerializedProgram], launche
     return SINGLETON_TOP_LAYER_MOD.curry(singleton_struct, innerpuz)
 
 
-def get_most_recent_singleton_coin_from_coin_spend(coin_sol: CoinSpend) -> Optional[Coin]:
+def get_most_recent_singleton_coin_from_coin_spend(coin_sol: CoinSpend) -> Coin | None:
     additions: list[Coin] = compute_additions(coin_sol)
     for coin in additions:
         if coin.amount % 2 == 1:

chia/wallet/singleton_record.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
@@ -21,11 +21,11 @@ class SingletonRecord:
     singleton_id: bytes32
     wallet_id: uint32
     parent_coinspend: CoinSpend
-    inner_puzzle_hash: Optional[bytes32]
+    inner_puzzle_hash: bytes32 | None
     pending: bool
     removed_height: int
     lineage_proof: LineageProof
-    custom_data: Optional[Any]
+    custom_data: Any | None
 
     def name(self) -> bytes32:  # pragma: no cover
         return self.coin.name()

chia/wallet/start_wallet.py

@@ -4,11 +4,11 @@ import os
 import pathlib
 import sys
 from multiprocessing import freeze_support
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs import ConsensusConstants
 
-from chia.apis import ApiProtocolRegistry
+from chia.apis import StubMetadataRegistry
 from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.protocols.outbound_message import NodeType
@@ -36,7 +36,7 @@ def create_wallet_service(
     root_path: pathlib.Path,
     config: dict[str, Any],
     consensus_constants: ConsensusConstants,
-    keychain: Optional[Keychain] = None,
+    keychain: Keychain | None = None,
     connect_to_daemon: bool = True,
 ) -> WalletService:
     service_config = config[SERVICE_NAME]
@@ -55,7 +55,7 @@ def create_wallet_service(
     )
     peer_api = WalletNodeAPI(node)
 
-    rpc_info: Optional[RpcInfo[WalletRpcApi]] = None
+    rpc_info: RpcInfo[WalletRpcApi] | None = None
     if service_config.get("start_rpc_server", True):
         rpc_info = (WalletRpcApi, service_config["rpc_port"])
 
@@ -72,7 +72,7 @@ def create_wallet_service(
         network_id=network_id,
         rpc_info=rpc_info,
         connect_to_daemon=connect_to_daemon,
-        class_for_type=ApiProtocolRegistry,
+        stub_metadata_for_type=StubMetadataRegistry,
     )
 
 

chia/wallet/trade_manager.py

@@ -4,14 +4,13 @@ import dataclasses
 import logging
 import time
 from collections import deque
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal
 
 from chia_rs import CoinState
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
-from typing_extensions import Literal
 
-from chia.data_layer.data_layer_wallet import DataLayerWallet
+from chia.data_layer.data_layer_wallet import DataLayerSummary, DataLayerWallet
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin, coin_as_list
 from chia.types.blockchain_format.program import Program, run
@@ -94,13 +93,13 @@ class TradeManager:
     wallet_state_manager: WalletStateManager
     log: logging.Logger
     trade_store: TradeStore
-    most_recently_deserialized_trade: Optional[tuple[bytes32, Offer]]
+    most_recently_deserialized_trade: tuple[bytes32, Offer] | None
 
     @staticmethod
     async def create(
         wallet_state_manager: Any,
         db_wrapper: DBWrapper2,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> TradeManager:
         self = TradeManager()
         if name:
@@ -140,7 +139,7 @@ class TradeManager:
         return trades_by_coin
 
     async def coins_of_interest_farmed(
-        self, coin_state: CoinState, fork_height: Optional[uint32], peer: WSChiaConnection
+        self, coin_state: CoinState, fork_height: uint32 | None, peer: WSChiaConnection
     ) -> None:
         """
         If both our coins and other coins in trade got removed that means that trade was successfully executed
@@ -233,7 +232,7 @@ class TradeManager:
         all: list[TradeRecord] = await self.trade_store.get_all_trades()
         return all
 
-    async def get_trade_by_id(self, trade_id: bytes32) -> Optional[TradeRecord]:
+    async def get_trade_by_id(self, trade_id: bytes32) -> TradeRecord | None:
         record = await self.trade_store.get_trade_record(trade_id)
         return record
 
@@ -421,15 +420,15 @@ class TradeManager:
 
     async def create_offer_for_ids(
         self,
-        offer: dict[Union[int, bytes32], int],
+        offer: dict[int | bytes32, int],
         action_scope: WalletActionScope,
-        driver_dict: Optional[dict[bytes32, PuzzleInfo]] = None,
-        solver: Optional[Solver] = None,
+        driver_dict: dict[bytes32, PuzzleInfo] | None = None,
+        solver: Solver | None = None,
         fee: uint64 = uint64(0),
         validate_only: bool = False,
         extra_conditions: tuple[Condition, ...] = tuple(),
         taking: bool = False,
-    ) -> Union[tuple[Literal[True], TradeRecord, None], tuple[Literal[False], None, str]]:
+    ) -> tuple[Literal[True], TradeRecord, None]:
         if driver_dict is None:
             driver_dict = {}
         if solver is None:
@@ -471,14 +470,14 @@ class TradeManager:
 
     async def _create_offer_for_ids(
         self,
-        offer_dict: dict[Union[int, bytes32], int],
+        offer_dict: dict[int | bytes32, int],
         action_scope: WalletActionScope,
-        driver_dict: Optional[dict[bytes32, PuzzleInfo]] = None,
-        solver: Optional[Solver] = None,
+        driver_dict: dict[bytes32, PuzzleInfo] | None = None,
+        solver: Solver | None = None,
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
         taking: bool = False,
-    ) -> Union[tuple[Literal[True], Offer, None], tuple[Literal[False], None, str]]:
+    ) -> tuple[Literal[True], Offer, None] | tuple[Literal[False], None, str]:
         """
         Offer is dictionary of wallet ids and amount
         """
@@ -487,11 +486,11 @@ class TradeManager:
         if solver is None:
             solver = Solver({})
         try:
-            coins_to_offer: dict[Union[int, bytes32], set[Coin]] = {}
-            requested_payments: dict[Optional[bytes32], list[CreateCoin]] = {}
-            offer_dict_no_ints: dict[Optional[bytes32], int] = {}
+            coins_to_offer: dict[int | bytes32, set[Coin]] = {}
+            requested_payments: dict[bytes32 | None, list[CreateCoin]] = {}
+            offer_dict_no_ints: dict[bytes32 | None, int] = {}
             for id, amount in offer_dict.items():
-                asset_id: Optional[bytes32] = None
+                asset_id: bytes32 | None = None
                 # asset_id can either be none if asset is XCH or
                 # bytes32 if another asset (e.g. NFT, CAT)
                 if amount > 0:
@@ -505,7 +504,7 @@ class TradeManager:
                         if wallet.type() != WalletType.STANDARD_WALLET:
                             if callable(getattr(wallet, "get_asset_id", None)):  # ATTENTION: new wallets
                                 assert isinstance(wallet, CATWallet)
-                                asset_id = bytes32(bytes.fromhex(wallet.get_asset_id()))
+                                asset_id = wallet.get_asset_id()
                                 memos = [p2_ph]
                             else:
                                 raise ValueError(
@@ -513,7 +512,7 @@ class TradeManager:
                                 )
                     else:
                         asset_id = id
-                        wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id.hex())
+                        wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id)
                         memos = [p2_ph]
                     requested_payments[asset_id] = [CreateCoin(p2_ph, uint64(amount), memos)]
                 elif amount < 0:
@@ -524,14 +523,14 @@ class TradeManager:
                         if wallet.type() != WalletType.STANDARD_WALLET:
                             if callable(getattr(wallet, "get_asset_id", None)):  # ATTENTION: new wallets
                                 assert isinstance(wallet, CATWallet)
-                                asset_id = bytes32(bytes.fromhex(wallet.get_asset_id()))
+                                asset_id = wallet.get_asset_id()
                             else:
                                 raise ValueError(
                                     f"Cannot offer assets from wallet id {wallet.id()} without more information"
                                 )
                     else:
                         asset_id = id
-                        wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id.hex())
+                        wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id)
                     assert wallet is not None
                     if not callable(getattr(wallet, "get_coins_to_offer", None)):  # ATTENTION: new wallets
                         raise ValueError(f"Cannot offer coins from wallet id {wallet.id()}")
@@ -579,7 +578,7 @@ class TradeManager:
                 requested_payments, driver_dict, taking
             )
 
-            potential_special_offer: Optional[Offer] = await self.check_for_special_offer_making(
+            potential_special_offer: Offer | None = await self.check_for_special_offer_making(
                 offer_dict_no_ints,
                 driver_dict,
                 action_scope,
@@ -592,7 +591,7 @@ class TradeManager:
                 return True, potential_special_offer, None
 
             all_coins: list[Coin] = [c for coins in coins_to_offer.values() for c in coins]
-            notarized_payments: dict[Optional[bytes32], list[NotarizedPayment]] = Offer.notarize_payments(
+            notarized_payments: dict[bytes32 | None, list[NotarizedPayment]] = Offer.notarize_payments(
                 requested_payments, all_coins
             )
             announcements_to_assert = Offer.calculate_announcements(notarized_payments, driver_dict)
@@ -606,7 +605,7 @@ class TradeManager:
                 if isinstance(id, int):
                     wallet = self.wallet_state_manager.wallets.get(uint32(id))
                 else:
-                    wallet = await self.wallet_state_manager.get_wallet_for_asset_id(id.hex())
+                    wallet = await self.wallet_state_manager.get_wallet_for_asset_id(id)
                 async with self.wallet_state_manager.new_action_scope(
                     action_scope.config.tx_config, push=False
                 ) as inner_action_scope:
@@ -815,23 +814,23 @@ class TradeManager:
         offer: Offer,
         peer: WSChiaConnection,
         action_scope: WalletActionScope,
-        solver: Optional[Solver] = None,
+        solver: Solver | None = None,
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
     ) -> TradeRecord:
         if solver is None:
             solver = Solver({})
-        take_offer_dict: dict[Union[bytes32, int], int] = {}
-        arbitrage: dict[Optional[bytes32], int] = offer.arbitrage()
+        take_offer_dict: dict[bytes32 | int, int] = {}
+        arbitrage: dict[bytes32 | None, int] = offer.arbitrage()
 
         for asset_id, amount in arbitrage.items():
             if asset_id is None:
-                wallet: Optional[WalletProtocol[Any]] = self.wallet_state_manager.main_wallet
+                wallet: WalletProtocol[Any] | None = self.wallet_state_manager.main_wallet
                 assert wallet is not None
-                key: Union[bytes32, int] = int(wallet.id())
+                key: bytes32 | int = int(wallet.id())
             else:
                 # ATTENTION: new wallets
-                wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id.hex())
+                wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id)
                 if wallet is None and amount < 0:
                     raise ValueError(f"Do not have a wallet for asset ID: {asset_id} to fulfill offer")
                 elif wallet is None or wallet.type() in {WalletType.NFT, WalletType.DATA_LAYER}:
@@ -909,13 +908,13 @@ class TradeManager:
 
     async def check_for_special_offer_making(
         self,
-        offer_dict: dict[Optional[bytes32], int],
+        offer_dict: dict[bytes32 | None, int],
         driver_dict: dict[bytes32, PuzzleInfo],
         action_scope: WalletActionScope,
         solver: Solver,
         fee: uint64 = uint64(0),
         extra_conditions: tuple[Condition, ...] = tuple(),
-    ) -> Optional[Offer]:
+    ) -> Offer | None:
         for puzzle_info in driver_dict.values():
             if (
                 puzzle_info.check_type([AssetType.SINGLETON.value, AssetType.METADATA.value, AssetType.OWNERSHIP.value])
@@ -966,7 +965,7 @@ class TradeManager:
                 return True
         return False
 
-    async def get_offer_summary(self, offer: Offer) -> dict[str, Any]:
+    async def get_dl_offer_summary(self, offer: Offer) -> DataLayerSummary | None:
         for puzzle_info in offer.driver_dict.values():
             if (
                 puzzle_info.check_type(
@@ -978,27 +977,7 @@ class TradeManager:
                 and puzzle_info.also()["updater_hash"] == ACS_MU_PH  # type: ignore
             ):
                 return await DataLayerWallet.get_offer_summary(offer)
-        # Otherwise just return the same thing as the RPC normally does
-        offered, requested, infos, valid_times = offer.summary()
-        return {
-            "offered": offered,
-            "requested": requested,
-            "fees": offer.fees(),
-            "additions": [c.name().hex() for c in offer.additions()],
-            "removals": [c.name().hex() for c in offer.removals()],
-            "infos": infos,
-            "valid_times": {
-                k: v
-                for k, v in valid_times.to_json_dict().items()
-                if k
-                not in {
-                    "max_secs_after_created",
-                    "min_secs_since_created",
-                    "max_blocks_after_created",
-                    "min_blocks_since_created",
-                }
-            },
-        }
+        return None
 
     async def check_for_final_modifications(
         self, offer: Offer, solver: Solver, action_scope: WalletActionScope
@@ -1031,10 +1010,10 @@ class TradeManager:
 
     async def check_for_requested_payment_modifications(
         self,
-        requested_payments: dict[Optional[bytes32], list[CreateCoin]],
+        requested_payments: dict[bytes32 | None, list[CreateCoin]],
         driver_dict: dict[bytes32, PuzzleInfo],
         taking: bool,
-    ) -> dict[Optional[bytes32], list[CreateCoin]]:
+    ) -> dict[bytes32 | None, list[CreateCoin]]:
         # This function exclusively deals with CR-CATs for now
         if not taking:
             for asset_id, puzzle_info in driver_dict.items():

chia/wallet/trade_record.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
@@ -22,16 +22,16 @@ class TradeRecordOld(Streamable):
     """
 
     confirmed_at_index: uint32
-    accepted_at_time: Optional[uint64]
+    accepted_at_time: uint64 | None
     created_at_time: uint64
     is_my_offer: bool
     sent: uint32
     offer: bytes
-    taken_offer: Optional[bytes]
+    taken_offer: bytes | None
     coins_of_interest: list[Coin]
     trade_id: bytes32
     status: uint32  # TradeStatus, enum not streamable
-    sent_to: list[tuple[str, uint8, Optional[str]]]  # MempoolSubmissionStatus.status enum not streamable
+    sent_to: list[tuple[str, uint8, str | None]]  # MempoolSubmissionStatus.status enum not streamable
 
     def to_json_dict_convenience(self) -> dict[str, Any]:
         formatted = self.to_json_dict()