chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/protocols/shared_protocol.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Optional
+
+from chia.server.outbound_message import NodeType
+from chia.util.ints import int16, uint8, uint16
+from chia.util.streamable import Streamable, streamable
+
+protocol_version = {
+    NodeType.FULL_NODE: "0.0.36",
+    NodeType.HARVESTER: "0.0.36",
+    NodeType.FARMER: "0.0.36",
+    NodeType.TIMELORD: "0.0.36",
+    NodeType.INTRODUCER: "0.0.36",
+    NodeType.WALLET: "0.0.38",
+    NodeType.DATA_LAYER: "0.0.36",
+}
+
+"""
+Handshake when establishing a connection between two servers.
+Note: When changing this file, also change protocol_message_types.py
+"""
+
+
+# Capabilities can be added here when new features are added to the protocol
+# These are passed in as uint16 into the Handshake
+class Capability(IntEnum):
+    BASE = 1  # Base capability just means it supports the chia protocol at mainnet
+    # introduces RequestBlockHeaders, which is a faster API for fetching header blocks
+    # !! the old API is *RequestHeaderBlock* !!
+    BLOCK_HEADERS = 2
+    # Specifies support for v1 and v2 versions of rate limits. Peers will use the lowest shared capability:
+    # if peer A support v3 and peer B supports v2, they should send:
+    # (BASE, RATE_LIMITS_V2, RATE_LIMITS_V3), and (BASE, RATE_LIMITS_V2) respectively. They will use the V2 limits.
+    RATE_LIMITS_V2 = 3
+
+    # a node can handle a None response and not wait the full timeout
+    # capability removed but functionality is still supported
+    NONE_RESPONSE = 4
+
+    # Opts in to receiving mempool updates for subscribed transactions
+    # This is between a full node and receiving wallet
+    MEMPOOL_UPDATES = 5
+
+
+# These are the default capabilities used in all outgoing handshakes.
+# "1" means the capability is supported and enabled.
+_capabilities: list[tuple[uint16, str]] = [
+    (uint16(Capability.BASE.value), "1"),
+    (uint16(Capability.BLOCK_HEADERS.value), "1"),
+    (uint16(Capability.RATE_LIMITS_V2.value), "1"),
+]
+_mempool_updates = [
+    (uint16(Capability.MEMPOOL_UPDATES.value), "1"),
+]
+
+default_capabilities = {
+    NodeType.FULL_NODE: _capabilities + _mempool_updates,
+    NodeType.HARVESTER: _capabilities,
+    NodeType.FARMER: _capabilities,
+    NodeType.TIMELORD: _capabilities,
+    NodeType.INTRODUCER: _capabilities,
+    NodeType.WALLET: _capabilities,
+    NodeType.DATA_LAYER: _capabilities,
+}
+
+
+@streamable
+@dataclass(frozen=True)
+class Handshake(Streamable):
+    network_id: str
+    protocol_version: str
+    software_version: str
+    server_port: uint16
+    node_type: uint8
+    capabilities: list[tuple[uint16, str]]
+
+
+@streamable
+@dataclass(frozen=True)
+class Error(Streamable):
+    code: int16  # Err
+    message: str
+    data: Optional[bytes] = None

chia/protocols/timelord_protocol.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from chia.types.blockchain_format.foliage import Foliage
+from chia.types.blockchain_format.reward_chain_block import RewardChainBlock, RewardChainBlockUnfinished
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
+from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
+from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
+from chia.util.ints import uint8, uint32, uint64, uint128
+from chia.util.streamable import Streamable, streamable
+
+"""
+Protocol between timelord 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 NewPeakTimelord(Streamable):
+    reward_chain_block: RewardChainBlock
+    difficulty: uint64
+    deficit: uint8
+    sub_slot_iters: uint64  # SSi in the slot where NewPeak has been infused
+    sub_epoch_summary: Optional[
+        SubEpochSummary
+    ]  # If NewPeak is the last slot in epoch, the next slot should include this
+    previous_reward_challenges: list[tuple[bytes32, uint128]]
+    last_challenge_sb_or_eos_total_iters: uint128
+    passes_ses_height_but_not_yet_included: bool
+
+
+@streamable
+@dataclass(frozen=True)
+class NewUnfinishedBlockTimelord(Streamable):
+    reward_chain_block: RewardChainBlockUnfinished  # Reward chain trunk data
+    difficulty: uint64
+    sub_slot_iters: uint64  # SSi in the slot where block is infused
+    foliage: Foliage  # Reward chain foliage data
+    sub_epoch_summary: Optional[SubEpochSummary]  # If this is the last slot in epoch, the next slot should include this
+    # This is the last thing infused in the reward chain before this signage point.
+    # The challenge that the SP reward chain VDF is based off of, or in the case of sp index 0, the previous infusion
+    rc_prev: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class NewInfusionPointVDF(Streamable):
+    unfinished_reward_hash: bytes32
+    challenge_chain_ip_vdf: VDFInfo
+    challenge_chain_ip_proof: VDFProof
+    reward_chain_ip_vdf: VDFInfo
+    reward_chain_ip_proof: VDFProof
+    infused_challenge_chain_ip_vdf: Optional[VDFInfo]
+    infused_challenge_chain_ip_proof: Optional[VDFProof]
+
+
+@streamable
+@dataclass(frozen=True)
+class NewSignagePointVDF(Streamable):
+    index_from_challenge: uint8
+    challenge_chain_sp_vdf: VDFInfo
+    challenge_chain_sp_proof: VDFProof
+    reward_chain_sp_vdf: VDFInfo
+    reward_chain_sp_proof: VDFProof
+
+
+@streamable
+@dataclass(frozen=True)
+class NewEndOfSubSlotVDF(Streamable):
+    end_of_sub_slot_bundle: EndOfSubSlotBundle
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestCompactProofOfTime(Streamable):
+    new_proof_of_time: VDFInfo
+    header_hash: bytes32
+    height: uint32
+    field_vdf: uint8
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondCompactProofOfTime(Streamable):
+    vdf_info: VDFInfo
+    vdf_proof: VDFProof
+    header_hash: bytes32
+    height: uint32
+    field_vdf: uint8

chia/protocols/wallet_protocol.py

@@ -0,0 +1,401 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Optional
+
+import chia_rs
+
+from chia.full_node.fee_estimate import FeeEstimateGroup
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.header_block import HeaderBlock
+from chia.types.spend_bundle import SpendBundle
+from chia.util.ints import uint8, uint32, uint64, uint128
+from chia.util.streamable import Streamable, streamable
+
+"""
+Protocol between wallet (SPV node) and full node.
+Note: When changing this file, also change protocol_message_types.py, and the protocol version in shared_protocol.py
+"""
+
+
+CoinState = chia_rs.CoinState
+RespondToPhUpdates = chia_rs.RespondToPhUpdates
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestPuzzleSolution(Streamable):
+    coin_name: bytes32
+    height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class PuzzleSolutionResponse(Streamable):
+    coin_name: bytes32
+    height: uint32
+    puzzle: SerializedProgram
+    solution: SerializedProgram
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondPuzzleSolution(Streamable):
+    response: PuzzleSolutionResponse
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectPuzzleSolution(Streamable):
+    coin_name: bytes32
+    height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class SendTransaction(Streamable):
+    transaction: SpendBundle
+
+
+@streamable
+@dataclass(frozen=True)
+class TransactionAck(Streamable):
+    txid: bytes32
+    status: uint8  # MempoolInclusionStatus
+    error: Optional[str]
+
+
+@streamable
+@dataclass(frozen=True)
+class NewPeakWallet(Streamable):
+    header_hash: bytes32
+    height: uint32
+    weight: uint128
+    fork_point_with_previous_peak: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestBlockHeader(Streamable):
+    height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondBlockHeader(Streamable):
+    header_block: HeaderBlock
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectHeaderRequest(Streamable):
+    height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestRemovals(Streamable):
+    height: uint32
+    header_hash: bytes32
+    coin_names: Optional[list[bytes32]]
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondRemovals(Streamable):
+    height: uint32
+    header_hash: bytes32
+    coins: list[tuple[bytes32, Optional[Coin]]]
+    proofs: Optional[list[tuple[bytes32, bytes]]]
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectRemovalsRequest(Streamable):
+    height: uint32
+    header_hash: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestAdditions(Streamable):
+    height: uint32
+    header_hash: Optional[bytes32]
+    puzzle_hashes: Optional[list[bytes32]]
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondAdditions(Streamable):
+    height: uint32
+    header_hash: bytes32
+    coins: list[tuple[bytes32, list[Coin]]]
+    proofs: Optional[list[tuple[bytes32, bytes, Optional[bytes]]]]
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectAdditionsRequest(Streamable):
+    height: uint32
+    header_hash: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondBlockHeaders(Streamable):
+    start_height: uint32
+    end_height: uint32
+    header_blocks: list[HeaderBlock]
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectBlockHeaders(Streamable):
+    start_height: uint32
+    end_height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestBlockHeaders(Streamable):
+    start_height: uint32
+    end_height: uint32
+    return_filter: bool
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestHeaderBlocks(Streamable):
+    start_height: uint32
+    end_height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectHeaderBlocks(Streamable):
+    start_height: uint32
+    end_height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondHeaderBlocks(Streamable):
+    start_height: uint32
+    end_height: uint32
+    header_blocks: list[HeaderBlock]
+
+
+# This class is implemented in Rust
+# @streamable
+# @dataclass(frozen=True)
+# class CoinState(Streamable):
+#    coin: Coin
+#    spent_height: Optional[uint32]
+#    created_height: Optional[uint32]
+
+
+@streamable
+@dataclass(frozen=True)
+class RegisterForPhUpdates(Streamable):
+    puzzle_hashes: list[bytes32]
+    min_height: uint32
+
+
+# This class is implemented in Rust
+# @streamable
+# @dataclass(frozen=True)
+# class RespondToPhUpdates(Streamable):
+#    puzzle_hashes: list[bytes32]
+#    min_height: uint32
+#    coin_states: list[CoinState]
+
+
+@streamable
+@dataclass(frozen=True)
+class RegisterForCoinUpdates(Streamable):
+    coin_ids: list[bytes32]
+    min_height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondToCoinUpdates(Streamable):
+    coin_ids: list[bytes32]
+    min_height: uint32
+    coin_states: list[CoinState]
+
+
+@streamable
+@dataclass(frozen=True)
+class CoinStateUpdate(Streamable):
+    height: uint32
+    fork_height: uint32
+    peak_hash: bytes32
+    items: list[CoinState]
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestChildren(Streamable):
+    coin_name: bytes32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondChildren(Streamable):
+    coin_states: list[CoinState]
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestSESInfo(Streamable):
+    start_height: uint32
+    end_height: uint32
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondSESInfo(Streamable):
+    reward_chain_hash: list[bytes32]
+    heights: list[list[uint32]]
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestFeeEstimates(Streamable):
+    """
+    time_targets (list[uint64]): Epoch timestamps in seconds to estimate FeeRates for.
+    """
+
+    time_targets: list[uint64]
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondFeeEstimates(Streamable):
+    estimates: FeeEstimateGroup
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestRemovePuzzleSubscriptions(Streamable):
+    puzzle_hashes: Optional[list[bytes32]]
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondRemovePuzzleSubscriptions(Streamable):
+    puzzle_hashes: list[bytes32]
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestRemoveCoinSubscriptions(Streamable):
+    coin_ids: Optional[list[bytes32]]
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondRemoveCoinSubscriptions(Streamable):
+    coin_ids: list[bytes32]
+
+
+@streamable
+@dataclass(frozen=True)
+class CoinStateFilters(Streamable):
+    include_spent: bool
+    include_unspent: bool
+    include_hinted: bool
+    min_amount: uint64
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestPuzzleState(Streamable):
+    puzzle_hashes: list[bytes32]
+    previous_height: Optional[uint32]
+    header_hash: bytes32
+    filters: CoinStateFilters
+    subscribe_when_finished: bool
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondPuzzleState(Streamable):
+    puzzle_hashes: list[bytes32]
+    height: uint32
+    header_hash: bytes32
+    is_finished: bool
+    coin_states: list[CoinState]
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectPuzzleState(Streamable):
+    reason: uint8  # RejectStateReason
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestCoinState(Streamable):
+    coin_ids: list[bytes32]
+    previous_height: Optional[uint32]
+    header_hash: bytes32
+    subscribe: bool
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondCoinState(Streamable):
+    coin_ids: list[bytes32]
+    coin_states: list[CoinState]
+
+
+@streamable
+@dataclass(frozen=True)
+class RejectCoinState(Streamable):
+    reason: uint8  # RejectStateReason
+
+
+class RejectStateReason(IntEnum):
+    REORG = 0
+    EXCEEDED_SUBSCRIPTION_LIMIT = 1
+
+
+@streamable
+@dataclass(frozen=True)
+class RemovedMempoolItem(Streamable):
+    transaction_id: bytes32
+    reason: uint8  # MempoolRemoveReason
+
+
+@streamable
+@dataclass(frozen=True)
+class MempoolItemsAdded(Streamable):
+    transaction_ids: list[bytes32]
+
+
+@streamable
+@dataclass(frozen=True)
+class MempoolItemsRemoved(Streamable):
+    removed_items: list[RemovedMempoolItem]
+
+
+@streamable
+@dataclass(frozen=True)
+class RequestCostInfo(Streamable):
+    pass
+
+
+@streamable
+@dataclass(frozen=True)
+class RespondCostInfo(Streamable):
+    max_transaction_cost: uint64
+    max_block_cost: uint64
+    max_mempool_cost: uint64
+    mempool_cost: uint64
+    mempool_fee: uint64
+    bump_fee_per_cost: uint8

chia/rpc/crawler_rpc_api.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import ipaddress
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
+from chia.rpc.rpc_server import Endpoint, EndpointResult
+from chia.seeder.crawler import Crawler
+from chia.util.ws_message import WsRpcMessage, create_payload_dict
+
+
+class CrawlerRpcApi:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcApiProtocol
+
+        _protocol_check: ClassVar[RpcApiProtocol] = cast("CrawlerRpcApi", None)
+
+    def __init__(self, crawler: Crawler):
+        self.service = crawler
+        self.service_name = "chia_crawler"
+
+    def get_routes(self) -> dict[str, Endpoint]:
+        return {
+            "/get_peer_counts": self.get_peer_counts,
+            "/get_ips_after_timestamp": self.get_ips_after_timestamp,
+        }
+
+    async def _state_changed(self, change: str, change_data: Optional[dict[str, Any]] = None) -> list[WsRpcMessage]:
+        payloads = []
+
+        if change_data is None:
+            change_data = await self.get_peer_counts({})
+
+        if change in {"crawl_batch_completed", "loaded_initial_peers"}:
+            payloads.append(create_payload_dict(change, change_data, self.service_name, "metrics"))
+
+        return payloads
+
+    async def get_peer_counts(self, _request: dict[str, Any]) -> EndpointResult:
+        ipv6_addresses_count = 0
+        for host in self.service.best_timestamp_per_peer.keys():
+            try:
+                ipaddress.IPv6Address(host)
+                ipv6_addresses_count += 1
+            except ipaddress.AddressValueError:
+                continue
+
+        reliable_peers = 0
+        if self.service.crawl_store is not None:
+            reliable_peers = self.service.crawl_store.get_reliable_peers()
+
+        data = {
+            "peer_counts": {
+                "total_last_5_days": len(self.service.best_timestamp_per_peer),
+                "reliable_nodes": reliable_peers,
+                "ipv4_last_5_days": len(self.service.best_timestamp_per_peer) - ipv6_addresses_count,
+                "ipv6_last_5_days": ipv6_addresses_count,
+                "versions": self.service.versions,
+            }
+        }
+        return data
+
+    async def get_ips_after_timestamp(self, _request: dict[str, Any]) -> EndpointResult:
+        after = _request.get("after", None)
+        if after is None:
+            raise ValueError("`after` is required and must be a unix timestamp")
+
+        offset = _request.get("offset", 0)
+        limit = _request.get("limit", 10000)
+
+        matched_ips: list[str] = []
+        for ip, timestamp in self.service.best_timestamp_per_peer.items():
+            if timestamp > after:
+                matched_ips.append(ip)
+
+        matched_ips.sort()
+
+        return {
+            "ips": matched_ips[offset : (offset + limit)],
+            "total": len(matched_ips),
+        }