chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/pools/pool_wallet_info.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Any, Optional
+
+from chia_rs import G1Element
+
+from chia.protocols.pool_protocol import POOL_PROTOCOL_VERSION
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint8, uint32
+from chia.util.streamable import Streamable, streamable
+
+
+class PoolSingletonState(IntEnum):
+    """
+    From the user's point of view, a pool group can be in these states:
+    `SELF_POOLING`: The singleton exists on the blockchain, and we are farming
+        block rewards to a wallet address controlled by the user
+
+    `LEAVING_POOL`: The singleton exists, and we have entered the "escaping" state, which
+        means we are waiting for a number of blocks = `relative_lock_height` to pass, so we can leave.
+
+    `FARMING_TO_POOL`: The singleton exists, and it is assigned to a pool.
+
+    `CLAIMING_SELF_POOLED_REWARDS`: We have submitted a transaction to sweep our
+        self-pooled funds.
+    """
+
+    SELF_POOLING = 1
+    LEAVING_POOL = 2
+    FARMING_TO_POOL = 3
+
+
+SELF_POOLING = PoolSingletonState.SELF_POOLING
+LEAVING_POOL = PoolSingletonState.LEAVING_POOL
+FARMING_TO_POOL = PoolSingletonState.FARMING_TO_POOL
+
+
+@streamable
+@dataclass(frozen=True)
+class PoolState(Streamable):
+    """
+    `PoolState` is a type that is serialized to the blockchain to track the state of the user's pool singleton
+    `target_puzzle_hash` is either the pool address, or the self-pooling address that pool rewards will be paid to.
+    `target_puzzle_hash` is NOT the p2_singleton puzzle that block rewards are sent to.
+    The `p2_singleton` address is the initial address, and the `target_puzzle_hash` is the final destination.
+    `relative_lock_height` is zero when in SELF_POOLING state
+    """
+
+    version: uint8
+    state: uint8  # PoolSingletonState
+    # `target_puzzle_hash`: A puzzle_hash we pay to
+    # When self-farming, this is a main wallet address
+    # When farming-to-pool, the pool sends this to the farmer during pool protocol setup
+    target_puzzle_hash: bytes32  # TODO: rename target_puzzle_hash -> pay_to_address
+    # owner_pubkey is set by the wallet, once
+    owner_pubkey: G1Element
+    pool_url: Optional[str]
+    relative_lock_height: uint32
+
+
+def initial_pool_state_from_dict(
+    state_dict: dict[str, Any],
+    owner_pubkey: G1Element,
+    owner_puzzle_hash: bytes32,
+) -> PoolState:
+    state_str = state_dict["state"]
+    singleton_state: PoolSingletonState = PoolSingletonState[state_str]
+
+    if singleton_state == SELF_POOLING:
+        target_puzzle_hash = owner_puzzle_hash
+        pool_url: str = ""
+        relative_lock_height = uint32(0)
+    elif singleton_state == FARMING_TO_POOL:
+        target_puzzle_hash = bytes32.from_hexstr(state_dict["target_puzzle_hash"])
+        pool_url = state_dict["pool_url"]
+        relative_lock_height = uint32(state_dict["relative_lock_height"])
+    else:
+        raise ValueError("Initial state must be SELF_POOLING or FARMING_TO_POOL")
+
+    # TODO: change create_pool_state to return error messages, as well
+    assert relative_lock_height is not None
+    return create_pool_state(singleton_state, target_puzzle_hash, owner_pubkey, pool_url, relative_lock_height)
+
+
+def create_pool_state(
+    state: PoolSingletonState,
+    target_puzzle_hash: bytes32,
+    owner_pubkey: G1Element,
+    pool_url: Optional[str],
+    relative_lock_height: uint32,
+) -> PoolState:
+    if state not in {s.value for s in PoolSingletonState}:
+        raise AssertionError(f"state {state} is not a valid PoolSingletonState,")
+    ps = PoolState(
+        POOL_PROTOCOL_VERSION, uint8(state), target_puzzle_hash, owner_pubkey, pool_url, relative_lock_height
+    )
+    # TODO Move verify here
+    return ps
+
+
+@streamable
+@dataclass(frozen=True)
+class PoolWalletInfo(Streamable):
+    """
+    Internal Pool Wallet state, not destined for the blockchain. This can be completely derived with
+    the Singleton's CoinSpends list, or with the information from the WalletPoolStore.
+    """
+
+    current: PoolState
+    target: Optional[PoolState]
+    launcher_coin: Coin
+    launcher_id: bytes32
+    p2_singleton_puzzle_hash: bytes32
+    tip_singleton_coin_id: bytes32
+    singleton_block_height: uint32  # Block height that current PoolState is from

chia/pools/puzzles/pool_member_innerpuz.clsp

@@ -0,0 +1,70 @@
+(mod (POOL_PUZZLE_HASH
+    P2_SINGLETON_PUZZLE_HASH
+    OWNER_PUBKEY
+    POOL_REWARD_PREFIX
+    WAITINGROOM_PUZHASH
+    Truths
+    p1
+    pool_reward_height
+  )
+
+
+  ; POOL_PUZZLE_HASH is commitment to the pool's puzzle hash
+  ; P2_SINGLETON_PUZZLE_HASH is the puzzle hash for your pay to singleton puzzle
+  ; OWNER_PUBKEY is the farmer pubkey which authorises a travel
+  ; POOL_REWARD_PREFIX is network-specific data (mainnet vs testnet) that helps determine if a coin is a pool reward
+  ; WAITINGROOM_PUZHASH is the puzzle_hash you'll go to when you initiate the leaving process
+
+  ; Absorbing money if pool_reward_height is an atom
+  ; Escaping if pool_reward_height is ()
+
+  ; p1 is pool_reward_amount if absorbing money
+  ; p1 is extra_data key_value_list if escaping
+
+  ; pool_reward_amount is the value of the coin reward - this is passed in so that this puzzle will still work after halvenings
+  ; pool_reward_height is the block height that the reward was generated at. This is used to calculate the coin ID.
+  ; key_value_list is signed extra data that the wallet may want to publicly announce for syncing purposes
+
+  (include condition_codes.clib)
+  (include singleton_truths.clib)
+
+  ; takes a lisp tree and returns the hash of it
+  (defun sha256tree (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree (f TREE)) (sha256tree (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  (defun-inline calculate_pool_reward (pool_reward_height P2_SINGLETON_PUZZLE_HASH POOL_REWARD_PREFIX pool_reward_amount)
+    (sha256 (logior POOL_REWARD_PREFIX (logand (- (lsh (q . 1) (q . 128)) (q . 1)) pool_reward_height)) P2_SINGLETON_PUZZLE_HASH pool_reward_amount)
+  )
+
+  (defun absorb_pool_reward (POOL_PUZZLE_HASH my_inner_puzzle_hash my_amount pool_reward_amount pool_reward_id)
+    (list
+      (list CREATE_COIN my_inner_puzzle_hash my_amount)
+      (list CREATE_COIN POOL_PUZZLE_HASH pool_reward_amount)
+      (list CREATE_PUZZLE_ANNOUNCEMENT pool_reward_id)
+      (list ASSERT_COIN_ANNOUNCEMENT (sha256 pool_reward_id '$'))
+    )
+  )
+
+  (defun-inline travel_to_waitingroom (OWNER_PUBKEY WAITINGROOM_PUZHASH my_amount extra_data)
+    (list (list AGG_SIG_ME OWNER_PUBKEY (sha256tree extra_data))
+      (list CREATE_COIN WAITINGROOM_PUZHASH my_amount)
+    )
+  )
+
+  ; main
+
+  (if pool_reward_height
+      (absorb_pool_reward POOL_PUZZLE_HASH
+        (my_inner_puzzle_hash_truth Truths)
+        (my_amount_truth Truths)
+        p1
+        (calculate_pool_reward pool_reward_height P2_SINGLETON_PUZZLE_HASH POOL_REWARD_PREFIX p1)
+      )
+      (travel_to_waitingroom OWNER_PUBKEY WAITINGROOM_PUZHASH (my_amount_truth Truths) p1)
+  )
+)
+)

chia/pools/puzzles/pool_member_innerpuz.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ffff03ff8202ffffff01ff02ff16ffff04ff02ffff04ff05ffff04ff8204bfffff04ff8206bfffff04ff82017fffff04ffff0bffff19ff2fffff18ffff019100ffffffffffffffffffffffffffffffffff8202ff8080ff0bff82017f80ff8080808080808080ffff01ff04ffff04ff08ffff04ff17ffff04ffff02ff1effff04ff02ffff04ff82017fff80808080ff80808080ffff04ffff04ff1cffff04ff5fffff04ff8206bfff80808080ff80808080ff0180ffff04ffff01ffff32ff3d33ff3effff04ffff04ff1cffff04ff0bffff04ff17ff80808080ffff04ffff04ff1cffff04ff05ffff04ff2fff80808080ffff04ffff04ff0affff04ff5fff808080ffff04ffff04ff14ffff04ffff0bff5fffff012480ff808080ff8080808080ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff1effff04ff02ffff04ff09ff80808080ffff02ff1effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/pools/puzzles/pool_waitingroom_innerpuz.clsp

@@ -0,0 +1,69 @@
+(mod (POOL_PUZZLE_HASH
+    P2_SINGLETON_PUZZLE_HASH
+    OWNER_PUBKEY
+    POOL_REWARD_PREFIX
+    RELATIVE_LOCK_HEIGHT
+    Truths
+    spend_type
+    p1
+    p2
+  )
+
+  ; POOL_PUZZLE_HASH is commitment to the pool's puzzle hash
+  ; P2_SINGLETON_PUZZLE_HASH is the puzzlehash for your pay_to_singleton puzzle
+  ; OWNER_PUBKEY is the farmer pubkey which signs the exit puzzle_hash
+  ; POOL_REWARD_PREFIX is network-specific data (mainnet vs testnet) that helps determine if a coin is a pool reward
+  ; RELATIVE_LOCK_HEIGHT is how long it takes to leave
+
+  ; spend_type is: 0 for absorbing money, 1 to escape
+  ; if spend_type is 0
+  ; p1 is pool_reward_amount - the value of the coin reward - this is passed in so that this puzzle will still work after halvenings
+  ; p2 is pool_reward_height - the block height that the reward was generated at. This is used to calculate the coin ID.
+  ; if spend_type is 1
+  ; p1 is extra_data key_value_list - signed extra data that the wallet may want to publicly announce for syncing purposes
+  ; p2 is destination_puzhash - the location that the escape spend wants to create itself to
+
+  (include condition_codes.clib)
+  (include singleton_truths.clib)
+
+  ; takes a lisp tree and returns the hash of it
+  (defun sha256tree (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree (f TREE)) (sha256tree (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  (defun-inline calculate_pool_reward (pool_reward_height P2_SINGLETON_PUZZLE_HASH POOL_REWARD_PREFIX pool_reward_amount)
+    (sha256 (logior POOL_REWARD_PREFIX (logand (- (lsh (q . 1) (q . 128)) (q . 1)) pool_reward_height)) P2_SINGLETON_PUZZLE_HASH pool_reward_amount)
+  )
+
+  (defun absorb_pool_reward (POOL_PUZZLE_HASH my_inner_puzzle_hash my_amount pool_reward_amount pool_reward_id)
+    (list
+      (list CREATE_COIN my_inner_puzzle_hash my_amount)
+      (list CREATE_COIN POOL_PUZZLE_HASH pool_reward_amount)
+      (list CREATE_PUZZLE_ANNOUNCEMENT pool_reward_id)
+      (list ASSERT_COIN_ANNOUNCEMENT (sha256 pool_reward_id '$'))
+    )
+  )
+
+  (defun-inline travel_spend (RELATIVE_LOCK_HEIGHT new_puzzle_hash my_amount extra_data)
+    (list (list ASSERT_HEIGHT_RELATIVE RELATIVE_LOCK_HEIGHT)
+      (list CREATE_COIN new_puzzle_hash my_amount)
+      (list AGG_SIG_ME OWNER_PUBKEY (sha256tree (list new_puzzle_hash extra_data)))
+    )
+  )
+
+  ; main
+
+  (if spend_type
+      (travel_spend RELATIVE_LOCK_HEIGHT p2 (my_amount_truth Truths) p1)
+      (absorb_pool_reward POOL_PUZZLE_HASH
+        (my_inner_puzzle_hash_truth Truths)
+        (my_amount_truth Truths)
+        p1
+        (calculate_pool_reward p2 P2_SINGLETON_PUZZLE_HASH POOL_REWARD_PREFIX p1)
+      )
+  )
+
+)

chia/pools/puzzles/pool_waitingroom_innerpuz.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ffff03ff82017fffff01ff04ffff04ff1cffff04ff5fff808080ffff04ffff04ff12ffff04ff8205ffffff04ff8206bfff80808080ffff04ffff04ff08ffff04ff17ffff04ffff02ff1effff04ff02ffff04ffff04ff8205ffffff04ff8202ffff808080ff80808080ff80808080ff80808080ffff01ff02ff16ffff04ff02ffff04ff05ffff04ff8204bfffff04ff8206bfffff04ff8202ffffff04ffff0bffff19ff2fffff18ffff019100ffffffffffffffffffffffffffffffffff8205ff8080ff0bff8202ff80ff808080808080808080ff0180ffff04ffff01ffff32ff3d52ffff333effff04ffff04ff12ffff04ff0bffff04ff17ff80808080ffff04ffff04ff12ffff04ff05ffff04ff2fff80808080ffff04ffff04ff1affff04ff5fff808080ffff04ffff04ff14ffff04ffff0bff5fffff012480ff808080ff8080808080ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff1effff04ff02ffff04ff09ff80808080ffff02ff1effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/protocols/farmer_protocol.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from chia_rs import G2Element
+
+from chia.types.blockchain_format.classgroup import ClassgroupElement
+from chia.types.blockchain_format.foliage import FoliageBlockData, FoliageTransactionBlock
+from chia.types.blockchain_format.pool_target import PoolTarget
+from chia.types.blockchain_format.proof_of_space import ProofOfSpace
+from chia.types.blockchain_format.reward_chain_block import RewardChainBlockUnfinished
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot
+from chia.util.ints import uint8, uint32, uint64
+from chia.util.streamable import Streamable, streamable
+
+"""
+Protocol between farmer and full node.
+Note: When changing this file, also change protocol_message_types.py, and the protocol version in shared_protocol.py
+"""
+
+
+@streamable
+@dataclass(frozen=True)
+class SPSubSlotSourceData(Streamable):
+    cc_sub_slot: ChallengeChainSubSlot
+    rc_sub_slot: RewardChainSubSlot
+
+
+@streamable
+@dataclass(frozen=True)
+class SPVDFSourceData(Streamable):
+    cc_vdf: ClassgroupElement
+    rc_vdf: ClassgroupElement
+
+
+@streamable
+@dataclass(frozen=True)
+class SignagePointSourceData(Streamable):
+    sub_slot_data: Optional[SPSubSlotSourceData] = None
+    vdf_data: Optional[SPVDFSourceData] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class NewSignagePoint(Streamable):
+    challenge_hash: bytes32
+    challenge_chain_sp: bytes32
+    reward_chain_sp: bytes32
+    difficulty: uint64
+    sub_slot_iters: uint64
+    signage_point_index: uint8
+    peak_height: uint32
+    sp_source_data: Optional[SignagePointSourceData] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class DeclareProofOfSpace(Streamable):
+    challenge_hash: bytes32
+    challenge_chain_sp: bytes32
+    signage_point_index: uint8
+    reward_chain_sp: bytes32
+    proof_of_space: ProofOfSpace
+    challenge_chain_sp_signature: G2Element
+    reward_chain_sp_signature: G2Element
+    farmer_puzzle_hash: bytes32
+    pool_target: Optional[PoolTarget]
+    pool_signature: Optional[G2Element]
+    include_signature_source_data: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestSignedValues(Streamable):
+    quality_string: bytes32
+    foliage_block_data_hash: bytes32
+    foliage_transaction_block_hash: bytes32
+    foliage_block_data: Optional[FoliageBlockData] = None
+    foliage_transaction_block_data: Optional[FoliageTransactionBlock] = None
+    rc_block_unfinished: Optional[RewardChainBlockUnfinished] = None
+
+
+@streamable
+@dataclass(frozen=True)
+class FarmingInfo(Streamable):
+    challenge_hash: bytes32
+    sp_hash: bytes32
+    timestamp: uint64
+    passed: uint32
+    proofs: uint32
+    total_plots: uint32
+    lookup_time: uint64
+
+
+@streamable
+@dataclass(frozen=True)
+class SignedValues(Streamable):
+    quality_string: bytes32
+    foliage_block_data_signature: G2Element
+    foliage_transaction_block_signature: G2Element

chia/protocols/full_node_protocol.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
+from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
+from chia.types.full_block import FullBlock
+from chia.types.peer_info import TimestampedPeerInfo
+from chia.types.spend_bundle import SpendBundle
+from chia.types.unfinished_block import UnfinishedBlock
+from chia.types.weight_proof import WeightProof
+from chia.util.ints import uint8, uint32, uint64, uint128
+from chia.util.streamable import Streamable, streamable
+
+"""
+Protocol between full nodes.
+Note: When changing this file, also change protocol_message_types.py, and the protocol version in shared_protocol.py
+"""
+
+
+@streamable
+@dataclass(frozen=True)
+class NewPeak(Streamable):
+    header_hash: bytes32
+    height: uint32
+    weight: uint128
+    fork_point_with_previous_peak: uint32
+    unfinished_reward_block_hash: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class NewTransaction(Streamable):
+    transaction_id: bytes32
+    cost: uint64
+    fees: uint64
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestTransaction(Streamable):
+    transaction_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondTransaction(Streamable):
+    transaction: SpendBundle
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestProofOfWeight(Streamable):
+    total_number_of_blocks: uint32
+    tip: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondProofOfWeight(Streamable):
+    wp: WeightProof
+    tip: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestBlock(Streamable):
+    height: uint32
+    include_transaction_block: bool
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectBlock(Streamable):
+    height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestBlocks(Streamable):
+    start_height: uint32
+    end_height: uint32
+    include_transaction_block: bool
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondBlocks(Streamable):
+    start_height: uint32
+    end_height: uint32
+    blocks: list[FullBlock]
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectBlocks(Streamable):
+    start_height: uint32
+    end_height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondBlock(Streamable):
+    block: FullBlock
+
+
+@streamable
+@dataclass(frozen=True)
+class NewUnfinishedBlock(Streamable):
+    unfinished_reward_hash: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestUnfinishedBlock(Streamable):
+    unfinished_reward_hash: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class NewUnfinishedBlock2(Streamable):
+    unfinished_reward_hash: bytes32
+    foliage_hash: Optional[bytes32]
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestUnfinishedBlock2(Streamable):
+    unfinished_reward_hash: bytes32
+    foliage_hash: Optional[bytes32]
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondUnfinishedBlock(Streamable):
+    unfinished_block: UnfinishedBlock
+
+
+@streamable
+@dataclass(frozen=True)
+class NewSignagePointOrEndOfSubSlot(Streamable):
+    prev_challenge_hash: Optional[bytes32]
+    challenge_hash: bytes32
+    index_from_challenge: uint8
+    last_rc_infusion: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestSignagePointOrEndOfSubSlot(Streamable):
+    challenge_hash: bytes32
+    index_from_challenge: uint8
+    last_rc_infusion: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondSignagePoint(Streamable):
+    index_from_challenge: uint8
+    challenge_chain_vdf: VDFInfo
+    challenge_chain_proof: VDFProof
+    reward_chain_vdf: VDFInfo
+    reward_chain_proof: VDFProof
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondEndOfSubSlot(Streamable):
+    end_of_slot_bundle: EndOfSubSlotBundle
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestMempoolTransactions(Streamable):
+    filter: bytes
+
+
+@streamable
+@dataclass(frozen=True)
+class NewCompactVDF(Streamable):
+    height: uint32
+    header_hash: bytes32
+    field_vdf: uint8
+    vdf_info: VDFInfo
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestCompactVDF(Streamable):
+    height: uint32
+    header_hash: bytes32
+    field_vdf: uint8
+    vdf_info: VDFInfo
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondCompactVDF(Streamable):
+    height: uint32
+    header_hash: bytes32
+    field_vdf: uint8
+    vdf_info: VDFInfo
+    vdf_proof: VDFProof
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestPeers(Streamable):
+    """
+    Return full list of peers
+    """
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondPeers(Streamable):
+    peer_list: list[TimestampedPeerInfo]