@libp2p/kad-dht 2.0.0 → 3.0.2

package/src/message/dht.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/export */
 /* eslint-disable @typescript-eslint/no-namespace */
 
-import { encodeMessage, decodeMessage, message, bytes, string, enumeration, int32 } from 'protons-runtime'
+import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
 
 export interface Record {
@@ -13,21 +14,85 @@ export interface Record {
 }
 
 export namespace Record {
+  let _codec: Codec<Record>
+
   export const codec = (): Codec<Record> => {
-    return message<Record>({
-      1: { name: 'key', codec: bytes, optional: true },
-      2: { name: 'value', codec: bytes, optional: true },
-      3: { name: 'author', codec: bytes, optional: true },
-      4: { name: 'signature', codec: bytes, optional: true },
-      5: { name: 'timeReceived', codec: string, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<Record>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.key != null) {
+          writer.uint32(10)
+          writer.bytes(obj.key)
+        }
+
+        if (obj.value != null) {
+          writer.uint32(18)
+          writer.bytes(obj.value)
+        }
+
+        if (obj.author != null) {
+          writer.uint32(26)
+          writer.bytes(obj.author)
+        }
+
+        if (obj.signature != null) {
+          writer.uint32(34)
+          writer.bytes(obj.signature)
+        }
+
+        if (obj.timeReceived != null) {
+          writer.uint32(42)
+          writer.string(obj.timeReceived)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.key = reader.bytes()
+              break
+            case 2:
+              obj.value = reader.bytes()
+              break
+            case 3:
+              obj.author = reader.bytes()
+              break
+            case 4:
+              obj.signature = reader.bytes()
+              break
+            case 5:
+              obj.timeReceived = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: Record): Uint8Array => {
     return encodeMessage(obj, Record.codec())
   }
 
-  export const decode = (buf: Uint8Array): Record => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Record => {
     return decodeMessage(buf, Record.codec())
   }
 }
@@ -62,7 +127,7 @@ export namespace Message {
 
   export namespace MessageType {
     export const codec = () => {
-      return enumeration<typeof MessageType>(__MessageTypeValues)
+      return enumeration<MessageType>(__MessageTypeValues)
     }
   }
 
@@ -82,7 +147,7 @@ export namespace Message {
 
   export namespace ConnectionType {
     export const codec = () => {
-      return enumeration<typeof ConnectionType>(__ConnectionTypeValues)
+      return enumeration<ConnectionType>(__ConnectionTypeValues)
     }
   }
 
@@ -93,39 +158,192 @@ export namespace Message {
   }
 
   export namespace Peer {
+    let _codec: Codec<Peer>
+
     export const codec = (): Codec<Peer> => {
-      return message<Peer>({
-        1: { name: 'id', codec: bytes, optional: true },
-        2: { name: 'addrs', codec: bytes, repeats: true },
-        3: { name: 'connection', codec: Message.ConnectionType.codec(), optional: true }
-      })
+      if (_codec == null) {
+        _codec = message<Peer>((obj, writer, opts = {}) => {
+          if (opts.lengthDelimited !== false) {
+            writer.fork()
+          }
+
+          if (obj.id != null) {
+            writer.uint32(10)
+            writer.bytes(obj.id)
+          }
+
+          if (obj.addrs != null) {
+            for (const value of obj.addrs) {
+              writer.uint32(18)
+              writer.bytes(value)
+            }
+          } else {
+            throw new Error('Protocol error: required field "addrs" was not found in object')
+          }
+
+          if (obj.connection != null) {
+            writer.uint32(24)
+            Message.ConnectionType.codec().encode(obj.connection, writer)
+          }
+
+          if (opts.lengthDelimited !== false) {
+            writer.ldelim()
+          }
+        }, (reader, length) => {
+          const obj: any = {}
+
+          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 = obj.addrs ?? []
+                obj.addrs.push(reader.bytes())
+                break
+              case 3:
+                obj.connection = Message.ConnectionType.codec().decode(reader)
+                break
+              default:
+                reader.skipType(tag & 7)
+                break
+            }
+          }
+
+          obj.addrs = obj.addrs ?? []
+
+          if (obj.addrs == null) {
+            throw new Error('Protocol error: value for required field "addrs" was not found in protobuf')
+          }
+
+          return obj
+        })
+      }
+
+      return _codec
     }
 
     export const encode = (obj: Peer): Uint8Array => {
       return encodeMessage(obj, Peer.codec())
     }
 
-    export const decode = (buf: Uint8Array): Peer => {
+    export const decode = (buf: Uint8Array | Uint8ArrayList): Peer => {
       return decodeMessage(buf, Peer.codec())
     }
   }
 
+  let _codec: Codec<Message>
+
   export const codec = (): Codec<Message> => {
-    return message<Message>({
-      1: { name: 'type', codec: Message.MessageType.codec(), optional: true },
-      10: { name: 'clusterLevelRaw', codec: int32, optional: true },
-      2: { name: 'key', codec: bytes, optional: true },
-      3: { name: 'record', codec: bytes, optional: true },
-      8: { name: 'closerPeers', codec: Message.Peer.codec(), repeats: true },
-      9: { name: 'providerPeers', codec: Message.Peer.codec(), repeats: true }
-    })
+    if (_codec == null) {
+      _codec = message<Message>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.type != null) {
+          writer.uint32(8)
+          Message.MessageType.codec().encode(obj.type, writer)
+        }
+
+        if (obj.clusterLevelRaw != null) {
+          writer.uint32(80)
+          writer.int32(obj.clusterLevelRaw)
+        }
+
+        if (obj.key != null) {
+          writer.uint32(18)
+          writer.bytes(obj.key)
+        }
+
+        if (obj.record != null) {
+          writer.uint32(26)
+          writer.bytes(obj.record)
+        }
+
+        if (obj.closerPeers != null) {
+          for (const value of obj.closerPeers) {
+            writer.uint32(66)
+            Message.Peer.codec().encode(value, writer)
+          }
+        } else {
+          throw new Error('Protocol error: required field "closerPeers" was not found in object')
+        }
+
+        if (obj.providerPeers != null) {
+          for (const value of obj.providerPeers) {
+            writer.uint32(74)
+            Message.Peer.codec().encode(value, writer)
+          }
+        } else {
+          throw new Error('Protocol error: required field "providerPeers" was not found in object')
+        }
+
+        if (opts.lengthDelimited !== false) {
+          writer.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = Message.MessageType.codec().decode(reader)
+              break
+            case 10:
+              obj.clusterLevelRaw = reader.int32()
+              break
+            case 2:
+              obj.key = reader.bytes()
+              break
+            case 3:
+              obj.record = reader.bytes()
+              break
+            case 8:
+              obj.closerPeers = obj.closerPeers ?? []
+              obj.closerPeers.push(Message.Peer.codec().decode(reader, reader.uint32()))
+              break
+            case 9:
+              obj.providerPeers = obj.providerPeers ?? []
+              obj.providerPeers.push(Message.Peer.codec().decode(reader, reader.uint32()))
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.closerPeers = obj.closerPeers ?? []
+        obj.providerPeers = obj.providerPeers ?? []
+
+        if (obj.closerPeers == null) {
+          throw new Error('Protocol error: value for required field "closerPeers" was not found in protobuf')
+        }
+
+        if (obj.providerPeers == null) {
+          throw new Error('Protocol error: value for required field "providerPeers" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: Message): Uint8Array => {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array): Message => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
     return decodeMessage(buf, Message.codec())
   }
 }

package/src/message/index.ts

@@ -3,6 +3,7 @@ import { Multiaddr } from '@multiformats/multiaddr'
 import { Libp2pRecord } from '@libp2p/record'
 import { Message as PBMessage } from './dht.js'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export const MESSAGE_TYPE = PBMessage.MessageType
 export const CONNECTION_TYPE = PBMessage.ConnectionType
@@ -64,14 +65,14 @@ export class Message {
       clusterLevelRaw: this.clusterLevelRaw,
       closerPeers: this.closerPeers.map(toPbPeer),
       providerPeers: this.providerPeers.map(toPbPeer),
-      record: this.record == null ? undefined : this.record.serialize()
+      record: this.record == null ? undefined : this.record.serialize().subarray()
     })
   }
 
   /**
    * Decode from protobuf
    */
-  static deserialize (raw: Uint8Array) {
+  static deserialize (raw: Uint8ArrayList | Uint8Array) {
     const dec = PBMessage.decode(raw)
 
     const msg = new Message(dec.type ?? PBMessage.MessageType.PUT_VALUE, dec.key ?? Uint8Array.from([]), dec.clusterLevelRaw ?? 0)

package/src/network.ts

@@ -21,6 +21,7 @@ import type { PeerInfo } from '@libp2p/interface-peer-info'
 import { Components, Initializable } from '@libp2p/components'
 import type { Stream } from '@libp2p/interface-connection'
 import { abortableDuplex } from 'abortable-iterator'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface NetworkInit {
   protocol: string
@@ -97,8 +98,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
 
     try {
       const connection = await this.components.getConnectionManager().openConnection(to, options)
-      const streamData = await connection.newStream(this.protocol, options)
-      stream = streamData.stream
+      const stream = await connection.newStream(this.protocol, options)
 
       const response = await this._writeReadMessage(stream, msg.serialize(), options)
 
@@ -134,8 +134,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
 
     try {
       const connection = await this.components.getConnectionManager().openConnection(to, options)
-      const data = await connection.newStream(this.protocol, options)
-      stream = data.stream
+      const stream = await connection.newStream(this.protocol, options)
 
       await this._writeMessage(stream, msg.serialize(), options)
 
@@ -152,7 +151,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
   /**
    * Write a message to the given stream
    */
-  async _writeMessage (stream: Duplex<Uint8Array>, msg: Uint8Array, options: AbortOptions) {
+  async _writeMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions) {
     if (options.signal != null) {
       stream = abortableDuplex(stream, options.signal)
     }
@@ -170,7 +169,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
    * If no response is received after the specified timeout
    * this will error out.
    */
-  async _writeReadMessage (stream: Duplex<Uint8Array>, msg: Uint8Array, options: AbortOptions) {
+  async _writeReadMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions) {
     if (options.signal != null) {
       stream = abortableDuplex(stream, options.signal)
     }

package/src/peer-routing/index.ts

@@ -58,7 +58,7 @@ export class PeerRouting implements Initializable {
    * Look if we are connected to a peer with the given id.
    * Returns its id and addresses, if found, otherwise `undefined`.
    */
-  async findPeerLocal (peer: PeerId) {
+  async findPeerLocal (peer: PeerId): Promise<PeerInfo | undefined> {
     let peerData
     const p = await this.routingTable.find(peer)
 
@@ -93,6 +93,8 @@ export class PeerRouting implements Initializable {
         protocols: []
       }
     }
+
+    return undefined
   }
 
   /**

package/src/routing-table/index.ts

@@ -158,7 +158,7 @@ export class RoutingTable implements Startable, Initializable {
 
               this.log('pinging old contact %p', oldContact.peer)
               const connection = await this.components.getConnectionManager().openConnection(oldContact.peer, options)
-              const { stream } = await connection.newStream(this.protocol, options)
+              const stream = await connection.newStream(this.protocol, options)
               stream.close()
               responded++
             } catch (err: any) {
@@ -213,30 +213,34 @@ export class RoutingTable implements Startable, Initializable {
   /**
    * Find a specific peer by id
    */
-  async find (peer: PeerId) {
+  async find (peer: PeerId): Promise<PeerId | undefined> {
     const key = await utils.convertPeerId(peer)
     const closest = this.closestPeer(key)
 
     if (closest != null && peer.equals(closest)) {
       return closest
     }
+
+    return undefined
   }
 
   /**
    * Retrieve the closest peers to the given key
    */
-  closestPeer (key: Uint8Array) {
+  closestPeer (key: Uint8Array): PeerId | undefined {
     const res = this.closestPeers(key, 1)
 
     if (res.length > 0) {
       return res[0]
     }
+
+    return undefined
   }
 
   /**
    * Retrieve the `count`-closest peers to the given key
    */
-  closestPeers (key: Uint8Array, count = this.kBucketSize) {
+  closestPeers (key: Uint8Array, count = this.kBucketSize): PeerId[] {
     if (this.kb == null) {
       return []
     }

package/src/rpc/handlers/put-value.ts

@@ -46,7 +46,7 @@ export class PutValueHandler implements DHTMessageHandler, Initializable {
 
       record.timeReceived = new Date()
       const recordKey = bufferToRecordKey(record.key)
-      await this.components.getDatastore().put(recordKey, record.serialize())
+      await this.components.getDatastore().put(recordKey, record.serialize().subarray())
       this.log('put record for %b into datastore under key %k', key, recordKey)
     } catch (err: any) {
       this.log('did not put record for key %b into datastore %o', key, err)

package/src/utils.ts

@@ -92,15 +92,15 @@ export function keyForPublicKey (peer: PeerId) {
 }
 
 export function isPublicKeyKey (key: Uint8Array) {
-  return uint8ArrayToString(key.slice(0, 4)) === '/pk/'
+  return uint8ArrayToString(key.subarray(0, 4)) === '/pk/'
 }
 
 export function isIPNSKey (key: Uint8Array) {
-  return uint8ArrayToString(key.slice(0, 4)) === '/ipns/'
+  return uint8ArrayToString(key.subarray(0, 4)) === '/ipns/'
 }
 
 export function fromPublicKeyKey (key: Uint8Array) {
-  return peerIdFromBytes(key.slice(4))
+  return peerIdFromBytes(key.subarray(4))
 }
 
 /**