chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/wallet/transaction_record.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
-import builtins
 from dataclasses import dataclass
-from typing import Any, Generic, Optional, TypeVar
+from typing import Generic, Optional, TypeVar
 
 from chia_rs import SpendBundle
 from chia_rs.sized_bytes import bytes32
@@ -11,7 +10,7 @@ from chia_rs.sized_ints import uint8, uint32, uint64
 from chia.consensus.coinbase import farmer_parent_id, pool_parent_id
 from chia.types.blockchain_format.coin import Coin
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
-from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
+from chia.util.bech32m import decode_puzzle_hash
 from chia.util.errors import Err
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.conditions import ConditionValidTimes
@@ -19,7 +18,6 @@ from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 T = TypeVar("T")
-_T_TransactionRecord = TypeVar("_T_TransactionRecord", bound="TransactionRecordOld")
 
 minimum_send_attempts = 6
 
@@ -57,7 +55,7 @@ class TransactionRecordOld(Streamable):
 
     # name is also called bundle_id and tx_id
     name: bytes32
-    memos: list[tuple[bytes32, list[bytes]]]
+    memos: dict[bytes32, list[bytes]]
 
     def is_in_mempool(self) -> bool:
         # If one of the nodes we sent it to responded with success or pending, we return True
@@ -81,51 +79,6 @@ class TransactionRecordOld(Streamable):
                     return uint32(block_index)
         return None
 
-    def get_memos(self) -> dict[bytes32, list[bytes]]:
-        return {coin_id: ms for coin_id, ms in self.memos}
-
-    @classmethod
-    def from_json_dict_convenience(
-        cls: builtins.type[_T_TransactionRecord], modified_tx_input: dict
-    ) -> _T_TransactionRecord:
-        modified_tx = modified_tx_input.copy()
-        if "to_address" in modified_tx:
-            modified_tx["to_puzzle_hash"] = decode_puzzle_hash(modified_tx["to_address"]).hex()
-        if "to_address" in modified_tx:
-            del modified_tx["to_address"]
-        # Converts memos from a flat dict into a nested list
-        memos_dict: dict[str, list[str]] = {}
-        memos_list: list = []
-        if "memos" in modified_tx:
-            for coin_id, memo in modified_tx["memos"].items():
-                if coin_id not in memos_dict:
-                    memos_dict[coin_id] = []
-                memos_dict[coin_id].append(memo)
-        for coin_id, memos in memos_dict.items():
-            memos_list.append((coin_id, memos))
-        modified_tx["memos"] = memos_list
-        return cls.from_json_dict(modified_tx)
-
-    @classmethod
-    def from_json_dict(cls: builtins.type[_T_TransactionRecord], json_dict: dict[str, Any]) -> _T_TransactionRecord:
-        try:
-            return super().from_json_dict(json_dict)
-        except Exception:
-            return cls.from_json_dict_convenience(json_dict)
-
-    def to_json_dict_convenience(self, config: dict) -> dict:
-        selected = config["selected_network"]
-        prefix = config["network_overrides"]["config"][selected]["address_prefix"]
-        formatted = self.to_json_dict()
-        formatted["to_address"] = encode_puzzle_hash(self.to_puzzle_hash, prefix)
-        formatted["memos"] = {
-            coin_id.hex(): memo.hex()
-            for coin_id, memos in self.get_memos().items()
-            for memo in memos
-            if memo is not None
-        }
-        return formatted
-
     def is_valid(self) -> bool:
         if len(self.sent_to) < minimum_send_attempts:
             # we haven't tried enough peers yet
@@ -139,13 +92,23 @@ class TransactionRecordOld(Streamable):
         return False
 
     def hint_dict(self) -> dict[bytes32, bytes32]:
-        return {coin_id: bytes32(memos[0]) for coin_id, memos in self.memos if len(memos) > 0 and len(memos[0]) == 32}
+        return {
+            coin_id: bytes32(memos[0])
+            for coin_id, memos in self.memos.items()
+            if len(memos) > 0 and len(memos[0]) == 32
+        }
 
 
 @streamable
 @dataclass(frozen=True)
 class TransactionRecord(TransactionRecordOld):
     valid_times: ConditionValidTimes
+    to_address: str
+
+    def __post_init__(self) -> None:
+        if decode_puzzle_hash(self.to_address) != self.to_puzzle_hash:
+            raise ValueError("Invalid tx record initialization, to_address must match to_puzzle_hash")
+        return super().__post_init__()
 
 
 @streamable

chia/wallet/util/clvm_streamable.py

@@ -3,17 +3,16 @@ from __future__ import annotations
 import dataclasses
 import functools
 from types import MappingProxyType
-from typing import Any, Callable, Generic, Optional, TypeVar, Union, get_args, get_type_hints
+from typing import Any, Callable, Generic, Optional, TypeVar, Union, 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
 from chia.util.streamable import (
     Streamable,
     function_to_convert_one_item,
-    is_type_List,
-    is_type_SpecificOptional,
     is_type_Tuple,
     recurse_jsonify,
     streamable,
@@ -94,14 +93,10 @@ def byte_deserialize_clvm_streamable(
     )
 
 
-def is_compound_type(typ: Any) -> bool:
-    return is_type_SpecificOptional(typ) or is_type_Tuple(typ) or is_type_List(typ)
-
-
 # TODO: this is more than _just_ a Streamable, but it is also a Streamable and that's
 #       useful for now
-def is_clvm_streamable_type(v: type[object]) -> TypeGuard[type[Streamable]]:
-    return issubclass(v, Streamable) and hasattr(v, "_clvm_streamable")
+def is_clvm_streamable_type(v: type[object]) -> bool:
+    return isinstance(v, type) and issubclass(v, Streamable) and hasattr(v, "_clvm_streamable")
 
 
 # TODO: this is more than _just_ a Streamable, but it is also a Streamable and that's
@@ -115,48 +110,40 @@ def json_deserialize_with_clvm_streamable(
     streamable_type: type[_T_Streamable],
     translation_layer: Optional[TranslationLayer] = None,
 ) -> _T_Streamable:
-    if isinstance(json_dict, str):
+    # 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.
+    if is_clvm_streamable_type(streamable_type) and isinstance(json_dict, str):
         return byte_deserialize_clvm_streamable(
-            bytes.fromhex(json_dict), streamable_type, translation_layer=translation_layer
+            hexstr_to_bytes(json_dict), streamable_type, translation_layer=translation_layer
         )
-    else:
+    elif hasattr(streamable_type, "streamable_fields"):
         old_streamable_fields = streamable_type.streamable_fields()
         new_streamable_fields = []
         for old_field in old_streamable_fields:
-            if is_compound_type(old_field.type):
-                inner_type = get_args(old_field.type)[0]
-                if is_clvm_streamable_type(inner_type):
-                    new_streamable_fields.append(
-                        dataclasses.replace(
-                            old_field,
-                            convert_function=function_to_convert_one_item(
-                                old_field.type,
-                                functools.partial(
-                                    json_deserialize_with_clvm_streamable,
-                                    streamable_type=inner_type,
-                                    translation_layer=translation_layer,
-                                ),
-                            ),
-                        )
-                    )
-                else:
-                    new_streamable_fields.append(old_field)
-            elif is_clvm_streamable_type(old_field.type):
-                new_streamable_fields.append(
-                    dataclasses.replace(
-                        old_field,
-                        convert_function=functools.partial(
+            new_streamable_fields.append(
+                dataclasses.replace(
+                    old_field,
+                    convert_function=function_to_convert_one_item(
+                        old_field.type,
+                        functools.partial(
                             json_deserialize_with_clvm_streamable,
-                            streamable_type=old_field.type,
                             translation_layer=translation_layer,
                         ),
-                    )
+                    ),
                 )
-            else:
-                new_streamable_fields.append(old_field)
-
+            )
         setattr(streamable_type, "_streamable_fields", tuple(new_streamable_fields))
-        return streamable_type.from_json_dict(json_dict)
+        return streamable_type.from_json_dict(json_dict)  # type: ignore[arg-type]
+    elif hasattr(streamable_type, "from_json_dict"):
+        return streamable_type.from_json_dict(json_dict)  # type: ignore[arg-type]
+    else:
+        return function_to_convert_one_item(  # type: ignore[return-value]
+            streamable_type,
+            functools.partial(
+                json_deserialize_with_clvm_streamable,
+                translation_layer=translation_layer,
+            ),
+        )(json_dict)
 
 
 _T_ClvmStreamable = TypeVar("_T_ClvmStreamable", bound="Streamable")

chia/wallet/util/merkle_utils.py

@@ -39,9 +39,9 @@ def build_merkle_tree_from_binary_tree(tuples: TupleTree) -> tuple[bytes32, dict
         proof.append(right_root)
         new_proofs[name] = (path, proof)
     for name, (path, proof) in right_proofs.items():
-        path |= 1 << len(proof)
+        appended_path = path | (1 << len(proof))
         proof.append(left_root)
-        new_proofs[name] = (path, proof)
+        new_proofs[name] = (appended_path, proof)
     return new_root, new_proofs
 
 

chia/wallet/util/tx_config.py

@@ -88,7 +88,7 @@ class CoinSelectionConfigLoader(Streamable):
 
     @classmethod
     def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
-        if "excluded_coins" in json_dict:
+        if json_dict.get("excluded_coins") is not None:
             excluded_coins: list[Coin] = [Coin.from_json_dict(c) for c in json_dict["excluded_coins"]]
             excluded_coin_ids: list[str] = [c.name().hex() for c in excluded_coins]
             if "excluded_coin_ids" in json_dict:
@@ -98,7 +98,8 @@ class CoinSelectionConfigLoader(Streamable):
         return super().from_json_dict(json_dict)
 
     # This function is purely for ergonomics
-    def override(self, **kwargs: Any) -> CoinSelectionConfigLoader:
+    # But creates a small linting complication
+    def override(self, **kwargs: Any) -> Self:
         return dataclasses.replace(self, **kwargs)
 
 
@@ -138,10 +139,6 @@ class TXConfigLoader(CoinSelectionConfigLoader):
             reuse_puzhash,
         )
 
-    # This function is purely for ergonomics
-    def override(self, **kwargs: Any) -> TXConfigLoader:
-        return dataclasses.replace(self, **kwargs)
-
 
 DEFAULT_COIN_SELECTION_CONFIG = CoinSelectionConfig(uint64(0), uint64(DEFAULT_CONSTANTS.MAX_COIN_AMOUNT), [], [])
 DEFAULT_TX_CONFIG = TXConfig(

chia/wallet/vc_wallet/cr_cat_wallet.py

@@ -136,8 +136,11 @@ class CRCATWallet(CATWallet):
         puzzle_driver: PuzzleInfo,
         name: Optional[str] = None,
         # We're hinting this as Any for mypy by should explore adding this to the wallet protocol and hinting properly
-        potential_subclasses: dict[AssetType, Any] = {},
+        potential_subclasses: Optional[dict[AssetType, Any]] = None,
     ) -> Any:
+        if potential_subclasses is None:
+            potential_subclasses = {}
+
         cr_layer: Optional[PuzzleInfo] = puzzle_driver.also()
         if cr_layer is None:  # pragma: no cover
             raise ValueError("create_from_puzzle_info called on CRCATWallet with a non CR-CAT puzzle driver")
@@ -250,6 +253,7 @@ class CRCATWallet(CATWallet):
                     confirmed_at_height=height,
                     created_at_time=uint64(created_timestamp),
                     to_puzzle_hash=hint_dict[coin.name()],
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(hint_dict[coin.name()]),
                     amount=uint64(coin.amount),
                     fee_amount=uint64(0),
                     confirmed=True,
@@ -262,7 +266,7 @@ class CRCATWallet(CATWallet):
                     trade_id=None,
                     type=uint32(TransactionType.INCOMING_CRCAT_PENDING),
                     name=coin.name(),
-                    memos=list(memos.items()),
+                    memos=memos,
                     valid_times=ConditionValidTimes(),
                 )
                 await self.wallet_state_manager.tx_store.add_transaction_record(tx_record)
@@ -657,8 +661,9 @@ class CRCATWallet(CATWallet):
             tx_list = [
                 TransactionRecord(
                     confirmed_at_height=uint32(0),
-                    created_at_time=uint64(int(time.time())),
+                    created_at_time=uint64(time.time()),
                     to_puzzle_hash=payment.puzzle_hash,
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(payment.puzzle_hash),
                     amount=payment.amount,
                     fee_amount=fee,
                     confirmed=False,
@@ -671,7 +676,7 @@ class CRCATWallet(CATWallet):
                     trade_id=None,
                     type=uint32(TransactionType.OUTGOING_TX.value),
                     name=spend_bundle.name() if i == 0 else payment.to_program().get_tree_hash(),
-                    memos=list(compute_memos(spend_bundle).items()),
+                    memos=compute_memos(spend_bundle),
                     valid_times=parse_timelock_info(extra_conditions),
                 )
                 for i, payment in enumerate(payments)
@@ -788,8 +793,9 @@ class CRCATWallet(CATWallet):
             interface.side_effects.transactions.append(
                 TransactionRecord(
                     confirmed_at_height=uint32(0),
-                    created_at_time=uint64(int(time.time())),
+                    created_at_time=uint64(time.time()),
                     to_puzzle_hash=to_puzzle_hash,
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(to_puzzle_hash),
                     amount=uint64(sum(c.amount for c in coins)),
                     fee_amount=fee,
                     confirmed=False,
@@ -802,7 +808,7 @@ class CRCATWallet(CATWallet):
                     trade_id=None,
                     type=uint32(TransactionType.INCOMING_TX.value),
                     name=claim_bundle.name(),
-                    memos=list(compute_memos(claim_bundle).items()),
+                    memos=compute_memos(claim_bundle),
                     valid_times=parse_timelock_info(extra_conditions),
                 )
             )

chia/wallet/vc_wallet/vc_wallet.py

@@ -200,7 +200,7 @@ class VCWallet:
             puzzle = await self.standard_wallet.puzzle_for_puzzle_hash(coin.puzzle_hash)
             coin_spends.append(make_spend(coin, puzzle, solution))
         spend_bundle = WalletSpendBundle(coin_spends, G2Element())
-        now = uint64(int(time.time()))
+        now = uint64(time.time())
         add_list: list[Coin] = list(spend_bundle.additions())
         rem_list: list[Coin] = list(spend_bundle.removals())
         vc_record: VCRecord = VCRecord(vc, uint32(0))
@@ -210,6 +210,7 @@ class VCWallet:
                     confirmed_at_height=uint32(0),
                     created_at_time=now,
                     to_puzzle_hash=inner_puzzle_hash,
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(inner_puzzle_hash),
                     amount=uint64(1),
                     fee_amount=uint64(fee),
                     confirmed=False,
@@ -222,7 +223,7 @@ class VCWallet:
                     trade_id=None,
                     type=uint32(TransactionType.OUTGOING_TX.value),
                     name=spend_bundle.name(),
-                    memos=list(compute_memos(spend_bundle).items()),
+                    memos=compute_memos(spend_bundle),
                     valid_times=parse_timelock_info(extra_conditions),
                 )
             )
@@ -339,7 +340,7 @@ class VCWallet:
                 )  # pragma: no cover
         add_list: list[Coin] = list(spend_bundle.additions())
         rem_list: list[Coin] = list(spend_bundle.removals())
-        now = uint64(int(time.time()))
+        now = uint64(time.time())
 
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
@@ -347,6 +348,7 @@ class VCWallet:
                     confirmed_at_height=uint32(0),
                     created_at_time=now,
                     to_puzzle_hash=puzzle_hashes[0],
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(puzzle_hashes[0]),
                     amount=uint64(1),
                     fee_amount=uint64(fee),
                     confirmed=False,
@@ -359,7 +361,7 @@ class VCWallet:
                     trade_id=None,
                     type=uint32(TransactionType.OUTGOING_TX.value),
                     name=spend_bundle.name(),
-                    memos=list(compute_memos(spend_bundle).items()),
+                    memos=compute_memos(spend_bundle),
                     valid_times=parse_timelock_info(extra_conditions),
                 )
             )
@@ -400,11 +402,6 @@ class VCWallet:
             )
             return
 
-        recovery_info: Optional[tuple[bytes32, bytes32, uint64]] = await did_wallet.get_info_for_recovery()
-        if recovery_info is None:
-            raise RuntimeError("DID could not currently be accessed while trying to revoke VC")  # pragma: no cover
-        _, provider_inner_puzhash, _ = recovery_info
-
         # Generate spend specific nonce
         coins = {await did_wallet.get_coin()}
         coins.add(vc.coin)
@@ -421,7 +418,10 @@ class VCWallet:
             )
 
         # Assemble final bundle
-        expected_did_announcement, vc_spend = vc.activate_backdoor(provider_inner_puzhash, announcement_nonce=nonce)
+        assert did_wallet.did_info.current_inner is not None
+        expected_did_announcement, vc_spend = vc.activate_backdoor(
+            did_wallet.did_info.current_inner.get_tree_hash(), announcement_nonce=nonce
+        )
         await did_wallet.create_message_spend(
             action_scope,
             extra_conditions=(*extra_conditions, expected_did_announcement, vc_announcement),
@@ -455,12 +455,10 @@ class VCWallet:
                     crcat_spends.append(crcat_spend)
                     if spend in offer._bundle.coin_spends:
                         spends_to_fix[spend.coin.name()] = spend
-                else:
-                    if spend in offer._bundle.coin_spends:  # pragma: no cover
-                        other_spends.append(spend)
-            else:
-                if spend in offer._bundle.coin_spends:
+                elif spend in offer._bundle.coin_spends:  # pragma: no cover
                     other_spends.append(spend)
+            elif spend in offer._bundle.coin_spends:
+                other_spends.append(spend)
 
         # Figure out what VC announcements are needed
         announcements_to_make: dict[bytes32, list[CreatePuzzleAnnouncement]] = {}

chia/wallet/wallet.py

@@ -420,7 +420,7 @@ class Wallet:
         assert len(transaction) > 0
         spend_bundle = WalletSpendBundle(transaction, G2Element())
 
-        now = uint64(int(time.time()))
+        now = uint64(time.time())
         add_list: list[Coin] = list(spend_bundle.additions())
         rem_list: list[Coin] = list(spend_bundle.removals())
 
@@ -431,12 +431,14 @@ class Wallet:
         else:
             assert output_amount == input_amount
 
+        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=add_list[0].puzzle_hash if len(add_list) > 0 else bytes32.zeros,
+                    to_puzzle_hash=to_ph,
+                    to_address=self.wallet_state_manager.encode_puzzle_hash(to_ph),
                     amount=uint64(non_change_amount),
                     fee_amount=uint64(fee),
                     confirmed=False,
@@ -449,7 +451,7 @@ class Wallet:
                     trade_id=None,
                     type=uint32(TransactionType.OUTGOING_TX.value),
                     name=spend_bundle.name(),
-                    memos=list(compute_memos(spend_bundle).items()),
+                    memos=compute_memos(spend_bundle),
                     valid_times=parse_timelock_info(extra_conditions),
                 )
             )

chia/wallet/wallet_node.py

@@ -911,14 +911,13 @@ class WalletNode:
         ):
             # only one peer told us to rollback so only clear for that peer
             await self.perform_atomic_rollback(fork_height, cache=cache)
-        else:
-            if fork_height is not None:
-                # only one peer told us to rollback so only clear for that peer
-                cache.clear_after_height(fork_height)
-                self.log.info(f"clear_after_height {fork_height} for peer {peer}")
-                if not trusted:
-                    # Rollback race_cache not in clear_after_height to avoid applying rollbacks from new peak processing
-                    cache.rollback_race_cache(fork_height=fork_height)
+        elif fork_height is not None:
+            # only one peer told us to rollback so only clear for that peer
+            cache.clear_after_height(fork_height)
+            self.log.info(f"clear_after_height {fork_height} for peer {peer}")
+            if not trusted:
+                # Rollback race_cache not in clear_after_height to avoid applying rollbacks from new peak processing
+                cache.rollback_race_cache(fork_height=fork_height)
 
         all_tasks: list[asyncio.Task[None]] = []
         target_concurrent_tasks: int = 30
@@ -989,18 +988,17 @@ class WalletNode:
                     )
                     if not await self.wallet_state_manager.add_coin_states(batch.entries, peer, fork_height):
                         return False
+            elif fork_height is not None:
+                cache.add_states_to_race_cache(batch.entries)
             else:
-                if fork_height is not None:
-                    cache.add_states_to_race_cache(batch.entries)
-                else:
-                    while len(all_tasks) >= target_concurrent_tasks:
-                        all_tasks = [task for task in all_tasks if not task.done()]
-                        await asyncio.sleep(0.1)
-                        if self._shut_down:
-                            self.log.info("Terminating receipt and validation due to shut down request")
-                            await asyncio.gather(*all_tasks)
-                            return False
-                    all_tasks.append(create_referenced_task(validate_and_add(batch.entries, idx)))
+                while len(all_tasks) >= target_concurrent_tasks:
+                    all_tasks = [task for task in all_tasks if not task.done()]
+                    await asyncio.sleep(0.1)
+                    if self._shut_down:
+                        self.log.info("Terminating receipt and validation due to shut down request")
+                        await asyncio.gather(*all_tasks)
+                        return False
+                all_tasks.append(create_referenced_task(validate_and_add(batch.entries, idx)))
             idx += len(batch.entries)
 
         still_connected = self._server is not None and peer.peer_node_id in self.server.all_connections
@@ -1158,9 +1156,8 @@ class WalletNode:
             await self.new_peak_from_trusted(
                 new_peak_hb, latest_timestamp, peer, new_peak.fork_point_with_previous_peak
             )
-        else:
-            if not await self.new_peak_from_untrusted(new_peak_hb, peer):
-                return
+        elif not await self.new_peak_from_untrusted(new_peak_hb, peer):
+            return
 
         # todo why do we call this if there was an exception / the sync is not finished
         async with self.wallet_state_manager.lock:
@@ -1272,10 +1269,9 @@ class WalletNode:
                 )
                 if success:
                     self.synced_peers.add(peer.peer_node_id)
-            else:
-                if peak_hb is not None and new_peak_hb.weight <= peak_hb.weight:
-                    # Don't process blocks at the same weight
-                    return False
+            elif peak_hb is not None and new_peak_hb.weight <= peak_hb.weight:
+                # Don't process blocks at the same weight
+                return False
 
             # For every block, we need to apply the cache from race_cache
             for potential_height in range(backtrack_fork_height + 1, new_peak_hb.height + 1):
@@ -1663,10 +1659,9 @@ class WalletNode:
                     if not prev_block_rc_hash == reversed_slots[-1].reward_chain.end_of_slot_vdf.challenge:
                         self.log.error("Failed validation 7")
                         return False
-                else:
-                    if not prev_block_rc_hash == reward_chain_hash:
-                        self.log.error("Failed validation 8")
-                        return False
+                elif not prev_block_rc_hash == reward_chain_hash:
+                    self.log.error("Failed validation 8")
+                    return False
                 blocks_to_cache.append((reward_chain_hash, en_block.height))
 
         agg_sig: G2Element = AugSchemeMPL.aggregate([sig for (_, _, sig) in pk_m_sig])