chia-blockchain 2.5.2rc1__py3-none-any.whl → 2.5.3rc1__py3-none-any.whl

chia/wallet/conditions.py

@@ -6,13 +6,13 @@ from dataclasses import dataclass, fields, replace
 from typing import Any, ClassVar, Optional, TypeVar, Union, final, get_type_hints
 
 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 chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.util.hash import std_hash
-from chia.util.ints import uint8, uint32, uint64
 from chia.util.streamable import Streamable, streamable
 
 _T_Condition = TypeVar("_T_Condition", bound="Condition")
@@ -221,7 +221,7 @@ class AggSigMe(Condition):
         )
 
 
-@final
+# @final  # subclassing allowed for NotarizedPayment
 @streamable
 @dataclass(frozen=True)
 class CreateCoin(Condition):
@@ -237,7 +237,7 @@ class CreateCoin(Condition):
         return condition
 
     @classmethod
-    def from_program(cls, program: Program) -> CreateCoin:
+    def from_program(cls: type[_T_CreateCoin], program: Program) -> _T_CreateCoin:
         potential_memos: Program = program.at("rrr")
         return cls(
             bytes32(program.at("rf").as_atom()),
@@ -249,6 +249,12 @@ class CreateCoin(Condition):
             ),
         )
 
+    def as_condition_args(self) -> list[Union[bytes32, uint64, Optional[list[bytes]]]]:
+        return [self.puzzle_hash, self.amount, self.memos]
+
+
+_T_CreateCoin = TypeVar("_T_CreateCoin", bound=CreateCoin)
+
 
 @final
 @streamable
@@ -445,9 +451,9 @@ class MessageParticipant(Streamable):
                     == self.coin_id_committed
                 ), "The value for coin_id_committed must be equal to the implied ID of the other three arguments"
         if self.mode_integer is not None:
-            assert (
-                self.mode == self.mode_integer
-            ), "If mode_integer is manually specified, you must specify committments that match with the mode"
+            assert self.mode == self.mode_integer, (
+                "If mode_integer is manually specified, you must specify committments that match with the mode"
+            )
 
     @property
     def _nothing_committed(self) -> bool:
@@ -561,14 +567,14 @@ class SendMessage(Condition):
             raise ValueError("Must specify either mode_integer or both sender and reciever")
 
         if self.mode_integer is not None and self.sender is not None:
-            assert (
-                self.mode_integer >> 3 == self.sender.mode
-            ), "The first 3 bits of mode_integer don't match the sender's mode"
+            assert self.mode_integer >> 3 == self.sender.mode, (
+                "The first 3 bits of mode_integer don't match the sender's mode"
+            )
 
         if self.mode_integer is not None and self.receiver is not None:
-            assert (
-                self.mode_integer & 0b000111 == self.receiver.mode
-            ), "The last 3 bits of mode_integer don't match the receiver's mode"
+            assert self.mode_integer & 0b000111 == self.receiver.mode, (
+                "The last 3 bits of mode_integer don't match the receiver's mode"
+            )
 
         if self.var_args is None and self._other_party is None:
             raise ValueError(
@@ -576,9 +582,9 @@ class SendMessage(Condition):
             )
 
         if self.var_args is not None and self._other_party is not None and not self._other_party._nothing_committed:
-            assert (
-                self.var_args == self._other_party.necessary_args
-            ), f"The implied arguments for {self._other_party} do not match the specified arguments {self.var_args}"
+            assert self.var_args == self._other_party.necessary_args, (
+                f"The implied arguments for {self._other_party} do not match the specified arguments {self.var_args}"
+            )
 
     @property
     def args(self) -> list[Program]:

chia/wallet/db_wallet/db_wallet_puzzles.py

@@ -3,31 +3,31 @@ from __future__ import annotations
 from collections.abc import Iterator
 from typing import Union
 
+from chia_puzzles_py.programs import GRAFTROOT_DL_OFFERS as GRAFTROOT_DL_OFFERS_BYTES
+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.serialized_program import SerializedProgram
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.util.ints import uint64
-from chia.wallet.nft_wallet.nft_puzzles import NFT_STATE_LAYER_MOD, create_nft_layer_puzzle_with_curry_params
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
-
-# from chia.types.condition_opcodes import ConditionOpcode
-# from chia.wallet.util.merkle_tree import MerkleTree, TreeType
+from chia.wallet.nft_wallet.nft_puzzle_utils import create_nft_layer_puzzle_with_curry_params
+from chia.wallet.nft_wallet.nft_puzzles import NFT_STATE_LAYER_MOD
+from chia.wallet.singleton import (
+    SINGLETON_LAUNCHER_PUZZLE_HASH,
+    SINGLETON_TOP_LAYER_MOD,
+)
 
 ACS_MU = Program.to(11)  # returns the third argument a.k.a the full solution
 ACS_MU_PH = ACS_MU.get_tree_hash()
-SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
-SINGLETON_LAUNCHER = load_clvm_maybe_recompile("singleton_launcher.clsp")
-GRAFTROOT_DL_OFFERS = load_clvm_maybe_recompile(
-    "graftroot_dl_offers.clsp", package_or_requirement="chia.data_layer.puzzles"
-)
-P2_PARENT = load_clvm_maybe_recompile("p2_parent.clsp")
+GRAFTROOT_DL_OFFERS = Program.from_bytes(GRAFTROOT_DL_OFFERS_BYTES)
+P2_PARENT = Program.from_bytes(P2_PARENT_BYTES)
 
 
 def create_host_fullpuz(innerpuz: Union[Program, bytes32], current_root: bytes32, genesis_id: bytes32) -> Program:
     db_layer = create_host_layer_puzzle(innerpuz, current_root)
     mod_hash = SINGLETON_TOP_LAYER_MOD.get_tree_hash()
-    singleton_struct = Program.to((mod_hash, (genesis_id, SINGLETON_LAUNCHER.get_tree_hash())))
+    singleton_struct = Program.to((mod_hash, (genesis_id, SINGLETON_LAUNCHER_PUZZLE_HASH)))
     return SINGLETON_TOP_LAYER_MOD.curry(singleton_struct, db_layer)
 
 
@@ -72,7 +72,7 @@ def launch_solution_to_singleton_info(launch_solution: Program) -> tuple[bytes32
 
 def launcher_to_struct(launcher_id: bytes32) -> Program:
     struct: Program = Program.to(
-        (SINGLETON_TOP_LAYER_MOD.get_tree_hash(), (launcher_id, SINGLETON_LAUNCHER.get_tree_hash()))
+        (SINGLETON_TOP_LAYER_MOD.get_tree_hash(), (launcher_id, SINGLETON_LAUNCHER_PUZZLE_HASH))
     )
     return struct
 

chia/wallet/derivation_record.py

@@ -4,9 +4,9 @@ from dataclasses import dataclass
 from typing import Union
 
 from chia_rs import G1Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
 
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint32
 from chia.wallet.util.wallet_types import WalletType
 
 

chia/wallet/derive_keys.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 from typing import Optional
 
 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.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint32
 
 # EIP 2334 bls key derivation
 # https://eips.ethereum.org/EIPS/eip-2334

chia/wallet/did_wallet/did_info.py

@@ -3,11 +3,12 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
+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.sized_bytes import bytes32
-from chia.util.ints import uint16, uint64
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.lineage_proof import LineageProof
 

chia/wallet/did_wallet/did_wallet.py

@@ -8,19 +8,21 @@ import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
 from chia_rs import AugSchemeMPL, G1Element, G2Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16, uint32, uint64, uint128
+from typing_extensions import Unpack
 
 from chia.protocols.wallet_protocol import CoinState
 from chia.server.ws_connection import WSChiaConnection
 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, make_spend
 from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
-from chia.util.ints import uint16, uint32, uint64, uint128
 from chia.wallet.conditions import (
     AssertCoinAnnouncement,
     Condition,
     ConditionValidTimes,
+    CreateCoin,
     CreateCoinAnnouncement,
     parse_timelock_info,
 )
@@ -29,7 +31,6 @@ from chia.wallet.did_wallet import did_wallet_puzzles
 from chia.wallet.did_wallet.did_info import DIDCoinData, DIDInfo
 from chia.wallet.did_wallet.did_wallet_puzzles import match_did_puzzle, uncurry_innerpuz
 from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.payment import Payment
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import (
     DEFAULT_HIDDEN_PUZZLE_HASH,
     calculate_synthetic_secret_key,
@@ -53,7 +54,7 @@ from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_action_scope import WalletActionScope
 from chia.wallet.wallet_coin_record import WalletCoinRecord
 from chia.wallet.wallet_info import WalletInfo
-from chia.wallet.wallet_protocol import WalletProtocol
+from chia.wallet.wallet_protocol import GSTOptionalArgs, WalletProtocol
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
@@ -488,6 +489,7 @@ class DIDWallet:
 
             children_state: CoinState = children[0]
             child_coin = children_state.coin
+            assert did_info.current_inner is not None
             future_parent = LineageProof(
                 parent_name=child_coin.parent_coin_info,
                 inner_puzzle_hash=did_info.current_inner.get_tree_hash(),
@@ -583,7 +585,7 @@ class DIDWallet:
         # innerpuz solution is (mode, p2_solution)
         p2_solution = self.standard_wallet.make_solution(
             primaries=[
-                Payment(
+                CreateCoin(
                     puzzle_hash=new_inner_puzzle.get_tree_hash(),
                     amount=uint64(coin.amount),
                     memos=[p2_puzzle.get_tree_hash()],
@@ -695,7 +697,7 @@ class DIDWallet:
             metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
         )
         p2_solution = self.standard_wallet.make_solution(
-            primaries=[Payment(new_did_puzhash, uint64(coin.amount), [new_puzhash])],
+            primaries=[CreateCoin(new_did_puzhash, uint64(coin.amount), [new_puzhash])],
             conditions=(*extra_conditions, CreateCoinAnnouncement(coin.name())),
         )
         # Need to include backup list reveal here, even we are don't recover
@@ -765,23 +767,31 @@ class DIDWallet:
         assert self.did_info.origin_coin is not None
         coin = await self.get_coin()
         innerpuz: Program = self.did_info.current_inner
+        assert (
+            create_singleton_puzzle(
+                innerpuz,
+                self.did_info.origin_coin.name(),
+            ).get_tree_hash()
+            == coin.puzzle_hash
+        )
+        uncurried = did_wallet_puzzles.uncurry_innerpuz(innerpuz)
+        assert uncurried is not None
+        p2_puzzle, id_list_hash, num_of_backup_ids_needed, _, metadata = uncurried
         # Quote message puzzle & solution
         if action_scope.config.tx_config.reuse_puzhash:
             new_innerpuzzle_hash = innerpuz.get_tree_hash()
-            uncurried = did_wallet_puzzles.uncurry_innerpuz(innerpuz)
-            assert uncurried is not None
-            p2_ph = uncurried[0].get_tree_hash()
+            p2_ph = p2_puzzle.get_tree_hash()
         else:
             p2_ph = await self.standard_wallet.get_puzzle_hash(new=True)
             new_innerpuzzle_hash = did_wallet_puzzles.get_inner_puzhash_by_p2(
                 p2_puzhash=p2_ph,
-                recovery_list=self.did_info.backup_ids,
-                num_of_backup_ids_needed=self.did_info.num_of_backup_ids_needed,
+                recovery_list_hash=bytes32(id_list_hash.as_atom()),
+                num_of_backup_ids_needed=uint64(num_of_backup_ids_needed.as_int()),
                 launcher_id=self.did_info.origin_coin.name(),
-                metadata=did_wallet_puzzles.metadata_to_program(json.loads(self.did_info.metadata)),
+                metadata=metadata,
             )
         p2_solution = self.standard_wallet.make_solution(
-            primaries=[Payment(puzzle_hash=new_innerpuzzle_hash, amount=uint64(coin.amount), memos=[p2_ph])],
+            primaries=[CreateCoin(puzzle_hash=new_innerpuzzle_hash, amount=uint64(coin.amount), memos=[p2_ph])],
             conditions=extra_conditions,
         )
         # innerpuz solution is (mode p2_solution)
@@ -916,8 +926,8 @@ class DIDWallet:
         # innerpuz solution is (mode, p2_solution)
         p2_solution = self.standard_wallet.make_solution(
             primaries=[
-                Payment(innerpuz.get_tree_hash(), uint64(coin.amount), [p2_puzzle.get_tree_hash()]),
-                Payment(innermessage, uint64(0)),
+                CreateCoin(innerpuz.get_tree_hash(), uint64(coin.amount), [p2_puzzle.get_tree_hash()]),
+                CreateCoin(innermessage, uint64(0)),
             ],
             conditions=extra_conditions,
         )
@@ -1224,12 +1234,11 @@ class DIDWallet:
         announcement_message = Program.to([did_puzzle_hash, amount, bytes(0x80)]).get_tree_hash()
 
         await self.standard_wallet.generate_signed_transaction(
-            amount=amount,
-            puzzle_hash=genesis_launcher_puz.get_tree_hash(),
+            amounts=[amount],
+            puzzle_hashes=[genesis_launcher_puz.get_tree_hash()],
             action_scope=action_scope,
             fee=fee,
             coins=coins,
-            primaries=None,
             origin_id=origin.name(),
             extra_conditions=(
                 AssertCoinAnnouncement(asserted_id=launcher_coin.name(), asserted_msg=announcement_message),
@@ -1309,7 +1318,7 @@ class DIDWallet:
         p2_puzzle = uncurried[0]
         # innerpuz solution is (mode p2_solution)
         p2_solution = self.standard_wallet.make_solution(
-            primaries=[Payment(innerpuz.get_tree_hash(), uint64(coin.amount), [p2_puzzle.get_tree_hash()])],
+            primaries=[CreateCoin(innerpuz.get_tree_hash(), uint64(coin.amount), [p2_puzzle.get_tree_hash()])],
             conditions=extra_conditions,
         )
         innersol = Program.to([1, p2_solution])
@@ -1492,3 +1501,16 @@ class DIDWallet:
             ).get_tree_hash_precalc(hint)
             == coin.puzzle_hash
         )
+
+    async def generate_signed_transaction(
+        self,
+        amounts: list[uint64],
+        puzzle_hashes: list[bytes32],
+        action_scope: WalletActionScope,
+        fee: uint64 = uint64(0),
+        coins: Optional[set[Coin]] = None,
+        memos: Optional[list[list[bytes]]] = None,
+        extra_conditions: tuple[Condition, ...] = tuple(),
+        **kwargs: Unpack[GSTOptionalArgs],
+    ) -> None:
+        raise NotImplementedError("DIDWallet does not implement `generate_signed_transaction`")

chia/wallet/did_wallet/did_wallet_puzzles.py

@@ -3,15 +3,15 @@ from __future__ import annotations
 from collections.abc import Iterator
 from typing import Optional, Union
 
+from chia_puzzles_py.programs import DID_INNERPUZ, DID_INNERPUZ_HASH, NFT_INTERMEDIATE_LAUNCHER
 from chia_rs import G1Element
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
 
 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, make_spend
 from chia.types.condition_opcodes import ConditionOpcode
-from chia.util.ints import uint64
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.singleton import (
     SINGLETON_LAUNCHER_PUZZLE_HASH,
     SINGLETON_LAUNCHER_PUZZLE_HASH_TREE_HASH,
@@ -29,14 +29,10 @@ from chia.wallet.util.curry_and_treehash import (
     shatree_pair,
 )
 
-DID_INNERPUZ_MOD = load_clvm_maybe_recompile(
-    "did_innerpuz.clsp", package_or_requirement="chia.wallet.did_wallet.puzzles"
-)
-DID_INNERPUZ_MOD_HASH = DID_INNERPUZ_MOD.get_tree_hash()
+DID_INNERPUZ_MOD = Program.from_bytes(DID_INNERPUZ)
+DID_INNERPUZ_MOD_HASH = bytes32(DID_INNERPUZ_HASH)
 DID_INNERPUZ_MOD_HASH_QUOTED = calculate_hash_of_quoted_mod_hash(DID_INNERPUZ_MOD_HASH)
-INTERMEDIATE_LAUNCHER_MOD = load_clvm_maybe_recompile(
-    "nft_intermediate_launcher.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles"
-)
+INTERMEDIATE_LAUNCHER_MOD = Program.from_bytes(NFT_INTERMEDIATE_LAUNCHER)
 
 
 def create_innerpuz(
@@ -70,10 +66,11 @@ def create_innerpuz(
 
 def get_inner_puzhash_by_p2(
     p2_puzhash: bytes32,
-    recovery_list: list[bytes32],
     num_of_backup_ids_needed: uint64,
     launcher_id: bytes32,
     metadata: Program = Program.to([]),
+    recovery_list: Optional[list[bytes32]] = None,
+    recovery_list_hash: Optional[bytes32] = None,
 ) -> bytes32:
     """
     Calculate DID inner puzzle hash based on a P2 puzzle hash
@@ -85,7 +82,16 @@ def get_inner_puzhash_by_p2(
     :return: DID inner puzzle hash
     """
 
-    backup_ids_hash = shatree_atom_list(recovery_list)
+    if recovery_list is None and recovery_list_hash is None:
+        raise ValueError("Cannot construct DID inner puzzle without information about recovery list")
+    if recovery_list is not None and recovery_list_hash is not None:
+        raise ValueError("Must only specify recovery information a single way to construct DID inner puzzle")
+
+    if recovery_list is not None:
+        backup_ids_hash = shatree_atom_list(recovery_list)
+    else:
+        assert recovery_list_hash is not None
+        backup_ids_hash = recovery_list_hash
 
     # singleton_struct = (MOD_HASH . (LAUNCHER_ID . LAUNCHER_PUZZLE_HASH))
     singleton_struct = shatree_pair(

chia/wallet/driver_protocol.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 from typing import Optional
 
+from chia_rs.sized_bytes import bytes32
 from typing_extensions import Protocol
 
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle
 

chia/wallet/lineage_proof.py

@@ -4,9 +4,10 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Optional
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
+
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
-from chia.util.ints import uint64
 from chia.util.streamable import Streamable, streamable
 
 

chia/wallet/nft_wallet/metadata_outer_puzzle.py

@@ -3,17 +3,16 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Callable, Optional
 
+from chia_rs.sized_bytes import bytes32
+
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.wallet.nft_wallet.nft_puzzles import (
+    NFT_STATE_LAYER_MOD,
+    NFT_STATE_LAYER_MOD_HASH,
+)
 from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
 
-NFT_STATE_LAYER_MOD = load_clvm_maybe_recompile(
-    "nft_state_layer.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles"
-)
-NFT_STATE_LAYER_MOD_HASH = NFT_STATE_LAYER_MOD.get_tree_hash()
-
 
 def match_metadata_layer_puzzle(puzzle: UncurriedPuzzle) -> tuple[bool, list[Program]]:
     if puzzle.mod == NFT_STATE_LAYER_MOD:

chia/wallet/nft_wallet/nft_info.py

@@ -3,15 +3,15 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16, uint32, uint64
+
 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.util.ints import uint16, uint32, uint64
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.lineage_proof import LineageProof
-from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+from chia.wallet.singleton import SINGLETON_LAUNCHER_PUZZLE_HASH
 
-LAUNCHER_PUZZLE = load_clvm_maybe_recompile("singleton_launcher.clsp")
 IN_TRANSACTION_STATUS = "IN_TRANSACTION"
 DEFAULT_STATUS = "DEFAULT"
 
@@ -85,7 +85,7 @@ class NFTInfo(Streamable):
     minter_did: Optional[bytes32] = None
     """DID of the NFT minter"""
 
-    launcher_puzhash: bytes32 = LAUNCHER_PUZZLE.get_tree_hash()
+    launcher_puzhash: bytes32 = SINGLETON_LAUNCHER_PUZZLE_HASH
     """Puzzle hash of the singleton launcher in hex"""
 
     off_chain_metadata: Optional[str] = None