chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/introducer/introducer.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+import time
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+
+from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
+from chia.server.introducer_peers import VettedPeer
+from chia.server.outbound_message import NodeType
+from chia.server.server import ChiaServer
+from chia.server.ws_connection import WSChiaConnection
+from chia.util.ints import uint64
+from chia.util.task_referencer import create_referenced_task
+
+
+class Introducer:
+    if TYPE_CHECKING:
+        from chia.rpc.rpc_server import RpcServiceProtocol
+
+        _protocol_check: ClassVar[RpcServiceProtocol] = cast("Introducer", None)
+
+    @property
+    def server(self) -> ChiaServer:
+        # This is a stop gap until the class usage is refactored such the values of
+        # integral attributes are known at creation of the instance.
+        if self._server is None:
+            raise RuntimeError("server not assigned")
+
+        return self._server
+
+    def __init__(self, max_peers_to_send: int, recent_peer_threshold: int):
+        self.max_peers_to_send = max_peers_to_send
+        self.recent_peer_threshold = recent_peer_threshold
+        self._shut_down = False
+        self._server: Optional[ChiaServer] = None
+        self.log = logging.getLogger(__name__)
+
+    @contextlib.asynccontextmanager
+    async def manage(self) -> AsyncIterator[None]:
+        self._vetting_task = create_referenced_task(self._vetting_loop())
+        try:
+            yield
+        finally:
+            self._shut_down = True
+            self._vetting_task.cancel()
+            # await self._vetting_task
+
+    async def on_connect(self, peer: WSChiaConnection) -> None:
+        pass
+
+    def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
+        # TODO: fill this out?
+        pass
+
+    def get_connections(self, request_node_type: Optional[NodeType]) -> list[dict[str, Any]]:
+        return default_get_connections(server=self.server, request_node_type=request_node_type)
+
+    def set_server(self, server: ChiaServer):
+        self._server = server
+
+    async def _vetting_loop(self):
+        while True:
+            if self._shut_down:
+                return None
+            try:
+                for i in range(60):
+                    if self._shut_down:
+                        return None
+                    await asyncio.sleep(1)
+                self.log.info("Vetting random peers.")
+                if self._server.introducer_peers is None:
+                    continue
+                raw_peers = self.server.introducer_peers.get_peers(100, True, 3 * self.recent_peer_threshold)
+
+                if len(raw_peers) == 0:
+                    continue
+
+                peer: VettedPeer
+                for peer in raw_peers:
+                    if self._shut_down:
+                        return None
+
+                    now = time.time()
+
+                    # if it was too long ago we checked this peer, check it
+                    # again
+                    if peer.vetted > 0 and now > peer.vetted_timestamp + 3600:
+                        peer.vetted = 0
+
+                    if peer.vetted > 0:
+                        continue
+
+                    # don't re-vet peers too frequently
+                    if now < peer.last_attempt + 500:
+                        continue
+
+                    try:
+                        peer.last_attempt = uint64(time.time())
+
+                        self.log.info(f"Vetting peer {peer.host} {peer.port}")
+                        _r, w = await asyncio.wait_for(
+                            asyncio.open_connection(peer.host, int(peer.port)),
+                            timeout=3,
+                        )
+                        w.close()
+                    except Exception as e:
+                        self.log.warning(f"Could not vet {peer}, removing. {type(e)}{e!s}")
+                        peer.vetted = min(peer.vetted - 1, -1)
+
+                        # if we have failed 6 times in a row, remove the peer
+                        if peer.vetted < -6:
+                            self.server.introducer_peers.remove(peer)
+                        continue
+
+                    self.log.info(f"Have vetted {peer} successfully!")
+                    peer.vetted_timestamp = uint64(time.time())
+                    peer.vetted = max(peer.vetted + 1, 1)
+            except Exception as e:
+                self.log.error(e)

chia/introducer/introducer_api.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, ClassVar, Optional, cast
+
+from chia.introducer.introducer import Introducer
+from chia.protocols.introducer_protocol import RequestPeersIntroducer, RespondPeersIntroducer
+from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.rpc.rpc_server import StateChangedProtocol
+from chia.server.api_protocol import ApiMetadata
+from chia.server.outbound_message import Message, make_msg
+from chia.server.ws_connection import WSChiaConnection
+from chia.types.peer_info import TimestampedPeerInfo
+from chia.util.ints import uint64
+
+
+class IntroducerAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("IntroducerAPI", None)
+
+    log: logging.Logger
+    introducer: Introducer
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
+
+    def __init__(self, introducer) -> None:
+        self.log = logging.getLogger(__name__)
+        self.introducer = introducer
+
+    def ready(self) -> bool:
+        return True
+
+    def _set_state_changed_callback(self, callback: StateChangedProtocol) -> None:
+        pass
+
+    @metadata.request(peer_required=True)
+    async def request_peers_introducer(
+        self,
+        request: RequestPeersIntroducer,
+        peer: WSChiaConnection,
+    ) -> Optional[Message]:
+        max_peers = self.introducer.max_peers_to_send
+        if self.introducer.server is None or self.introducer.server.introducer_peers is None:
+            return None
+        rawpeers = self.introducer.server.introducer_peers.get_peers(
+            max_peers * 5, True, self.introducer.recent_peer_threshold
+        )
+
+        peers = []
+        for r_peer in rawpeers:
+            if r_peer.vetted <= 0:
+                continue
+
+            if r_peer.host == peer.peer_info.host and r_peer.port == peer.peer_server_port:
+                continue
+            peer_without_timestamp = TimestampedPeerInfo(
+                r_peer.host,
+                r_peer.port,
+                uint64(0),
+            )
+            peers.append(peer_without_timestamp)
+
+            if len(peers) >= max_peers:
+                break
+
+        self.introducer.log.info(f"Sending vetted {peers}")
+
+        msg = make_msg(ProtocolMessageTypes.respond_peers_introducer, RespondPeersIntroducer(peers))
+        return msg

chia/legacy/keyring.py

@@ -0,0 +1,155 @@
+"""
+Provides a helper to access the legacy keyring which was supported up to version 1.6.1 of chia-blockchain. To use this
+helper it's required to install the `legacy_keyring` extra dependency which can be done via the install-option `-l`.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Callable, Union, cast
+
+import click
+from chia_rs import G1Element
+from keyring.backends.macOS import Keyring as MacKeyring
+from keyring.backends.Windows import WinVaultKeyring as WinKeyring
+
+from chia.util.ints import uint32
+
+try:
+    from keyrings.cryptfile.cryptfile import CryptFileKeyring
+except ImportError:
+    if sys.platform == "linux":
+        sys.exit("Use `install.sh -l` to install the legacy_keyring dependency.")
+    CryptFileKeyring = None
+
+
+from chia.util.errors import KeychainUserNotFound
+from chia.util.keychain import MAX_KEYS, KeyData, KeyDataSecrets, get_private_key_user
+
+LegacyKeyring = Union[MacKeyring, WinKeyring, CryptFileKeyring]
+
+
+CURRENT_KEY_VERSION = "1.8"
+DEFAULT_USER = f"user-chia-{CURRENT_KEY_VERSION}"  # e.g. user-chia-1.8
+DEFAULT_SERVICE = f"chia-{DEFAULT_USER}"  # e.g. chia-user-chia-1.8
+
+
+# casting to compensate for a combination of mypy and keyring issues
+# https://github.com/python/mypy/issues/9025
+# https://github.com/jaraco/keyring/issues/437
+def create_legacy_keyring() -> LegacyKeyring:
+    if sys.platform == "darwin":
+        return cast(Callable[[], LegacyKeyring], MacKeyring)()
+    elif sys.platform == "win32" or sys.platform == "cygwin":
+        return cast(Callable[[], LegacyKeyring], WinKeyring)()
+    elif sys.platform == "linux":
+        keyring: CryptFileKeyring = CryptFileKeyring()
+        keyring.keyring_key = "your keyring password"
+        return keyring
+    raise click.ClickException(f"platform '{sys.platform}' not supported.")
+
+
+def generate_and_add(keyring: LegacyKeyring) -> KeyData:
+    key = KeyData.generate()
+    index = 0
+    while True:
+        try:
+            get_key_data(keyring, index)
+            index += 1
+        except KeychainUserNotFound:
+            keyring.set_password(
+                DEFAULT_SERVICE,
+                get_private_key_user(DEFAULT_USER, index),
+                bytes(key.public_key).hex() + key.entropy.hex(),
+            )
+            return key
+
+
+def get_key_data(keyring: LegacyKeyring, index: int) -> KeyData:
+    user = get_private_key_user(DEFAULT_USER, index)
+    read_str = keyring.get_password(DEFAULT_SERVICE, user)
+    if read_str is None or len(read_str) == 0:
+        raise KeychainUserNotFound(DEFAULT_SERVICE, user)
+    str_bytes = bytes.fromhex(read_str)
+
+    public_key = G1Element.from_bytes(str_bytes[: G1Element.SIZE])
+    fingerprint = public_key.get_fingerprint()
+    entropy = str_bytes[G1Element.SIZE : G1Element.SIZE + 32]
+
+    return KeyData(
+        fingerprint=uint32(fingerprint),
+        public_key=public_key,
+        label=None,
+        secrets=KeyDataSecrets.from_entropy(entropy),
+    )
+
+
+def get_keys(keyring: LegacyKeyring) -> list[KeyData]:
+    keys: list[KeyData] = []
+    for index in range(MAX_KEYS):
+        try:
+            keys.append(get_key_data(keyring, index))
+        except KeychainUserNotFound:
+            pass
+    return keys
+
+
+def print_key(key: KeyData) -> None:
+    print(f"fingerprint: {key.fingerprint}, mnemonic: {key.mnemonic_str()}")
+
+
+def print_keys(keyring: LegacyKeyring) -> None:
+    keys = get_keys(keyring)
+
+    if len(keys) == 0:
+        raise click.ClickException("No keys found in the legacy keyring.")
+
+    for key in keys:
+        print_key(key)
+
+
+def remove_keys(keyring: LegacyKeyring) -> None:
+    removed = 0
+    for index in range(MAX_KEYS):
+        try:
+            keyring.delete_password(DEFAULT_SERVICE, get_private_key_user(DEFAULT_USER, index))
+            removed += 1
+        except Exception:
+            pass
+
+    print(f"{removed} key{'s' if removed != 1 else ''} removed.")
+
+
+@click.group(help="Manage the keys in the legacy keyring.")
+def legacy_keyring() -> None:
+    pass
+
+
+@legacy_keyring.command(help="Generate and add a random key (for testing)", hidden=True)
+def generate() -> None:
+    keyring = create_legacy_keyring()
+    key = generate_and_add(keyring)
+    print_key(key)
+
+
+@legacy_keyring.command(help="Show all available keys")
+def show() -> None:
+    print_keys(create_legacy_keyring())
+
+
+@legacy_keyring.command(help="Remove all keys")
+def clear() -> None:
+    keyring = create_legacy_keyring()
+
+    print_keys(keyring)
+
+    if not click.confirm(
+        "\nDo you really want to remove all the keys from the legacy keyring? This can't be undone.", default=None
+    ):
+        raise click.ClickException("Aborted!")
+
+    remove_keys(keyring)
+
+
+if __name__ == "__main__":
+    legacy_keyring()

chia/plot_sync/delta.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Union
+
+from chia.protocols.harvester_protocol import Plot
+
+
+@dataclass
+class DeltaType:
+    additions: Union[dict[str, Plot], list[str]]
+    removals: list[str]
+
+    def __str__(self) -> str:
+        return f"+{len(self.additions)}/-{len(self.removals)}"
+
+    def clear(self) -> None:
+        self.additions.clear()
+        self.removals.clear()
+
+    def empty(self) -> bool:
+        return len(self.additions) == 0 and len(self.removals) == 0
+
+
+@dataclass
+class PlotListDelta(DeltaType):
+    additions: dict[str, Plot] = field(default_factory=dict)
+    removals: list[str] = field(default_factory=list)
+
+
+@dataclass
+class PathListDelta(DeltaType):
+    additions: list[str] = field(default_factory=list)
+    removals: list[str] = field(default_factory=list)
+
+    @staticmethod
+    def from_lists(old: list[str], new: list[str]) -> PathListDelta:
+        return PathListDelta([x for x in new if x not in old], [x for x in old if x not in new])
+
+
+@dataclass
+class Delta:
+    valid: PlotListDelta = field(default_factory=PlotListDelta)
+    invalid: PathListDelta = field(default_factory=PathListDelta)
+    keys_missing: PathListDelta = field(default_factory=PathListDelta)
+    duplicates: PathListDelta = field(default_factory=PathListDelta)
+
+    def empty(self) -> bool:
+        return self.valid.empty() and self.invalid.empty() and self.keys_missing.empty() and self.duplicates.empty()
+
+    def __str__(self) -> str:
+        return (
+            f"[valid {self.valid}, invalid {self.invalid}, keys missing: {self.keys_missing}, "
+            f"duplicates: {self.duplicates}]"
+        )
+
+    def clear(self) -> None:
+        self.valid.clear()
+        self.invalid.clear()
+        self.keys_missing.clear()
+        self.duplicates.clear()

chia/plot_sync/exceptions.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Any
+
+from chia.plot_sync.util import ErrorCodes, State
+from chia.protocols.harvester_protocol import PlotSyncIdentifier
+from chia.server.outbound_message import NodeType
+from chia.util.ints import uint64
+
+
+class PlotSyncException(Exception):
+    def __init__(self, message: str, error_code: ErrorCodes) -> None:
+        super().__init__(message)
+        self.error_code = error_code
+
+
+class AlreadyStartedError(Exception):
+    def __init__(self) -> None:
+        super().__init__("Already started!")
+
+
+class InvalidValueError(PlotSyncException):
+    def __init__(self, message: str, actual: Any, expected: Any, error_code: ErrorCodes) -> None:
+        super().__init__(f"{message}: Actual {actual}, Expected {expected}", error_code)
+
+
+class InvalidIdentifierError(InvalidValueError):
+    def __init__(self, actual_identifier: PlotSyncIdentifier, expected_identifier: PlotSyncIdentifier) -> None:
+        super().__init__("Invalid identifier", actual_identifier, expected_identifier, ErrorCodes.invalid_identifier)
+        self.actual_identifier: PlotSyncIdentifier = actual_identifier
+        self.expected_identifier: PlotSyncIdentifier = expected_identifier
+
+
+class InvalidLastSyncIdError(InvalidValueError):
+    def __init__(self, actual: uint64, expected: uint64) -> None:
+        super().__init__("Invalid last-sync-id", actual, expected, ErrorCodes.invalid_last_sync_id)
+
+
+class InvalidConnectionTypeError(InvalidValueError):
+    def __init__(self, actual: NodeType, expected: NodeType) -> None:
+        super().__init__("Unexpected connection type", actual, expected, ErrorCodes.invalid_connection_type)
+
+
+class PlotAlreadyAvailableError(PlotSyncException):
+    def __init__(self, state: State, path: str) -> None:
+        super().__init__(f"{state.name}: Plot already available - {path}", ErrorCodes.plot_already_available)
+
+
+class PlotNotAvailableError(PlotSyncException):
+    def __init__(self, state: State, path: str) -> None:
+        super().__init__(f"{state.name}: Plot not available - {path}", ErrorCodes.plot_not_available)
+
+
+class SyncIdsMatchError(PlotSyncException):
+    def __init__(self, state: State, sync_id: uint64) -> None:
+        super().__init__(f"{state.name}: Sync ids are equal - {sync_id}", ErrorCodes.sync_ids_match)