@libp2p/kad-dht 1.0.3 → 1.0.6

package/src/message/dht.ts

@@ -0,0 +1,112 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { encodeMessage, decodeMessage, message, bytes, string, enumeration, int32 } from 'protons-runtime'
+
+export interface Record {
+  key?: Uint8Array
+  value?: Uint8Array
+  author?: Uint8Array
+  signature?: Uint8Array
+  timeReceived?: string
+}
+
+export namespace Record {
+  export const codec = () => {
+    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 }
+    })
+  }
+
+  export const encode = (obj: Record): Uint8Array => {
+    return encodeMessage(obj, Record.codec())
+  }
+
+  export const decode = (buf: Uint8Array): Record => {
+    return decodeMessage(buf, Record.codec())
+  }
+}
+
+export interface Message {
+  type?: Message.MessageType
+  clusterLevelRaw?: number
+  key?: Uint8Array
+  record?: Uint8Array
+  closerPeers: Message.Peer[]
+  providerPeers: Message.Peer[]
+}
+
+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'
+  }
+
+  export namespace MessageType {
+    export const codec = () => {
+      return enumeration<typeof MessageType>(MessageType)
+    }
+  }
+  export enum ConnectionType {
+    NOT_CONNECTED = 'NOT_CONNECTED',
+    CONNECTED = 'CONNECTED',
+    CAN_CONNECT = 'CAN_CONNECT',
+    CANNOT_CONNECT = 'CANNOT_CONNECT'
+  }
+
+  export namespace ConnectionType {
+    export const codec = () => {
+      return enumeration<typeof ConnectionType>(ConnectionType)
+    }
+  }
+  export interface Peer {
+    id?: Uint8Array
+    addrs: Uint8Array[]
+    connection?: Message.ConnectionType
+  }
+
+  export namespace Peer {
+    export const codec = () => {
+      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 }
+      })
+    }
+
+    export const encode = (obj: Peer): Uint8Array => {
+      return encodeMessage(obj, Peer.codec())
+    }
+
+    export const decode = (buf: Uint8Array): Peer => {
+      return decodeMessage(buf, Peer.codec())
+    }
+  }
+
+  export const codec = () => {
+    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 }
+    })
+  }
+
+  export const encode = (obj: Message): Uint8Array => {
+    return encodeMessage(obj, Message.codec())
+  }
+
+  export const decode = (buf: Uint8Array): Message => {
+    return decodeMessage(buf, Message.codec())
+  }
+}

package/src/message/index.ts

@@ -1,33 +1,31 @@
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import { Multiaddr } from '@multiformats/multiaddr'
 import { Libp2pRecord } from '@libp2p/record'
-import Proto from './dht.js'
+import { Message as PBMessage } from './dht.js'
 import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 
-export const MESSAGE_TYPE = Proto.Message.MessageType
-export const CONNECTION_TYPE = Proto.Message.ConnectionType
+export const MESSAGE_TYPE = PBMessage.MessageType
+export const CONNECTION_TYPE = PBMessage.ConnectionType
 export const MESSAGE_TYPE_LOOKUP = Object.keys(MESSAGE_TYPE)
 
-type ConnectionType = 0|1|2|3|4
-
 interface PBPeer {
   id: Uint8Array
   addrs: Uint8Array[]
-  connection: ConnectionType
+  connection: PBMessage.ConnectionType
 }
 
 /**
  * Represents a single DHT control message.
  */
 export class Message {
-  public type: Proto.Message.MessageType
+  public type: PBMessage.MessageType
   public key: Uint8Array
   private clusterLevelRaw: number
   public closerPeers: PeerInfo[]
   public providerPeers: PeerInfo[]
   public record?: Libp2pRecord
 
-  constructor (type: Proto.Message.MessageType, key: Uint8Array, level: number) {
+  constructor (type: PBMessage.MessageType, key: Uint8Array, level: number) {
     if (!(key instanceof Uint8Array)) {
       throw new Error('Key must be a Uint8Array')
     }
@@ -60,23 +58,23 @@ export class Message {
    * Encode into protobuf
    */
   serialize () {
-    return Proto.Message.encode({
+    return PBMessage.encode({
       key: this.key,
       type: this.type,
       clusterLevelRaw: this.clusterLevelRaw,
       closerPeers: this.closerPeers.map(toPbPeer),
       providerPeers: this.providerPeers.map(toPbPeer),
       record: this.record == null ? undefined : this.record.serialize()
-    }).finish()
+    })
   }
 
   /**
    * Decode from protobuf
    */
   static deserialize (raw: Uint8Array) {
-    const dec = Proto.Message.decode(raw)
+    const dec = PBMessage.decode(raw)
 
-    const msg = new Message(dec.type ?? 0, dec.key ?? Uint8Array.from([]), dec.clusterLevelRaw ?? 0)
+    const msg = new Message(dec.type ?? PBMessage.MessageType.PUT_VALUE, dec.key ?? Uint8Array.from([]), dec.clusterLevelRaw ?? 0)
     msg.closerPeers = dec.closerPeers.map(fromPbPeer)
     msg.providerPeers = dec.providerPeers.map(fromPbPeer)
 
@@ -98,7 +96,7 @@ function toPbPeer (peer: PeerInfo) {
   return output
 }
 
-function fromPbPeer (peer: Proto.Message.IPeer) {
+function fromPbPeer (peer: PBMessage.Peer) {
   if (peer.id == null) {
     throw new Error('Invalid peer in message')
   }

package/src/network.ts

@@ -3,7 +3,7 @@ import { pipe } from 'it-pipe'
 import * as lp from 'it-length-prefixed'
 import drain from 'it-drain'
 import first from 'it-first'
-import { Message, MESSAGE_TYPE_LOOKUP } from './message/index.js'
+import { Message } from './message/index.js'
 import { EventEmitter, CustomEvent } from '@libp2p/interfaces'
 import {
   dialingPeerEvent,
@@ -86,7 +86,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
       return
     }
 
-    this.log('sending %s to %p', MESSAGE_TYPE_LOOKUP[msg.type], to)
+    this.log('sending %s to %p', msg.type, to)
 
     try {
       yield dialingPeerEvent({ peer: to })
@@ -117,7 +117,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable, I
       return
     }
 
-    this.log('sending %s to %p', MESSAGE_TYPE_LOOKUP[msg.type], to)
+    this.log('sending %s to %p', msg.type, to)
 
     yield dialingPeerEvent({ peer: to })
 

package/src/peer-routing/index.ts

@@ -286,6 +286,10 @@ export class PeerRouting implements Initializable {
    * Throws an error if the record is invalid.
    */
   async _verifyRecordOnline (record: DHTRecord) {
+    if (record.timeReceived == null) {
+      throw errcode(new Error('invalid record received'), 'ERR_INVALID_RECORD')
+    }
+
     await verifyRecord(this.validators, new Libp2pRecord(record.key, record.value, record.timeReceived))
   }
 

package/src/query/events.ts

@@ -1,21 +1,13 @@
 import { MESSAGE_TYPE_LOOKUP } from '../message/index.js'
-import type { SendingQueryEvent, PeerResponseEvent, MessageType, DialingPeerEvent, AddingPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '@libp2p/interfaces/dht'
+import type { Message } from '../message/dht.js'
+import type { SendingQueryEvent, PeerResponseEvent, DialingPeerEvent, AddingPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '@libp2p/interfaces/dht'
 import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { Libp2pRecord } from '@libp2p/record'
 
-const MESSAGE_NAMES = [
-  'PUT_VALUE',
-  'GET_VALUE',
-  'ADD_PROVIDER',
-  'GET_PROVIDERS',
-  'FIND_NODE',
-  'PING'
-]
-
 export interface QueryEventFields {
   to: PeerId
-  type: MessageType
+  type: Message.MessageType
 }
 
 export function sendingQueryEvent (fields: QueryEventFields): SendingQueryEvent {
@@ -23,15 +15,14 @@ export function sendingQueryEvent (fields: QueryEventFields): SendingQueryEvent
     ...fields,
     name: 'SENDING_QUERY',
     type: 0,
-    // @ts-expect-error cannot look up values like this
-    messageName: MESSAGE_TYPE_LOOKUP[fields.type],
-    messageType: fields.type
+    messageName: fields.type,
+    messageType: MESSAGE_TYPE_LOOKUP.indexOf(fields.type.toString())
   }
 }
 
 export interface PeerResponseEventField {
   from: PeerId
-  messageType: MessageType
+  messageType: Message.MessageType
   closer?: PeerInfo[]
   providers?: PeerInfo[]
   record?: Libp2pRecord
@@ -42,8 +33,7 @@ export function peerResponseEvent (fields: PeerResponseEventField): PeerResponse
     ...fields,
     name: 'PEER_RESPONSE',
     type: 1,
-    // @ts-expect-error cannot look up values like this
-    messageName: MESSAGE_NAMES[fields.messageType],
+    messageName: fields.messageType,
     closer: (fields.closer != null) ? fields.closer : [],
     providers: (fields.providers != null) ? fields.providers : []
   }

package/src/query/manager.ts

@@ -6,10 +6,8 @@ import {
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { queryPath } from './query-path.js'
 import merge from 'it-merge'
-import {
-  // @ts-expect-error only defined in node 15+
-  setMaxListeners
-} from 'events'
+// @ts-expect-error setMaxListeners is missing from the types
+import { setMaxListeners } from 'events'
 import { EventEmitter, CustomEvent } from '@libp2p/interfaces'
 import { logger } from '@libp2p/logger'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
@@ -91,6 +89,14 @@ export class QueryManager implements Startable, Initializable {
       // don't let queries run forever
       timeoutController = new TimeoutController(DEFAULT_QUERY_TIMEOUT)
       options.signal = timeoutController.signal
+
+      // this signal will get listened to for network requests, etc
+      // so make sure we don't make a lot of noise in the logs
+      try {
+        if (setMaxListeners != null) {
+          setMaxListeners(Infinity, timeoutController.signal)
+        }
+      } catch {} // fails on node < 15.4
     }
 
     // allow us to stop queries on shut down
@@ -108,7 +114,7 @@ export class QueryManager implements Startable, Initializable {
     // so make sure we don't make a lot of noise in the logs
     try {
       if (setMaxListeners != null) {
-        setMaxListeners(0, signal)
+        setMaxListeners(Infinity, signal)
       }
     } catch {} // fails on node < 15.4
 

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

@@ -63,7 +63,7 @@ export class GetValueHandler implements DHTMessageHandler, Initializable {
 
       if (pubKey != null) {
         log('returning found public key')
-        response.record = new Libp2pRecord(key, pubKey)
+        response.record = new Libp2pRecord(key, pubKey, new Date())
         return response
       }
     }

package/src/rpc/index.ts

@@ -3,7 +3,7 @@ import * as lp from 'it-length-prefixed'
 import { Logger, logger } from '@libp2p/logger'
 import type { RoutingTable } from '../routing-table'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
-import { Message, MESSAGE_TYPE, MESSAGE_TYPE_LOOKUP } from '../message/index.js'
+import { Message, MESSAGE_TYPE } from '../message/index.js'
 import { AddProviderHandler } from './handlers/add-provider.js'
 import { FindNodeHandler } from './handlers/find-node.js'
 import { GetProvidersHandler } from './handlers/get-providers.js'
@@ -29,7 +29,7 @@ export interface RPCInit {
 }
 
 export class RPC implements Initializable {
-  private readonly handlers: Record<number, DHTMessageHandler & Initializable>
+  private readonly handlers: Record<string, DHTMessageHandler & Initializable>
   private readonly routingTable: RoutingTable
   private readonly log: Logger
 
@@ -99,7 +99,7 @@ export class RPC implements Initializable {
           for await (const msg of source) {
             // handle the message
             const desMessage = Message.deserialize(msg.slice())
-            self.log('incoming %s from %p', MESSAGE_TYPE_LOOKUP[desMessage.type], peerId)
+            self.log('incoming %s from %p', desMessage.type, peerId)
             const res = await self.handleMessage(peerId, desMessage)
 
             // Not all handlers will return a response

package/src/utils.ts

@@ -23,7 +23,10 @@ export function removePrivateAddresses (peer: PeerInfo): PeerInfo {
         return false
       }
 
-      // @ts-expect-error types are wrong https://github.com/frenchbread/private-ip/issues/18
+      if (addr == null) {
+        return false
+      }
+
       return !isPrivateIp(addr)
     })
   }
@@ -39,7 +42,10 @@ export function removePublicAddresses (peer: PeerInfo): PeerInfo {
         return false
       }
 
-      // @ts-expect-error types are wrong https://github.com/frenchbread/private-ip/issues/18
+      if (addr == null) {
+        return false
+      }
+
       return isPrivateIp(addr)
     })
   }

package/src/message/dht.d.ts

@@ -1,297 +0,0 @@
-import * as $protobuf from "protobufjs";
-/** Properties of a Record. */
-export interface IRecord {
-
-    /** Record key */
-    key?: (Uint8Array|null);
-
-    /** Record value */
-    value?: (Uint8Array|null);
-
-    /** Record author */
-    author?: (Uint8Array|null);
-
-    /** Record signature */
-    signature?: (Uint8Array|null);
-
-    /** Record timeReceived */
-    timeReceived?: (string|null);
-}
-
-/** Represents a Record. */
-export class Record implements IRecord {
-
-    /**
-     * Constructs a new Record.
-     * @param [p] Properties to set
-     */
-    constructor(p?: IRecord);
-
-    /** Record key. */
-    public key?: (Uint8Array|null);
-
-    /** Record value. */
-    public value?: (Uint8Array|null);
-
-    /** Record author. */
-    public author?: (Uint8Array|null);
-
-    /** Record signature. */
-    public signature?: (Uint8Array|null);
-
-    /** Record timeReceived. */
-    public timeReceived?: (string|null);
-
-    /** Record _key. */
-    public _key?: "key";
-
-    /** Record _value. */
-    public _value?: "value";
-
-    /** Record _author. */
-    public _author?: "author";
-
-    /** Record _signature. */
-    public _signature?: "signature";
-
-    /** Record _timeReceived. */
-    public _timeReceived?: "timeReceived";
-
-    /**
-     * Encodes the specified Record message. Does not implicitly {@link Record.verify|verify} messages.
-     * @param m Record message or plain object to encode
-     * @param [w] Writer to encode to
-     * @returns Writer
-     */
-    public static encode(m: IRecord, w?: $protobuf.Writer): $protobuf.Writer;
-
-    /**
-     * Decodes a Record message from the specified reader or buffer.
-     * @param r Reader or buffer to decode from
-     * @param [l] Message length if known beforehand
-     * @returns Record
-     * @throws {Error} If the payload is not a reader or valid buffer
-     * @throws {$protobuf.util.ProtocolError} If required fields are missing
-     */
-    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Record;
-
-    /**
-     * Creates a Record message from a plain object. Also converts values to their respective internal types.
-     * @param d Plain object
-     * @returns Record
-     */
-    public static fromObject(d: { [k: string]: any }): Record;
-
-    /**
-     * Creates a plain object from a Record message. Also converts values to other types if specified.
-     * @param m Record
-     * @param [o] Conversion options
-     * @returns Plain object
-     */
-    public static toObject(m: Record, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-    /**
-     * Converts this Record to JSON.
-     * @returns JSON object
-     */
-    public toJSON(): { [k: string]: any };
-}
-
-/** Properties of a Message. */
-export interface IMessage {
-
-    /** Message type */
-    type?: (Message.MessageType|null);
-
-    /** Message clusterLevelRaw */
-    clusterLevelRaw?: (number|null);
-
-    /** Message key */
-    key?: (Uint8Array|null);
-
-    /** Message record */
-    record?: (Uint8Array|null);
-
-    /** Message closerPeers */
-    closerPeers?: (Message.IPeer[]|null);
-
-    /** Message providerPeers */
-    providerPeers?: (Message.IPeer[]|null);
-}
-
-/** Represents a Message. */
-export class Message implements IMessage {
-
-    /**
-     * Constructs a new Message.
-     * @param [p] Properties to set
-     */
-    constructor(p?: IMessage);
-
-    /** Message type. */
-    public type?: (Message.MessageType|null);
-
-    /** Message clusterLevelRaw. */
-    public clusterLevelRaw?: (number|null);
-
-    /** Message key. */
-    public key?: (Uint8Array|null);
-
-    /** Message record. */
-    public record?: (Uint8Array|null);
-
-    /** Message closerPeers. */
-    public closerPeers: Message.IPeer[];
-
-    /** Message providerPeers. */
-    public providerPeers: Message.IPeer[];
-
-    /** Message _type. */
-    public _type?: "type";
-
-    /** Message _clusterLevelRaw. */
-    public _clusterLevelRaw?: "clusterLevelRaw";
-
-    /** Message _key. */
-    public _key?: "key";
-
-    /** Message _record. */
-    public _record?: "record";
-
-    /**
-     * Encodes the specified Message message. Does not implicitly {@link Message.verify|verify} messages.
-     * @param m Message message or plain object to encode
-     * @param [w] Writer to encode to
-     * @returns Writer
-     */
-    public static encode(m: IMessage, w?: $protobuf.Writer): $protobuf.Writer;
-
-    /**
-     * Decodes a Message message from the specified reader or buffer.
-     * @param r Reader or buffer to decode from
-     * @param [l] Message length if known beforehand
-     * @returns Message
-     * @throws {Error} If the payload is not a reader or valid buffer
-     * @throws {$protobuf.util.ProtocolError} If required fields are missing
-     */
-    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Message;
-
-    /**
-     * Creates a Message message from a plain object. Also converts values to their respective internal types.
-     * @param d Plain object
-     * @returns Message
-     */
-    public static fromObject(d: { [k: string]: any }): Message;
-
-    /**
-     * Creates a plain object from a Message message. Also converts values to other types if specified.
-     * @param m Message
-     * @param [o] Conversion options
-     * @returns Plain object
-     */
-    public static toObject(m: Message, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-    /**
-     * Converts this Message to JSON.
-     * @returns JSON object
-     */
-    public toJSON(): { [k: string]: any };
-}
-
-export namespace Message {
-
-    /** MessageType enum. */
-    enum MessageType {
-        PUT_VALUE = 0,
-        GET_VALUE = 1,
-        ADD_PROVIDER = 2,
-        GET_PROVIDERS = 3,
-        FIND_NODE = 4,
-        PING = 5
-    }
-
-    /** ConnectionType enum. */
-    enum ConnectionType {
-        NOT_CONNECTED = 0,
-        CONNECTED = 1,
-        CAN_CONNECT = 2,
-        CANNOT_CONNECT = 3
-    }
-
-    /** Properties of a Peer. */
-    interface IPeer {
-
-        /** Peer id */
-        id?: (Uint8Array|null);
-
-        /** Peer addrs */
-        addrs?: (Uint8Array[]|null);
-
-        /** Peer connection */
-        connection?: (Message.ConnectionType|null);
-    }
-
-    /** Represents a Peer. */
-    class Peer implements IPeer {
-
-        /**
-         * Constructs a new Peer.
-         * @param [p] Properties to set
-         */
-        constructor(p?: Message.IPeer);
-
-        /** Peer id. */
-        public id?: (Uint8Array|null);
-
-        /** Peer addrs. */
-        public addrs: Uint8Array[];
-
-        /** Peer connection. */
-        public connection?: (Message.ConnectionType|null);
-
-        /** Peer _id. */
-        public _id?: "id";
-
-        /** Peer _connection. */
-        public _connection?: "connection";
-
-        /**
-         * Encodes the specified Peer message. Does not implicitly {@link Message.Peer.verify|verify} messages.
-         * @param m Peer message or plain object to encode
-         * @param [w] Writer to encode to
-         * @returns Writer
-         */
-        public static encode(m: Message.IPeer, w?: $protobuf.Writer): $protobuf.Writer;
-
-        /**
-         * Decodes a Peer message from the specified reader or buffer.
-         * @param r Reader or buffer to decode from
-         * @param [l] Message length if known beforehand
-         * @returns Peer
-         * @throws {Error} If the payload is not a reader or valid buffer
-         * @throws {$protobuf.util.ProtocolError} If required fields are missing
-         */
-        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Message.Peer;
-
-        /**
-         * Creates a Peer message from a plain object. Also converts values to their respective internal types.
-         * @param d Plain object
-         * @returns Peer
-         */
-        public static fromObject(d: { [k: string]: any }): Message.Peer;
-
-        /**
-         * Creates a plain object from a Peer message. Also converts values to other types if specified.
-         * @param m Peer
-         * @param [o] Conversion options
-         * @returns Plain object
-         */
-        public static toObject(m: Message.Peer, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-        /**
-         * Converts this Peer to JSON.
-         * @returns JSON object
-         */
-        public toJSON(): { [k: string]: any };
-    }
-}