chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/protocols/harvester_protocol.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Optional
+
+from chia_rs import G1Element, G2Element
+
+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.util.ints import int16, uint8, uint32, uint64
+from chia.util.streamable import Streamable, streamable
+
+"""
+Protocol between harvester and farmer.
+Note: When changing this file, also change protocol_message_types.py, and the protocol version in shared_protocol.py
+"""
+
+
+@streamable
+@dataclass(frozen=True)
+class PoolDifficulty(Streamable):
+    difficulty: uint64
+    sub_slot_iters: uint64
+    pool_contract_puzzle_hash: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class HarvesterHandshake(Streamable):
+    farmer_public_keys: list[G1Element]
+    pool_public_keys: list[G1Element]
+
+
+@streamable
+@dataclass(frozen=True)
+class NewSignagePointHarvester(Streamable):
+    challenge_hash: bytes32
+    difficulty: uint64
+    sub_slot_iters: uint64
+    signage_point_index: uint8
+    sp_hash: bytes32
+    pool_difficulties: list[PoolDifficulty]
+    filter_prefix_bits: uint8
+
+
+@streamable
+@dataclass(frozen=True)
+class ProofOfSpaceFeeInfo(Streamable):
+    applied_fee_threshold: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class NewProofOfSpace(Streamable):
+    challenge_hash: bytes32
+    sp_hash: bytes32
+    plot_identifier: str
+    proof: ProofOfSpace
+    signage_point_index: uint8
+    include_source_signature_data: bool
+    farmer_reward_address_override: Optional[bytes32]
+    fee_info: Optional[ProofOfSpaceFeeInfo]
+
+
+# Source data corresponding to the hash that is sent to the Harvester for signing
+class SigningDataKind(IntEnum):
+    FOLIAGE_BLOCK_DATA = 1
+    FOLIAGE_TRANSACTION_BLOCK = 2
+    CHALLENGE_CHAIN_VDF = 3
+    REWARD_CHAIN_VDF = 4
+    CHALLENGE_CHAIN_SUB_SLOT = 5
+    REWARD_CHAIN_SUB_SLOT = 6
+    PARTIAL = 7
+
+
+@streamable
+@dataclass(frozen=True)
+class SignatureRequestSourceData(Streamable):
+    kind: uint8
+    data: bytes
+
+
+# message_data elements are optional as FoliageTransactionBlock may not always be present in
+# the case of the UnfinishedBlock not being a transaction block.
+@streamable
+@dataclass(frozen=True)
+class RequestSignatures(Streamable):
+    plot_identifier: str
+    challenge_hash: bytes32
+    sp_hash: bytes32
+    messages: list[bytes32]
+    # This, and rc_block_unfinished are only set when using a third-party harvester (see CHIP-22)
+    message_data: Optional[list[Optional[SignatureRequestSourceData]]]
+    rc_block_unfinished: Optional[RewardChainBlockUnfinished]
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondSignatures(Streamable):
+    plot_identifier: str
+    challenge_hash: bytes32
+    sp_hash: bytes32
+    local_pk: G1Element
+    farmer_pk: G1Element
+    message_signatures: list[tuple[bytes32, G2Element]]
+    include_source_signature_data: bool
+    farmer_reward_address_override: Optional[bytes32]
+
+
+@streamable
+@dataclass(frozen=True)
+class Plot(Streamable):
+    filename: str
+    size: uint8
+    plot_id: bytes32
+    pool_public_key: Optional[G1Element]
+    pool_contract_puzzle_hash: Optional[bytes32]
+    plot_public_key: G1Element
+    file_size: uint64
+    time_modified: uint64
+    compression_level: Optional[uint8]
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestPlots(Streamable):
+    pass
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondPlots(Streamable):
+    plots: list[Plot]
+    failed_to_open_filenames: list[str]
+    no_key_filenames: list[str]
+
+
+@streamable
+@dataclass(frozen=True)
+class PlotSyncIdentifier(Streamable):
+    timestamp: uint64
+    sync_id: uint64
+    message_id: uint64
+
+
+@streamable
+@dataclass(frozen=True)
+class PlotSyncStart(Streamable):
+    identifier: PlotSyncIdentifier
+    initial: bool
+    last_sync_id: uint64
+    plot_file_count: uint32
+    harvesting_mode: uint8
+
+    def __str__(self) -> str:
+        return (
+            f"PlotSyncStart: identifier {self.identifier}, initial {self.initial}, "
+            f"last_sync_id {self.last_sync_id}, plot_file_count {self.plot_file_count}, "
+            f"harvesting_mode {self.harvesting_mode}"
+        )
+
+
+@streamable
+@dataclass(frozen=True)
+class PlotSyncPathList(Streamable):
+    identifier: PlotSyncIdentifier
+    data: list[str]
+    final: bool
+
+    def __str__(self) -> str:
+        return f"PlotSyncPathList: identifier {self.identifier}, count {len(self.data)}, final {self.final}"
+
+
+@streamable
+@dataclass(frozen=True)
+class PlotSyncPlotList(Streamable):
+    identifier: PlotSyncIdentifier
+    data: list[Plot]
+    final: bool
+
+    def __str__(self) -> str:
+        return f"PlotSyncPlotList: identifier {self.identifier}, count {len(self.data)}, final {self.final}"
+
+
+@streamable
+@dataclass(frozen=True)
+class PlotSyncDone(Streamable):
+    identifier: PlotSyncIdentifier
+    duration: uint64
+
+    def __str__(self) -> str:
+        return f"PlotSyncDone: identifier {self.identifier}, duration {self.duration}"
+
+
+@streamable
+@dataclass(frozen=True)
+class PlotSyncError(Streamable):
+    code: int16
+    message: str
+    expected_identifier: Optional[PlotSyncIdentifier]
+
+    def __str__(self) -> str:
+        return f"PlotSyncError: code {self.code}, count {self.message}, expected_identifier {self.expected_identifier}"
+
+
+@streamable
+@dataclass(frozen=True)
+class PlotSyncResponse(Streamable):
+    identifier: PlotSyncIdentifier
+    message_type: int16
+    error: Optional[PlotSyncError]
+
+    def __str__(self) -> str:
+        return f"PlotSyncResponse: identifier {self.identifier}, message_type {self.message_type}, error {self.error}"

chia/protocols/introducer_protocol.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from chia.types.peer_info import TimestampedPeerInfo
+from chia.util.streamable import Streamable, streamable
+
+"""
+Protocol to introducer
+Note: When changing this file, also change protocol_message_types.py, and the protocol version in shared_protocol.py
+"""
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestPeersIntroducer(Streamable):
+    """
+    Return full list of peers
+    """
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondPeersIntroducer(Streamable):
+    peer_list: list[TimestampedPeerInfo]

chia/protocols/pool_protocol.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+from chia_rs import G1Element, G2Element
+
+from chia.types.blockchain_format.proof_of_space import ProofOfSpace
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint8, uint16, uint32, uint64
+from chia.util.streamable import Streamable, streamable
+
+POOL_PROTOCOL_VERSION = uint8(1)
+
+
+class PoolErrorCode(Enum):
+    REVERTED_SIGNAGE_POINT = 1
+    TOO_LATE = 2
+    NOT_FOUND = 3
+    INVALID_PROOF = 4
+    PROOF_NOT_GOOD_ENOUGH = 5
+    INVALID_DIFFICULTY = 6
+    INVALID_SIGNATURE = 7
+    SERVER_EXCEPTION = 8
+    INVALID_P2_SINGLETON_PUZZLE_HASH = 9
+    FARMER_NOT_KNOWN = 10
+    FARMER_ALREADY_KNOWN = 11
+    INVALID_AUTHENTICATION_TOKEN = 12
+    INVALID_PAYOUT_INSTRUCTIONS = 13
+    INVALID_SINGLETON = 14
+    DELAY_TIME_TOO_SHORT = 15
+    REQUEST_FAILED = 16
+
+
+# Used to verify GET /farmer and GET /login
+@streamable
+@dataclass(frozen=True)
+class AuthenticationPayload(Streamable):
+    method_name: str
+    launcher_id: bytes32
+    target_puzzle_hash: bytes32
+    authentication_token: uint64
+
+
+# GET /pool_info
+@streamable
+@dataclass(frozen=True)
+class GetPoolInfoResponse(Streamable):
+    name: str
+    logo_url: str
+    minimum_difficulty: uint64
+    relative_lock_height: uint32
+    protocol_version: uint8
+    fee: str
+    description: str
+    target_puzzle_hash: bytes32
+    authentication_token_timeout: uint8
+
+
+# POST /partial
+
+
+@streamable
+@dataclass(frozen=True)
+class PostPartialPayload(Streamable):
+    launcher_id: bytes32
+    authentication_token: uint64
+    proof_of_space: ProofOfSpace
+    sp_hash: bytes32
+    end_of_sub_slot: bool
+    harvester_id: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class PostPartialRequest(Streamable):
+    payload: PostPartialPayload
+    aggregate_signature: G2Element
+
+
+# Response in success case
+@streamable
+@dataclass(frozen=True)
+class PostPartialResponse(Streamable):
+    new_difficulty: uint64
+
+
+# GET /farmer
+
+
+# Response in success case
+@streamable
+@dataclass(frozen=True)
+class GetFarmerResponse(Streamable):
+    authentication_public_key: G1Element
+    payout_instructions: str
+    current_difficulty: uint64
+    current_points: uint64
+
+
+# POST /farmer
+
+
+@streamable
+@dataclass(frozen=True)
+class PostFarmerPayload(Streamable):
+    launcher_id: bytes32
+    authentication_token: uint64
+    authentication_public_key: G1Element
+    payout_instructions: str
+    suggested_difficulty: Optional[uint64]
+
+
+@streamable
+@dataclass(frozen=True)
+class PostFarmerRequest(Streamable):
+    payload: PostFarmerPayload
+    signature: G2Element
+
+
+# Response in success case
+@streamable
+@dataclass(frozen=True)
+class PostFarmerResponse(Streamable):
+    welcome_message: str
+
+
+# PUT /farmer
+
+
+@streamable
+@dataclass(frozen=True)
+class PutFarmerPayload(Streamable):
+    launcher_id: bytes32
+    authentication_token: uint64
+    authentication_public_key: Optional[G1Element]
+    payout_instructions: Optional[str]
+    suggested_difficulty: Optional[uint64]
+
+
+@streamable
+@dataclass(frozen=True)
+class PutFarmerRequest(Streamable):
+    payload: PutFarmerPayload
+    signature: G2Element
+
+
+# Response in success case
+@streamable
+@dataclass(frozen=True)
+class PutFarmerResponse(Streamable):
+    authentication_public_key: Optional[bool]
+    payout_instructions: Optional[bool]
+    suggested_difficulty: Optional[bool]
+
+
+# Misc
+
+
+# Response in error case for all endpoints of the pool protocol
+@streamable
+@dataclass(frozen=True)
+class ErrorResponse(Streamable):
+    error_code: uint16
+    error_message: Optional[str]
+
+
+# Get the current authentication token according to "Farmer authentication" in SPECIFICATION.md
+def get_current_authentication_token(timeout: uint8) -> uint64:
+    return uint64(int(int(time.time() / 60) / timeout))
+
+
+# Validate a given authentication token against our local time
+def validate_authentication_token(token: uint64, timeout: uint8) -> bool:
+    return abs(token - get_current_authentication_token(timeout)) <= timeout

chia/protocols/protocol_message_types.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class ProtocolMessageTypes(Enum):
+    # Shared protocol (all services)
+    handshake = 1
+
+    # Harvester protocol (harvester <-> farmer)
+    harvester_handshake = 3
+    # new_signage_point_harvester = 4 Changed to 66 in new protocol
+    new_proof_of_space = 5
+    request_signatures = 6
+    respond_signatures = 7
+
+    # Farmer protocol (farmer <-> full_node)
+    new_signage_point = 8
+    declare_proof_of_space = 9
+    request_signed_values = 10
+    signed_values = 11
+    farming_info = 12
+
+    # Timelord protocol (timelord <-> full_node)
+    new_peak_timelord = 13
+    new_unfinished_block_timelord = 14
+    new_infusion_point_vdf = 15
+    new_signage_point_vdf = 16
+    new_end_of_sub_slot_vdf = 17
+    request_compact_proof_of_time = 18
+    respond_compact_proof_of_time = 19
+
+    # Full node protocol (full_node <-> full_node)
+    new_peak = 20
+    new_transaction = 21
+    request_transaction = 22
+    respond_transaction = 23
+    request_proof_of_weight = 24
+    respond_proof_of_weight = 25
+    request_block = 26
+    respond_block = 27
+    reject_block = 28
+    request_blocks = 29
+    respond_blocks = 30
+    reject_blocks = 31
+    new_unfinished_block = 32
+    request_unfinished_block = 33
+    respond_unfinished_block = 34
+    new_signage_point_or_end_of_sub_slot = 35
+    request_signage_point_or_end_of_sub_slot = 36
+    respond_signage_point = 37
+    respond_end_of_sub_slot = 38
+    request_mempool_transactions = 39
+    request_compact_vdf = 40
+    respond_compact_vdf = 41
+    new_compact_vdf = 42
+    request_peers = 43
+    respond_peers = 44
+    none_response = 91
+
+    # Wallet protocol (wallet <-> full_node)
+    request_puzzle_solution = 45
+    respond_puzzle_solution = 46
+    reject_puzzle_solution = 47
+    send_transaction = 48
+    transaction_ack = 49
+    new_peak_wallet = 50
+    request_block_header = 51
+    respond_block_header = 52
+    reject_header_request = 53
+    request_removals = 54
+    respond_removals = 55
+    reject_removals_request = 56
+    request_additions = 57
+    respond_additions = 58
+    reject_additions_request = 59
+    request_header_blocks = 60
+    reject_header_blocks = 61
+    respond_header_blocks = 62
+
+    # Introducer protocol (introducer <-> full_node)
+    request_peers_introducer = 63
+    respond_peers_introducer = 64
+
+    # Simulator protocol
+    farm_new_block = 65
+
+    # New harvester protocol
+    new_signage_point_harvester = 66
+    request_plots = 67
+    respond_plots = 68
+    plot_sync_start = 78
+    plot_sync_loaded = 79
+    plot_sync_removed = 80
+    plot_sync_invalid = 81
+    plot_sync_keys_missing = 82
+    plot_sync_duplicates = 83
+    plot_sync_done = 84
+    plot_sync_response = 85
+
+    # More wallet protocol
+    coin_state_update = 69
+    register_for_ph_updates = 70
+    respond_to_ph_updates = 71
+    register_for_coin_updates = 72
+    respond_to_coin_updates = 73
+    request_children = 74
+    respond_children = 75
+    request_ses_hashes = 76
+    respond_ses_hashes = 77
+    request_block_headers = 86
+    reject_block_headers = 87
+    respond_block_headers = 88
+    request_fee_estimates = 89
+    respond_fee_estimates = 90
+
+    # new Full Node protocol messages
+    new_unfinished_block2 = 92
+    request_unfinished_block2 = 93
+
+    # New wallet sync protocol
+    request_remove_puzzle_subscriptions = 94
+    respond_remove_puzzle_subscriptions = 95
+    request_remove_coin_subscriptions = 96
+    respond_remove_coin_subscriptions = 97
+    request_puzzle_state = 98
+    respond_puzzle_state = 99
+    reject_puzzle_state = 100
+    request_coin_state = 101
+    respond_coin_state = 102
+    reject_coin_state = 103
+
+    # Wallet protocol mempool updates
+    mempool_items_added = 104
+    mempool_items_removed = 105
+    request_cost_info = 106
+    respond_cost_info = 107
+
+    error = 255

chia/protocols/protocol_state_machine.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.protocols.protocol_message_types import ProtocolMessageTypes as pmt
+
+NO_REPLY_EXPECTED = [
+    # full_node -> full_node messages
+    pmt.new_peak,
+    pmt.new_transaction,
+    pmt.new_unfinished_block,
+    pmt.new_unfinished_block2,
+    pmt.new_signage_point_or_end_of_sub_slot,
+    pmt.request_mempool_transactions,
+    pmt.new_compact_vdf,
+    pmt.coin_state_update,
+    pmt.mempool_items_added,
+    pmt.mempool_items_removed,
+]
+
+"""
+VALID_REPLY_MESSAGE_MAP:
+key: sent message type.
+value: valid reply message types, from the view of the requester.
+A state machine can be built from this message map.
+"""
+
+VALID_REPLY_MESSAGE_MAP = {
+    # messages for all services
+    # pmt.handshake is handled in WSChiaConnection.perform_handshake
+    # full_node -> full_node protocol messages
+    pmt.request_transaction: [pmt.respond_transaction],
+    pmt.request_proof_of_weight: [pmt.respond_proof_of_weight],
+    pmt.request_block: [pmt.respond_block, pmt.reject_block],
+    pmt.request_blocks: [pmt.respond_blocks, pmt.reject_blocks],
+    pmt.request_unfinished_block: [pmt.respond_unfinished_block],
+    pmt.request_unfinished_block2: [pmt.respond_unfinished_block],
+    pmt.request_block_header: [pmt.respond_block_header, pmt.reject_header_request],
+    pmt.request_removals: [pmt.respond_removals, pmt.reject_removals_request],
+    pmt.request_additions: [pmt.respond_additions, pmt.reject_additions_request],
+    pmt.request_signage_point_or_end_of_sub_slot: [pmt.respond_signage_point, pmt.respond_end_of_sub_slot],
+    pmt.request_compact_vdf: [pmt.respond_compact_vdf],
+    pmt.request_peers: [pmt.respond_peers],
+    pmt.request_header_blocks: [pmt.respond_header_blocks, pmt.reject_header_blocks, pmt.reject_block_headers],
+    pmt.register_for_ph_updates: [pmt.respond_to_ph_updates],
+    pmt.register_for_coin_updates: [pmt.respond_to_coin_updates],
+    pmt.request_children: [pmt.respond_children],
+    pmt.request_ses_hashes: [pmt.respond_ses_hashes],
+    pmt.request_block_headers: [pmt.respond_block_headers, pmt.reject_block_headers, pmt.reject_header_blocks],
+    pmt.request_peers_introducer: [pmt.respond_peers_introducer],
+    pmt.request_puzzle_solution: [pmt.respond_puzzle_solution, pmt.reject_puzzle_solution],
+    pmt.send_transaction: [pmt.transaction_ack],
+    pmt.request_remove_puzzle_subscriptions: [pmt.respond_remove_puzzle_subscriptions],
+    pmt.request_remove_coin_subscriptions: [pmt.respond_remove_coin_subscriptions],
+    pmt.request_puzzle_state: [pmt.respond_puzzle_state, pmt.reject_puzzle_state],
+    pmt.request_coin_state: [pmt.respond_coin_state, pmt.reject_coin_state],
+    pmt.request_cost_info: [pmt.respond_cost_info],
+}
+
+
+def static_check_sent_message_response() -> None:
+    """Check that allowed message data structures VALID_REPLY_MESSAGE_MAP and NO_REPLY_EXPECTED are consistent."""
+    # Reply and non-reply sets should not overlap: This check should be static
+    overlap = set(NO_REPLY_EXPECTED).intersection(set(VALID_REPLY_MESSAGE_MAP.keys()))
+    if len(overlap) != 0:
+        raise AssertionError(f"Overlapping NO_REPLY_EXPECTED and VALID_REPLY_MESSAGE_MAP values: {overlap}")
+
+
+def message_requires_reply(sent: ProtocolMessageTypes) -> bool:
+    """Return True if message has an entry in the full node P2P message map"""
+    # If we knew the peer NodeType is FULL_NODE, we could also check `sent not in NO_REPLY_EXPECTED`
+    return sent in VALID_REPLY_MESSAGE_MAP
+
+
+def message_response_ok(sent: ProtocolMessageTypes, received: ProtocolMessageTypes) -> bool:
+    """
+    Check to see that peers respect protocol message types in reply.
+    Call with received == None to indicate that we do not expect a specific reply message type.
+    """
+    # Errors below are runtime protocol message mismatches from peers
+    if sent in VALID_REPLY_MESSAGE_MAP:
+        return received in VALID_REPLY_MESSAGE_MAP[sent]
+
+    return True
+
+
+# Run `static_check_sent_message_response` to check this static invariant at import time
+static_check_sent_message_response()

chia/protocols/protocol_timing.py

@@ -0,0 +1,8 @@
+# These settings should not be end-user configurable
+from __future__ import annotations
+
+INVALID_PROTOCOL_BAN_SECONDS = 10
+API_EXCEPTION_BAN_SECONDS = 10
+INTERNAL_PROTOCOL_ERROR_BAN_SECONDS = 10  # Don't flap if our client is at fault
+CONSENSUS_ERROR_BAN_SECONDS = 600
+RATE_LIMITER_BAN_SECONDS = 300