diff --git a/docs/legacy/ref/p2p.rst b/docs/legacy/ref/p2p.rst
index 439c88c65..fca514871 100644
--- a/docs/legacy/ref/p2p.rst
+++ b/docs/legacy/ref/p2p.rst
@@ -27,7 +27,7 @@ The :py:mod:`hathor.p2p.states` has all states and messages of the p2p network.
 to send new messages and handle the new incoming ones.
 
 
-The :py:class:`hathor.p2p.peer_id.PeerId` stores the peer's identity, entrypoint, reputation and history.
+The :py:class:`hathor.p2p.peer.Peer` stores the peer's identity, entrypoint, reputation and history.
 
 
 
diff --git a/hathor/builder/builder.py b/hathor/builder/builder.py
index 455384852..8160bae17 100644
--- a/hathor/builder/builder.py
+++ b/hathor/builder/builder.py
@@ -35,7 +35,7 @@
 from hathor.manager import HathorManager
 from hathor.mining.cpu_mining_service import CpuMiningService
 from hathor.p2p.manager import ConnectionsManager
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.pubsub import PubSubManager
 from hathor.reactor import ReactorProtocol as Reactor
 from hathor.storage import RocksDBStorage
@@ -96,7 +96,7 @@ class StorageType(Enum):
 
 class BuildArtifacts(NamedTuple):
     """Artifacts created by a builder."""
-    peer_id: PeerId
+    peer: Peer
     settings: HathorSettingsType
     rng: Random
     reactor: Reactor
@@ -137,7 +137,7 @@ def __init__(self) -> None:
         self._checkpoints: Optional[list[Checkpoint]] = None
         self._capabilities: Optional[list[str]] = None
 
-        self._peer_id: Optional[PeerId] = None
+        self._peer: Optional[Peer] = None
         self._network: Optional[str] = None
         self._cmdline: str = ''
 
@@ -212,7 +212,7 @@ def build(self) -> BuildArtifacts:
         reactor = self._get_reactor()
         pubsub = self._get_or_create_pubsub()
 
-        peer_id = self._get_peer_id()
+        peer = self._get_peer()
 
         execution_manager = self._get_or_create_execution_manager()
         consensus_algorithm = self._get_or_create_consensus()
@@ -256,7 +256,7 @@ def build(self) -> BuildArtifacts:
             pubsub=pubsub,
             consensus_algorithm=consensus_algorithm,
             daa=daa,
-            peer_id=peer_id,
+            peer=peer,
             tx_storage=tx_storage,
             p2p_manager=p2p_manager,
             event_manager=event_manager,
@@ -264,7 +264,7 @@ def build(self) -> BuildArtifacts:
             rng=self._rng,
             checkpoints=self._checkpoints,
             capabilities=self._capabilities,
-            environment_info=get_environment_info(self._cmdline, peer_id.id),
+            environment_info=get_environment_info(self._cmdline, peer.id),
             bit_signaling_service=bit_signaling_service,
             verification_service=verification_service,
             cpu_mining_service=cpu_mining_service,
@@ -284,7 +284,7 @@ def build(self) -> BuildArtifacts:
             stratum_factory = self._create_stratum_server(manager)
 
         self.artifacts = BuildArtifacts(
-            peer_id=peer_id,
+            peer=peer,
             settings=settings,
             rng=self._rng,
             reactor=reactor,
@@ -337,9 +337,9 @@ def set_capabilities(self, capabilities: list[str]) -> 'Builder':
         self._capabilities = capabilities
         return self
 
-    def set_peer_id(self, peer_id: PeerId) -> 'Builder':
+    def set_peer(self, peer: Peer) -> 'Builder':
         self.check_if_can_modify()
-        self._peer_id = peer_id
+        self._peer = peer
         return self
 
     def _get_or_create_settings(self) -> HathorSettingsType:
@@ -361,10 +361,10 @@ def _get_soft_voided_tx_ids(self) -> set[bytes]:
 
         return set(settings.SOFT_VOIDED_TX_IDS)
 
-    def _get_peer_id(self) -> PeerId:
-        if self._peer_id is not None:
-            return self._peer_id
-        raise ValueError('peer_id not set')
+    def _get_peer(self) -> Peer:
+        if self._peer is not None:
+            return self._peer
+        raise ValueError('peer not set')
 
     def _get_or_create_execution_manager(self) -> ExecutionManager:
         if self._execution_manager is None:
@@ -416,7 +416,7 @@ def _get_or_create_p2p_manager(self) -> ConnectionsManager:
 
         enable_ssl = True
         reactor = self._get_reactor()
-        my_peer = self._get_peer_id()
+        my_peer = self._get_peer()
 
         assert self._network is not None
 
@@ -510,12 +510,12 @@ def _get_or_create_event_storage(self) -> EventStorage:
 
     def _get_or_create_event_manager(self) -> EventManager:
         if self._event_manager is None:
-            peer_id = self._get_peer_id()
+            peer = self._get_peer()
             settings = self._get_or_create_settings()
             reactor = self._get_reactor()
             storage = self._get_or_create_event_storage()
             factory = EventWebsocketFactory(
-                peer_id=not_none(peer_id.id),
+                peer_id=not_none(peer.id),
                 network=settings.NETWORK_NAME,
                 reactor=reactor,
                 event_storage=storage,
diff --git a/hathor/builder/cli_builder.py b/hathor/builder/cli_builder.py
index 3f3304f2a..54e7b8fa4 100644
--- a/hathor/builder/cli_builder.py
+++ b/hathor/builder/cli_builder.py
@@ -36,7 +36,7 @@
 from hathor.mining.cpu_mining_service import CpuMiningService
 from hathor.p2p.entrypoint import Entrypoint
 from hathor.p2p.manager import ConnectionsManager
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.utils import discover_hostname, get_genesis_short_hash
 from hathor.pubsub import PubSubManager
 from hathor.reactor import ReactorProtocol as Reactor
@@ -98,7 +98,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
         self.log = logger.new()
         self.reactor = reactor
 
-        peer_id = PeerId.create_from_json_path(self._args.peer) if self._args.peer else PeerId()
+        peer = Peer.create_from_json_path(self._args.peer) if self._args.peer else Peer()
         python = f'{platform.python_version()}-{platform.python_implementation()}'
 
         self.log.info(
@@ -106,7 +106,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             hathor=hathor.__version__,
             pid=os.getpid(),
             genesis=get_genesis_short_hash(),
-            my_peer_id=str(peer_id.id),
+            my_peer_id=str(peer.id),
             python=python,
             platform=platform.platform(),
             settings=settings_source,
@@ -225,7 +225,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
 
         if self._args.x_enable_event_queue:
             self.event_ws_factory = EventWebsocketFactory(
-                peer_id=not_none(peer_id.id),
+                peer_id=not_none(peer.id),
                 network=network,
                 reactor=reactor,
                 event_storage=event_storage
@@ -307,7 +307,7 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             settings=settings,
             reactor=reactor,
             network=network,
-            my_peer=peer_id,
+            my_peer=peer,
             pubsub=pubsub,
             ssl=True,
             whitelist_only=False,
@@ -348,13 +348,13 @@ def create_manager(self, reactor: Reactor) -> HathorManager:
             pubsub=pubsub,
             consensus_algorithm=consensus_algorithm,
             daa=daa,
-            peer_id=peer_id,
+            peer=peer,
             tx_storage=tx_storage,
             p2p_manager=p2p_manager,
             event_manager=event_manager,
             wallet=self.wallet,
             checkpoints=settings.CHECKPOINTS,
-            environment_info=get_environment_info(args=str(self._args), peer_id=peer_id.id),
+            environment_info=get_environment_info(args=str(self._args), peer_id=peer.id),
             full_verification=full_verification,
             enable_event_queue=self._args.x_enable_event_queue,
             bit_signaling_service=bit_signaling_service,
diff --git a/hathor/cli/peer_id.py b/hathor/cli/peer_id.py
index 3e0319ee6..45bf3a04d 100644
--- a/hathor/cli/peer_id.py
+++ b/hathor/cli/peer_id.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-""" Generates a random PeerId and print it to stdout.
+""" Generates a random Peer and print it to stdout.
 It may be used to testing purposes.
 """
 
@@ -20,9 +20,9 @@
 
 
 def main() -> None:
-    from hathor.p2p.peer_id import PeerId
+    from hathor.p2p.peer import Peer
 
-    peer_id = PeerId()
-    data = peer_id.to_json(include_private_key=True)
+    peer = Peer()
+    data = peer.to_json(include_private_key=True)
     txt = json.dumps(data, indent=4)
     print(txt)
diff --git a/hathor/cli/run_node.py b/hathor/cli/run_node.py
index 399560307..a7d7be0d6 100644
--- a/hathor/cli/run_node.py
+++ b/hathor/cli/run_node.py
@@ -219,7 +219,7 @@ def prepare(self, *, register_resources: bool = True) -> None:
 
         from hathor.builder.builder import BuildArtifacts
         self.artifacts = BuildArtifacts(
-            peer_id=self.manager.my_peer,
+            peer=self.manager.my_peer,
             settings=settings,
             rng=self.manager.rng,
             reactor=self.manager.reactor,
diff --git a/hathor/daa.py b/hathor/daa.py
index afd309726..d3ae33379 100644
--- a/hathor/daa.py
+++ b/hathor/daa.py
@@ -47,7 +47,7 @@ class TestMode(IntFlag):
 
 
 class DifficultyAdjustmentAlgorithm:
-    # TODO: This singleton is temporary, and only used in PeerId. It should be removed from there, and then from here.
+    # TODO: This singleton is temporary, and only used in Peer. It should be removed from there, and then from here.
     singleton: ClassVar[Optional['DifficultyAdjustmentAlgorithm']] = None
 
     def __init__(self, *, settings: HathorSettings, test_mode: TestMode = TestMode.DISABLED) -> None:
diff --git a/hathor/manager.py b/hathor/manager.py
index 9f1210d40..0218fd663 100644
--- a/hathor/manager.py
+++ b/hathor/manager.py
@@ -46,7 +46,7 @@
 from hathor.mining import BlockTemplate, BlockTemplates
 from hathor.mining.cpu_mining_service import CpuMiningService
 from hathor.p2p.manager import ConnectionsManager
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.profiler import get_cpu_profiler
 from hathor.pubsub import HathorEvents, PubSubManager
 from hathor.reactor import ReactorProtocol as Reactor
@@ -96,7 +96,7 @@ def __init__(
         pubsub: PubSubManager,
         consensus_algorithm: ConsensusAlgorithm,
         daa: DifficultyAdjustmentAlgorithm,
-        peer_id: PeerId,
+        peer: Peer,
         tx_storage: TransactionStorage,
         p2p_manager: ConnectionsManager,
         event_manager: EventManager,
@@ -119,7 +119,7 @@ def __init__(
     ) -> None:
         """
         :param reactor: Twisted reactor which handles the mainloop and the events.
-        :param peer_id: Id of this node.
+        :param peer: Peer object, with peer-id of this node.
         :param network: Name of the network this node participates. Usually it is either testnet or mainnet.
         :type network: string
 
@@ -163,7 +163,7 @@ def __init__(
         # Remote address, which can be different from local address.
         self.remote_address = None
 
-        self.my_peer = peer_id
+        self.my_peer = peer
         self.network = network
 
         self.is_started: bool = False
@@ -976,7 +976,7 @@ def on_new_tx(
     def has_sync_version_capability(self) -> bool:
         return self._settings.CAPABILITY_SYNC_VERSION in self.capabilities
 
-    def add_peer_to_whitelist(self, peer_id):
+    def add_peer_to_whitelist(self, peer_id: str) -> None:
         if not self._settings.ENABLE_PEER_WHITELIST:
             return
 
diff --git a/hathor/p2p/factory.py b/hathor/p2p/factory.py
index a90cf2882..521abaa09 100644
--- a/hathor/p2p/factory.py
+++ b/hathor/p2p/factory.py
@@ -19,7 +19,7 @@
 
 from hathor.conf.settings import HathorSettings
 from hathor.p2p.manager import ConnectionsManager
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.protocol import HathorLineReceiver
 
 if TYPE_CHECKING:
@@ -39,7 +39,7 @@ class HathorServerFactory(protocol.ServerFactory):
     def __init__(
         self,
         network: str,
-        my_peer: PeerId,
+        my_peer: Peer,
         p2p_manager: ConnectionsManager,
         *,
         settings: HathorSettings,
@@ -75,7 +75,7 @@ class HathorClientFactory(protocol.ClientFactory):
     def __init__(
         self,
         network: str,
-        my_peer: PeerId,
+        my_peer: Peer,
         p2p_manager: ConnectionsManager,
         *,
         settings: HathorSettings,
diff --git a/hathor/p2p/manager.py b/hathor/p2p/manager.py
index c0f6b58f6..4cf4e240e 100644
--- a/hathor/p2p/manager.py
+++ b/hathor/p2p/manager.py
@@ -27,8 +27,8 @@
 from hathor.conf.settings import HathorSettings
 from hathor.p2p.entrypoint import Entrypoint
 from hathor.p2p.netfilter.factory import NetfilterFactory
+from hathor.p2p.peer import Peer
 from hathor.p2p.peer_discovery import PeerDiscovery
-from hathor.p2p.peer_id import PeerId
 from hathor.p2p.peer_storage import PeerStorage
 from hathor.p2p.protocol import HathorProtocol
 from hathor.p2p.rate_limiter import RateLimiter
@@ -93,7 +93,7 @@ def __init__(
         settings: HathorSettings,
         reactor: Reactor,
         network: str,
-        my_peer: PeerId,
+        my_peer: Peer,
         pubsub: PubSubManager,
         ssl: bool,
         rng: Random,
@@ -159,7 +159,7 @@ def __init__(
         self.received_peer_storage = PeerStorage()
 
         # List of known peers.
-        self.peer_storage = PeerStorage()  # dict[string (peer.id), PeerId]
+        self.peer_storage = PeerStorage()  # dict[string (peer.id), Peer]
 
         # Maximum unseen time before removing a peer (seconds).
         self.max_peer_unseen_dt: float = 30 * 60   # 30-minutes
@@ -366,7 +366,7 @@ def disconnect_all_peers(self, *, force: bool = False) -> None:
         for conn in self.iter_all_connections():
             conn.disconnect(force=force)
 
-    def on_connection_failure(self, failure: Failure, peer: Optional[PeerId], endpoint: IStreamClientEndpoint) -> None:
+    def on_connection_failure(self, failure: Failure, peer: Optional[Peer], endpoint: IStreamClientEndpoint) -> None:
         connecting_peer = self.connecting_peers[endpoint]
         entrypoint = connecting_peer.entrypoint
         self.log.warn('connection failure', entrypoint=entrypoint, failure=failure.getErrorMessage())
@@ -433,7 +433,7 @@ def on_peer_ready(self, protocol: HathorProtocol) -> None:
         # Notify other peers about this new peer connection.
         self.relay_peer_to_ready_connections(protocol.peer)
 
-    def relay_peer_to_ready_connections(self, peer: PeerId) -> None:
+    def relay_peer_to_ready_connections(self, peer: Peer) -> None:
         """Relay peer to all ready connections."""
         for conn in self.iter_ready_connections():
             if conn.peer == peer:
@@ -491,7 +491,7 @@ def is_peer_connected(self, peer_id: str) -> bool:
         """
         return peer_id in self.connected_peers
 
-    def on_receive_peer(self, peer: PeerId, origin: Optional[ReadyState] = None) -> None:
+    def on_receive_peer(self, peer: Peer, origin: Optional[ReadyState] = None) -> None:
         """ Update a peer information in our storage, and instantly attempt to connect
         to it if it is not connected yet.
         """
@@ -503,7 +503,7 @@ def on_receive_peer(self, peer: PeerId, origin: Optional[ReadyState] = None) ->
     def peers_cleanup(self) -> None:
         """Clean up aged peers."""
         now = self.reactor.seconds()
-        to_be_removed: list[PeerId] = []
+        to_be_removed: list[Peer] = []
         for peer in self.peer_storage.values():
             assert peer.id is not None
             if self.is_peer_connected(peer.id):
@@ -574,7 +574,7 @@ def _update_whitelist_cb(self, body: bytes) -> None:
         for peer_id in peers_to_remove:
             self.manager.remove_peer_from_whitelist_and_disconnect(peer_id)
 
-    def connect_to_if_not_connected(self, peer: PeerId, now: int) -> None:
+    def connect_to_if_not_connected(self, peer: Peer, now: int) -> None:
         """ Attempts to connect if it is not connected to the peer.
         """
         if not peer.entrypoints:
@@ -594,7 +594,7 @@ def connect_to_if_not_connected(self, peer: PeerId, now: int) -> None:
     def _connect_to_callback(
         self,
         protocol: IProtocol,
-        peer: Optional[PeerId],
+        peer: Optional[Peer],
         endpoint: IStreamClientEndpoint,
         entrypoint: Entrypoint,
     ) -> None:
@@ -610,7 +610,7 @@ def _connect_to_callback(
     def connect_to(
         self,
         entrypoint: Entrypoint,
-        peer: Optional[PeerId] = None,
+        peer: Optional[Peer] = None,
         use_ssl: Optional[bool] = None,
     ) -> None:
         """ Attempt to connect to a peer, even if a connection already exists.
diff --git a/hathor/p2p/peer_id.py b/hathor/p2p/peer.py
similarity index 95%
rename from hathor/p2p/peer_id.py
rename to hathor/p2p/peer.py
index d2aef2634..9d40ec7b6 100644
--- a/hathor/p2p/peer_id.py
+++ b/hathor/p2p/peer.py
@@ -49,7 +49,7 @@ class PeerFlags(str, Enum):
     RETRIES_EXCEEDED = 'retries_exceeded'
 
 
-class PeerId:
+class Peer:
     """ Identify a peer, even when it is disconnected.
 
     The public_key and private_key are used to ensure that a new connection
@@ -92,7 +92,7 @@ def __init__(self, auto_generate_keys: bool = True) -> None:
 
     def __str__(self):
         return (
-            f'PeerId(id={self.id}, entrypoints={self.entrypoints_as_str()}, retry_timestamp={self.retry_timestamp}, '
+            f'Peer(id={self.id}, entrypoints={self.entrypoints_as_str()}, retry_timestamp={self.retry_timestamp}, '
             f'retry_interval={self.retry_interval})'
         )
 
@@ -100,8 +100,8 @@ def entrypoints_as_str(self) -> list[str]:
         """Return a list of entrypoints serialized as str"""
         return list(map(str, self.entrypoints))
 
-    def merge(self, other: 'PeerId') -> None:
-        """ Merge two PeerId objects, checking that they have the same
+    def merge(self, other: 'Peer') -> None:
+        """ Merge two Peer objects, checking that they have the same
         id, public_key, and private_key. The entrypoints are merged without
         duplicating their entries.
         """
@@ -174,18 +174,18 @@ def verify_signature(self, signature: bytes, data: bytes) -> bool:
             return True
 
     @classmethod
-    def create_from_json_path(cls, path: str) -> 'PeerId':
-        """Create a new PeerId from a JSON file."""
+    def create_from_json_path(cls, path: str) -> 'Peer':
+        """Create a new Peer from a JSON file."""
         data = json.load(open(path, 'r'))
-        peer = PeerId.create_from_json(data)
+        peer = Peer.create_from_json(data)
         peer.source_file = path
         return peer
 
     @classmethod
-    def create_from_json(cls, data: dict[str, Any]) -> 'PeerId':
-        """ Create a new PeerId from JSON data.
+    def create_from_json(cls, data: dict[str, Any]) -> 'Peer':
+        """ Create a new Peer from JSON data.
 
-        It is used both to load a PeerId from disk and to create a PeerId
+        It is used both to load a Peer from disk and to create a Peer
         from a peer connection.
         """
         obj = cls(auto_generate_keys=False)
@@ -436,18 +436,18 @@ def validate_certificate(self, protocol: 'HathorProtocol') -> bool:
         return True
 
     def reload_entrypoints_from_source_file(self) -> None:
-        """Update this PeerId's entrypoints from the json file."""
+        """Update this Peer's entrypoints from the json file."""
         if not self.source_file:
             raise Exception('Trying to reload entrypoints but no peer config file was provided.')
 
-        new_peer_id = PeerId.create_from_json_path(self.source_file)
+        new_peer = Peer.create_from_json_path(self.source_file)
 
-        if new_peer_id.id != self.id:
+        if new_peer.id != self.id:
             self._log.error(
                 'Ignoring peer id file update because the peer_id does not match.',
                 current_peer_id=self.id,
-                new_peer_id=new_peer_id.id,
+                new_peer_id=new_peer.id,
             )
             return
 
-        self.entrypoints = new_peer_id.entrypoints
+        self.entrypoints = new_peer.entrypoints
diff --git a/hathor/p2p/peer_storage.py b/hathor/p2p/peer_storage.py
index 52131df11..6efb8a549 100644
--- a/hathor/p2p/peer_storage.py
+++ b/hathor/p2p/peer_storage.py
@@ -12,15 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 
 
-class PeerStorage(dict[str, PeerId]):
+class PeerStorage(dict[str, Peer]):
     """ PeerStorage is used to store all known peers in memory.
     It is a dict of peer objects, and peers can be retrieved by their `peer.id`.
     """
 
-    def add(self, peer: PeerId) -> None:
+    def add(self, peer: Peer) -> None:
         """ Add a new peer to the storage.
 
         Raises a `ValueError` if the peer has already been added.
@@ -30,7 +30,7 @@ def add(self, peer: PeerId) -> None:
             raise ValueError('Peer has already been added')
         self[peer.id] = peer
 
-    def add_or_merge(self, peer: PeerId) -> PeerId:
+    def add_or_merge(self, peer: Peer) -> Peer:
         """ Add a peer to the storage if it has not been added yet.
         Otherwise, merge the current peer with the given one.
         """
@@ -43,7 +43,7 @@ def add_or_merge(self, peer: PeerId) -> PeerId:
             current.merge(peer)
             return current
 
-    def remove(self, peer: PeerId) -> None:
+    def remove(self, peer: Peer) -> None:
         """ Remove a peer from the storage
         """
         assert peer.id is not None
diff --git a/hathor/p2p/protocol.py b/hathor/p2p/protocol.py
index 99c63b29e..eeec521f2 100644
--- a/hathor/p2p/protocol.py
+++ b/hathor/p2p/protocol.py
@@ -26,7 +26,7 @@
 from hathor.conf.settings import HathorSettings
 from hathor.p2p.entrypoint import Entrypoint
 from hathor.p2p.messages import ProtocolMessages
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.rate_limiter import RateLimiter
 from hathor.p2p.states import BaseState, HelloState, PeerIdState, ReadyState
 from hathor.p2p.sync_version import SyncVersion
@@ -73,12 +73,12 @@ class WarningFlags(str, Enum):
         NO_ENTRYPOINTS = 'no_entrypoints'
 
     network: str
-    my_peer: PeerId
+    my_peer: Peer
     connections: 'ConnectionsManager'
     node: 'HathorManager'
     app_version: str
     last_message: float
-    peer: Optional[PeerId]
+    peer: Optional[Peer]
     transport: Optional[ITransport]
     state: Optional[BaseState]
     connection_time: float
@@ -94,7 +94,7 @@ class WarningFlags(str, Enum):
     def __init__(
         self,
         network: str,
-        my_peer: PeerId,
+        my_peer: Peer,
         p2p_manager: 'ConnectionsManager',
         *,
         settings: HathorSettings,
diff --git a/hathor/p2p/states/peer_id.py b/hathor/p2p/states/peer_id.py
index 8d68b669b..439ccd4b0 100644
--- a/hathor/p2p/states/peer_id.py
+++ b/hathor/p2p/states/peer_id.py
@@ -18,7 +18,7 @@
 
 from hathor.conf.settings import HathorSettings
 from hathor.p2p.messages import ProtocolMessages
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.states.base import BaseState
 from hathor.util import json_dumps, json_loads
 
@@ -87,7 +87,7 @@ async def handle_peer_id(self, payload: str) -> None:
 
         data = json_loads(payload)
 
-        peer = PeerId.create_from_json(data)
+        peer = Peer.create_from_json(data)
         peer.validate()
         assert peer.id is not None
 
diff --git a/hathor/p2p/states/ready.py b/hathor/p2p/states/ready.py
index 35802b877..c04d97b4c 100644
--- a/hathor/p2p/states/ready.py
+++ b/hathor/p2p/states/ready.py
@@ -21,7 +21,7 @@
 from hathor.conf.settings import HathorSettings
 from hathor.indexes.height_index import HeightInfo
 from hathor.p2p.messages import ProtocolMessages
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.states.base import BaseState
 from hathor.p2p.sync_agent import SyncAgent
 from hathor.p2p.utils import to_height_info, to_serializable_best_blockchain
@@ -158,7 +158,7 @@ def handle_get_peers(self, payload: str) -> None:
         for peer in self.protocol.connections.peer_storage.values():
             self.send_peers([peer])
 
-    def send_peers(self, peer_list: Iterable['PeerId']) -> None:
+    def send_peers(self, peer_list: Iterable['Peer']) -> None:
         """ Send a PEERS command with a list of peers.
         """
         data = []
@@ -177,7 +177,7 @@ def handle_peers(self, payload: str) -> None:
         """
         received_peers = json_loads(payload)
         for data in received_peers:
-            peer = PeerId.create_from_json(data)
+            peer = Peer.create_from_json(data)
             peer.validate()
             if self.protocol.connections:
                 self.protocol.connections.on_receive_peer(peer, origin=self)
diff --git a/hathor/simulator/fake_connection.py b/hathor/simulator/fake_connection.py
index a2170d233..4473813e8 100644
--- a/hathor/simulator/fake_connection.py
+++ b/hathor/simulator/fake_connection.py
@@ -22,13 +22,13 @@
 
 if TYPE_CHECKING:
     from hathor.manager import HathorManager
-    from hathor.p2p.peer_id import PeerId
+    from hathor.p2p.peer import Peer
 
 logger = get_logger()
 
 
 class HathorStringTransport(StringTransport):
-    def __init__(self, peer: 'PeerId'):
+    def __init__(self, peer: 'Peer'):
         super().__init__()
         self.peer = peer
 
diff --git a/hathor/simulator/simulator.py b/hathor/simulator/simulator.py
index 5eb4e20e0..c1d0754f4 100644
--- a/hathor/simulator/simulator.py
+++ b/hathor/simulator/simulator.py
@@ -26,7 +26,7 @@
 from hathor.daa import DifficultyAdjustmentAlgorithm
 from hathor.feature_activation.feature_service import FeatureService
 from hathor.manager import HathorManager
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.simulator.clock import HeapClock, MemoryReactorHeapClock
 from hathor.simulator.miner.geometric_miner import GeometricMiner
 from hathor.simulator.patches import SimulatorCpuMiningService, SimulatorVertexVerifier
@@ -81,7 +81,7 @@ def get_default_builder(self) -> Builder:
         """
         return Builder() \
             .set_network(self._network) \
-            .set_peer_id(PeerId()) \
+            .set_peer(Peer()) \
             .set_soft_voided_tx_ids(set()) \
             .enable_full_verification() \
             .enable_sync_v1() \
diff --git a/tests/cli/test_sysctl_init.py b/tests/cli/test_sysctl_init.py
index a696e2008..b71da9d1e 100644
--- a/tests/cli/test_sysctl_init.py
+++ b/tests/cli/test_sysctl_init.py
@@ -156,13 +156,15 @@ def register_signal_handlers(self) -> None:
                 expected_sysctl_dict['p2p.sync_update_interval'])
 
         # assert always_enabled_sync when it is set with a file
+        peer_1 = '0e2bd0d8cd1fb6d040801c32ec27e8986ce85eb8810b6c878dcad15bce3b5b1e'
+        peer_2 = '2ff0d2c80c50f724de79f132a2f8cae576c64b57ea531d400577adf7db3e7c15'
         expected_sysctl_dict = {
-            'p2p.always_enable_sync': ['peer-3', 'peer-4'],
+            'p2p.always_enable_sync': [peer_1, peer_2],
         }
 
         file_content = [
-            'peer-3',
-            'peer-4',
+            peer_1,
+            peer_2,
         ]
 
         # set the always_enabled_sync peers file
@@ -195,6 +197,6 @@ def register_signal_handlers(self) -> None:
         self.assertTrue(run_node is not None)
         conn = run_node.manager.connections
 
-        curr_always_enabled_sync = list(conn.always_enable_sync)
+        curr_always_enabled_sync = list(map(str, conn.always_enable_sync))
         self.assertTrue(
                 set(curr_always_enabled_sync).issuperset(set(expected_sysctl_dict['p2p.always_enable_sync'])))
diff --git a/tests/event/event_simulation_tester.py b/tests/event/event_simulation_tester.py
index 3e2bc4659..5541c6397 100644
--- a/tests/event/event_simulation_tester.py
+++ b/tests/event/event_simulation_tester.py
@@ -23,7 +23,7 @@
 from hathor.event.websocket import EventWebsocketProtocol
 from hathor.event.websocket.request import Request
 from hathor.event.websocket.response import EventResponse, InvalidRequestResponse
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.transaction.util import unpack, unpack_len
 from hathor.util import json_loadb
 from tests.simulation.base import SimulatorTestCase
@@ -34,14 +34,14 @@ class BaseEventSimulationTester(SimulatorTestCase):
     builder: Builder
 
     def _create_artifacts(self) -> None:
-        peer_id = PeerId()
-        builder = self.builder.set_peer_id(peer_id) \
+        peer = Peer()
+        builder = self.builder.set_peer(peer) \
             .disable_full_verification() \
             .enable_event_queue()
         artifacts = self.simulator.create_artifacts(builder)
 
-        assert peer_id.id is not None
-        self.peer_id: str = peer_id.id
+        assert peer.id is not None
+        self.peer_id: str = peer.id
         self.manager = artifacts.manager
         self.manager.allow_mining_without_peers()
         self.settings = artifacts.settings
diff --git a/tests/others/test_metrics.py b/tests/others/test_metrics.py
index 6573c43a2..99c410c50 100644
--- a/tests/others/test_metrics.py
+++ b/tests/others/test_metrics.py
@@ -5,7 +5,7 @@
 
 from hathor.p2p.entrypoint import Entrypoint
 from hathor.p2p.manager import PeerConnectionsMetrics
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.protocol import HathorProtocol
 from hathor.pubsub import HathorEvents
 from hathor.simulator.utils import add_new_blocks
@@ -61,7 +61,7 @@ def test_connections_manager_integration(self):
         wallet.unlock(b'teste')
         manager = self.create_peer('testnet', tx_storage=tx_storage, wallet=wallet)
 
-        manager.connections.peer_storage.update({"1": PeerId(), "2": PeerId(), "3": PeerId()})
+        manager.connections.peer_storage.update({"1": Peer(), "2": Peer(), "3": Peer()})
         manager.connections.connected_peers.update({"1": Mock(), "2": Mock()})
         manager.connections.handshaking_peers.update({Mock()})
 
@@ -223,7 +223,7 @@ def build_hathor_protocol():
                 inbound=False,
                 settings=self._settings
             )
-            protocol.peer = PeerId()
+            protocol.peer = Peer()
 
             return protocol
 
diff --git a/tests/p2p/netfilter/test_match.py b/tests/p2p/netfilter/test_match.py
index 39bb844fe..b8debf58f 100644
--- a/tests/p2p/netfilter/test_match.py
+++ b/tests/p2p/netfilter/test_match.py
@@ -11,7 +11,7 @@
     NetfilterMatchOr,
     NetfilterMatchPeerId,
 )
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.simulator import FakeConnection
 from tests import unittest
 
@@ -202,15 +202,15 @@ class BaseNetfilterMatchTest(unittest.TestCase):
 
     def test_match_peer_id(self) -> None:
         network = 'testnet'
-        peer_id1 = PeerId()
-        peer_id2 = PeerId()
-        manager1 = self.create_peer(network, peer_id=peer_id1)
-        manager2 = self.create_peer(network, peer_id=peer_id2)
+        peer1 = Peer()
+        peer2 = Peer()
+        manager1 = self.create_peer(network, peer=peer1)
+        manager2 = self.create_peer(network, peer=peer2)
 
         conn = FakeConnection(manager1, manager2)
         self.assertTrue(conn.proto2.is_state(conn.proto2.PeerState.HELLO))
 
-        matcher = NetfilterMatchPeerId(str(peer_id1.id))
+        matcher = NetfilterMatchPeerId(str(peer1.id))
         context = NetfilterContext(protocol=conn.proto2)
         self.assertFalse(matcher.match(context))
 
@@ -231,7 +231,7 @@ def test_match_peer_id(self) -> None:
         # Guarantee the to_json is working fine
         json = matcher.to_json()
         self.assertEqual(json['type'], 'NetfilterMatchPeerId')
-        self.assertEqual(json['match_params']['peer_id'], str(peer_id1.id))
+        self.assertEqual(json['match_params']['peer_id'], str(peer1.id))
 
 
 class SyncV1NetfilterMatchTest(unittest.SyncV1Params, BaseNetfilterMatchTest):
diff --git a/tests/p2p/test_bootstrap.py b/tests/p2p/test_bootstrap.py
index b6a851a5c..721a1a1e2 100644
--- a/tests/p2p/test_bootstrap.py
+++ b/tests/p2p/test_bootstrap.py
@@ -6,9 +6,9 @@
 
 from hathor.p2p.entrypoint import Entrypoint, Protocol
 from hathor.p2p.manager import ConnectionsManager
+from hathor.p2p.peer import Peer
 from hathor.p2p.peer_discovery import DNSPeerDiscovery, PeerDiscovery
 from hathor.p2p.peer_discovery.dns import LookupResult
-from hathor.p2p.peer_id import PeerId
 from hathor.pubsub import PubSubManager
 from tests import unittest
 from tests.test_memory_reactor_clock import TestMemoryReactorClock
@@ -48,7 +48,7 @@ def do_lookup_text(self, host: str) -> Deferred[LookupResult]:
 class BootstrapTestCase(unittest.TestCase):
     def test_mock_discovery(self) -> None:
         pubsub = PubSubManager(self.clock)
-        connections = ConnectionsManager(self._settings, self.clock, 'testnet', PeerId(), pubsub, True, self.rng, True)
+        connections = ConnectionsManager(self._settings, self.clock, 'testnet', Peer(), pubsub, True, self.rng, True)
         host_ports1 = [
             ('foobar', 1234),
             ('127.0.0.99', 9999),
@@ -71,7 +71,7 @@ def test_mock_discovery(self) -> None:
 
     def test_dns_discovery(self) -> None:
         pubsub = PubSubManager(self.clock)
-        connections = ConnectionsManager(self._settings, self.clock, 'testnet', PeerId(), pubsub, True, self.rng, True)
+        connections = ConnectionsManager(self._settings, self.clock, 'testnet', Peer(), pubsub, True, self.rng, True)
         bootstrap_a = [
             '127.0.0.99',
             '127.0.0.88',
diff --git a/tests/p2p/test_peer_id.py b/tests/p2p/test_peer_id.py
index aec32921a..b947f8337 100644
--- a/tests/p2p/test_peer_id.py
+++ b/tests/p2p/test_peer_id.py
@@ -7,7 +7,7 @@
 from twisted.internet.interfaces import ITransport
 
 from hathor.p2p.entrypoint import Entrypoint
-from hathor.p2p.peer_id import InvalidPeerIdException, PeerId
+from hathor.p2p.peer import InvalidPeerIdException, Peer
 from hathor.p2p.peer_storage import PeerStorage
 from hathor.util import not_none
 from tests import unittest
@@ -16,41 +16,41 @@
 
 class PeerIdTest(unittest.TestCase):
     def test_invalid_id(self) -> None:
-        p1 = PeerId()
+        p1 = Peer()
         p1.id = not_none(p1.id)[::-1]
         self.assertRaises(InvalidPeerIdException, p1.validate)
 
     def test_invalid_public_key(self) -> None:
-        p1 = PeerId()
-        p2 = PeerId()
+        p1 = Peer()
+        p2 = Peer()
         p1.public_key = p2.public_key
         self.assertRaises(InvalidPeerIdException, p1.validate)
 
     def test_invalid_private_key(self) -> None:
-        p1 = PeerId()
-        p2 = PeerId()
+        p1 = Peer()
+        p2 = Peer()
         p1.private_key = p2.private_key
         self.assertRaises(InvalidPeerIdException, p1.validate)
 
     def test_no_private_key(self) -> None:
-        p1 = PeerId()
+        p1 = Peer()
         p1.private_key = None
         p1.validate()
 
     def test_create_from_json(self) -> None:
-        p1 = PeerId()
+        p1 = Peer()
         data1 = p1.to_json(include_private_key=True)
-        p2 = PeerId.create_from_json(data1)
+        p2 = Peer.create_from_json(data1)
         data2 = p2.to_json(include_private_key=True)
         self.assertEqual(data1, data2)
         p2.validate()
 
     def test_create_from_json_without_private_key(self) -> None:
-        p1 = PeerId()
+        p1 = Peer()
         data1 = p1.to_json()
         # Just to test a part of the code
         del data1['entrypoints']
-        p2 = PeerId.create_from_json(data1)
+        p2 = Peer.create_from_json(data1)
         data2 = p2.to_json()
         self.assertEqual(data2['entrypoints'], [])
         data1['entrypoints'] = []
@@ -59,13 +59,13 @@ def test_create_from_json_without_private_key(self) -> None:
 
     def test_sign_verify(self) -> None:
         data = b'abacate'
-        p1 = PeerId()
+        p1 = Peer()
         signature = p1.sign(data)
         self.assertTrue(p1.verify_signature(signature, data))
 
     def test_sign_verify_fail(self) -> None:
         data = b'abacate'
-        p1 = PeerId()
+        p1 = Peer()
         signature = p1.sign(data)
         signature = signature[::-1]
         self.assertFalse(p1.verify_signature(signature, data))
@@ -74,8 +74,8 @@ def test_merge_peer(self) -> None:
         # Testing peer storage with merge of peers
         peer_storage = PeerStorage()
 
-        p1 = PeerId()
-        p2 = PeerId()
+        p1 = Peer()
+        p2 = Peer()
         p2.id = p1.id
         p2.public_key = p1.public_key
         p1.public_key = None
@@ -95,12 +95,12 @@ def test_merge_peer(self) -> None:
         ep2 = Entrypoint.parse('tcp://127.0.0.1:1002')
         ep3 = Entrypoint.parse('tcp://127.0.0.1:1003')
 
-        p3 = PeerId()
+        p3 = Peer()
         p3.entrypoints.append(ep1)
         p3.entrypoints.append(ep2)
         p3.public_key = None
 
-        p4 = PeerId()
+        p4 = Peer()
         p4.public_key = None
         p4.private_key = None
         p4.id = p3.id
@@ -124,7 +124,7 @@ def test_merge_peer(self) -> None:
     def test_save_peer_file(self) -> None:
         import json
 
-        p = PeerId()
+        p = Peer()
         tmpdir = tempfile.mkdtemp()
         path = os.path.join(tmpdir, 'peer.json')
         p.save_to_file(path)
@@ -138,7 +138,7 @@ def test_save_peer_file(self) -> None:
         shutil.rmtree(tmpdir)
 
     def test_retry_connection(self) -> None:
-        p = PeerId()
+        p = Peer()
         interval = p.retry_interval
         p.increment_retry_attempt(0)
         self.assertEqual(self._settings.PEER_CONNECTION_RETRY_INTERVAL_MULTIPLIER*interval, p.retry_interval)
@@ -159,7 +159,7 @@ def test_validate_certificate(self) -> None:
         artifacts = builder.build()
         protocol = artifacts.p2p_manager.server_factory.buildProtocol(Mock())
 
-        peer = PeerId()
+        peer = Peer()
 
         from OpenSSL import crypto
 
@@ -167,14 +167,14 @@ class FakeTransport:
             def getPeerCertificate(self) -> crypto.X509:
 
                 # we use a new peer here just to save the trouble of manually creating a certificate
-                random_peer = PeerId()
+                random_peer = Peer()
                 return crypto.X509.from_cryptography(random_peer.get_certificate())
         protocol.transport = cast(ITransport, FakeTransport())
         result = peer.validate_certificate(protocol)
         self.assertFalse(result)
 
     def test_retry_logic(self) -> None:
-        peer = PeerId()
+        peer = Peer()
         self.assertTrue(peer.can_retry(0))
 
         retry_interval = peer.retry_interval
@@ -220,26 +220,26 @@ class BasePeerIdTest(unittest.TestCase):
 
     async def test_validate_entrypoint(self) -> None:
         manager = self.create_peer('testnet', unlock_wallet=False)
-        peer_id = manager.my_peer
-        peer_id.entrypoints = [Entrypoint.parse('tcp://127.0.0.1:40403')]
+        peer = manager.my_peer
+        peer.entrypoints = [Entrypoint.parse('tcp://127.0.0.1:40403')]
 
         # we consider that we are starting the connection to the peer
         protocol = manager.connections.client_factory.buildProtocol('127.0.0.1')
         protocol.entrypoint = Entrypoint.parse('tcp://127.0.0.1:40403')
-        result = await peer_id.validate_entrypoint(protocol)
+        result = await peer.validate_entrypoint(protocol)
         self.assertTrue(result)
         # if entrypoint is an URI
-        peer_id.entrypoints = [Entrypoint.parse('tcp://uri_name:40403')]
-        result = await peer_id.validate_entrypoint(protocol)
+        peer.entrypoints = [Entrypoint.parse('tcp://uri_name:40403')]
+        result = await peer.validate_entrypoint(protocol)
         self.assertTrue(result)
         # test invalid. DNS in test mode will resolve to '127.0.0.1:40403'
         protocol.entrypoint = Entrypoint.parse('tcp://45.45.45.45:40403')
-        result = await peer_id.validate_entrypoint(protocol)
+        result = await peer.validate_entrypoint(protocol)
         self.assertFalse(result)
 
         # now test when receiving the connection - i.e. the peer starts it
         protocol.entrypoint = None
-        peer_id.entrypoints = [Entrypoint.parse('tcp://127.0.0.1:40403')]
+        peer.entrypoints = [Entrypoint.parse('tcp://127.0.0.1:40403')]
 
         from collections import namedtuple
         Peer = namedtuple('Peer', 'host')
@@ -248,11 +248,11 @@ class FakeTransport:
             def getPeer(self) -> Peer:
                 return Peer(host='127.0.0.1')
         protocol.transport = FakeTransport()
-        result = await peer_id.validate_entrypoint(protocol)
+        result = await peer.validate_entrypoint(protocol)
         self.assertTrue(result)
         # if entrypoint is an URI
-        peer_id.entrypoints = [Entrypoint.parse('tcp://uri_name:40403')]
-        result = await peer_id.validate_entrypoint(protocol)
+        peer.entrypoints = [Entrypoint.parse('tcp://uri_name:40403')]
+        result = await peer.validate_entrypoint(protocol)
         self.assertTrue(result)
 
 
diff --git a/tests/p2p/test_protocol.py b/tests/p2p/test_protocol.py
index 317675c81..7187c7149 100644
--- a/tests/p2p/test_protocol.py
+++ b/tests/p2p/test_protocol.py
@@ -6,7 +6,7 @@
 from twisted.python.failure import Failure
 
 from hathor.p2p.entrypoint import Entrypoint
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.protocol import HathorLineReceiver, HathorProtocol
 from hathor.simulator import FakeConnection
 from hathor.util import json_dumps, json_loadb
@@ -19,10 +19,10 @@ class BaseHathorProtocolTestCase(unittest.TestCase):
     def setUp(self) -> None:
         super().setUp()
         self.network = 'testnet'
-        self.peer_id1 = PeerId()
-        self.peer_id2 = PeerId()
-        self.manager1 = self.create_peer(self.network, peer_id=self.peer_id1)
-        self.manager2 = self.create_peer(self.network, peer_id=self.peer_id2)
+        self.peer1 = Peer()
+        self.peer2 = Peer()
+        self.manager1 = self.create_peer(self.network, peer=self.peer1)
+        self.manager2 = self.create_peer(self.network, peer=self.peer2)
         self.conn = FakeConnection(self.manager1, self.manager2)
 
     def assertAndStepConn(self, conn: FakeConnection, regex1: bytes, regex2: Optional[bytes] = None) -> None:
@@ -70,11 +70,11 @@ def _check_cmd_and_value(self, result: bytes, expected: tuple[bytes, bytes]) ->
     def test_on_connect(self) -> None:
         self._check_result_only_cmd(self.conn.peek_tr1_value(), b'HELLO')
 
-    def test_peer_id_with_entrypoint(self) -> None:
+    def test_peer_with_entrypoint(self) -> None:
         entrypoint_str = 'tcp://192.168.1.1:54321'
         entrypoint = Entrypoint.parse(entrypoint_str)
-        self.peer_id1.entrypoints.append(entrypoint)
-        self.peer_id2.entrypoints.append(entrypoint)
+        self.peer1.entrypoints.append(entrypoint)
+        self.peer2.entrypoints.append(entrypoint)
         self.conn.run_one_step()  # HELLO
 
         msg1 = self.conn.peek_tr1_value()
@@ -196,7 +196,7 @@ def test_valid_hello(self) -> None:
         self.assertFalse(self.conn.tr2.disconnecting)
 
     def test_invalid_same_peer_id(self) -> None:
-        manager3 = self.create_peer(self.network, peer_id=self.peer_id1)
+        manager3 = self.create_peer(self.network, peer=self.peer1)
         conn = FakeConnection(self.manager1, manager3)
         conn.run_one_step()  # HELLO
         conn.run_one_step()  # PEER-ID
@@ -213,7 +213,7 @@ def test_invalid_same_peer_id2(self) -> None:
         # runs the main loop.
         self.conn.disable_idle_timeout()
         # Create new peer and disable idle timeout.
-        manager3 = self.create_peer(self.network, peer_id=self.peer_id2)
+        manager3 = self.create_peer(self.network, peer=self.peer2)
         conn = FakeConnection(manager3, self.manager1)
         # Disable idle timeout.
         conn.disable_idle_timeout()
@@ -287,26 +287,26 @@ def test_on_disconnect_after_hello(self) -> None:
         self.conn.disconnect(Failure(Exception('testing')))
         self.assertNotIn(self.conn.proto1, self.manager1.connections.handshaking_peers)
 
-    def test_on_disconnect_after_peer_id(self) -> None:
+    def test_on_disconnect_after_peer(self) -> None:
         self.conn.run_one_step()  # HELLO
         self.assertIn(self.conn.proto1, self.manager1.connections.handshaking_peers)
         # No peer id in the peer_storage (known_peers)
-        self.assertNotIn(self.peer_id2.id, self.manager1.connections.peer_storage)
+        self.assertNotIn(self.peer2.id, self.manager1.connections.peer_storage)
         # The peer READY now depends on a message exchange from both peers, so we need one more step
         self.conn.run_one_step()  # PEER-ID
         self.conn.run_one_step()  # READY
         self.assertIn(self.conn.proto1, self.manager1.connections.connected_peers.values())
         # Peer id 2 in the peer_storage (known_peers) after connection
-        self.assertIn(self.peer_id2.id, self.manager1.connections.peer_storage)
+        self.assertIn(self.peer2.id, self.manager1.connections.peer_storage)
         self.assertNotIn(self.conn.proto1, self.manager1.connections.handshaking_peers)
         self.conn.disconnect(Failure(Exception('testing')))
         # Peer id 2 in the peer_storage (known_peers) after disconnection but before looping call
-        self.assertIn(self.peer_id2.id, self.manager1.connections.peer_storage)
+        self.assertIn(self.peer2.id, self.manager1.connections.peer_storage)
         self.assertNotIn(self.conn.proto1, self.manager1.connections.connected_peers.values())
 
         self.clock.advance(10)
         # Peer id 2 removed from peer_storage (known_peers) after disconnection and after looping call
-        self.assertNotIn(self.peer_id2.id, self.manager1.connections.peer_storage)
+        self.assertNotIn(self.peer2.id, self.manager1.connections.peer_storage)
 
     def test_idle_connection(self) -> None:
         self.clock.advance(self._settings.PEER_IDLE_TIMEOUT - 10)
diff --git a/tests/p2p/test_sync_v2.py b/tests/p2p/test_sync_v2.py
index 06e35ebdf..3e8af4f8b 100644
--- a/tests/p2p/test_sync_v2.py
+++ b/tests/p2p/test_sync_v2.py
@@ -7,7 +7,7 @@
 from twisted.python.failure import Failure
 
 from hathor.p2p.messages import ProtocolMessages
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.states import ReadyState
 from hathor.p2p.sync_v2.agent import NodeBlockSync, _HeightInfo
 from hathor.simulator import FakeConnection
@@ -66,9 +66,9 @@ def _run_restart_test(self, *, full_verification: bool, use_tx_storage_cache: bo
 
         # Create a new peer and run sync for a while (but stop before getting synced).
         path = self.mkdtemp()
-        peer_id = PeerId()
+        peer = Peer()
         builder2 = self.simulator.get_default_builder() \
-            .set_peer_id(peer_id) \
+            .set_peer(peer) \
             .disable_sync_v1() \
             .enable_sync_v2() \
             .use_rocksdb(path)
@@ -107,7 +107,7 @@ def _run_restart_test(self, *, full_verification: bool, use_tx_storage_cache: bo
 
         # Restart full node using the same db.
         builder3 = self.simulator.get_default_builder() \
-            .set_peer_id(peer_id) \
+            .set_peer(peer) \
             .disable_sync_v1() \
             .enable_sync_v2() \
             .use_rocksdb(path)
@@ -220,9 +220,9 @@ def test_exceeds_streaming_and_mempool_limits(self) -> None:
             print()
 
         # Create a new peer and run sync for a while (but stop before getting synced).
-        peer_id = PeerId()
+        peer = Peer()
         builder2 = self.simulator.get_default_builder() \
-            .set_peer_id(peer_id) \
+            .set_peer(peer) \
             .disable_sync_v1() \
             .enable_sync_v2() \
 
@@ -311,9 +311,9 @@ def custom_gen_new_tx(manager: HathorManager, _address: str, value: int) -> Tran
         self.assertGreater(mempool_tips_count, 30)
 
         # Create a new peer and run sync for a while (but stop before getting synced).
-        peer_id = PeerId()
+        peer = Peer()
         builder2 = self.simulator.get_default_builder() \
-            .set_peer_id(peer_id) \
+            .set_peer(peer) \
             .disable_sync_v1() \
             .enable_sync_v2() \
 
diff --git a/tests/resources/p2p/test_add_peer.py b/tests/resources/p2p/test_add_peer.py
index c22598b8a..79bb9fa5d 100644
--- a/tests/resources/p2p/test_add_peer.py
+++ b/tests/resources/p2p/test_add_peer.py
@@ -1,7 +1,7 @@
 from twisted.internet.defer import inlineCallbacks
 
 from hathor.p2p.entrypoint import Entrypoint
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.resources import AddPeersResource
 from tests import unittest
 from tests.resources.base_resource import StubSite, _BaseResourceTest
@@ -21,7 +21,7 @@ def test_connecting_peers(self):
         self.assertTrue(data['success'])
 
         # test when we send a peer we're already connected to
-        peer = PeerId()
+        peer = Peer()
         peer.entrypoints = [Entrypoint.parse('tcp://localhost:8006')]
         self.manager.connections.peer_storage.add(peer)
         response = yield self.web.post('p2p/peers', ['tcp://localhost:8006', 'tcp://localhost:8007'])
diff --git a/tests/simulation/base.py b/tests/simulation/base.py
index 1811dd873..e3de5b68e 100644
--- a/tests/simulation/base.py
+++ b/tests/simulation/base.py
@@ -48,7 +48,7 @@ def create_peer(  # type: ignore[override]
             simulator = self.simulator
 
         builder = simulator.get_default_builder() \
-            .set_peer_id(self.get_random_peer_id_from_pool(rng=simulator.rng)) \
+            .set_peer(self.get_random_peer_from_pool(rng=simulator.rng)) \
             .set_soft_voided_tx_ids(soft_voided_tx_ids) \
             .set_sync_v1_support(sync_v1_support) \
             .set_sync_v2_support(sync_v2_support)
diff --git a/tests/simulation/test_simulator_itself.py b/tests/simulation/test_simulator_itself.py
index 22b1c311b..146f327ce 100644
--- a/tests/simulation/test_simulator_itself.py
+++ b/tests/simulation/test_simulator_itself.py
@@ -2,7 +2,7 @@
 
 from hathor.builder import SyncSupportLevel
 from hathor.manager import HathorManager
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.simulator import FakeConnection, Simulator
 from tests import unittest
 
@@ -42,7 +42,7 @@ def tearDown(self) -> None:
     def create_simulator_peer(
         self,
         simulator: Simulator,
-        peer_id_pool: list[PeerId],
+        peer_pool: list[Peer],
         enable_sync_v1: bool | None = None,
         enable_sync_v2: bool | None = None
     ) -> HathorManager:
@@ -59,7 +59,7 @@ def create_simulator_peer(
         sync_v2_support = SyncSupportLevel.ENABLED if enable_sync_v2 else SyncSupportLevel.DISABLED
 
         builder = simulator.get_default_builder() \
-            .set_peer_id(self.get_random_peer_id_from_pool()) \
+            .set_peer(self.get_random_peer_from_pool()) \
             .set_sync_v1_support(sync_v1_support) \
             .set_sync_v2_support(sync_v2_support)
 
@@ -74,9 +74,9 @@ def _simulate_run(self, run_i: int, simulator: Simulator) -> list[HathorManager]
         nodes = []
         miners = []
         tx_generators = []
-        peer_id_pool = self.new_peer_id_pool()
+        peer_pool = self.new_peer_pool()
 
-        manager = self.create_simulator_peer(simulator, peer_id_pool)
+        manager = self.create_simulator_peer(simulator, peer_pool)
         nodes.append(manager)
         miner = simulator.create_miner(manager, hashpower=10e6)
         miner.start()
@@ -85,7 +85,7 @@ def _simulate_run(self, run_i: int, simulator: Simulator) -> list[HathorManager]
         simulator.run(10)
 
         for i, hashpower in enumerate([10e6, 8e6, 5e6]):
-            manager = self.create_simulator_peer(simulator, peer_id_pool)
+            manager = self.create_simulator_peer(simulator, peer_pool)
             for node in nodes:
                 conn = FakeConnection(manager, node, latency=0.085)
                 simulator.add_connection(conn)
@@ -103,7 +103,7 @@ def _simulate_run(self, run_i: int, simulator: Simulator) -> list[HathorManager]
 
         self.log.debug(f'run{run_i}: adding late node')
 
-        late_manager = self.create_simulator_peer(simulator, peer_id_pool)
+        late_manager = self.create_simulator_peer(simulator, peer_pool)
         for node in nodes:
             conn = FakeConnection(late_manager, node, latency=0.300)
             simulator.add_connection(conn)
@@ -152,18 +152,18 @@ def test_determinism_interleaved(self) -> None:
         miners2 = []
         tx_generators1 = []
         tx_generators2 = []
-        peer_id_pool1 = self.new_peer_id_pool()
-        peer_id_pool2 = self.new_peer_id_pool()
+        peer_pool1 = self.new_peer_pool()
+        peer_pool2 = self.new_peer_pool()
 
         self.log.debug('part1 simulator1')
-        manager1 = self.create_simulator_peer(self.simulator1, peer_id_pool1)
+        manager1 = self.create_simulator_peer(self.simulator1, peer_pool1)
         nodes1.append(manager1)
         miner1 = self.simulator1.create_miner(manager1, hashpower=10e6)
         miner1.start()
         miners1.append(miner1)
 
         self.log.debug('part1 simulator2')
-        manager2 = self.create_simulator_peer(self.simulator2, peer_id_pool2)
+        manager2 = self.create_simulator_peer(self.simulator2, peer_pool2)
         nodes2.append(manager2)
         miner2 = self.simulator2.create_miner(manager2, hashpower=10e6)
         miner2.start()
@@ -179,7 +179,7 @@ def test_determinism_interleaved(self) -> None:
 
         for i, hashpower in enumerate([10e6, 8e6, 5e6]):
             self.log.debug(f'part2.{i} simulator1')
-            manager1 = self.create_simulator_peer(self.simulator1, peer_id_pool1)
+            manager1 = self.create_simulator_peer(self.simulator1, peer_pool1)
             for node in nodes1:
                 conn = FakeConnection(manager1, node, latency=0.085)
                 self.simulator1.add_connection(conn)
@@ -189,7 +189,7 @@ def test_determinism_interleaved(self) -> None:
             miners1.append(miner1)
 
             self.log.debug(f'part2.{i} simulator2')
-            manager2 = self.create_simulator_peer(self.simulator2, peer_id_pool2)
+            manager2 = self.create_simulator_peer(self.simulator2, peer_pool2)
             for node in nodes2:
                 conn = FakeConnection(manager2, node, latency=0.085)
                 self.simulator2.add_connection(conn)
@@ -222,14 +222,14 @@ def test_determinism_interleaved(self) -> None:
         self.log.debug('adding late node')
 
         self.log.debug('part4 simulator1')
-        late_manager1 = self.create_simulator_peer(self.simulator1, peer_id_pool1)
+        late_manager1 = self.create_simulator_peer(self.simulator1, peer_pool1)
         for node in nodes1:
             conn = FakeConnection(late_manager1, node, latency=0.300)
             self.simulator1.add_connection(conn)
         nodes1.append(late_manager1)
 
         self.log.debug('part4 simulator2')
-        late_manager2 = self.create_simulator_peer(self.simulator2, peer_id_pool2)
+        late_manager2 = self.create_simulator_peer(self.simulator2, peer_pool2)
         for node in nodes2:
             conn = FakeConnection(late_manager2, node, latency=0.300)
             self.simulator2.add_connection(conn)
diff --git a/tests/unittest.py b/tests/unittest.py
index bac8fca7c..fc5ec27f1 100644
--- a/tests/unittest.py
+++ b/tests/unittest.py
@@ -17,7 +17,7 @@
 from hathor.event import EventManager
 from hathor.event.storage import EventStorage
 from hathor.manager import HathorManager
-from hathor.p2p.peer_id import PeerId
+from hathor.p2p.peer import Peer
 from hathor.p2p.sync_v1.agent import NodeSyncTimestamp
 from hathor.p2p.sync_v2.agent import NodeBlockSync
 from hathor.p2p.sync_version import SyncVersion
@@ -40,7 +40,7 @@ def short_hashes(container: Collection[bytes]) -> Iterable[str]:
     return map(lambda hash_bytes: hash_bytes[-2:].hex(), container)
 
 
-def _load_peer_id_pool(file_path: Optional[str] = None) -> Iterator[PeerId]:
+def _load_peer_pool(file_path: Optional[str] = None) -> Iterator[Peer]:
     import json
 
     if file_path is None:
@@ -49,7 +49,7 @@ def _load_peer_id_pool(file_path: Optional[str] = None) -> Iterator[PeerId]:
     with open(file_path) as peer_id_pool_file:
         peer_id_pool_dict = json.load(peer_id_pool_file)
         for peer_id_dict in peer_id_pool_dict:
-            yield PeerId.create_from_json(peer_id_dict)
+            yield Peer.create_from_json(peer_id_dict)
 
 
 def _get_default_peer_id_pool_filepath() -> str:
@@ -60,7 +60,7 @@ def _get_default_peer_id_pool_filepath() -> str:
     return file_path
 
 
-PEER_ID_POOL = list(_load_peer_id_pool())
+PEER_ID_POOL = list(_load_peer_pool())
 
 # XXX: Sync*Params classes should be inherited before the TestCase class when a sync version is needed
 
@@ -97,10 +97,10 @@ def build(self) -> BuildArtifacts:
         artifacts.manager.connections.disable_rate_limiter()
         return artifacts
 
-    def _get_peer_id(self) -> PeerId:
-        if self._peer_id is not None:
-            return self._peer_id
-        return PeerId()
+    def _get_peer(self) -> Peer:
+        if self._peer is not None:
+            return self._peer
+        return Peer()
 
     def _get_reactor(self) -> Reactor:
         if self._reactor is None:
@@ -120,7 +120,7 @@ def setUp(self) -> None:
         self.clock.advance(time.time())
         self.reactor = self.clock
         self.log = logger.new()
-        self.reset_peer_id_pool()
+        self.reset_peer_pool()
         self.seed = secrets.randbits(64) if self.seed_config is None else self.seed_config
         self.log.info('set seed', seed=self.seed)
         self.rng = Random(self.seed)
@@ -132,23 +132,22 @@ def tearDown(self) -> None:
         for fn in self._pending_cleanups:
             fn()
 
-    def reset_peer_id_pool(self) -> None:
-        self._free_peer_id_pool = self.new_peer_id_pool()
+    def reset_peer_pool(self) -> None:
+        self._free_peer_pool = self.new_peer_pool()
 
-    def new_peer_id_pool(self) -> list[PeerId]:
+    def new_peer_pool(self) -> list[Peer]:
         return PEER_ID_POOL.copy()
 
-    def get_random_peer_id_from_pool(self, pool: Optional[list[PeerId]] = None,
-                                     rng: Optional[Random] = None) -> PeerId:
+    def get_random_peer_from_pool(self, pool: Optional[list[Peer]] = None, rng: Optional[Random] = None) -> Peer:
         if pool is None:
-            pool = self._free_peer_id_pool
+            pool = self._free_peer_pool
         if not pool:
             raise RuntimeError('no more peer ids on the pool')
         if rng is None:
             rng = self.rng
-        peer_id = self.rng.choice(pool)
-        pool.remove(peer_id)
-        return peer_id
+        peer = self.rng.choice(pool)
+        pool.remove(peer)
+        return peer
 
     def mkdtemp(self) -> str:
         tmpdir = tempfile.mkdtemp()
@@ -194,7 +193,7 @@ def create_peer_from_builder(self, builder: Builder, start_manager: bool = True)
     def create_peer(  # type: ignore[no-untyped-def]
         self,
         network: str,
-        peer_id: PeerId | None = None,
+        peer: Peer | None = None,
         wallet: BaseWallet | None = None,
         tx_storage: TransactionStorage | None = None,
         unlock_wallet: bool = True,
@@ -225,9 +224,9 @@ def create_peer(  # type: ignore[no-untyped-def]
         if pubsub:
             builder.set_pubsub(pubsub)
 
-        if peer_id is None:
-            peer_id = PeerId()
-        builder.set_peer_id(peer_id)
+        if peer is None:
+            peer = Peer()
+        builder.set_peer(peer)
 
         if not wallet:
             wallet = self._create_test_wallet()