chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/transaction_record.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import builtins
+from dataclasses import dataclass
+from typing import Any, Generic, Optional, TypeVar
+
+from chia_rs import SpendBundle
+
+from chia.consensus.coinbase import farmer_parent_id, pool_parent_id
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
+from chia.util.errors import Err
+from chia.util.ints import uint8, uint32, uint64
+from chia.util.streamable import Streamable, streamable
+from chia.wallet.conditions import ConditionValidTimes
+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
+
+
+@dataclass
+class ItemAndTransactionRecords(Generic[T]):
+    item: T
+    transaction_records: list[TransactionRecord]
+
+
+@streamable
+@dataclass(frozen=True)
+class TransactionRecordOld(Streamable):
+    """
+    Used for storing transaction data and status in wallets.
+    """
+
+    confirmed_at_height: uint32
+    created_at_time: uint64
+    to_puzzle_hash: bytes32
+    amount: uint64
+    fee_amount: uint64
+    confirmed: bool
+    sent: uint32
+    spend_bundle: Optional[WalletSpendBundle]
+    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]
+    type: uint32  # TransactionType
+
+    # name is also called bundle_id and tx_id
+    name: bytes32
+    memos: list[tuple[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
+        for _, mis, _ in self.sent_to:
+            if MempoolInclusionStatus(mis) in {MempoolInclusionStatus.SUCCESS, MempoolInclusionStatus.PENDING}:
+                return True
+        return False
+
+    def height_farmed(self, genesis_challenge: bytes32) -> Optional[uint32]:
+        if not self.confirmed:
+            return None
+        if self.type in {TransactionType.FEE_REWARD, TransactionType.COINBASE_REWARD}:
+            for block_index in range(self.confirmed_at_height, self.confirmed_at_height - 100, -1):
+                if block_index < 0:
+                    return None
+                pool_parent = pool_parent_id(uint32(block_index), genesis_challenge)
+                farmer_parent = farmer_parent_id(uint32(block_index), genesis_challenge)
+                if pool_parent == self.additions[0].parent_coin_info:
+                    return uint32(block_index)
+                if farmer_parent == self.additions[0].parent_coin_info:
+                    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
+            return True
+        if any(x[1] == MempoolInclusionStatus.SUCCESS for x in self.sent_to):
+            # we managed to push it to mempool at least once
+            return True
+        if any(x[2] in {Err.INVALID_FEE_LOW_FEE.name, Err.INVALID_FEE_TOO_CLOSE_TO_ZERO.name} for x in self.sent_to):
+            # we tried to push it to mempool and got a fee error so it's a temporary error
+            return True
+        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}
+
+
+@streamable
+@dataclass(frozen=True)
+class TransactionRecord(TransactionRecordOld):
+    valid_times: ConditionValidTimes
+
+
+@streamable
+@dataclass(frozen=True)
+class LightTransactionRecord(Streamable):
+    name: bytes32
+    type: uint32
+    additions: list[Coin]
+    removals: list[Coin]
+    spend_bundle: Optional[SpendBundle]

chia/wallet/transaction_sorting.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import enum
+
+
+class SortKey(enum.Enum):
+    CONFIRMED_AT_HEIGHT = "ORDER BY confirmed_at_height {ASC}"
+    RELEVANCE = "ORDER BY confirmed {ASC}, confirmed_at_height {DESC}, created_at_time {DESC}"
+
+    def ascending(self) -> str:
+        return self.value.format(ASC="ASC", DESC="DESC")
+
+    def descending(self) -> str:
+        return self.value.format(ASC="DESC", DESC="ASC")

chia/wallet/uncurried_puzzle.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Union
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+
+
+@dataclass(frozen=True)
+class UncurriedPuzzle:
+    mod: Program
+    args: Program
+
+
+def uncurry_puzzle(puzzle: Union[Program, SerializedProgram]) -> UncurriedPuzzle:
+    return UncurriedPuzzle(*puzzle.uncurry())

chia/wallet/util/address_type.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from chia.util.bech32m import bech32_decode, convertbits
+from chia.util.config import selected_network_address_prefix
+
+
+class AddressType(Enum):
+    XCH = "xch"
+    NFT = "nft"
+    DID = "did:chia:"
+
+    def hrp(self, config: dict[str, Any]) -> str:
+        if self == AddressType.XCH:
+            # Special case to map XCH to the current network's address prefix
+            return selected_network_address_prefix(config)
+        return str(self.value)
+
+    def expected_decoded_length(self) -> int:
+        # Current address types encode 32 bytes. If future address types vary in
+        # their length, this will need to be updated.
+        return 32
+
+
+def is_valid_address(address: str, allowed_types: set[AddressType], config: dict[str, Any]) -> bool:
+    try:
+        ensure_valid_address(address, allowed_types=allowed_types, config=config)
+        return True
+    except ValueError:
+        return False
+
+
+def ensure_valid_address(address: str, *, allowed_types: set[AddressType], config: dict[str, Any]) -> str:
+    hrp, b32data = bech32_decode(address)
+    if not b32data or not hrp:
+        raise ValueError(f"Invalid address: {address}")
+    # Match by prefix (hrp) and return the corresponding address type
+    address_type = next(
+        (addr_type for (addr_type, addr_hrp) in ((a, a.hrp(config)) for a in allowed_types) if addr_hrp == hrp),
+        None,
+    )
+    if address_type is None:
+        raise ValueError(
+            f"Invalid address: {address}. "
+            f"Expected an address with one of the following prefixes: {[t.hrp(config) for t in allowed_types]}"
+        )
+    decoded_data = convertbits(b32data, 5, 8, False)
+    if len(decoded_data) != address_type.expected_decoded_length():
+        raise ValueError(
+            f"Invalid address: {address}. "
+            f"Expected {address_type.expected_decoded_length()} bytes, got {len(decoded_data)}"
+        )
+    return address

chia/wallet/util/blind_signer_tl.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+from chia.util.streamable import Streamable
+from chia.wallet.signer_protocol import (
+    KeyHints,
+    PathHint,
+    SigningInstructions,
+    SigningResponse,
+    SigningTarget,
+    SumHint,
+    TransactionInfo,
+    UnsignedTransaction,
+)
+from chia.wallet.util.clvm_streamable import TranslationLayer, TranslationLayerMapping, clvm_streamable
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLSigningTarget(Streamable):
+    fingerprint: bytes = field(metadata=dict(key="f"))
+    message: bytes = field(metadata=dict(key="m"))
+    hook: bytes32 = field(metadata=dict(key="h"))
+
+    @staticmethod
+    def from_wallet_api(_from: SigningTarget) -> BSTLSigningTarget:
+        return BSTLSigningTarget(**_from.__dict__)
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLSigningTarget) -> SigningTarget:
+        return SigningTarget(**_from.__dict__)
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLSumHint(Streamable):
+    fingerprints: list[bytes] = field(metadata=dict(key="f"))
+    synthetic_offset: bytes = field(metadata=dict(key="o"))
+    final_pubkey: bytes = field(metadata=dict(key="p"))
+
+    @staticmethod
+    def from_wallet_api(_from: SumHint) -> BSTLSumHint:
+        return BSTLSumHint(**_from.__dict__)
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLSumHint) -> SumHint:
+        return SumHint(**_from.__dict__)
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLPathHint(Streamable):
+    root_fingerprint: bytes = field(metadata=dict(key="f"))
+    path: list[uint64] = field(metadata=dict(key="p"))
+
+    @staticmethod
+    def from_wallet_api(_from: PathHint) -> BSTLPathHint:
+        return BSTLPathHint(**_from.__dict__)
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLPathHint) -> PathHint:
+        return PathHint(**_from.__dict__)
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLSigningInstructions(Streamable):
+    sum_hints: list[BSTLSumHint] = field(metadata=dict(key="s"))
+    path_hints: list[BSTLPathHint] = field(metadata=dict(key="p"))
+    targets: list[BSTLSigningTarget] = field(metadata=dict(key="t"))
+
+    @staticmethod
+    def from_wallet_api(_from: SigningInstructions) -> BSTLSigningInstructions:
+        return BSTLSigningInstructions(
+            [BSTLSumHint.from_wallet_api(sum_hint) for sum_hint in _from.key_hints.sum_hints],
+            [BSTLPathHint.from_wallet_api(path_hint) for path_hint in _from.key_hints.path_hints],
+            [BSTLSigningTarget.from_wallet_api(signing_target) for signing_target in _from.targets],
+        )
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLSigningInstructions) -> SigningInstructions:
+        return SigningInstructions(
+            KeyHints(
+                [BSTLSumHint.to_wallet_api(sum_hint) for sum_hint in _from.sum_hints],
+                [BSTLPathHint.to_wallet_api(path_hint) for path_hint in _from.path_hints],
+            ),
+            [BSTLSigningTarget.to_wallet_api(signing_target) for signing_target in _from.targets],
+        )
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLUnsignedTransaction(Streamable):
+    sum_hints: list[BSTLSumHint] = field(metadata=dict(key="s"))
+    path_hints: list[BSTLPathHint] = field(metadata=dict(key="p"))
+    targets: list[BSTLSigningTarget] = field(metadata=dict(key="t"))
+
+    @staticmethod
+    def from_wallet_api(_from: UnsignedTransaction) -> BSTLUnsignedTransaction:
+        return BSTLUnsignedTransaction(
+            [BSTLSumHint.from_wallet_api(sum_hint) for sum_hint in _from.signing_instructions.key_hints.sum_hints],
+            [BSTLPathHint.from_wallet_api(path_hint) for path_hint in _from.signing_instructions.key_hints.path_hints],
+            [
+                BSTLSigningTarget.from_wallet_api(signing_target)
+                for signing_target in _from.signing_instructions.targets
+            ],
+        )
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLUnsignedTransaction) -> UnsignedTransaction:
+        return UnsignedTransaction(
+            TransactionInfo([]),
+            SigningInstructions(
+                KeyHints(
+                    [BSTLSumHint.to_wallet_api(sum_hint) for sum_hint in _from.sum_hints],
+                    [BSTLPathHint.to_wallet_api(path_hint) for path_hint in _from.path_hints],
+                ),
+                [BSTLSigningTarget.to_wallet_api(signing_target) for signing_target in _from.targets],
+            ),
+        )
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLSigningResponse(Streamable):
+    signature: bytes = field(metadata=dict(key="s"))
+    hook: bytes32 = field(metadata=dict(key="h"))
+
+    @staticmethod
+    def from_wallet_api(_from: SigningResponse) -> BSTLSigningResponse:
+        return BSTLSigningResponse(**_from.__dict__)
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLSigningResponse) -> SigningResponse:
+        return SigningResponse(**_from.__dict__)
+
+
+BLIND_SIGNER_TRANSLATION = TranslationLayer(
+    [
+        TranslationLayerMapping(
+            SigningTarget, BSTLSigningTarget, BSTLSigningTarget.from_wallet_api, BSTLSigningTarget.to_wallet_api
+        ),
+        TranslationLayerMapping(SumHint, BSTLSumHint, BSTLSumHint.from_wallet_api, BSTLSumHint.to_wallet_api),
+        TranslationLayerMapping(PathHint, BSTLPathHint, BSTLPathHint.from_wallet_api, BSTLPathHint.to_wallet_api),
+        TranslationLayerMapping(
+            SigningInstructions,
+            BSTLSigningInstructions,
+            BSTLSigningInstructions.from_wallet_api,
+            BSTLSigningInstructions.to_wallet_api,
+        ),
+        TranslationLayerMapping(
+            SigningResponse, BSTLSigningResponse, BSTLSigningResponse.from_wallet_api, BSTLSigningResponse.to_wallet_api
+        ),
+        TranslationLayerMapping(
+            UnsignedTransaction,
+            BSTLUnsignedTransaction,
+            BSTLUnsignedTransaction.from_wallet_api,
+            BSTLUnsignedTransaction.to_wallet_api,
+        ),
+    ]
+)

chia/wallet/util/clvm_streamable.py

@@ -0,0 +1,203 @@
+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 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.streamable import (
+    Streamable,
+    function_to_convert_one_item,
+    is_type_List,
+    is_type_SpecificOptional,
+    is_type_Tuple,
+    recurse_jsonify,
+    streamable,
+)
+
+_T_Streamable = TypeVar("_T_Streamable", bound=Streamable)
+
+
+def clvm_streamable(cls: type[Streamable]) -> type[Streamable]:
+    wrapped_cls: type[Streamable] = streamable(cls)
+    setattr(wrapped_cls, "_clvm_streamable", True)
+
+    hints = get_type_hints(cls)
+    # no way to hint that wrapped_cls is a dataclass here but @streamable checks that
+    for field in dataclasses.fields(wrapped_cls):  # type: ignore[arg-type]
+        field.metadata = MappingProxyType({"key": field.name, **field.metadata})
+        if is_type_Tuple(hints[field.name]):
+            raise ValueError("@clvm_streamable does not support tuples")
+
+    return wrapped_cls
+
+
+def program_serialize_clvm_streamable(
+    clvm_streamable: Streamable, translation_layer: Optional[TranslationLayer] = None
+) -> Program:
+    if translation_layer is not None:
+        mapping = translation_layer.get_mapping(clvm_streamable.__class__)
+        if mapping is not None:
+            clvm_streamable = translation_layer.serialize_for_translation(clvm_streamable, mapping)
+    # Underlying hinting problem with clvm_serde
+    return to_program_for_type(type(clvm_streamable))(clvm_streamable)  # type: ignore[no-any-return]
+
+
+def byte_serialize_clvm_streamable(
+    clvm_streamable: Streamable, translation_layer: Optional[TranslationLayer] = 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_env: Any,
+) -> Union[str, dict[str, Any]]:
+    if next_recursion_step is None:
+        next_recursion_step = recurse_jsonify
+    if is_clvm_streamable(streamable):
+        # If we are using clvm_serde, we stop JSON serialization at this point and instead return the clvm blob
+        return byte_serialize_clvm_streamable(streamable, translation_layer=translation_layer).hex()
+    else:
+        return next_recursion_step(
+            streamable, json_serialize_with_clvm_streamable, translation_layer=translation_layer, **next_recursion_env
+        )
+
+
+def program_deserialize_clvm_streamable(
+    program: Program, clvm_streamable_type: type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
+) -> _T_Streamable:
+    type_to_deserialize_from: type[Streamable] = clvm_streamable_type
+    if translation_layer is not None:
+        mapping = translation_layer.get_mapping(clvm_streamable_type)
+        if mapping is not None:
+            type_to_deserialize_from = mapping.to_type
+    as_instance = from_program_for_type(type_to_deserialize_from)(program)
+    if translation_layer is not None and mapping is not None:
+        return translation_layer.deserialize_from_translation(as_instance, mapping)
+    else:
+        # Underlying hinting problem with clvm_serde
+        return as_instance  # type: ignore[no-any-return]
+
+
+def byte_deserialize_clvm_streamable(
+    blob: bytes, clvm_streamable_type: type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
+) -> _T_Streamable:
+    return program_deserialize_clvm_streamable(
+        Program.from_bytes(blob), clvm_streamable_type, translation_layer=translation_layer
+    )
+
+
+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")
+
+
+# TODO: this is more than _just_ a Streamable, but it is also a Streamable and that's
+#       useful for now
+def is_clvm_streamable(v: object) -> TypeGuard[Streamable]:
+    return isinstance(v, Streamable) and hasattr(v, "_clvm_streamable")
+
+
+def json_deserialize_with_clvm_streamable(
+    json_dict: Union[str, dict[str, Any]],
+    streamable_type: type[_T_Streamable],
+    translation_layer: Optional[TranslationLayer] = None,
+) -> _T_Streamable:
+    if isinstance(json_dict, str):
+        return byte_deserialize_clvm_streamable(
+            bytes.fromhex(json_dict), streamable_type, translation_layer=translation_layer
+        )
+    else:
+        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(
+                            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)
+
+
+_T_ClvmStreamable = TypeVar("_T_ClvmStreamable", bound="Streamable")
+_T_TLClvmStreamable = TypeVar("_T_TLClvmStreamable", bound="Streamable")
+
+
+@dataclasses.dataclass(frozen=True)
+class TranslationLayerMapping(Generic[_T_ClvmStreamable, _T_TLClvmStreamable]):
+    from_type: type[_T_ClvmStreamable]
+    to_type: type[_T_TLClvmStreamable]
+    serialize_function: Callable[[_T_ClvmStreamable], _T_TLClvmStreamable]
+    deserialize_function: Callable[[_T_TLClvmStreamable], _T_ClvmStreamable]
+
+
+@dataclasses.dataclass(frozen=True)
+class TranslationLayer:
+    type_mappings: list[TranslationLayerMapping[Any, Any]]
+
+    def get_mapping(
+        self, _type: type[_T_ClvmStreamable]
+    ) -> Optional[TranslationLayerMapping[_T_ClvmStreamable, Streamable]]:
+        mappings = [m for m in self.type_mappings if m.from_type == _type]
+        if len(mappings) == 1:
+            return mappings[0]
+        elif len(mappings) == 0:
+            return None
+        else:  # pragma: no cover
+            raise RuntimeError("Malformed TranslationLayer")
+
+    def serialize_for_translation(
+        self, instance: _T_ClvmStreamable, mapping: TranslationLayerMapping[_T_ClvmStreamable, _T_TLClvmStreamable]
+    ) -> _T_TLClvmStreamable:
+        if mapping is None:
+            return instance
+        else:
+            return mapping.serialize_function(instance)
+
+    def deserialize_from_translation(
+        self, instance: _T_TLClvmStreamable, mapping: TranslationLayerMapping[_T_ClvmStreamable, _T_TLClvmStreamable]
+    ) -> _T_ClvmStreamable:
+        if mapping is None:
+            return instance
+        else:
+            return mapping.deserialize_function(instance)

chia/wallet/util/compute_hints.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from chia.consensus.condition_costs import ConditionCost
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.errors import Err, ValidationError
+from chia.util.ints import uint64
+
+
+@dataclass(frozen=True)
+class HintedCoin:
+    coin: Coin
+    hint: Optional[bytes32]
+
+
+def compute_spend_hints_and_additions(
+    cs: CoinSpend,
+    *,
+    max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
+) -> tuple[dict[bytes32, HintedCoin], int]:
+    cost, result_program = cs.puzzle_reveal.run_with_cost(max_cost, cs.solution)
+
+    hinted_coins: dict[bytes32, HintedCoin] = {}
+    for condition in result_program.as_iter():
+        if cost > max_cost:
+            raise ValidationError(Err.BLOCK_COST_EXCEEDS_MAX, "compute_spend_hints_and_additions() for CoinSpend")
+        atoms = condition.as_iter()
+        op = next(atoms).atom
+        if op in {
+            ConditionOpcode.AGG_SIG_PARENT,
+            ConditionOpcode.AGG_SIG_PUZZLE,
+            ConditionOpcode.AGG_SIG_AMOUNT,
+            ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT,
+            ConditionOpcode.AGG_SIG_PARENT_AMOUNT,
+            ConditionOpcode.AGG_SIG_PARENT_PUZZLE,
+            ConditionOpcode.AGG_SIG_UNSAFE,
+            ConditionOpcode.AGG_SIG_ME,
+        }:
+            cost += ConditionCost.AGG_SIG.value
+            continue
+        if op != ConditionOpcode.CREATE_COIN.value:
+            continue
+        cost += ConditionCost.CREATE_COIN.value
+
+        rf = condition.at("rf").atom
+        assert rf is not None
+
+        coin: Coin = Coin(cs.coin.name(), bytes32(rf), uint64(condition.at("rrf").as_int()))
+        hint: Optional[bytes32] = None
+        if (
+            condition.at("rrr") != Program.to(None)  # 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
+            if potential_hint is not None and len(potential_hint) == 32:
+                hint = bytes32(potential_hint)
+        hinted_coins[bytes32(coin.name())] = HintedCoin(coin, hint)
+
+    return hinted_coins, cost