chia-blockchain 2.4.4__py3-none-any.whl

chia/server/address_manager_store.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from timeit import default_timer as timer
+from typing import Any, Dict, List, Optional, Tuple
+
+import aiofiles
+
+from chia.server.address_manager import (
+    BUCKET_SIZE,
+    NEW_BUCKET_COUNT,
+    NEW_BUCKETS_PER_ADDRESS,
+    AddressManager,
+    ExtendedPeerInfo,
+)
+from chia.util.files import write_file_async
+from chia.util.ints import uint64
+from chia.util.streamable import Streamable, streamable
+
+log = logging.getLogger(__name__)
+
+
+@streamable
+@dataclass(frozen=True)
+class PeerDataSerialization(Streamable):
+    """
+    Serializable property bag for the peer data that was previously stored in sqlite.
+    """
+
+    metadata: List[Tuple[str, str]]
+    nodes: List[Tuple[uint64, str]]
+    new_table: List[Tuple[uint64, uint64]]
+
+
+async def makePeerDataSerialization(
+    metadata: List[Tuple[str, Any]], nodes: List[Tuple[int, ExtendedPeerInfo]], new_table: List[Tuple[int, int]]
+) -> bytes:
+    """
+    Create a PeerDataSerialization, adapting the provided collections
+    """
+    transformed_nodes: List[Tuple[uint64, str]] = []
+    transformed_new_table: List[Tuple[uint64, uint64]] = []
+
+    for index, [node_id, peer_info] in enumerate(nodes):
+        transformed_nodes.append((uint64(node_id), peer_info.to_string()))
+        # Come up to breathe for a moment
+        if index % 1000 == 0:
+            await asyncio.sleep(0)
+
+    for index, [node_id, bucket_id] in enumerate(new_table):
+        transformed_new_table.append((uint64(node_id), uint64(bucket_id)))
+        # Come up to breathe for a moment
+        if index % 1000 == 0:
+            await asyncio.sleep(0)
+
+    serialized_bytes: bytes = bytes(PeerDataSerialization(metadata, transformed_nodes, transformed_new_table))
+    return serialized_bytes
+
+
+class AddressManagerStore:
+    """
+    Metadata table:
+    - private key
+    - new table count
+    - tried table count
+    Nodes table:
+    * Maps entries from new/tried table to unique node ids.
+    - node_id
+    - IP, port, together with the IP, port of the source peer.
+    New table:
+    * Stores node_id, bucket for each occurrence in the new table of an entry.
+    * Once we know the buckets, we can also deduce the bucket positions.
+    Every other information, such as tried_matrix, map_addr, map_info, random_pos,
+    be deduced and it is not explicitly stored, instead it is recalculated.
+    """
+
+    @classmethod
+    async def create_address_manager(cls, peers_file_path: Path) -> AddressManager:
+        """
+        Create an address manager using data deserialized from a peers file.
+        """
+        address_manager: Optional[AddressManager] = None
+        if peers_file_path.exists():
+            try:
+                log.info(f"Loading peers from {peers_file_path}")
+                address_manager = await cls._deserialize(peers_file_path)
+            except Exception:
+                log.exception(f"Unable to create address_manager from {peers_file_path}")
+
+        if address_manager is None:
+            log.info("Creating new address_manager")
+            address_manager = AddressManager()
+
+        return address_manager
+
+    @classmethod
+    async def serialize(cls, address_manager: AddressManager, peers_file_path: Path) -> None:
+        """
+        Serialize the address manager's peer data to a file.
+        """
+        metadata: List[Tuple[str, str]] = []
+        nodes: List[Tuple[int, ExtendedPeerInfo]] = []
+        new_table_entries: List[Tuple[int, int]] = []
+        unique_ids: Dict[int, int] = {}
+        count_ids: int = 0
+
+        log.info("Serializing peer data")
+        metadata.append(("key", str(address_manager.key)))
+
+        for node_id, info in address_manager.map_info.items():
+            unique_ids[node_id] = count_ids
+            if info.ref_count > 0:
+                assert count_ids != address_manager.new_count
+                nodes.append((count_ids, info))
+                count_ids += 1
+        metadata.append(("new_count", str(count_ids)))
+
+        tried_ids = 0
+        for node_id, info in address_manager.map_info.items():
+            if info.is_tried:
+                assert info is not None
+                assert tried_ids != address_manager.tried_count
+                nodes.append((count_ids, info))
+                count_ids += 1
+                tried_ids += 1
+        metadata.append(("tried_count", str(tried_ids)))
+
+        for bucket in range(NEW_BUCKET_COUNT):
+            for i in range(BUCKET_SIZE):
+                if address_manager.new_matrix[bucket][i] != -1:
+                    index = unique_ids[address_manager.new_matrix[bucket][i]]
+                    new_table_entries.append((index, bucket))
+
+        try:
+            # Ensure the parent directory exists
+            peers_file_path.parent.mkdir(parents=True, exist_ok=True)
+            start_time = timer()
+            await cls._write_peers(peers_file_path, metadata, nodes, new_table_entries)
+            log.debug(f"Serializing peer data took {timer() - start_time} seconds")
+        except Exception:
+            log.exception(f"Failed to write peer data to {peers_file_path}")
+
+    @classmethod
+    async def _deserialize(cls, peers_file_path: Path) -> AddressManager:
+        """
+        Create an address manager using data deserialized from a peers file.
+        """
+        peer_data: Optional[PeerDataSerialization] = None
+        address_manager = AddressManager()
+        start_time = timer()
+        try:
+            peer_data = await cls._read_peers(peers_file_path)
+        except Exception:
+            log.exception(f"Unable to deserialize peers from {peers_file_path}")
+
+        if peer_data is not None:
+            metadata: Dict[str, str] = {key: value for key, value in peer_data.metadata}
+            nodes: List[Tuple[int, ExtendedPeerInfo]] = [
+                (node_id, ExtendedPeerInfo.from_string(info_str)) for node_id, info_str in peer_data.nodes
+            ]
+            new_table_entries: List[Tuple[int, int]] = [(node_id, bucket) for node_id, bucket in peer_data.new_table]
+            log.debug(f"Deserializing peer data took {timer() - start_time} seconds")
+
+            address_manager.key = int(metadata["key"])
+            address_manager.new_count = int(metadata["new_count"])
+            # address_manager.tried_count = int(metadata["tried_count"])
+            address_manager.tried_count = 0
+
+            new_table_nodes = [(node_id, info) for node_id, info in nodes if node_id < address_manager.new_count]
+            for n, info in new_table_nodes:
+                address_manager.map_addr[info.peer_info.host] = n
+                address_manager.map_info[n] = info
+                info.random_pos = len(address_manager.random_pos)
+                address_manager.random_pos.append(n)
+            address_manager.id_count = len(new_table_nodes)
+            tried_table_nodes = [(node_id, info) for node_id, info in nodes if node_id >= address_manager.new_count]
+            # lost_count = 0
+            for node_id, info in tried_table_nodes:
+                tried_bucket = info.get_tried_bucket(address_manager.key)
+                tried_bucket_pos = info.get_bucket_position(address_manager.key, False, tried_bucket)
+                if address_manager.tried_matrix[tried_bucket][tried_bucket_pos] == -1:
+                    info.random_pos = len(address_manager.random_pos)
+                    info.is_tried = True
+                    id_count = address_manager.id_count
+                    address_manager.random_pos.append(id_count)
+                    address_manager.map_info[id_count] = info
+                    address_manager.map_addr[info.peer_info.host] = id_count
+                    address_manager.tried_matrix[tried_bucket][tried_bucket_pos] = id_count
+                    address_manager.id_count += 1
+                    address_manager.tried_count += 1
+                # else:
+                #    lost_count += 1
+
+            # address_manager.tried_count -= lost_count
+            for node_id, bucket in new_table_entries:
+                if node_id >= 0 and node_id < address_manager.new_count:
+                    info = address_manager.map_info[node_id]
+                    bucket_pos = info.get_bucket_position(address_manager.key, True, bucket)
+                    if (
+                        address_manager.new_matrix[bucket][bucket_pos] == -1
+                        and info.ref_count < NEW_BUCKETS_PER_ADDRESS
+                    ):
+                        info.ref_count += 1
+                        address_manager.new_matrix[bucket][bucket_pos] = node_id
+
+            for node_id, info in list(address_manager.map_info.items()):
+                if not info.is_tried and info.ref_count == 0:
+                    address_manager.delete_new_entry_(node_id)
+
+            address_manager.load_used_table_positions()
+
+        return address_manager
+
+    @classmethod
+    async def _read_peers(cls, peers_file_path: Path) -> PeerDataSerialization:
+        """
+        Read the peers file and return the data as a PeerDataSerialization object.
+        """
+        async with aiofiles.open(peers_file_path, "rb") as f:
+            return PeerDataSerialization.from_bytes(await f.read())
+
+    @classmethod
+    async def _write_peers(
+        cls,
+        peers_file_path: Path,
+        metadata: List[Tuple[str, Any]],
+        nodes: List[Tuple[int, ExtendedPeerInfo]],
+        new_table: List[Tuple[int, int]],
+    ) -> None:
+        """
+        Serializes the given peer data and writes it to the peers file.
+        """
+        serialized_bytes: bytes = await makePeerDataSerialization(metadata, nodes, new_table)
+        await write_file_async(peers_file_path, serialized_bytes, file_mode=0o644)

chia/server/api_protocol.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from logging import Logger
+
+from typing_extensions import Protocol
+
+
+class ApiProtocol(Protocol):
+    log: Logger
+
+    def ready(self) -> bool: ...

chia/server/capabilities.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Iterable, List, Set, Tuple
+
+from chia.protocols.shared_protocol import Capability
+from chia.util.ints import uint16
+
+
+def known_active_capabilities(values: Iterable[Tuple[uint16, str]]) -> List[Capability]:
+    # NOTE: order is not guaranteed
+    # TODO: what if there's a claim for both supporting and not?
+    #       presently it considers it supported
+    filtered: Set[Capability] = set()
+    for value, state in values:
+        if state != "1":
+            continue
+
+        try:
+            filtered.add(Capability(value))
+        except ValueError:
+            pass
+
+    # TODO: consider changing all uses to sets instead of lists
+    return list(filtered)

chia/server/chia_policy.py

@@ -0,0 +1,345 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import socket
+import ssl
+import struct
+import sys
+
+if sys.platform == "win32":
+    import _overlapped
+    import _winapi
+
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, Tuple, Union
+
+from typing_extensions import Protocol, TypeAlias
+
+# https://github.com/python/asyncio/pull/448
+global_max_concurrent_connections: int = 250
+
+
+if TYPE_CHECKING:
+    # typeshed, for mypy, doesn't include the private attributes.  Documenting them
+    # here so the actual inheriting code can be left tidy.
+
+    # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/base_events.pyi#L22-L25
+    # _ProtocolFactory: TypeAlias = Callable[[], asyncio.protocols.BaseProtocol]
+    class _ProtocolFactory(Protocol):
+        # https://github.com/python/mypy/issues/6910#issuecomment-1081107831
+        # https://github.com/python/typeshed/pull/5718/files
+        def __call__(self) -> asyncio.protocols.BaseProtocol: ...
+
+    _SSLContext: TypeAlias = Union[bool, None, ssl.SSLContext]
+
+    # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/base_events.py#L389
+    # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/base_events.pyi#L64
+    class EventsAbstractEventLoop(asyncio.events.AbstractEventLoop):
+        # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/selector_events.py#L142
+        # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/proactor_events.py#L814
+        def _start_serving(
+            self,
+            protocol_factory: _ProtocolFactory,
+            sock: socket.socket,
+            sslcontext: Optional[_SSLContext] = ...,
+            server: Optional[asyncio.base_events.Server] = ...,
+            backlog: int = ...,
+            # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/constants.py#L16
+            ssl_handshake_timeout: Optional[float] = ...,
+        ) -> None: ...
+
+    # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/base_events.py#L278
+    # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/base_events.pyi#L27
+    class BaseEventsServer(asyncio.base_events.Server):
+        if sys.platform == "win32":
+            _loop: ChiaProactorEventLoop
+        else:
+            _loop: EventsAbstractEventLoop
+        _sockets: Iterable[socket.socket]
+        _active_count: int
+        _protocol_factory: _ProtocolFactory
+        _backlog: int
+        _ssl_context: _SSLContext
+        _ssl_handshake_timeout: Optional[float]
+
+        def _attach(self) -> None: ...
+
+        def _detach(self) -> None: ...
+
+        def _start_serving(self) -> None: ...
+
+    if sys.platform == "win32":
+        # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/windows_events.py#L48
+        class _OverlappedFuture(asyncio.Future[Any]): ...
+
+        # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/windows_events.py#L410
+        # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/windows_events.pyi#L44
+        class IocpProactor(asyncio.windows_events.IocpProactor):
+            _loop: Optional[asyncio.events.AbstractEventLoop]
+
+            def _register_with_iocp(self, obj: object) -> None: ...
+
+            def _register(
+                self,
+                ov: _overlapped.Overlapped,
+                obj: socket.socket,
+                callback: Callable[[object, socket.socket, _overlapped.Overlapped], Tuple[socket.socket, object]],
+            ) -> _OverlappedFuture: ...
+
+            def _get_accept_socket(self, family: socket.AddressFamily) -> socket.socket: ...
+
+        # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/windows_events.py#L309
+        # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/windows_events.pyi#L35
+        class ProactorEventLoop(asyncio.windows_events.ProactorEventLoop):
+            # Actually provided on BaseProactorEventLoop
+            # https://github.com/python/cpython/blob/v3.10.8/Lib/asyncio/proactor_events.py#L627
+            # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/proactor_events.pyi#L75
+            _proactor: Any
+
+else:
+    BaseEventsServer = asyncio.base_events.Server
+    if sys.platform == "win32":
+        IocpProactor = asyncio.windows_events.IocpProactor
+        ProactorEventLoop = asyncio.windows_events.ProactorEventLoop
+
+
+class PausableServer(BaseEventsServer):
+    _paused: bool
+    max_concurrent_connections: int
+
+    # https://github.com/python/typeshed/blob/d084079fc3d89a7b51b89095ad67762944e0ace3/stdlib/asyncio/base_events.pyi#L40-L48
+    def __init__(
+        self,
+        loop: asyncio.AbstractEventLoop,
+        sockets: Iterable[socket.socket],
+        protocol_factory: _ProtocolFactory,
+        ssl_context: _SSLContext,
+        backlog: int,
+        ssl_handshake_timeout: Optional[float],
+        max_concurrent_connections: Optional[int] = None,
+    ) -> None:
+        super().__init__(
+            loop=loop,
+            sockets=sockets,
+            protocol_factory=protocol_factory,
+            ssl_context=ssl_context,
+            backlog=backlog,
+            ssl_handshake_timeout=ssl_handshake_timeout,
+        )
+        self._paused = False
+        self.max_concurrent_connections = (
+            max_concurrent_connections if max_concurrent_connections is not None else global_max_concurrent_connections
+        )
+
+    def _attach(self) -> None:
+        super()._attach()
+        logging.getLogger(__name__).debug(f"New connection. Total connections: {self._active_count}")
+        if not self._paused and self._active_count >= self.max_concurrent_connections:
+            self._chia_pause()
+
+    def _detach(self) -> None:
+        super()._detach()
+        logging.getLogger(__name__).debug(f"Connection lost. Total connections: {self._active_count}")
+        if (
+            self._active_count > 0
+            and self._sockets is not None
+            and self._paused
+            and self._active_count < self.max_concurrent_connections
+        ):
+            self._chia_resume()
+
+    def _chia_pause(self) -> None:
+        """Pause future calls to accept()."""
+        self._paused = True
+        if sys.platform == "win32":
+            # proactor
+            self._loop.disable_connections()
+        else:
+            # selector
+            for sock in self._sockets:
+                self._loop.remove_reader(sock.fileno())
+        logging.getLogger(__name__).debug("Maximum number of connections reached, paused accepting connections.")
+
+    def _chia_resume(self) -> None:
+        """Resume use of accept() on listening socket(s)."""
+        self._paused = False
+        if sys.platform == "win32":
+            # proactor
+            self._loop.enable_connections()
+        else:
+            # selector
+            for sock in self._sockets:
+                self._loop._start_serving(
+                    self._protocol_factory,
+                    sock,
+                    self._ssl_context,
+                    self,
+                    self._backlog,
+                    self._ssl_handshake_timeout,
+                )
+        logging.getLogger(__name__).debug("Resumed accepting connections.")
+
+
+async def _chia_create_server(
+    cls: Any,
+    protocol_factory: _ProtocolFactory,
+    host: Any,
+    port: Any,
+    *,
+    family: socket.AddressFamily = socket.AF_UNSPEC,
+    flags: socket.AddressInfo = socket.AI_PASSIVE,
+    sock: Any = None,
+    backlog: int = 100,
+    ssl: _SSLContext = None,
+    reuse_address: Optional[bool] = None,
+    reuse_port: Optional[bool] = None,
+    ssl_handshake_timeout: Optional[float] = 30,
+    start_serving: bool = True,
+) -> PausableServer:
+    server: BaseEventsServer = await cls.create_server(
+        protocol_factory=protocol_factory,
+        host=host,
+        port=port,
+        family=family,
+        flags=flags,
+        sock=sock,
+        backlog=backlog,
+        ssl=ssl,
+        reuse_address=reuse_address,
+        reuse_port=reuse_port,
+        # TODO: tweaked
+        ssl_handshake_timeout=ssl_handshake_timeout if ssl is not None else None,
+        start_serving=False,
+    )
+    pausable_server = PausableServer(
+        loop=server._loop,
+        sockets=server._sockets,
+        protocol_factory=server._protocol_factory,
+        ssl_context=server._ssl_context,
+        backlog=server._backlog,
+        ssl_handshake_timeout=server._ssl_handshake_timeout,
+    )
+    if start_serving:
+        pausable_server._start_serving()
+        # Skip one loop iteration so that all 'loop.add_reader'
+        # go through.
+        await asyncio.sleep(0)
+
+    return pausable_server
+
+
+class ChiaSelectorEventLoop(asyncio.SelectorEventLoop):
+    # Ignoring lack of typing since we are passing through and also never call this
+    # ourselves. There may be a good solution if needed in the future.  We should
+    # generally get a warning about calling an untyped function in case we do.
+    async def create_server(self, *args, **kwargs) -> PausableServer:  # type: ignore[no-untyped-def]
+        return await _chia_create_server(super(), *args, **kwargs)
+
+
+if sys.platform == "win32":
+
+    class ChiaProactor(IocpProactor):
+        allow_connections: bool
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            super().__init__(*args, **kwargs)
+            self.allow_connections = True
+
+        def enable_connections(self) -> None:
+            self.allow_connections = True
+
+        def disable_connections(self) -> None:
+            self.allow_connections = False
+
+        async def _chia_accept_loop(self, listener: socket.socket) -> Tuple[socket.socket, Tuple[object, ...]]:
+            while True:
+                # TODO: switch to Event code.
+                while not self.allow_connections:
+                    await asyncio.sleep(0.01)
+
+                try:
+                    return await self._chia_accept(listener)
+                except OSError as exc:
+                    if exc.winerror not in (  # pylint: disable=E1101
+                        _winapi.ERROR_NETNAME_DELETED,
+                        _winapi.ERROR_OPERATION_ABORTED,
+                    ):
+                        raise
+
+        def _chia_accept(self, listener: socket.socket) -> asyncio.Future[Tuple[socket.socket, Tuple[object, ...]]]:
+            self._register_with_iocp(listener)
+            conn = self._get_accept_socket(listener.family)  # pylint: disable=assignment-from-no-return
+            ov = _overlapped.Overlapped(_winapi.NULL)
+            ov.AcceptEx(listener.fileno(), conn.fileno())
+
+            def finish_accept(
+                trans: object, key: socket.socket, ov: _overlapped.Overlapped
+            ) -> Tuple[socket.socket, object]:
+                ov.getresult()
+                # Use SO_UPDATE_ACCEPT_CONTEXT so getsockname() etc work.
+                buf = struct.pack("@P", listener.fileno())
+                conn.setsockopt(socket.SOL_SOCKET, _overlapped.SO_UPDATE_ACCEPT_CONTEXT, buf)
+                conn.settimeout(listener.gettimeout())
+                return conn, conn.getpeername()
+
+            async def accept_coro(self: ChiaProactor, future: asyncio.Future[object], conn: socket.socket) -> None:
+                # Coroutine closing the accept socket if the future is cancelled
+                try:
+                    await future
+                except asyncio.CancelledError:
+                    conn.close()
+                    raise
+                except OSError as exc:
+                    # https://github.com/python/cpython/issues/93821#issuecomment-1157945855
+                    if exc.winerror not in (  # pylint: disable=E1101
+                        _winapi.ERROR_NETNAME_DELETED,
+                        _winapi.ERROR_OPERATION_ABORTED,
+                    ):
+                        raise
+
+            future = self._register(ov, listener, finish_accept)  # pylint: disable=assignment-from-no-return
+            coro = accept_coro(self, future, conn)
+            asyncio.ensure_future(coro, loop=self._loop)
+            return future
+
+        def accept(self, listener: socket.socket) -> asyncio.Future[Tuple[socket.socket, Tuple[object, ...]]]:
+            coro = self._chia_accept_loop(listener)
+            return asyncio.ensure_future(coro)
+
+    class ChiaProactorEventLoop(ProactorEventLoop):
+        # Ignoring lack of typing (via Any) since we are passing through and also never
+        # call this ourselves.  There may be a good solution if needed in the future.
+        # It would be better to use a real ignore since then we would get a complaint
+        # if we were to start calling this but we can not do that since this is
+        # platform dependent code and running mypy on other platforms will complain
+        # about the ignore being unused.
+        async def create_server(self, *args: Any, **kwargs: Any) -> PausableServer:
+            return await _chia_create_server(super(), *args, **kwargs)
+
+        def __init__(self) -> None:
+            proactor = ChiaProactor()
+            super().__init__(proactor=proactor)
+
+        def enable_connections(self) -> None:
+            self._proactor.enable_connections()
+
+        def disable_connections(self) -> None:
+            self._proactor.disable_connections()
+
+
+class ChiaPolicy(asyncio.DefaultEventLoopPolicy):
+    def new_event_loop(self) -> asyncio.AbstractEventLoop:
+        # overriding https://github.com/python/cpython/blob/v3.11.0/Lib/asyncio/events.py#L689-L695
+        if sys.platform == "win32":
+            loop_factory = ChiaProactorEventLoop
+        else:
+            loop_factory = ChiaSelectorEventLoop
+
+        return loop_factory()
+
+
+def set_chia_policy(connection_limit: int) -> None:
+    global global_max_concurrent_connections
+    # Add "+100" to the desired peer count as a safety margin.
+    global_max_concurrent_connections = connection_limit + 100
+    asyncio.set_event_loop_policy(ChiaPolicy())

chia/server/introducer_peers.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import random
+import time
+from dataclasses import dataclass
+from typing import List, Optional, Set
+
+from chia.types.peer_info import PeerInfo
+from chia.util.ints import uint16, uint64
+
+
+@dataclass(frozen=False)
+class VettedPeer:
+    host: str
+    port: uint16
+
+    # 0 means we have not attempted to vet this peer yet
+    # a negative number means we have failed that many vetting attempts in a row
+    # a positive number means we have successfully vetted the peer this many
+    # times in a row
+    vetted: int = 0
+    # the timestamp of the last *successful* vetting of this peer
+    vetted_timestamp: uint64 = uint64(0)
+    # the last time we attempted to vet this peer, or 0 if we haven't tried yet
+    # we set this regardless of whether the vetting is successful or not
+    last_attempt: uint64 = uint64(0)
+    time_added: uint64 = uint64(0)
+
+    def __eq__(self, rhs: object) -> bool:
+        return self.host == rhs.host and self.port == rhs.port  # type: ignore[no-any-return, attr-defined]
+
+    def __hash__(self) -> int:
+        return hash((self.host, self.port))
+
+
+class IntroducerPeers:
+    """
+    Has the list of known full node peers that are already connected or may be
+    connected to, and the time that they were last added.
+    """
+
+    def __init__(self) -> None:
+        self._peers: Set[VettedPeer] = set()
+
+    def add(self, peer: Optional[PeerInfo]) -> bool:
+        if peer is None or not peer.port:
+            return False
+
+        p = VettedPeer(peer.host, peer.port)
+        p.time_added = uint64(int(time.time()))
+
+        if p in self._peers:
+            return True
+
+        self._peers.add(p)
+        return True
+
+    def remove(self, peer: Optional[VettedPeer]) -> bool:
+        if peer is None or not peer.port:
+            return False
+        try:
+            self._peers.remove(peer)
+            return True
+        except ValueError:
+            return False
+
+    def get_peers(
+        self, max_peers: int = 0, randomize: bool = False, recent_threshold: float = 9999999
+    ) -> List[VettedPeer]:
+        target_peers = [peer for peer in self._peers if time.time() - float(peer.time_added) < recent_threshold]
+        if not max_peers or max_peers > len(target_peers):
+            max_peers = len(target_peers)
+        if randomize:
+            return random.sample(target_peers, max_peers)
+        else:
+            return target_peers[:max_peers]