chia-blockchain 2.5.4rc1__py3-none-any.whl → 2.5.5__py3-none-any.whl

chia/wallet/signer_protocol.py

@@ -2,13 +2,12 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
 from chia.types.blockchain_format.coin import Coin as _Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.coin_spend import CoinSpend
 from chia.util.streamable import Streamable
 from chia.wallet.util.clvm_streamable import clvm_streamable
 
@@ -39,8 +38,8 @@ class Spend(Streamable):
                 coin_spend.coin.puzzle_hash,
                 uint64(coin_spend.coin.amount),
             ),
-            coin_spend.puzzle_reveal.to_program(),
-            coin_spend.solution.to_program(),
+            Program.from_serialized(coin_spend.puzzle_reveal),
+            Program.from_serialized(coin_spend.solution),
         )
 
     def as_coin_spend(self) -> CoinSpend:
@@ -50,8 +49,8 @@ class Spend(Streamable):
                 self.coin.puzzle_hash,
                 self.coin.amount,
             ),
-            SerializedProgram.from_program(self.puzzle),
-            SerializedProgram.from_program(self.solution),
+            self.puzzle.to_serialized(),
+            self.solution.to_serialized(),
         )
 
 

chia/wallet/singleton.py

@@ -8,12 +8,13 @@ from chia_puzzles_py.programs import (
     SINGLETON_TOP_LAYER_V1_1,
     SINGLETON_TOP_LAYER_V1_1_HASH,
 )
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.program import Program, uncurry
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.coin_spend import CoinSpend, compute_additions
+from chia.wallet.util.compute_additions import compute_additions
 from chia.wallet.util.curry_and_treehash import (
     calculate_hash_of_quoted_mod_hash,
     curry_and_treehash,
@@ -36,7 +37,7 @@ def get_inner_puzzle_from_singleton(puzzle: Union[Program, SerializedProgram]) -
     :param puzzle: Singleton puzzle
     :return: Inner puzzle
     """
-    r = puzzle.uncurry()
+    r = uncurry(puzzle)
     if r is None:
         return None
     inner_f, args = r
@@ -52,7 +53,7 @@ def get_singleton_id_from_puzzle(puzzle: Union[Program, SerializedProgram]) -> O
     :param puzzle: Singleton puzzle
     :return: Inner puzzle
     """
-    r = puzzle.uncurry()
+    r = uncurry(puzzle)
     if r is None:
         return None  # pragma: no cover
     inner_f, args = r

chia/wallet/singleton_record.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Optional
 
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.coin_spend import CoinSpend
 from chia.wallet.lineage_proof import LineageProof
 
 

chia/wallet/trade_manager.py

@@ -6,16 +6,15 @@ import time
 from collections import deque
 from typing import TYPE_CHECKING, Any, Optional, Union
 
+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.protocols.wallet_protocol import CoinState
 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
-from chia.types.spend_bundle import estimate_fees
+from chia.types.blockchain_format.program import Program, run
 from chia.util.db_wrapper import DBWrapper2
 from chia.util.hash import std_hash
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
@@ -29,6 +28,7 @@ from chia.wallet.conditions import (
     parse_timelock_info,
 )
 from chia.wallet.db_wallet.db_wallet_puzzles import ACS_MU_PH
+from chia.wallet.estimate_fees import estimate_fees
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
 from chia.wallet.outer_puzzles import AssetType
 from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
@@ -122,7 +122,7 @@ class TradeManager:
     ) -> set[bytes32]:
         """
         Returns list of coins we want to check if they are included in filter,
-        These will include coins that belong to us and coins that that on other side of treade
+        These will include coins that belong to us and coins that on other side of trade
         """
         coin_ids = await self.trade_store.get_coin_ids_of_interest_with_trade_statuses(
             trade_statuses=[TradeStatus.PENDING_ACCEPT, TradeStatus.PENDING_CONFIRM, TradeStatus.PENDING_CANCEL]
@@ -301,9 +301,7 @@ class TradeManager:
                     self.log.error(f"Cannot find wallet for offer {trade.trade_id}, skip cancellation.")
                     continue
 
-                new_ph = await wallet.wallet_state_manager.main_wallet.get_puzzle_hash(
-                    new=(not action_scope.config.tx_config.reuse_puzhash)
-                )
+                new_ph = await action_scope.get_puzzle_hash(self.wallet_state_manager)
 
                 if len(trade_records) > 1 or len(cancellation_coins) > 1:
                     announcement_conditions: tuple[Condition, ...] = (
@@ -498,18 +496,11 @@ class TradeManager:
                 if amount > 0:
                     # this is what we are receiving in the trade
                     memos: list[bytes] = []
+                    p2_ph = await action_scope.get_puzzle_hash(self.wallet_state_manager)
                     if isinstance(id, int):
                         wallet_id = uint32(id)
                         wallet = self.wallet_state_manager.wallets.get(wallet_id)
-                        assert isinstance(wallet, (CATWallet, Wallet))
-                        if isinstance(wallet, Wallet):
-                            p2_ph: bytes32 = await wallet.get_puzzle_hash(
-                                new=not action_scope.config.tx_config.reuse_puzhash
-                            )
-                        else:
-                            p2_ph = await wallet.standard_wallet.get_puzzle_hash(
-                                new=not action_scope.config.tx_config.reuse_puzhash
-                            )
+                        assert isinstance(wallet, (Wallet, CATWallet))
                         if wallet.type() != WalletType.STANDARD_WALLET:
                             if callable(getattr(wallet, "get_asset_id", None)):  # ATTENTION: new wallets
                                 assert isinstance(wallet, CATWallet)
@@ -520,9 +511,6 @@ class TradeManager:
                                     f"Cannot request assets from wallet id {wallet.id()} without more information"
                                 )
                     else:
-                        p2_ph = await self.wallet_state_manager.main_wallet.get_puzzle_hash(
-                            new=not action_scope.config.tx_config.reuse_puzhash
-                        )
                         asset_id = id
                         wallet = await self.wallet_state_manager.get_wallet_for_asset_id(asset_id.hex())
                         memos = [p2_ph]
@@ -716,7 +704,7 @@ class TradeManager:
             parse_conditions_non_consensus(
                 condition
                 for spend in final_spend_bundle.coin_spends
-                for condition in spend.puzzle_reveal.to_program().run(spend.solution.to_program()).as_iter()
+                for condition in run(spend.puzzle_reveal, Program.from_serialized(spend.solution)).as_iter()
             )
         )
         # this executes the puzzles again
@@ -874,6 +862,16 @@ class TradeManager:
             complete_offer, valid_spend_solver = await self.check_for_final_modifications(
                 Offer.aggregate([offer, take_offer]), solver, inner_action_scope
             )
+
+        async with action_scope.use() as interface:
+            if interface.side_effects.get_unused_derivation_record_result is not None:
+                # This error is of a protection against potential misues of this band-aid solution.
+                # We should put more thought into how sub-action scopes are generated and what effects
+                # we might want to push. A ticket to this respect can be found [CHIA-2984].
+                raise ValueError("Cannot use `respond_to_offer` with existing puzzle hash generation")
+            interface.side_effects.get_unused_derivation_record_result = (
+                inner_action_scope.side_effects.get_unused_derivation_record_result
+            )
         self.log.info("COMPLETE OFFER: %s", complete_offer.to_bech32())
         assert complete_offer.is_valid()
         final_spend_bundle: WalletSpendBundle = complete_offer.to_valid_spend(

chia/wallet/trade_record.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Optional, TypeVar
+from typing import Any, Optional
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
+from typing_extensions import Self
 
 from chia.types.blockchain_format.coin import Coin
 from chia.util.streamable import Streamable, streamable
@@ -12,8 +13,6 @@ from chia.wallet.conditions import ConditionValidTimes
 from chia.wallet.trading.offer import Offer
 from chia.wallet.trading.trade_status import TradeStatus
 
-_T_TradeRecord = TypeVar("_T_TradeRecord", bound="TradeRecordOld")
-
 
 @streamable
 @dataclass(frozen=True)
@@ -51,9 +50,7 @@ class TradeRecordOld(Streamable):
         return formatted
 
     @classmethod
-    def from_json_dict_convenience(
-        cls: type[_T_TradeRecord], record: dict[str, Any], offer: str = ""
-    ) -> _T_TradeRecord:
+    def from_json_dict_convenience(cls, record: dict[str, Any], offer: str = "") -> Self:
         new_record = record.copy()
         new_record["status"] = TradeStatus[record["status"]].value
         del new_record["summary"]

chia/wallet/trading/offer.py

@@ -4,15 +4,15 @@ from dataclasses import dataclass, field
 from typing import Any, BinaryIO, Optional, Union
 
 from chia_puzzles_py.programs import SETTLEMENT_PAYMENT, SETTLEMENT_PAYMENT_HASH
-from chia_rs import G2Element
+from chia_rs import CoinSpend, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 from clvm_tools.binutils import disassemble
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.coin import Coin, coin_as_list
-from chia.types.blockchain_format.program import INFINITE_COST, Program
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.blockchain_format.program import INFINITE_COST, Program, run_with_cost, uncurry
+from chia.types.coin_spend import make_spend
 from chia.util.bech32m import bech32_decode, bech32_encode, convertbits
 from chia.util.errors import Err, ValidationError
 from chia.util.streamable import parse_rust
@@ -43,6 +43,8 @@ from chia.wallet.util.puzzle_compression import (
 )
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
+OfferSummary = dict[Union[int, bytes32], int]
+
 OFFER_MOD = Program.from_bytes(SETTLEMENT_PAYMENT)
 OFFER_MOD_HASH = bytes32(SETTLEMENT_PAYMENT_HASH)
 
@@ -170,7 +172,7 @@ class Offer:
             max_cost = int(DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM)
             for cs in self._bundle.coin_spends:
                 try:
-                    cost, conds = cs.puzzle_reveal.run_with_cost(max_cost, cs.solution)
+                    cost, conds = run_with_cost(cs.puzzle_reveal, max_cost, cs.solution)
                     max_cost -= cost
                     conditions[cs.coin] = parse_conditions_non_consensus(conds.as_iter())
                 except Exception:  # pragma: no cover
@@ -227,13 +229,13 @@ class Offer:
             coins_for_this_spend: list[Coin] = []
 
             parent_puzzle: UncurriedPuzzle = uncurry_puzzle(parent_spend.puzzle_reveal)
-            parent_solution: Program = parent_spend.solution.to_program()
+            parent_solution = Program.from_serialized(parent_spend.solution)
             additions: list[Coin] = self._additions[parent_spend.coin]
 
             puzzle_driver = match_puzzle(parent_puzzle)
             if puzzle_driver is not None:
                 asset_id = create_asset_id(puzzle_driver)
-                inner_puzzle: Optional[Program] = get_inner_puzzle(puzzle_driver, parent_puzzle)
+                inner_puzzle: Optional[Program] = get_inner_puzzle(puzzle_driver, parent_puzzle, parent_solution)
                 inner_solution: Optional[Program] = get_inner_solution(puzzle_driver, parent_solution)
                 assert inner_puzzle is not None and inner_solution is not None
 
@@ -259,10 +261,7 @@ class Offer:
                     matching_spend_additions = [
                         a
                         for a in matching_spend_additions
-                        if a.puzzle_hash
-                        == construct_puzzle(puzzle_driver, OFFER_MOD_HASH).get_tree_hash_precalc(  # type: ignore
-                            OFFER_MOD_HASH
-                        )
+                        if a.puzzle_hash == construct_puzzle(puzzle_driver, OFFER_MOD).get_tree_hash()
                     ]
                     if len(matching_spend_additions) == expected_num_matches:
                         coins_for_this_spend.extend(matching_spend_additions)
@@ -412,7 +411,7 @@ class Offer:
             coin_names.append(name)
             dependencies[name] = []
             announcements[name] = []
-            conditions: Program = spend.puzzle_reveal.run_with_cost(INFINITE_COST, spend.solution)[1]
+            conditions: Program = run_with_cost(spend.puzzle_reveal, INFINITE_COST, spend.solution)[1]
             for condition in conditions.as_iter():
                 if condition.first() == 60:  # create coin announcement
                     announcements[name].append(
@@ -626,7 +625,7 @@ class Offer:
                 asset_id = None
             if coin_spend.coin.parent_coin_info == bytes32.zeros:
                 notarized_payments: list[NotarizedPayment] = []
-                for payment_group in coin_spend.solution.to_program().as_iter():
+                for payment_group in Program.from_serialized(coin_spend.solution).as_iter():
                     nonce = bytes32(payment_group.first().as_atom())
                     payment_args_list = payment_group.rest().as_iter()
                     notarized_payments.extend(
@@ -652,7 +651,7 @@ class Offer:
     def compress(self, version: Optional[int] = None) -> bytes:
         as_spend_bundle = self.to_spend_bundle()
         if version is None:
-            mods: list[bytes] = [bytes(s.puzzle_reveal.to_program().uncurry()[0]) for s in as_spend_bundle.coin_spends]
+            mods: list[bytes] = [bytes(uncurry(s.puzzle_reveal)[0]) for s in as_spend_bundle.coin_spends]
             version = max(lowest_best_version(mods), 6)  # Clients lower than version 6 should not be able to parse
         return compress_object_with_puzzles(bytes(as_spend_bundle), version)
 

chia/wallet/uncurried_puzzle.py

@@ -3,7 +3,7 @@ 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.program import Program, uncurry
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 
 
@@ -14,4 +14,4 @@ class UncurriedPuzzle:
 
 
 def uncurry_puzzle(puzzle: Union[Program, SerializedProgram]) -> UncurriedPuzzle:
-    return UncurriedPuzzle(*puzzle.uncurry())
+    return UncurriedPuzzle(*uncurry(puzzle))

chia/wallet/util/compute_additions.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from chia_rs import CoinSpend
+from chia_rs.sized_ints import uint64
+
+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, run_with_cost
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.errors import Err, ValidationError
+
+
+def compute_additions_with_cost(
+    cs: CoinSpend,
+    *,
+    max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
+) -> tuple[list[Coin], int]:
+    """
+    Run the puzzle in the specified CoinSpend and return the cost and list of
+    coins created by the puzzle, i.e. additions. If the cost (CLVM- and
+    condition cost) exceeds the specified max_cost, the function fails with a
+    ValidationError exception. Byte cost is not included since at this point the
+    puzzle and solution may have been decompressed, the true byte-cost can only be
+    measured at the block generator level.
+    """
+    parent_id = cs.coin.name()
+    ret: list[Coin] = []
+    cost, r = run_with_cost(cs.puzzle_reveal, max_cost, cs.solution)
+    for cond in Program.to(r).as_iter():
+        if cost > max_cost:
+            raise ValidationError(Err.BLOCK_COST_EXCEEDS_MAX, "compute_additions() for CoinSpend")
+        atoms = cond.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
+        puzzle_hash = next(atoms).as_atom()
+        amount = uint64(next(atoms).as_int())
+        ret.append(Coin(parent_id, puzzle_hash, uint64(amount)))
+
+    return ret, cost
+
+
+def compute_additions(cs: CoinSpend, *, max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM) -> list[Coin]:
+    return compute_additions_with_cost(cs, max_cost=max_cost)[0]

chia/wallet/util/compute_hints.py

@@ -3,14 +3,14 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
 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.coin_spend import CoinSpend
+from chia.types.blockchain_format.program import Program, run_with_cost
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.errors import Err, ValidationError
 
@@ -26,7 +26,7 @@ def compute_spend_hints_and_additions(
     *,
     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)
+    cost, result_program = run_with_cost(cs.puzzle_reveal, max_cost, cs.solution)
 
     hinted_coins: dict[bytes32, HintedCoin] = {}
     for condition in result_program.as_iter():

chia/wallet/util/compute_memos.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
-from clvm.casts import int_from_bytes
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import INFINITE_COST
-from chia.types.coin_spend import CoinSpend
+from chia.types.blockchain_format.program import INFINITE_COST, run_with_cost
 from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.casts import int_from_bytes
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
 def compute_memos_for_spend(coin_spend: CoinSpend) -> dict[bytes32, list[bytes]]:
-    _, result = coin_spend.puzzle_reveal.run_with_cost(INFINITE_COST, coin_spend.solution)
+    _, result = run_with_cost(coin_spend.puzzle_reveal, INFINITE_COST, coin_spend.solution)
     memos: dict[bytes32, list[bytes]] = {}
     for condition in result.as_python():
         if condition[0] == ConditionOpcode.CREATE_COIN and len(condition) >= 4:

chia/wallet/util/curry_and_treehash.py

@@ -5,7 +5,8 @@ from hashlib import sha256
 from typing import Callable
 
 from chia_rs.sized_bytes import bytes32
-from clvm.casts import int_to_bytes
+
+from chia.util.casts import int_to_bytes
 
 CurryHashFunction = Callable[..., bytes32]
 

chia/wallet/util/debug_spend_bundle.py

@@ -4,11 +4,11 @@ from chia_rs import AugSchemeMPL
 from clvm.operators import KEYWORD_FROM_ATOM
 from clvm_tools.binutils import disassemble as bu_disassemble
 
+from chia.consensus.condition_tools import conditions_dict_for_solution, pkm_pairs_for_conditions_dict
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import INFINITE_COST, Program
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.util.condition_tools import conditions_dict_for_solution, pkm_pairs_for_conditions_dict
 from chia.util.hash import std_hash
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 

chia/wallet/util/merkle_tree.py

@@ -5,8 +5,8 @@ from enum import Enum
 from typing import Optional
 
 from chia_rs.sized_bytes import bytes32
-from clvm.casts import int_to_bytes
 
+from chia.util.casts import int_to_bytes
 from chia.util.hash import std_hash
 
 ONE = int_to_bytes(1)

chia/wallet/util/peer_request_cache.py

@@ -3,11 +3,10 @@ from __future__ import annotations
 import asyncio
 from typing import Any, Optional
 
+from chia_rs import CoinState, HeaderBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
-from chia.protocols.wallet_protocol import CoinState
-from chia.types.header_block import HeaderBlock
 from chia.util.hash import std_hash
 from chia.util.lru_cache import LRUCache
 

chia/wallet/util/tx_config.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Optional, TypeVar
+from typing import Any, Optional
 
 from chia_rs import ConsensusConstants
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
-from typing_extensions import NotRequired, TypedDict, Unpack
+from typing_extensions import NotRequired, Self, TypedDict, Unpack
 
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.types.blockchain_format.coin import Coin
@@ -66,9 +66,6 @@ class AutofillArgs(TypedDict):
     logged_in_fingerprint: NotRequired[int]
 
 
-_T_CoinSelectionConfigLoader = TypeVar("_T_CoinSelectionConfigLoader", bound="CoinSelectionConfigLoader")
-
-
 @streamable
 @dataclasses.dataclass(frozen=True)
 class CoinSelectionConfigLoader(Streamable):
@@ -90,9 +87,7 @@ class CoinSelectionConfigLoader(Streamable):
         )
 
     @classmethod
-    def from_json_dict(
-        cls: type[_T_CoinSelectionConfigLoader], json_dict: dict[str, Any]
-    ) -> _T_CoinSelectionConfigLoader:
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
         if "excluded_coins" in json_dict:
             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]

chia/wallet/util/wallet_sync_utils.py

@@ -5,14 +5,21 @@ import logging
 import random
 from typing import Any, Optional, Union
 
-from chia_rs import compute_merkle_set_root, confirm_included_already_hashed, confirm_not_included_already_hashed
+from chia_rs import (
+    CoinSpend,
+    CoinState,
+    HeaderBlock,
+    RespondToPhUpdates,
+    compute_merkle_set_root,
+    confirm_included_already_hashed,
+    confirm_not_included_already_hashed,
+)
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols.shared_protocol import Capability
 from chia.protocols.wallet_protocol import (
-    CoinState,
     RegisterForCoinUpdates,
     RegisterForPhUpdates,
     RejectAdditionsRequest,
@@ -30,12 +37,10 @@ from chia.protocols.wallet_protocol import (
     RespondPuzzleSolution,
     RespondRemovals,
     RespondToCoinUpdates,
-    RespondToPhUpdates,
 )
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin, hash_coin_ids
-from chia.types.coin_spend import CoinSpend, make_spend
-from chia.types.header_block import HeaderBlock
+from chia.types.coin_spend import make_spend
 from chia.util.task_referencer import create_referenced_task
 from chia.wallet.util.peer_request_cache import PeerRequestCache
 

chia/wallet/util/wallet_types.py

@@ -28,6 +28,7 @@ class WalletType(IntEnum):
     DATA_LAYER_OFFER = 12
     VC = 13
     CRCAT = 57
+    RCAT = 132
 
     def to_json_dict(self) -> str:
         # yes, this isn't a `dict`, but it is json and