@libp2p/kad-dht 11.0.8 → 12.0.0-4e0135c7d

package/src/message/dht.ts

@@ -4,8 +4,8 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime'
+import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Record {
@@ -63,24 +63,30 @@ export namespace Record {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.key = reader.bytes()
               break
-            case 2:
+            }
+            case 2: {
               obj.value = reader.bytes()
               break
-            case 3:
+            }
+            case 3: {
               obj.author = reader.bytes()
               break
-            case 4:
+            }
+            case 4: {
               obj.signature = reader.bytes()
               break
-            case 5:
+            }
+            case 5: {
               obj.timeReceived = reader.string()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -100,138 +106,141 @@ export namespace Record {
   }
 }
 
-export interface Message {
-  type?: Message.MessageType
-  clusterLevelRaw?: number
-  key?: Uint8Array
-  record?: Uint8Array
-  closerPeers: Message.Peer[]
-  providerPeers: Message.Peer[]
+export enum MessageType {
+  PUT_VALUE = 'PUT_VALUE',
+  GET_VALUE = 'GET_VALUE',
+  ADD_PROVIDER = 'ADD_PROVIDER',
+  GET_PROVIDERS = 'GET_PROVIDERS',
+  FIND_NODE = 'FIND_NODE',
+  PING = 'PING'
 }
 
-export namespace Message {
-  export enum MessageType {
-    PUT_VALUE = 'PUT_VALUE',
-    GET_VALUE = 'GET_VALUE',
-    ADD_PROVIDER = 'ADD_PROVIDER',
-    GET_PROVIDERS = 'GET_PROVIDERS',
-    FIND_NODE = 'FIND_NODE',
-    PING = 'PING'
-  }
-
-  enum __MessageTypeValues {
-    PUT_VALUE = 0,
-    GET_VALUE = 1,
-    ADD_PROVIDER = 2,
-    GET_PROVIDERS = 3,
-    FIND_NODE = 4,
-    PING = 5
-  }
+enum __MessageTypeValues {
+  PUT_VALUE = 0,
+  GET_VALUE = 1,
+  ADD_PROVIDER = 2,
+  GET_PROVIDERS = 3,
+  FIND_NODE = 4,
+  PING = 5
+}
 
-  export namespace MessageType {
-    export const codec = (): Codec<MessageType> => {
-      return enumeration<MessageType>(__MessageTypeValues)
-    }
+export namespace MessageType {
+  export const codec = (): Codec<MessageType> => {
+    return enumeration<MessageType>(__MessageTypeValues)
   }
+}
+export enum ConnectionType {
+  NOT_CONNECTED = 'NOT_CONNECTED',
+  CONNECTED = 'CONNECTED',
+  CAN_CONNECT = 'CAN_CONNECT',
+  CANNOT_CONNECT = 'CANNOT_CONNECT'
+}
 
-  export enum ConnectionType {
-    NOT_CONNECTED = 'NOT_CONNECTED',
-    CONNECTED = 'CONNECTED',
-    CAN_CONNECT = 'CAN_CONNECT',
-    CANNOT_CONNECT = 'CANNOT_CONNECT'
-  }
+enum __ConnectionTypeValues {
+  NOT_CONNECTED = 0,
+  CONNECTED = 1,
+  CAN_CONNECT = 2,
+  CANNOT_CONNECT = 3
+}
 
-  enum __ConnectionTypeValues {
-    NOT_CONNECTED = 0,
-    CONNECTED = 1,
-    CAN_CONNECT = 2,
-    CANNOT_CONNECT = 3
+export namespace ConnectionType {
+  export const codec = (): Codec<ConnectionType> => {
+    return enumeration<ConnectionType>(__ConnectionTypeValues)
   }
+}
+export interface PeerInfo {
+  id: Uint8Array
+  multiaddrs: Uint8Array[]
+  connection?: ConnectionType
+}
 
-  export namespace ConnectionType {
-    export const codec = (): Codec<ConnectionType> => {
-      return enumeration<ConnectionType>(__ConnectionTypeValues)
-    }
-  }
+export namespace PeerInfo {
+  let _codec: Codec<PeerInfo>
 
-  export interface Peer {
-    id?: Uint8Array
-    addrs: Uint8Array[]
-    connection?: Message.ConnectionType
-  }
+  export const codec = (): Codec<PeerInfo> => {
+    if (_codec == null) {
+      _codec = message<PeerInfo>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
 
-  export namespace Peer {
-    let _codec: Codec<Peer>
+        if ((obj.id != null && obj.id.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.id)
+        }
 
-    export const codec = (): Codec<Peer> => {
-      if (_codec == null) {
-        _codec = message<Peer>((obj, w, opts = {}) => {
-          if (opts.lengthDelimited !== false) {
-            w.fork()
+        if (obj.multiaddrs != null) {
+          for (const value of obj.multiaddrs) {
+            w.uint32(18)
+            w.bytes(value)
           }
+        }
 
-          if (obj.id != null) {
-            w.uint32(10)
-            w.bytes(obj.id)
-          }
+        if (obj.connection != null) {
+          w.uint32(24)
+          ConnectionType.codec().encode(obj.connection, w)
+        }
 
-          if (obj.addrs != null) {
-            for (const value of obj.addrs) {
-              w.uint32(18)
-              w.bytes(value)
-            }
-          }
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {
+          id: uint8ArrayAlloc(0),
+          multiaddrs: []
+        }
 
-          if (obj.connection != null) {
-            w.uint32(24)
-            Message.ConnectionType.codec().encode(obj.connection, w)
-          }
+        const end = length == null ? reader.len : reader.pos + length
 
-          if (opts.lengthDelimited !== false) {
-            w.ldelim()
-          }
-        }, (reader, length) => {
-          const obj: any = {
-            addrs: []
-          }
+        while (reader.pos < end) {
+          const tag = reader.uint32()
 
-          const end = length == null ? reader.len : reader.pos + length
-
-          while (reader.pos < end) {
-            const tag = reader.uint32()
-
-            switch (tag >>> 3) {
-              case 1:
-                obj.id = reader.bytes()
-                break
-              case 2:
-                obj.addrs.push(reader.bytes())
-                break
-              case 3:
-                obj.connection = Message.ConnectionType.codec().decode(reader)
-                break
-              default:
-                reader.skipType(tag & 7)
-                break
+          switch (tag >>> 3) {
+            case 1: {
+              obj.id = reader.bytes()
+              break
+            }
+            case 2: {
+              obj.multiaddrs.push(reader.bytes())
+              break
+            }
+            case 3: {
+              obj.connection = ConnectionType.codec().decode(reader)
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
             }
           }
+        }
 
-          return obj
-        })
-      }
-
-      return _codec
+        return obj
+      })
     }
 
-    export const encode = (obj: Partial<Peer>): Uint8Array => {
-      return encodeMessage(obj, Peer.codec())
-    }
+    return _codec
+  }
 
-    export const decode = (buf: Uint8Array | Uint8ArrayList): Peer => {
-      return decodeMessage(buf, Peer.codec())
-    }
+  export const encode = (obj: Partial<PeerInfo>): Uint8Array => {
+    return encodeMessage(obj, PeerInfo.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): PeerInfo => {
+    return decodeMessage(buf, PeerInfo.codec())
   }
+}
+
+export interface Message {
+  type: MessageType
+  clusterLevel?: number
+  key?: Uint8Array
+  record?: Uint8Array
+  closer: PeerInfo[]
+  providers: PeerInfo[]
+}
 
+export namespace Message {
   let _codec: Codec<Message>
 
   export const codec = (): Codec<Message> => {
@@ -241,14 +250,14 @@ export namespace Message {
           w.fork()
         }
 
-        if (obj.type != null) {
+        if (obj.type != null && __MessageTypeValues[obj.type] !== 0) {
           w.uint32(8)
-          Message.MessageType.codec().encode(obj.type, w)
+          MessageType.codec().encode(obj.type, w)
         }
 
-        if (obj.clusterLevelRaw != null) {
+        if (obj.clusterLevel != null) {
           w.uint32(80)
-          w.int32(obj.clusterLevelRaw)
+          w.int32(obj.clusterLevel)
         }
 
         if (obj.key != null) {
@@ -261,17 +270,17 @@ export namespace Message {
           w.bytes(obj.record)
         }
 
-        if (obj.closerPeers != null) {
-          for (const value of obj.closerPeers) {
+        if (obj.closer != null) {
+          for (const value of obj.closer) {
             w.uint32(66)
-            Message.Peer.codec().encode(value, w)
+            PeerInfo.codec().encode(value, w)
           }
         }
 
-        if (obj.providerPeers != null) {
-          for (const value of obj.providerPeers) {
+        if (obj.providers != null) {
+          for (const value of obj.providers) {
             w.uint32(74)
-            Message.Peer.codec().encode(value, w)
+            PeerInfo.codec().encode(value, w)
           }
         }
 
@@ -280,8 +289,9 @@ export namespace Message {
         }
       }, (reader, length) => {
         const obj: any = {
-          closerPeers: [],
-          providerPeers: []
+          type: MessageType.PUT_VALUE,
+          closer: [],
+          providers: []
         }
 
         const end = length == null ? reader.len : reader.pos + length
@@ -290,27 +300,34 @@ export namespace Message {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
-              obj.type = Message.MessageType.codec().decode(reader)
+            case 1: {
+              obj.type = MessageType.codec().decode(reader)
               break
-            case 10:
-              obj.clusterLevelRaw = reader.int32()
+            }
+            case 10: {
+              obj.clusterLevel = reader.int32()
               break
-            case 2:
+            }
+            case 2: {
               obj.key = reader.bytes()
               break
-            case 3:
+            }
+            case 3: {
               obj.record = reader.bytes()
               break
-            case 8:
-              obj.closerPeers.push(Message.Peer.codec().decode(reader, reader.uint32()))
+            }
+            case 8: {
+              obj.closer.push(PeerInfo.codec().decode(reader, reader.uint32()))
               break
-            case 9:
-              obj.providerPeers.push(Message.Peer.codec().decode(reader, reader.uint32()))
+            }
+            case 9: {
+              obj.providers.push(PeerInfo.codec().decode(reader, reader.uint32()))
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 

package/src/message/utils.ts

@@ -0,0 +1,25 @@
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import { multiaddr } from '@multiformats/multiaddr'
+import type { PeerInfo as PBPeerInfo, ConnectionType } from './dht.js'
+import type { PeerInfo } from '@libp2p/interface'
+
+export function toPbPeerInfo (peer: PeerInfo, connection?: ConnectionType): PBPeerInfo {
+  const output: PBPeerInfo = {
+    id: peer.id.toBytes(),
+    multiaddrs: (peer.multiaddrs ?? []).map((m) => m.bytes),
+    connection
+  }
+
+  return output
+}
+
+export function fromPbPeerInfo (peer: PBPeerInfo): PeerInfo {
+  if (peer.id == null) {
+    throw new Error('Invalid peer in message')
+  }
+
+  return {
+    id: peerIdFromBytes(peer.id),
+    multiaddrs: (peer.multiaddrs ?? []).map((a) => multiaddr(a))
+  }
+}

package/src/network.ts

@@ -1,18 +1,21 @@
-import { TypedEventEmitter, CustomEvent } from '@libp2p/interface'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { pbStream } from 'it-protobuf-stream'
-import { Message } from './message/index.js'
+import { CodeError } from 'protons-runtime'
+import { Message } from './message/dht.js'
+import { fromPbPeerInfo } from './message/utils.js'
 import {
   dialPeerEvent,
   sendQueryEvent,
   peerResponseEvent,
   queryErrorEvent
 } from './query/events.js'
-import type { KadDHTComponents, QueryEvent, QueryOptions } from './index.js'
-import type { AbortOptions, Logger, Stream, PeerId, PeerInfo, Startable } from '@libp2p/interface'
+import { Libp2pRecord } from './record/index.js'
+import type { KadDHTComponents, QueryEvent } from './index.js'
+import type { AbortOptions, Logger, Stream, PeerId, PeerInfo, Startable, RoutingOptions } from '@libp2p/interface'
 
 export interface NetworkInit {
   protocol: string
-  lan: boolean
+  logPrefix: string
 }
 
 interface NetworkEvents {
@@ -34,9 +37,9 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
   constructor (components: KadDHTComponents, init: NetworkInit) {
     super()
 
-    const { protocol, lan } = init
+    const { protocol } = init
     this.components = components
-    this.log = components.logger.forComponent(`libp2p:kad-dht:${lan ? 'lan' : 'wan'}:network`)
+    this.log = components.logger.forComponent(`${init.logPrefix}:network`)
     this.running = false
     this.protocol = protocol
   }
@@ -69,14 +72,20 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
   /**
    * Send a request and record RTT for latency measurements
    */
-  async * sendRequest (to: PeerId, msg: Message, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
+  async * sendRequest (to: PeerId, msg: Partial<Message>, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       return
     }
 
+    const type = msg.type
+
+    if (type == null) {
+      throw new CodeError('Message type was missing', 'ERR_INVALID_PARAMETERS')
+    }
+
     this.log('sending %s to %p', msg.type, to)
     yield dialPeerEvent({ peer: to }, options)
-    yield sendQueryEvent({ to, type: msg.type }, options)
+    yield sendQueryEvent({ to, type }, options)
 
     let stream: Stream | undefined
 
@@ -89,11 +98,12 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
       yield peerResponseEvent({
         from: to,
         messageType: response.type,
-        closer: response.closerPeers,
-        providers: response.providerPeers,
-        record: response.record
+        closer: response.closer.map(fromPbPeerInfo),
+        providers: response.providers.map(fromPbPeerInfo),
+        record: response.record == null ? undefined : Libp2pRecord.deserialize(response.record)
       }, options)
     } catch (err: any) {
+      this.log.error('could not send %s to %p', msg.type, to, err)
       yield queryErrorEvent({ from: to, error: err }, options)
     } finally {
       if (stream != null) {
@@ -105,14 +115,20 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
   /**
    * Sends a message without expecting an answer
    */
-  async * sendMessage (to: PeerId, msg: Message, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
+  async * sendMessage (to: PeerId, msg: Partial<Message>, options: RoutingOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       return
     }
 
+    const type = msg.type
+
+    if (type == null) {
+      throw new CodeError('Message type was missing', 'ERR_INVALID_PARAMETERS')
+    }
+
     this.log('sending %s to %p', msg.type, to)
     yield dialPeerEvent({ peer: to }, options)
-    yield sendQueryEvent({ to, type: msg.type }, options)
+    yield sendQueryEvent({ to, type }, options)
 
     let stream: Stream | undefined
 
@@ -122,7 +138,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
 
       await this._writeMessage(stream, msg, options)
 
-      yield peerResponseEvent({ from: to, messageType: msg.type }, options)
+      yield peerResponseEvent({ from: to, messageType: type }, options)
     } catch (err: any) {
       yield queryErrorEvent({ from: to, error: err }, options)
     } finally {
@@ -135,7 +151,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
   /**
    * Write a message to the given stream
    */
-  async _writeMessage (stream: Stream, msg: Message, options: AbortOptions): Promise<void> {
+  async _writeMessage (stream: Stream, msg: Partial<Message>, options: AbortOptions): Promise<void> {
     const pb = pbStream(stream)
     await pb.write(msg, Message, options)
     await pb.unwrap().close(options)
@@ -146,7 +162,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
    * If no response is received after the specified timeout
    * this will error out.
    */
-  async _writeReadMessage (stream: Stream, msg: Message, options: AbortOptions): Promise<Message> {
+  async _writeReadMessage (stream: Stream, msg: Partial<Message>, options: AbortOptions): Promise<Message> {
     const pb = pbStream(stream)
 
     await pb.write(msg, Message, options)
@@ -156,15 +172,15 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
     await pb.unwrap().close(options)
 
     // tell any listeners about new peers we've seen
-    message.closerPeers.forEach(peerData => {
-      this.dispatchEvent(new CustomEvent('peer', {
-        detail: peerData
-      }))
+    message.closer.forEach(peerData => {
+      this.safeDispatchEvent<PeerInfo>('peer', {
+        detail: fromPbPeerInfo(peerData)
+      })
     })
-    message.providerPeers.forEach(peerData => {
-      this.dispatchEvent(new CustomEvent('peer', {
-        detail: peerData
-      }))
+    message.providers.forEach(peerData => {
+      this.safeDispatchEvent<PeerInfo>('peer', {
+        detail: fromPbPeerInfo(peerData)
+      })
     })
 
     return message