chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/db_wallet/db_wallet_puzzles.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Union
+
+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
+
+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")
+
+
+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())))
+    return SINGLETON_TOP_LAYER_MOD.curry(singleton_struct, db_layer)
+
+
+def create_host_layer_puzzle(innerpuz: Union[Program, bytes32], current_root: bytes32) -> Program:
+    # some hard coded metadata formatting and metadata updater for now
+    return create_nft_layer_puzzle_with_curry_params(
+        Program.to((current_root, None)),
+        ACS_MU_PH,
+        # TODO: the nft driver doesn't like the Union yet, but changing that is out of scope for me rn - Quex
+        innerpuz,  # type: ignore
+    )
+
+
+def match_dl_singleton(puzzle: Union[Program, SerializedProgram]) -> tuple[bool, Iterator[Program]]:
+    """
+    Given a puzzle test if it's a CAT and, if it is, return the curried arguments
+    """
+    mod, singleton_curried_args = puzzle.uncurry()
+    if mod == SINGLETON_TOP_LAYER_MOD:
+        mod, dl_curried_args = singleton_curried_args.at("rf").uncurry()
+        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")
+            innerpuz = dl_curried_args.at("rrrf")
+            return True, iter((innerpuz, root, launcher_id))
+
+    return False, iter(())
+
+
+def launch_solution_to_singleton_info(launch_solution: Program) -> tuple[bytes32, uint64, bytes32, bytes32]:
+    solution = launch_solution.as_python()
+    try:
+        full_puzzle_hash = bytes32(solution[0])
+        amount = uint64(int.from_bytes(solution[1], "big"))
+        root = bytes32(solution[2][0])
+        inner_puzzle_hash = bytes32(solution[2][1])
+    except (IndexError, TypeError):
+        raise ValueError("Launcher is not a data layer launcher")
+
+    return full_puzzle_hash, amount, root, inner_puzzle_hash
+
+
+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()))
+    )
+    return struct
+
+
+def create_graftroot_offer_puz(
+    launcher_ids: list[bytes32], values_to_prove: list[list[bytes32]], inner_puzzle: Program
+) -> Program:
+    return GRAFTROOT_DL_OFFERS.curry(
+        inner_puzzle,
+        [launcher_to_struct(launcher) for launcher in launcher_ids],
+        [NFT_STATE_LAYER_MOD.get_tree_hash()] * len(launcher_ids),
+        values_to_prove,
+    )
+
+
+def create_mirror_puzzle() -> Program:
+    return P2_PARENT.curry(Program.to(1))
+
+
+MIRROR_PUZZLE_HASH = create_mirror_puzzle().get_tree_hash()
+
+
+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)
+    for condition in conditions.as_iter():
+        if (
+            condition.first().as_python() == ConditionOpcode.CREATE_COIN
+            and condition.at("rf").as_python() == create_mirror_puzzle().get_tree_hash()
+        ):
+            memos: list[bytes] = condition.at("rrrf").as_python()
+            launcher_id = bytes32(memos[0])
+            return launcher_id, [url for url in memos[1:]]
+    raise ValueError("The provided puzzle and solution do not create a mirror coin")

chia/wallet/derivation_record.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Union
+
+from chia_rs import G1Element
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint32
+from chia.wallet.util.wallet_types import WalletType
+
+
+@dataclass(frozen=True)
+class DerivationRecord:
+    """
+    These are records representing a puzzle hash, which is generated from a
+    public key, derivation index, and wallet type. Stored in the puzzle_store.
+    """
+
+    index: uint32
+    puzzle_hash: bytes32
+    _pubkey: Union[G1Element, bytes]
+    wallet_type: WalletType
+    wallet_id: uint32
+    hardened: bool
+
+    @property
+    def pubkey(self) -> G1Element:
+        assert isinstance(self._pubkey, G1Element)
+        return self._pubkey

chia/wallet/derive_keys.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from chia_rs import AugSchemeMPL, G1Element, PrivateKey
+
+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
+# 12381 = bls spec number
+# 8444 = Chia blockchain number and port number
+# 0, 1, 2, 3, 4, 5, 6 farmer, pool, wallet, local, backup key, singleton, pooling authentication key numbers
+
+# Allows up to 100 pool wallets (plot NFTs)
+MAX_POOL_WALLETS = 100
+
+
+def _derive_path(sk: PrivateKey, path: list[int]) -> PrivateKey:
+    for index in path:
+        sk = AugSchemeMPL.derive_child_sk(sk, index)
+    return sk
+
+
+def _derive_path_unhardened(sk: PrivateKey, path: list[int]) -> PrivateKey:
+    for index in path:
+        sk = AugSchemeMPL.derive_child_sk_unhardened(sk, index)
+    return sk
+
+
+def _derive_pk_unhardened(pk: G1Element, path: list[int]) -> G1Element:
+    for index in path:
+        pk = AugSchemeMPL.derive_child_pk_unhardened(pk, index)
+    return pk
+
+
+def master_sk_to_farmer_sk(master: PrivateKey) -> PrivateKey:
+    return _derive_path(master, [12381, 8444, 0, 0])
+
+
+def master_sk_to_pool_sk(master: PrivateKey) -> PrivateKey:
+    return _derive_path(master, [12381, 8444, 1, 0])
+
+
+def master_sk_to_wallet_sk_intermediate(master: PrivateKey) -> PrivateKey:
+    return _derive_path(master, [12381, 8444, 2])
+
+
+def master_sk_to_wallet_sk(master: PrivateKey, index: uint32) -> PrivateKey:
+    intermediate = master_sk_to_wallet_sk_intermediate(master)
+    return _derive_path(intermediate, [index])
+
+
+def master_sk_to_wallet_sk_unhardened_intermediate(master: PrivateKey) -> PrivateKey:
+    return _derive_path_unhardened(master, [12381, 8444, 2])
+
+
+def master_pk_to_wallet_pk_unhardened_intermediate(master: G1Element) -> G1Element:
+    return _derive_pk_unhardened(master, [12381, 8444, 2])
+
+
+def master_sk_to_wallet_sk_unhardened(master: PrivateKey, index: uint32) -> PrivateKey:
+    intermediate = master_sk_to_wallet_sk_unhardened_intermediate(master)
+    return _derive_path_unhardened(intermediate, [index])
+
+
+def master_pk_to_wallet_pk_unhardened(master: G1Element, index: uint32) -> G1Element:
+    intermediate = master_pk_to_wallet_pk_unhardened_intermediate(master)
+    return _derive_pk_unhardened(intermediate, [index])
+
+
+def master_sk_to_local_sk(master: PrivateKey) -> PrivateKey:
+    return _derive_path(master, [12381, 8444, 3, 0])
+
+
+def master_sk_to_backup_sk(master: PrivateKey) -> PrivateKey:
+    return _derive_path(master, [12381, 8444, 4, 0])
+
+
+def master_sk_to_singleton_owner_sk(master: PrivateKey, pool_wallet_index: uint32) -> PrivateKey:
+    """
+    This key controls a singleton on the blockchain, allowing for dynamic pooling (changing pools)
+    """
+    return _derive_path(master, [12381, 8444, 5, pool_wallet_index])
+
+
+def master_sk_to_pooling_authentication_sk(master: PrivateKey, pool_wallet_index: uint32, index: uint32) -> PrivateKey:
+    """
+    This key is used for the farmer to authenticate to the pool when sending partials
+    """
+    assert index < 10000
+    assert pool_wallet_index < 10000
+    return _derive_path(master, [12381, 8444, 6, pool_wallet_index * 10000 + index])
+
+
+def find_owner_sk(all_sks: list[PrivateKey], owner_pk: G1Element) -> Optional[tuple[PrivateKey, uint32]]:
+    for pool_wallet_index in range(MAX_POOL_WALLETS):
+        for sk in all_sks:
+            try_owner_sk = master_sk_to_singleton_owner_sk(sk, uint32(pool_wallet_index))
+            if try_owner_sk.get_g1() == owner_pk:
+                return try_owner_sk, uint32(pool_wallet_index)
+    return None
+
+
+def find_authentication_sk(all_sks: list[PrivateKey], owner_pk: G1Element) -> Optional[PrivateKey]:
+    # NOTE: might need to increase this if using a large number of wallets, or have switched authentication keys
+    # many times.
+    for pool_wallet_index in range(MAX_POOL_WALLETS):
+        for sk in all_sks:
+            try_owner_sk = master_sk_to_singleton_owner_sk(sk, uint32(pool_wallet_index))
+            if try_owner_sk.get_g1() == owner_pk:
+                # NOTE: ONLY use 0 for authentication key index to ensure compatibility
+                return master_sk_to_pooling_authentication_sk(sk, uint32(pool_wallet_index), uint32(0))
+    return None
+
+
+def match_address_to_sk(
+    sk: PrivateKey, addresses_to_search: list[bytes32], max_ph_to_search: int = 500
+) -> set[bytes32]:
+    """
+    Checks the list of given address is a derivation of the given sk within the given number of derivations
+    Returns a Set of the addresses that are derivations of the given sk
+    """
+    if sk is None or not addresses_to_search:
+        return set()
+
+    found_addresses: set[bytes32] = set()
+    search_list: set[bytes32] = set(addresses_to_search)
+
+    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()),
+        ]
+
+        for address in search_list:
+            if address in phs:
+                found_addresses.add(address)
+
+        search_list -= found_addresses
+        if not len(search_list):
+            return found_addresses
+
+    return found_addresses

chia/wallet/did_wallet/did_info.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+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
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDInfo(Streamable):
+    origin_coin: Optional[Coin]  # Coin ID of this coin is our DID
+    backup_ids: list[bytes32]
+    num_of_backup_ids_needed: uint64
+    parent_info: list[tuple[bytes32, Optional[LineageProof]]]  # {coin.name(): LineageProof}
+    current_inner: Optional[Program]  # represents a Program as bytes
+    temp_coin: Optional[Coin]  # partially recovered wallet uses these to hold info
+    temp_puzhash: Optional[bytes32]
+    temp_pubkey: Optional[bytes]
+    sent_recovery_transaction: bool
+    metadata: str  # JSON of the user defined metadata
+
+
+@streamable
+@dataclass(frozen=True)
+class DIDCoinData(Streamable):
+    p2_puzzle: Program
+    recovery_list_hash: bytes32
+    num_verification: uint16
+    singleton_struct: Program
+    metadata: Program
+    inner_puzzle: Optional[Program]
+    coin_state: CoinState