@libp2p/kad-dht 9.3.8 → 10.0.0

package/src/record/record.ts

@@ -0,0 +1,87 @@
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+
+import { encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface Record {
+  key: Uint8Array
+  value: Uint8Array
+  timeReceived: string
+}
+
+export namespace Record {
+  let _codec: Codec<Record>
+
+  export const codec = (): Codec<Record> => {
+    if (_codec == null) {
+      _codec = message<Record>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if ((obj.key != null && obj.key.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.key)
+        }
+
+        if ((obj.value != null && obj.value.byteLength > 0)) {
+          w.uint32(18)
+          w.bytes(obj.value)
+        }
+
+        if ((obj.timeReceived != null && obj.timeReceived !== '')) {
+          w.uint32(42)
+          w.string(obj.timeReceived)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {
+          key: new Uint8Array(0),
+          value: new Uint8Array(0),
+          timeReceived: ''
+        }
+
+        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 5:
+              obj.timeReceived = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<Record>): Uint8Array => {
+    return encodeMessage(obj, Record.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Record => {
+    return decodeMessage(buf, Record.codec())
+  }
+}

package/src/record/selectors.ts

@@ -0,0 +1,50 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { Selectors } from '../index.js'
+
+/**
+ * Select the best record out of the given records
+ */
+export function bestRecord (selectors: Selectors, k: Uint8Array, records: Uint8Array[]): number {
+  if (records.length === 0) {
+    const errMsg = 'No records given'
+
+    throw new CodeError(errMsg, 'ERR_NO_RECORDS_RECEIVED')
+  }
+
+  const kStr = uint8ArrayToString(k)
+  const parts = kStr.split('/')
+
+  if (parts.length < 3) {
+    const errMsg = 'Record key does not have a selector function'
+
+    throw new CodeError(errMsg, 'ERR_NO_SELECTOR_FUNCTION_FOR_RECORD_KEY')
+  }
+
+  const selector = selectors[parts[1].toString()]
+
+  if (selector == null) {
+    const errMsg = `Unrecognized key prefix: ${parts[1]}`
+
+    throw new CodeError(errMsg, 'ERR_UNRECOGNIZED_KEY_PREFIX')
+  }
+
+  if (records.length === 1) {
+    return 0
+  }
+
+  return selector(k, records)
+}
+
+/**
+ * Best record selector, for public key records.
+ * Simply returns the first record, as all valid public key
+ * records are equal
+ */
+function publickKey (k: Uint8Array, records: Uint8Array[]): number {
+  return 0
+}
+
+export const selectors: Selectors = {
+  pk: publickKey
+}

package/src/record/utils.ts

@@ -0,0 +1,46 @@
+/**
+ * Convert a JavaScript date into an `RFC3339Nano` formatted
+ * string
+ */
+export function toRFC3339 (time: Date): string {
+  const year = time.getUTCFullYear()
+  const month = String(time.getUTCMonth() + 1).padStart(2, '0')
+  const day = String(time.getUTCDate()).padStart(2, '0')
+  const hour = String(time.getUTCHours()).padStart(2, '0')
+  const minute = String(time.getUTCMinutes()).padStart(2, '0')
+  const seconds = String(time.getUTCSeconds()).padStart(2, '0')
+  const milliseconds = time.getUTCMilliseconds()
+  const nanoseconds = String(milliseconds * 1000 * 1000).padStart(9, '0')
+
+  return `${year}-${month}-${day}T${hour}:${minute}:${seconds}.${nanoseconds}Z`
+}
+
+/**
+ * Parses a date string formatted as `RFC3339Nano` into a
+ * JavaScript Date object
+ */
+export function parseRFC3339 (time: string): Date {
+  const rfc3339Matcher = new RegExp(
+    // 2006-01-02T
+    '(\\d{4})-(\\d{2})-(\\d{2})T' +
+    // 15:04:05
+    '(\\d{2}):(\\d{2}):(\\d{2})' +
+    // .999999999Z
+    '\\.(\\d+)Z'
+  )
+  const m = String(time).trim().match(rfc3339Matcher)
+
+  if (m == null) {
+    throw new Error('Invalid format')
+  }
+
+  const year = parseInt(m[1], 10)
+  const month = parseInt(m[2], 10) - 1
+  const date = parseInt(m[3], 10)
+  const hour = parseInt(m[4], 10)
+  const minute = parseInt(m[5], 10)
+  const second = parseInt(m[6], 10)
+  const millisecond = parseInt(m[7].slice(0, -6), 10)
+
+  return new Date(Date.UTC(year, month, date, hour, minute, second, millisecond))
+}

package/src/record/validators.ts

@@ -0,0 +1,69 @@
+import { CodeError } from '@libp2p/interface/errors'
+import { sha256 } from 'multiformats/hashes/sha2'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { Libp2pRecord } from './index.js'
+import type { Validators } from '../index.js'
+
+/**
+ * Checks a record and ensures it is still valid.
+ * It runs the needed validators.
+ * If verification fails the returned Promise will reject with the error.
+ */
+export async function verifyRecord (validators: Validators, record: Libp2pRecord): Promise<void> {
+  const key = record.key
+  const keyString = uint8ArrayToString(key)
+  const parts = keyString.split('/')
+
+  if (parts.length < 3) {
+    // No validator available
+    return
+  }
+
+  const validator = validators[parts[1].toString()]
+
+  if (validator == null) {
+    const errMsg = 'Invalid record keytype'
+
+    throw new CodeError(errMsg, 'ERR_INVALID_RECORD_KEY_TYPE')
+  }
+
+  await validator(key, record.value)
+}
+
+/**
+ * Validator for public key records.
+ * Verifies that the passed in record value is the PublicKey
+ * that matches the passed in key.
+ * If validation fails the returned Promise will reject with the error.
+ *
+ * @param {Uint8Array} key - A valid key is of the form `'/pk/<keymultihash>'`
+ * @param {Uint8Array} publicKey - The public key to validate against (protobuf encoded).
+ */
+const validatePublicKeyRecord = async (key: Uint8Array, publicKey: Uint8Array): Promise<void> => {
+  if (!(key instanceof Uint8Array)) {
+    throw new CodeError('"key" must be a Uint8Array', 'ERR_INVALID_RECORD_KEY_NOT_BUFFER')
+  }
+
+  if (key.byteLength < 5) {
+    throw new CodeError('invalid public key record', 'ERR_INVALID_RECORD_KEY_TOO_SHORT')
+  }
+
+  const prefix = uint8ArrayToString(key.subarray(0, 4))
+
+  if (prefix !== '/pk/') {
+    throw new CodeError('key was not prefixed with /pk/', 'ERR_INVALID_RECORD_KEY_BAD_PREFIX')
+  }
+
+  const keyhash = key.slice(4)
+
+  const publicKeyHash = await sha256.digest(publicKey)
+
+  if (!uint8ArrayEquals(keyhash, publicKeyHash.bytes)) {
+    throw new CodeError('public key does not match passed in key', 'ERR_INVALID_RECORD_HASH_MISMATCH')
+  }
+}
+
+export const validators: Validators = {
+  pk: validatePublicKeyRecord
+}

package/src/routing-table/index.ts

@@ -1,14 +1,14 @@
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import Queue from 'p-queue'
 import * as utils from '../utils.js'
 import { KBucket, type PingEventDetails } from './k-bucket.js'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Metric, Metrics } from '@libp2p/interface-metrics'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { Metric, Metrics } from '@libp2p/interface/metrics'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { Logger } from '@libp2p/logger'
 
 export const KAD_CLOSE_TAG_NAME = 'kad-close'
@@ -217,7 +217,7 @@ export class RoutingTable extends EventEmitter<RoutingTableEvents> implements St
               this.log('pinging old contact %p', oldContact.peer)
               const connection = await this.components.connectionManager.openConnection(oldContact.peer, options)
               const stream = await connection.newStream(this.protocol, options)
-              stream.close()
+              await stream.close()
               responded++
             } catch (err: any) {
               if (this.running && this.kb != null) {

package/src/routing-table/k-bucket.ts

@@ -27,8 +27,8 @@ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 */
 
-import { EventEmitter } from '@libp2p/interfaces/events'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import { EventEmitter } from '@libp2p/interface/events'
+import type { PeerId } from '@libp2p/interface/peer-id'
 
 function arrayEquals (array1: Uint8Array, array2: Uint8Array): boolean {
   if (array1 === array2) {

package/src/routing-table/refresh.ts

@@ -8,7 +8,7 @@ import { TABLE_REFRESH_INTERVAL, TABLE_REFRESH_QUERY_TIMEOUT } from '../constant
 import GENERATED_PREFIXES from './generated-prefix-list.js'
 import type { RoutingTable } from './index.js'
 import type { PeerRouting } from '../peer-routing/index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Logger } from '@libp2p/logger'
 
 /**

package/src/rpc/handlers/add-provider.ts

@@ -1,10 +1,10 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { CID } from 'multiformats/cid'
 import type { Message } from '../../message/index.js'
 import type { Providers } from '../../providers'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:add-provider')
 

package/src/rpc/handlers/find-node.ts

@@ -8,9 +8,9 @@ import {
 } from '../../utils.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:find-node')
 

package/src/rpc/handlers/get-providers.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { CID } from 'multiformats/cid'
 import { Message } from '../../message/index.js'
@@ -9,9 +9,9 @@ import {
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { Providers } from '../../providers.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { PeerStore } from '@libp2p/interface/peer-store'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-providers')

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

@@ -1,15 +1,15 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
-import { Libp2pRecord } from '@libp2p/record'
 import {
   MAX_RECORD_AGE
 } from '../../constants.js'
 import { Message, MESSAGE_TYPE } from '../../message/index.js'
+import { Libp2pRecord } from '../../record/index.js'
 import { bufferToRecordKey, isPublicKeyKey, fromPublicKeyKey } from '../../utils.js'
 import type { PeerRouting } from '../../peer-routing/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore } from '@libp2p/interface/peer-store'
 import type { Datastore } from 'interface-datastore'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:get-value')

package/src/rpc/handlers/ping.ts

@@ -1,7 +1,7 @@
 import { logger } from '@libp2p/logger'
 import type { Message } from '../../message/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 
 const log = logger('libp2p:kad-dht:rpc:handlers:ping')
 

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

@@ -1,11 +1,11 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { type Logger, logger } from '@libp2p/logger'
-import { verifyRecord } from '@libp2p/record/validators'
+import { verifyRecord } from '../../record/validators.js'
 import { bufferToRecordKey } from '../../utils.js'
 import type { Validators } from '../../index.js'
 import type { Message } from '../../message/index.js'
 import type { DHTMessageHandler } from '../index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Datastore } from 'interface-datastore'
 
 export interface PutValueHandlerInit {

package/src/rpc/index.ts

@@ -12,8 +12,8 @@ import type { Validators } from '../index.js'
 import type { PeerRouting } from '../peer-routing'
 import type { Providers } from '../providers'
 import type { RoutingTable } from '../routing-table'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { IncomingStreamData } from '@libp2p/interface-registrar'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
 
 export interface DHTMessageHandler {
   handle: (peerId: PeerId, msg: Message) => Promise<Message | undefined>

package/src/topology-listener.ts

@@ -1,9 +1,8 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { CustomEvent, EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
-import { createTopology } from '@libp2p/topology'
 import type { KadDHTComponents } from '.'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Startable } from '@libp2p/interface/startable'
 import type { Logger } from '@libp2p/logger'
 
 export interface TopologyListenerInit {
@@ -51,7 +50,7 @@ export class TopologyListener extends EventEmitter<TopologyListenerEvents> imple
     this.running = true
 
     // register protocol with topology
-    const topology = createTopology({
+    this.registrarId = await this.components.registrar.register(this.protocol, {
       onConnect: (peerId) => {
         this.log('observed peer %p with protocol %s', peerId, this.protocol)
         this.dispatchEvent(new CustomEvent('peer', {
@@ -59,7 +58,6 @@ export class TopologyListener extends EventEmitter<TopologyListenerEvents> imple
         }))
       }
     })
-    this.registrarId = await this.components.registrar.register(this.protocol, topology)
   }
 
   /**

package/src/utils.ts

@@ -1,5 +1,4 @@
 import { peerIdFromBytes } from '@libp2p/peer-id'
-import { Libp2pRecord } from '@libp2p/record'
 import { Key } from 'interface-datastore/key'
 import { sha256 } from 'multiformats/hashes/sha2'
 import isPrivateIp from 'private-ip'
@@ -7,8 +6,9 @@ import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { RECORD_KEY_PREFIX } from './constants.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
+import { Libp2pRecord } from './record/index.js'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
 
 // const IPNS_PREFIX = uint8ArrayFromString('/ipns/')
 const PK_PREFIX = uint8ArrayFromString('/pk/')

package/dist/typedoc-urls.json

@@ -1,29 +0,0 @@
-{
-  "ProvidersInit": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/_internal_.ProvidersInit.html",
-  "EventTypes": "https://libp2p.github.io/js-libp2p-kad-dht/enums/EventTypes.html",
-  "MessageType": "https://libp2p.github.io/js-libp2p-kad-dht/enums/MessageType.html",
-  "AddPeerEvent": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/AddPeerEvent.html",
-  "DHTRecord": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/DHTRecord.html",
-  "DialPeerEvent": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/DialPeerEvent.html",
-  "DualKadDHT": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/DualKadDHT.html",
-  "FinalPeerEvent": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/FinalPeerEvent.html",
-  "KadDHT": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/KadDHT.html",
-  "KadDHTComponents": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/KadDHTComponents.html",
-  "KadDHTInit": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/KadDHTInit.html",
-  "PeerResponseEvent": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/PeerResponseEvent.html",
-  "ProviderEvent": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/ProviderEvent.html",
-  "QueryErrorEvent": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/QueryErrorEvent.html",
-  "QueryOptions": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/QueryOptions.html",
-  "RoutingTable": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/RoutingTable.html",
-  "SelectFn": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/SelectFn.html",
-  "SendQueryEvent": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/SendQueryEvent.html",
-  "SingleKadDHT": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/SingleKadDHT.html",
-  "ValidateFn": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/ValidateFn.html",
-  "ValueEvent": "https://libp2p.github.io/js-libp2p-kad-dht/interfaces/ValueEvent.html",
-  "DHTProgressEvents": "https://libp2p.github.io/js-libp2p-kad-dht/types/DHTProgressEvents.html",
-  "MessageName": "https://libp2p.github.io/js-libp2p-kad-dht/types/MessageName.html",
-  "QueryEvent": "https://libp2p.github.io/js-libp2p-kad-dht/types/QueryEvent.html",
-  "Selectors": "https://libp2p.github.io/js-libp2p-kad-dht/types/Selectors.html",
-  "Validators": "https://libp2p.github.io/js-libp2p-kad-dht/types/Validators.html",
-  "kadDHT": "https://libp2p.github.io/js-libp2p-kad-dht/functions/kadDHT-1.html"
-}