Refactor ID to take in type bytes only

libp2p/__init__.py

@@ -47,7 +47,7 @@ def initialize_default_kademlia_router(ksize=20, alpha=3, id_opt=None, storage=N
     if not id_opt:
         id_opt = generate_id()
 
-    node_id = id_opt.get_raw_id()
+    node_id = id_opt
     server = KademliaServer(ksize=ksize, alpha=alpha, node_id=node_id, storage=storage)
     return KadmeliaPeerRouter(server)
 

libp2p/kademlia/kad_peerinfo.py

@@ -16,9 +16,8 @@ class KadPeerInfo(PeerInfo):
     def __init__(self, peer_id, peer_data=None):
         super(KadPeerInfo, self).__init__(peer_id, peer_data)
 
-        self.peer_id_obj = peer_id
-        self.peer_id = peer_id.get_raw_id()
-        self.xor_id = peer_id.get_xor_id()
+        self.peer_id = peer_id
+        self.xor_id = peer_id.xor_id
 
         self.addrs = peer_data.get_addrs() if peer_data else None
 
@@ -137,9 +136,8 @@ class KadPeerHeap:
     def get_uncontacted(self):
         return [n for n in self if n.peer_id not in self.contacted]
 
-
-def create_kad_peerinfo(raw_node_id=None, sender_ip=None, sender_port=None):
-    node_id = ID(raw_node_id) if raw_node_id else ID(digest(random.getrandbits(255)))
+def create_kad_peerinfo(node_id=None, sender_ip=None, sender_port=None):
+    node_id = node_id if node_id else ID(digest(random.getrandbits(255)))
     peer_data = None
     if sender_ip and sender_port:
         peer_data = PeerData()  # pylint: disable=no-value-for-parameter

libp2p/peer/id.py

@@ -18,52 +18,55 @@ MAX_INLINE_KEY_LENGTH = 42
 
 class ID:
 
-    _id_str: bytes
+    _bytes: bytes
+    _xor_id: int
 
-    def __init__(self, id_str: bytes) -> None:
-        self._id_str = id_str
+    def __init__(self, peer_id_bytes: bytes) -> None:
+        self._bytes = peer_id_bytes
+
+    @property
+    def xor_id(self) -> int:
+        if not self._xor_id:
+            self._xor_id = int(digest(self._bytes).hex(), 16)
+        return self._xor_id
 
     def to_bytes(self) -> bytes:
-        return self._id_str
-
-    def get_raw_id(self) -> bytes:
-        return self._id_str
+        return self._bytes
 
     def pretty(self) -> str:
-        return base58.b58encode(self._id_str).decode()
-
-    def get_xor_id(self) -> int:
-        return int(digest(self.get_raw_id()).hex(), 16)
+        return base58.b58encode(self._bytes).decode()
 
     def __str__(self) -> str:
-        pid = self.pretty()
-        return pid
+        return self.pretty()
 
     __repr__ = __str__
 
     def __eq__(self, other: object) -> bool:
-        # pylint: disable=protected-access
-        if not isinstance(other, ID):
+        #pylint: disable=protected-access, no-else-return
+        if isinstance(other, bytes):
+            return self._bytes == other
+        elif isinstance(other, ID):
+            return self._bytes == other._bytes
+        else:
             return NotImplemented
-        return self._id_str == other._id_str
 
     def __hash__(self) -> int:
-        return hash(self._id_str)
+        return hash(self._bytes)
 
 
 def id_b58_encode(peer_id: ID) -> str:
     """
     return a b58-encoded string
     """
-    # pylint: disable=protected-access
-    return base58.b58encode(peer_id.get_raw_id()).decode()
+    #pylint: disable=protected-access
+    return base58.b58encode(peer_id.to_bytes()).decode()
 
 
-def id_b58_decode(peer_id_str: str) -> ID:
+def id_b58_decode(b58_encoded_peer_id_str: str) -> ID:
     """
     return a base58-decoded peer ID
     """
-    return ID(base58.b58decode(peer_id_str))
+    return ID(base58.b58decode(b58_encoded_peer_id_str))
 
 
 def id_from_public_key(key: RsaKey) -> ID:

libp2p/routing/kademlia/kademlia_peer_router.py

@@ -22,7 +22,7 @@ class KadmeliaPeerRouter(IPeerRouting):
         :return: KadPeerInfo of specified peer
         """
         # switching peer_id to xor_id used by kademlia as node_id
-        xor_id = peer_id.get_xor_id()
+        xor_id = peer_id.xor_id
         value = await self.server.get(xor_id)
         return decode_peerinfo(value)