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

chia/wallet/cat_wallet/r_cat_wallet.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
+from chia_rs import G1Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint16
+from typing_extensions import Self
+
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import Program
+from chia.util.streamable import Streamable, streamable
+from chia.wallet.cat_wallet.cat_constants import DEFAULT_CATS
+from chia.wallet.cat_wallet.cat_info import CATCoinData, RCATInfo
+from chia.wallet.cat_wallet.cat_utils import (
+    CAT_MOD,
+    CAT_MOD_HASH,
+    CAT_MOD_HASH_HASH,
+    QUOTED_CAT_MOD_HASH,
+    construct_cat_puzzle,
+)
+from chia.wallet.cat_wallet.cat_wallet import CATWallet
+from chia.wallet.cat_wallet.lineage_store import CATLineageStore
+from chia.wallet.conditions import (
+    Condition,
+    CreateCoin,
+)
+from chia.wallet.derivation_record import DerivationRecord
+from chia.wallet.lineage_proof import LineageProof
+from chia.wallet.outer_puzzles import AssetType
+from chia.wallet.puzzle_drivers import PuzzleInfo
+from chia.wallet.util.curry_and_treehash import curry_and_treehash
+from chia.wallet.util.wallet_types import WalletType
+from chia.wallet.vc_wallet.vc_drivers import create_revocation_layer, solve_revocation_layer
+from chia.wallet.wallet import Wallet
+from chia.wallet.wallet_info import WalletInfo
+from chia.wallet.wallet_protocol import WalletProtocol
+
+if TYPE_CHECKING:
+    from chia.wallet.wallet_state_manager import WalletStateManager
+
+
+class RCATVersion(IntEnum):
+    V1 = uint16(1)
+
+
+@streamable
+@dataclass(frozen=True)
+class RCATMetadata(Streamable):
+    lineage_proof: LineageProof
+    inner_puzzle_hash: bytes32
+
+
+class RCATWallet(CATWallet):
+    if TYPE_CHECKING:
+        _protocol_check: ClassVar[WalletProtocol[CATCoinData]] = cast("RCATWallet", None)
+
+    wallet_state_manager: WalletStateManager
+    log: logging.Logger
+    wallet_info: WalletInfo
+    cat_info: RCATInfo
+    standard_wallet: Wallet
+    lineage_store: CATLineageStore
+    wallet_type: ClassVar[WalletType] = WalletType.RCAT
+    wallet_info_type: ClassVar[type[RCATInfo]] = RCATInfo
+
+    # this is a legacy method and is not available on R-CAT wallets
+    create_new_cat_wallet = None  # type: ignore[assignment]
+
+    @staticmethod
+    def default_wallet_name_for_unknown_cat(limitations_program_hash_hex: str) -> str:
+        return f"Revocable-CAT {limitations_program_hash_hex[:16]}..."
+
+    # We need to override this with a different signature.
+    # It's not immediately clear what is proper here, likely needs a bit of a refactor.
+    @classmethod
+    async def get_or_create_wallet_for_cat(  # type: ignore[override]
+        cls,
+        wallet_state_manager: WalletStateManager,
+        wallet: Wallet,
+        limitations_program_hash_hex: str,
+        hidden_puzzle_hash: bytes32,
+        name: Optional[str] = None,
+    ) -> Self:
+        self = cls()
+        self.standard_wallet = wallet
+        self.log = logging.getLogger(__name__)
+
+        limitations_program_hash_hex = bytes32.from_hexstr(limitations_program_hash_hex).hex()  # Normalize the format
+
+        for id, w in wallet_state_manager.wallets.items():
+            if w.type() == cls.type():
+                assert isinstance(w, cls)
+                if w.get_asset_id() == limitations_program_hash_hex:
+                    self.log.warning("Not creating wallet for already existing CAT wallet")
+                    return w
+
+        self.wallet_state_manager = wallet_state_manager
+        if limitations_program_hash_hex in DEFAULT_CATS:
+            cat_info = DEFAULT_CATS[limitations_program_hash_hex]
+            name = cat_info["name"]
+        elif name is None:
+            name = self.default_wallet_name_for_unknown_cat(limitations_program_hash_hex)
+
+        limitations_program_hash = bytes32.from_hexstr(limitations_program_hash_hex)
+        self.cat_info = cls.wallet_info_type(limitations_program_hash, None, hidden_puzzle_hash)
+        info_as_string = bytes(self.cat_info).hex()
+        self.wallet_info = await wallet_state_manager.user_store.create_wallet(name, cls.wallet_type, info_as_string)
+
+        self.lineage_store = await CATLineageStore.create(self.wallet_state_manager.db_wrapper, self.get_asset_id())
+        # Inherited from duplicating parent
+        await self.wallet_state_manager.add_new_wallet(self)
+
+        delete: bool = False
+        for state in await self.wallet_state_manager.interested_store.get_unacknowledged_states_for_asset_id(
+            limitations_program_hash
+        ):
+            new_peer = self.wallet_state_manager.wallet_node.get_full_node_peer()
+            if new_peer is not None:
+                delete = True
+                peer_id: bytes32 = new_peer.peer_node_id
+                await self.wallet_state_manager.retry_store.add_state(state[0], peer_id, state[1])
+
+        if delete:
+            await self.wallet_state_manager.interested_store.delete_unacknowledged_states_for_asset_id(
+                limitations_program_hash
+            )
+
+        return self
+
+    @classmethod
+    async def create_from_puzzle_info(
+        cls,
+        wallet_state_manager: WalletStateManager,
+        wallet: Wallet,
+        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] = {},
+    ) -> Any:
+        rev_layer: Optional[PuzzleInfo] = puzzle_driver.also()
+        if rev_layer is None:
+            raise ValueError("create_from_puzzle_info called on RCATWallet with a non R-CAT puzzle driver")
+        return await cls.get_or_create_wallet_for_cat(
+            wallet_state_manager,
+            wallet,
+            puzzle_driver["tail"].hex(),
+            bytes32(rev_layer["hidden_puzzle_hash"]),
+            name,
+        )
+
+    @property
+    def cost_of_single_tx(self) -> int:
+        return 78000000  # Estimate measured in testing
+
+    @classmethod
+    async def convert_to_revocable(
+        cls,
+        cat_wallet: CATWallet,
+        hidden_puzzle_hash: bytes32,
+    ) -> bool:
+        if not cat_wallet.lineage_store.is_empty():
+            cat_wallet.log.error("Received a revocable CAT to a CAT wallet that already has CATs")
+            return False
+        replace_self = cls()
+        replace_self.standard_wallet = cat_wallet.standard_wallet
+        replace_self.log = logging.getLogger(cat_wallet.get_name())
+        replace_self.log.info(f"Converting CAT wallet {cat_wallet.id()} to R-CAT wallet")
+        replace_self.wallet_state_manager = cat_wallet.wallet_state_manager
+        replace_self.lineage_store = cat_wallet.lineage_store
+        replace_self.cat_info = cls.wallet_info_type(
+            cat_wallet.cat_info.limitations_program_hash, None, hidden_puzzle_hash
+        )
+        await cat_wallet.wallet_state_manager.user_store.update_wallet(
+            WalletInfo(
+                cat_wallet.id(), cat_wallet.get_name(), uint8(cls.wallet_type.value), bytes(replace_self.cat_info).hex()
+            )
+        )
+        updated_wallet_info = await cat_wallet.wallet_state_manager.user_store.get_wallet_by_id(cat_wallet.id())
+        assert updated_wallet_info is not None
+        replace_self.wallet_info = updated_wallet_info
+
+        cat_wallet.wallet_state_manager.wallets[cat_wallet.id()] = replace_self
+        await cat_wallet.wallet_state_manager.puzzle_store.delete_wallet(cat_wallet.id())
+        result = await cat_wallet.wallet_state_manager.create_more_puzzle_hashes()
+        await result.commit(cat_wallet.wallet_state_manager)
+        return True
+
+    def puzzle_for_pk(self, pubkey: G1Element) -> Program:
+        inner_puzzle = create_revocation_layer(
+            self.cat_info.hidden_puzzle_hash, self.standard_wallet.puzzle_hash_for_pk(pubkey)
+        )
+        cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, self.cat_info.limitations_program_hash, inner_puzzle)
+        return cat_puzzle
+
+    def puzzle_hash_for_pk(self, pubkey: G1Element) -> bytes32:
+        inner_puzzle_hash = create_revocation_layer(
+            self.cat_info.hidden_puzzle_hash, self.standard_wallet.puzzle_hash_for_pk(pubkey)
+        ).get_tree_hash()
+        limitations_program_hash_hash = Program.to(self.cat_info.limitations_program_hash).get_tree_hash()
+        return curry_and_treehash(
+            QUOTED_CAT_MOD_HASH, CAT_MOD_HASH_HASH, limitations_program_hash_hash, inner_puzzle_hash
+        )
+
+    async def inner_puzzle_for_cat_puzhash(self, cat_hash: bytes32) -> Program:
+        return create_revocation_layer(
+            self.cat_info.hidden_puzzle_hash, (await super().inner_puzzle_for_cat_puzhash(cat_hash)).get_tree_hash()
+        )
+
+    async def make_inner_solution(
+        self,
+        coin: Coin,
+        primaries: list[CreateCoin],
+        conditions: tuple[Condition, ...] = tuple(),
+    ) -> Program:
+        record: Optional[
+            DerivationRecord
+        ] = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(coin.puzzle_hash)
+        if record is None:
+            raise RuntimeError(f"Missing Derivation Record for CAT puzzle_hash {coin.puzzle_hash}")
+        return solve_revocation_layer(
+            self.standard_wallet.puzzle_for_pk(record.pubkey),
+            (await super().make_inner_solution(coin, primaries=primaries, conditions=conditions)),
+        )
+
+    async def match_puzzle_info(self, puzzle_driver: PuzzleInfo) -> bool:
+        if (
+            AssetType(puzzle_driver.type()) == AssetType.CAT
+            and puzzle_driver["tail"] == self.cat_info.limitations_program_hash
+        ):
+            inner_puzzle_driver: Optional[PuzzleInfo] = puzzle_driver.also()
+            if inner_puzzle_driver is None:
+                raise ValueError("Malformed puzzle driver passed to RCATWallet.match_puzzle_info")
+            return (
+                AssetType(inner_puzzle_driver.type()) == AssetType.REVOCATION_LAYER
+                and bytes32(inner_puzzle_driver["hidden_puzzle_hash"]) == self.cat_info.hidden_puzzle_hash
+            )
+        return False
+
+    async def get_puzzle_info(self, asset_id: bytes32) -> PuzzleInfo:
+        return PuzzleInfo(
+            {
+                "type": AssetType.CAT.value,
+                "tail": "0x" + self.get_asset_id(),
+                "also": {
+                    "type": AssetType.REVOCATION_LAYER.value,
+                    "hidden_puzzle_hash": "0x" + self.cat_info.hidden_puzzle_hash.hex(),
+                },
+            }
+        )
+
+    async def match_hinted_coin(self, coin: Coin, hint: bytes32) -> bool:
+        """
+        This matches coins that are RCATs with the hint as the inner puzzle
+        """
+
+        hint_inner_hash: bytes32 = create_revocation_layer(
+            self.cat_info.hidden_puzzle_hash,
+            hint,
+        ).get_tree_hash()
+        if (
+            construct_cat_puzzle(
+                Program.to(CAT_MOD_HASH),
+                self.cat_info.limitations_program_hash,
+                hint_inner_hash,
+                mod_code_hash=CAT_MOD_HASH_HASH,
+            ).get_tree_hash_precalc(hint, CAT_MOD_HASH, CAT_MOD_HASH_HASH, hint_inner_hash)
+            == coin.puzzle_hash
+        ):
+            return True
+        return False

chia/wallet/conditions.py

@@ -8,10 +8,11 @@ from typing import Any, ClassVar, Optional, TypeVar, Union, final, get_type_hint
 from chia_rs import Coin, G1Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
-from clvm.casts import int_from_bytes, int_to_bytes
+from typing_extensions import Self
 
 from chia.types.blockchain_format.program import Program
 from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.casts import int_from_bytes, int_to_bytes
 from chia.util.hash import std_hash
 from chia.util.streamable import Streamable, streamable
 
@@ -237,7 +238,7 @@ class CreateCoin(Condition):
         return condition
 
     @classmethod
-    def from_program(cls: type[_T_CreateCoin], program: Program) -> _T_CreateCoin:
+    def from_program(cls, program: Program) -> Self:
         potential_memos: Program = program.at("rrr")
         return cls(
             bytes32(program.at("rf").as_atom()),
@@ -253,9 +254,6 @@ class CreateCoin(Condition):
         return [self.puzzle_hash, self.amount, self.memos]
 
 
-_T_CreateCoin = TypeVar("_T_CreateCoin", bound=CreateCoin)
-
-
 @final
 @streamable
 @dataclass(frozen=True)
@@ -541,9 +539,6 @@ class MessageParticipant(Streamable):
         )
 
 
-_T_MessageCondition = TypeVar("_T_MessageCondition", bound="SendMessage")
-
-
 @streamable
 @dataclass(frozen=True)
 class SendMessage(Condition):
@@ -564,7 +559,7 @@ class SendMessage(Condition):
 
     def __post_init__(self) -> None:
         if self.mode_integer is None and (self.sender is None or self.receiver is None):
-            raise ValueError("Must specify either mode_integer or both sender and reciever")
+            raise ValueError("Must specify either mode_integer or both sender and receiver")
 
         if self.mode_integer is not None and self.sender is not None:
             assert self.mode_integer >> 3 == self.sender.mode, (
@@ -607,7 +602,7 @@ class SendMessage(Condition):
         return condition
 
     @classmethod
-    def from_program(cls: type[_T_MessageCondition], program: Program) -> _T_MessageCondition:
+    def from_program(cls, program: Program) -> Self:
         full_mode = uint8(program.at("rf").as_int())
         var_args = list(program.at("rrr").as_iter())
         return cls(

chia/wallet/db_wallet/db_wallet_puzzles.py

@@ -8,7 +8,7 @@ from chia_puzzles_py.programs import P2_PARENT as P2_PARENT_BYTES
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
-from chia.types.blockchain_format.program import INFINITE_COST, Program
+from chia.types.blockchain_format.program import INFINITE_COST, Program, run_with_cost, uncurry
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.wallet.nft_wallet.nft_puzzle_utils import create_nft_layer_puzzle_with_curry_params
@@ -45,9 +45,9 @@ def match_dl_singleton(puzzle: Union[Program, SerializedProgram]) -> tuple[bool,
     """
     Given a puzzle test if it's a CAT and, if it is, return the curried arguments
     """
-    mod, singleton_curried_args = puzzle.uncurry()
+    mod, singleton_curried_args = uncurry(puzzle)
     if mod == SINGLETON_TOP_LAYER_MOD:
-        mod, dl_curried_args = singleton_curried_args.at("rf").uncurry()
+        mod, dl_curried_args = uncurry(singleton_curried_args.at("rf"))
         if mod == NFT_STATE_LAYER_MOD and dl_curried_args.at("rrf") == ACS_MU_PH:
             launcher_id = singleton_curried_args.at("frf")
             root = dl_curried_args.at("rff")
@@ -99,7 +99,7 @@ def get_mirror_info(
     parent_puzzle: Union[Program, SerializedProgram], parent_solution: Union[Program, SerializedProgram]
 ) -> tuple[bytes32, list[bytes]]:
     assert type(parent_puzzle) is type(parent_solution)
-    _, conditions = parent_puzzle.run_with_cost(INFINITE_COST, parent_solution)
+    _, conditions = run_with_cost(parent_puzzle, INFINITE_COST, parent_solution)
     for condition in conditions.as_iter():
         if (
             condition.first().as_python() == ConditionOpcode.CREATE_COIN

chia/wallet/derivation_record.py

@@ -7,6 +7,7 @@ from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
+from chia.util.streamable import Streamable, streamable
 from chia.wallet.util.wallet_types import WalletType
 
 
@@ -28,3 +29,35 @@ class DerivationRecord:
     def pubkey(self) -> G1Element:
         assert isinstance(self._pubkey, G1Element)
         return self._pubkey
+
+
+@streamable
+@dataclass(frozen=True)
+class StreamableDerivationRecord(Streamable):
+    index: uint32
+    puzzle_hash: bytes32
+    pubkey: bytes
+    wallet_type: uint32
+    wallet_id: uint32
+    hardened: bool
+
+    @classmethod
+    def from_standard(cls, record: DerivationRecord) -> StreamableDerivationRecord:
+        return cls(
+            record.index,
+            record.puzzle_hash,
+            bytes(record._pubkey),
+            uint32(record.wallet_type.value),
+            record.wallet_id,
+            record.hardened,
+        )
+
+    def to_standard(self) -> DerivationRecord:
+        return DerivationRecord(
+            self.index,
+            self.puzzle_hash,
+            G1Element.from_bytes(self.pubkey),
+            WalletType(self.wallet_type),
+            self.wallet_id,
+            self.hardened,
+        )

chia/wallet/derive_keys.py

@@ -6,7 +6,7 @@ from chia_rs import AugSchemeMPL, G1Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
-from chia.consensus.coinbase import create_puzzlehash_for_pk
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 
 # EIP 2334 bls key derivation
 # https://eips.ethereum.org/EIPS/eip-2334
@@ -131,8 +131,8 @@ def match_address_to_sk(
 
     for i in range(max_ph_to_search):
         phs = [
-            create_puzzlehash_for_pk(master_sk_to_wallet_sk(sk, uint32(i)).get_g1()),
-            create_puzzlehash_for_pk(master_sk_to_wallet_sk_unhardened(sk, uint32(i)).get_g1()),
+            puzzle_hash_for_pk(master_sk_to_wallet_sk(sk, uint32(i)).get_g1()),
+            puzzle_hash_for_pk(master_sk_to_wallet_sk_unhardened(sk, uint32(i)).get_g1()),
         ]
 
         for address in search_list:

chia/wallet/did_wallet/did_info.py

@@ -3,14 +3,23 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
+from chia_rs import CoinState
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint64
 
-from chia.protocols.wallet_protocol import CoinState
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.program import NIL, Program
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.lineage_proof import LineageProof
+from chia.wallet.util.curry_and_treehash import NIL_TREEHASH
+
+
+def did_recovery_is_nil(recovery_program: Program) -> bool:
+    # cannot use set as not hashable
+    if recovery_program in (NIL, NIL_TREEHASH):  # noqa: PLR6201
+        return True
+    else:
+        return False
 
 
 @streamable
@@ -32,7 +41,7 @@ class DIDInfo(Streamable):
 @dataclass(frozen=True)
 class DIDCoinData(Streamable):
     p2_puzzle: Program
-    recovery_list_hash: bytes32
+    recovery_list_hash: Optional[bytes32]
     num_verification: uint16
     singleton_struct: Program
     metadata: Program