@libp2p/kad-dht 12.1.5-50b897139 → 12.1.5-5214dec4a

package/src/message/dht.ts

@@ -4,7 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { type Codec, decodeMessage, encodeMessage, enumeration, message } from 'protons-runtime'
+import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, enumeration, MaxLengthError, message } from 'protons-runtime'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -54,7 +54,7 @@ export namespace Record {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -101,8 +101,8 @@ export namespace Record {
     return encodeMessage(obj, Record.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Record => {
-    return decodeMessage(buf, Record.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Record>): Record => {
+    return decodeMessage(buf, Record.codec(), opts)
   }
 }
 
@@ -184,7 +184,7 @@ export namespace PeerInfo {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           id: uint8ArrayAlloc(0),
           multiaddrs: []
@@ -201,6 +201,10 @@ export namespace PeerInfo {
               break
             }
             case 2: {
+              if (opts.limits?.multiaddrs != null && obj.multiaddrs.length === opts.limits.multiaddrs) {
+                throw new MaxLengthError('Decode error - map field "multiaddrs" had too many elements')
+              }
+
               obj.multiaddrs.push(reader.bytes())
               break
             }
@@ -226,8 +230,8 @@ export namespace PeerInfo {
     return encodeMessage(obj, PeerInfo.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): PeerInfo => {
-    return decodeMessage(buf, PeerInfo.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<PeerInfo>): PeerInfo => {
+    return decodeMessage(buf, PeerInfo.codec(), opts)
   }
 }
 
@@ -287,7 +291,7 @@ export namespace Message {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           type: MessageType.PUT_VALUE,
           closer: [],
@@ -317,11 +321,23 @@ export namespace Message {
               break
             }
             case 8: {
-              obj.closer.push(PeerInfo.codec().decode(reader, reader.uint32()))
+              if (opts.limits?.closer != null && obj.closer.length === opts.limits.closer) {
+                throw new MaxLengthError('Decode error - map field "closer" had too many elements')
+              }
+
+              obj.closer.push(PeerInfo.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.closer$
+              }))
               break
             }
             case 9: {
-              obj.providers.push(PeerInfo.codec().decode(reader, reader.uint32()))
+              if (opts.limits?.providers != null && obj.providers.length === opts.limits.providers) {
+                throw new MaxLengthError('Decode error - map field "providers" had too many elements')
+              }
+
+              obj.providers.push(PeerInfo.codec().decode(reader, reader.uint32(), {
+                limits: opts.limits?.providers$
+              }))
               break
             }
             default: {
@@ -342,7 +358,7 @@ export namespace Message {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
-    return decodeMessage(buf, Message.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message => {
+    return decodeMessage(buf, Message.codec(), opts)
   }
 }

package/src/message/utils.ts

@@ -1,11 +1,12 @@
-import { peerIdFromBytes } from '@libp2p/peer-id'
+import { peerIdFromMultihash } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
+import * as Digest from 'multiformats/hashes/digest'
 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(),
+    id: peer.id.toMultihash().bytes,
     multiaddrs: (peer.multiaddrs ?? []).map((m) => m.bytes),
     connection
   }
@@ -18,8 +19,10 @@ export function fromPbPeerInfo (peer: PBPeerInfo): PeerInfo {
     throw new Error('Invalid peer in message')
   }
 
+  const multihash = Digest.decode(peer.id)
+
   return {
-    id: peerIdFromBytes(peer.id),
+    id: peerIdFromMultihash(multihash),
     multiaddrs: (peer.multiaddrs ?? []).map((a) => multiaddr(a))
   }
 }

package/src/network.ts

@@ -1,8 +1,7 @@
-import { TypedEventEmitter } from '@libp2p/interface'
+import { InvalidParametersError, TypedEventEmitter } from '@libp2p/interface'
 import { Libp2pRecord } from '@libp2p/record'
 import { AdaptiveTimeout, type AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
 import { pbStream } from 'it-protobuf-stream'
-import { CodeError } from 'protons-runtime'
 import { Message } from './message/dht.js'
 import { fromPbPeerInfo } from './message/utils.js'
 import {
@@ -88,7 +87,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
     const type = msg.type
 
     if (type == null) {
-      throw new CodeError('Message type was missing', 'ERR_INVALID_PARAMETERS')
+      throw new InvalidParametersError('Message type was missing')
     }
 
     this.log('sending %s to %p', msg.type, to)
@@ -141,7 +140,7 @@ export class Network extends TypedEventEmitter<NetworkEvents> implements Startab
     const type = msg.type
 
     if (type == null) {
-      throw new CodeError('Message type was missing', 'ERR_INVALID_PARAMETERS')
+      throw new InvalidParametersError('Message type was missing')
     }
 
     this.log('sending %s to %p', msg.type, to)

package/src/peer-routing/index.ts

@@ -1,8 +1,9 @@
-import { keys } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interface'
-import { peerIdFromKeys } from '@libp2p/peer-id'
+import { publicKeyFromProtobuf } from '@libp2p/crypto/keys'
+import { InvalidPublicKeyError, NotFoundError } from '@libp2p/interface'
+import { peerIdFromPublicKey } from '@libp2p/peer-id'
 import { Libp2pRecord } from '@libp2p/record'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { QueryError, InvalidRecordError } from '../errors.js'
 import { MessageType } from '../message/dht.js'
 import { PeerDistanceList } from '../peer-list/peer-distance-list.js'
 import {
@@ -63,7 +64,7 @@ export class PeerRouting {
       try {
         peerData = await this.peerStore.get(p)
       } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
+        if (err.name !== 'NotFoundError') {
           throw err
         }
       }
@@ -73,7 +74,7 @@ export class PeerRouting {
       try {
         peerData = await this.peerStore.get(peer)
       } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
+        if (err.name !== 'NotFoundError') {
           throw err
         }
       }
@@ -113,22 +114,26 @@ export class PeerRouting {
       yield event
 
       if (event.name === 'PEER_RESPONSE' && event.record != null) {
-        const recPeer = await peerIdFromKeys(keys.marshalPublicKey({ bytes: event.record.value }))
+        const publicKey = publicKeyFromProtobuf(event.record.value)
+        const recPeer = peerIdFromPublicKey(publicKey)
 
         // compare hashes of the pub key
         if (!recPeer.equals(peer)) {
-          throw new CodeError('public key does not match id', 'ERR_PUBLIC_KEY_DOES_NOT_MATCH_ID')
+          throw new InvalidPublicKeyError('public key does not match id')
         }
 
         if (recPeer.publicKey == null) {
-          throw new CodeError('public key missing', 'ERR_PUBLIC_KEY_MISSING')
+          throw new InvalidPublicKeyError('public key missing')
         }
 
-        yield valueEvent({ from: peer, value: recPeer.publicKey }, options)
+        yield valueEvent({
+          from: peer,
+          value: event.record.value
+        }, options)
       }
     }
 
-    throw new CodeError(`Node not responding with its public key: ${peer.toString()}`, 'ERR_INVALID_RECORD')
+    throw new QueryError(`Node not responding with its public key: ${peer.toString()}`)
   }
 
   /**
@@ -160,7 +165,7 @@ export class PeerRouting {
       const findPeerQuery: QueryFunc = async function * ({ peer, signal }) {
         const request: Partial<Message> = {
           type: MessageType.FIND_NODE,
-          key: id.toBytes()
+          key: id.toMultihash().bytes
         }
 
         for await (const event of self.network.sendRequest(peer, request, {
@@ -180,7 +185,7 @@ export class PeerRouting {
         }
       }
 
-      for await (const event of this.queryManager.run(id.toBytes(), findPeerQuery, options)) {
+      for await (const event of this.queryManager.run(id.toMultihash().bytes, findPeerQuery, options)) {
         if (event.name === 'FINAL_PEER') {
           foundPeer = true
         }
@@ -190,7 +195,7 @@ export class PeerRouting {
     }
 
     if (!foundPeer) {
-      yield queryErrorEvent({ from: this.peerId, error: new CodeError('Not found', 'ERR_NOT_FOUND') }, options)
+      yield queryErrorEvent({ from: this.peerId, error: new NotFoundError('Not found') }, options)
     }
   }
 
@@ -257,7 +262,7 @@ export class PeerRouting {
             const errMsg = 'invalid record received, discarded'
             this.log(errMsg)
 
-            yield queryErrorEvent({ from: event.from, error: new CodeError(errMsg, 'ERR_INVALID_RECORD') }, options)
+            yield queryErrorEvent({ from: event.from, error: new QueryError(errMsg) }, options)
             continue
           }
         }
@@ -273,7 +278,7 @@ export class PeerRouting {
    */
   async _verifyRecordOnline (record: DHTRecord): Promise<void> {
     if (record.timeReceived == null) {
-      throw new CodeError('invalid record received', 'ERR_INVALID_RECORD')
+      throw new InvalidRecordError('invalid record received')
     }
 
     await verifyRecord(this.validators, new Libp2pRecord(record.key, record.value, record.timeReceived))
@@ -301,7 +306,7 @@ export class PeerRouting {
           multiaddrs: peer.addresses.map(({ multiaddr }) => multiaddr)
         })
       } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
+        if (err.name !== 'NotFoundError') {
           throw err
         }
       }

package/src/query/events.ts

@@ -1,4 +1,3 @@
-import { CustomEvent } from '@libp2p/interface'
 import type { MessageType, SendQueryEvent, PeerResponseEvent, DialPeerEvent, AddPeerEvent, ValueEvent, ProviderEvent, QueryErrorEvent, FinalPeerEvent } from '../index.js'
 import type { PeerId, PeerInfo } from '@libp2p/interface'
 import type { Libp2pRecord } from '@libp2p/record'

package/src/query/manager.ts

@@ -223,7 +223,7 @@ export class QueryManager implements Startable {
 
       queryFinished = true
     } catch (err: any) {
-      if (!this.running && err.code === 'ERR_QUERY_ABORTED') {
+      if (!this.running && err.name === 'QueryAbortedError') {
         // ignore query aborted errors that were thrown during query manager shutdown
       } else {
         throw err

package/src/query/query-path.ts

@@ -1,8 +1,9 @@
-import { CodeError, setMaxListeners } from '@libp2p/interface'
+import { setMaxListeners } from '@libp2p/interface'
 import { Queue } from '@libp2p/utils/queue'
 import { anySignal } from 'any-signal'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { xorCompare as uint8ArrayXorCompare } from 'uint8arrays/xor-compare'
+import { QueryAbortedError } from '../errors.js'
 import { convertPeerId, convertBuffer } from '../utils.js'
 import { queryErrorEvent } from './events.js'
 import type { QueryEvent } from '../index.js'
@@ -195,7 +196,7 @@ export async function * queryPath (options: QueryPathOptions): AsyncGenerator<Qu
     }
   } catch (err) {
     if (signal.aborted) {
-      throw new CodeError('Query aborted', 'ERR_QUERY_ABORTED')
+      throw new QueryAbortedError('Query aborted')
     }
 
     throw err

package/src/query-self.ts

@@ -125,7 +125,7 @@ export class QuerySelf implements Startable {
         const start = Date.now()
 
         const found = await pipe(
-          this.peerRouting.getClosestPeers(this.peerId.toBytes(), {
+          this.peerRouting.getClosestPeers(this.peerId.toMultihash().bytes, {
             signal,
             isSelfQuery: true
           }),

package/src/record/selectors.ts

@@ -1,5 +1,6 @@
-import { CodeError } from '@libp2p/interface'
+import { InvalidParametersError } from '@libp2p/interface'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { MissingSelectorError } from '../errors.js'
 import type { Selectors } from '../index.js'
 
 /**
@@ -7,26 +8,20 @@ import type { Selectors } from '../index.js'
  */
 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')
+    throw new InvalidParametersError('No records given')
   }
 
   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')
+    throw new InvalidParametersError('Record key does not have a selector function')
   }
 
   const selector = selectors[parts[1].toString()]
 
   if (selector == null) {
-    const errMsg = `No selector function configured for key type "${parts[1]}"`
-
-    throw new CodeError(errMsg, 'ERR_UNRECOGNIZED_KEY_PREFIX')
+    throw new MissingSelectorError(`No selector function configured for key type "${parts[1]}"`)
   }
 
   if (records.length === 1) {

package/src/record/validators.ts

@@ -1,5 +1,5 @@
-import { CodeError } from '@libp2p/interface'
-import { sha256 } from 'multiformats/hashes/sha2'
+import { publicKeyFromProtobuf } from '@libp2p/crypto/keys'
+import { InvalidParametersError } from '@libp2p/interface'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import type { Validators } from '../index.js'
@@ -23,9 +23,7 @@ export async function verifyRecord (validators: Validators, record: Libp2pRecord
   const validator = validators[parts[1].toString()]
 
   if (validator == null) {
-    const errMsg = `No validator available for key type "${parts[1]}"`
-
-    throw new CodeError(errMsg, 'ERR_INVALID_RECORD_KEY_TYPE')
+    throw new InvalidParametersError(`No validator available for key type "${parts[1]}"`)
   }
 
   await validator(key, record.value)
@@ -42,25 +40,24 @@ export async function verifyRecord (validators: Validators, record: Libp2pRecord
  */
 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')
+    throw new InvalidParametersError('"key" must be a Uint8Array')
   }
 
   if (key.byteLength < 5) {
-    throw new CodeError('invalid public key record', 'ERR_INVALID_RECORD_KEY_TOO_SHORT')
+    throw new InvalidParametersError('Invalid public key record')
   }
 
   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')
+    throw new InvalidParametersError('key was not prefixed with /pk/')
   }
 
+  const pubKey = publicKeyFromProtobuf(publicKey)
   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')
+  if (!uint8ArrayEquals(keyhash, pubKey.toMultihash().bytes)) {
+    throw new InvalidParametersError('public key does not match passed in key')
   }
 }
 

package/src/routing-table/index.ts

@@ -1,4 +1,4 @@
-import { CodeError, TypedEventEmitter } from '@libp2p/interface'
+import { InvalidMessageError, TypedEventEmitter } from '@libp2p/interface'
 import { PeerSet } from '@libp2p/peer-collections'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { pbStream } from 'it-protobuf-stream'
@@ -254,7 +254,7 @@ export class RoutingTable extends TypedEventEmitter<RoutingTableEvents> implemen
             await pb.unwrap().close()
 
             if (response.type !== MessageType.PING) {
-              throw new CodeError(`Incorrect message type received, expected PING got ${response.type}`, 'ERR_BAD_PING_RESPONSE')
+              throw new InvalidMessageError(`Incorrect message type received, expected PING got ${response.type}`)
             }
 
             return true

package/src/routing-table/refresh.ts

@@ -1,7 +1,8 @@
 import { randomBytes } from '@libp2p/crypto'
 import { setMaxListeners } from '@libp2p/interface'
-import { peerIdFromBytes } from '@libp2p/peer-id'
+import { peerIdFromMultihash } from '@libp2p/peer-id'
 import length from 'it-length'
+import * as Digest from 'multiformats/hashes/digest'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { xor as uint8ArrayXor } from 'uint8arrays/xor'
 import { TABLE_REFRESH_INTERVAL, TABLE_REFRESH_QUERY_TIMEOUT } from '../constants.js'
@@ -140,7 +141,7 @@ export class RoutingTableRefresh {
     const signal = AbortSignal.timeout(this.refreshQueryTimeout)
     setMaxListeners(Infinity, signal)
 
-    const peers = await length(this.peerRouting.getClosestPeers(peerId.toBytes(), {
+    const peers = await length(this.peerRouting.getClosestPeers(peerId.toMultihash().bytes, {
       signal
     }))
 
@@ -172,8 +173,9 @@ export class RoutingTableRefresh {
     const randomUint16 = (randomData[1] << 8) + randomData[0]
 
     const key = await this._makePeerId(this.routingTable.kb.localPeer.kadId, randomUint16, targetCommonPrefixLength)
+    const multihash = Digest.decode(key)
 
-    return peerIdFromBytes(key)
+    return peerIdFromMultihash(multihash)
   }
 
   async _makePeerId (localKadId: Uint8Array, randomPrefix: number, targetCommonPrefixLength: number): Promise<Uint8Array> {

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

@@ -1,7 +1,8 @@
-import { CodeError } from '@libp2p/interface'
-import { peerIdFromBytes } from '@libp2p/peer-id'
+import { InvalidMessageError } from '@libp2p/interface'
+import { peerIdFromMultihash } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import { CID } from 'multiformats/cid'
+import * as Digest from 'multiformats/hashes/digest'
 import type { Message } from '../../message/dht.js'
 import type { Providers } from '../../providers'
 import type { DHTMessageHandler } from '../index.js'
@@ -29,7 +30,7 @@ export class AddProviderHandler implements DHTMessageHandler {
     this.log('start')
 
     if (msg.key == null || msg.key.length === 0) {
-      throw new CodeError('Missing key', 'ERR_MISSING_KEY')
+      throw new InvalidMessageError('Missing key')
     }
 
     let cid: CID
@@ -37,7 +38,7 @@ export class AddProviderHandler implements DHTMessageHandler {
       // this is actually just the multihash, not the whole CID
       cid = CID.decode(msg.key)
     } catch (err: any) {
-      throw new CodeError('Invalid CID', 'ERR_INVALID_CID')
+      throw new InvalidMessageError('Invalid CID')
     }
 
     if (msg.providers == null || msg.providers.length === 0) {
@@ -59,7 +60,9 @@ export class AddProviderHandler implements DHTMessageHandler {
 
         this.log('received provider %p for %s (addrs %s)', peerId, cid, pi.multiaddrs.map((m) => multiaddr(m).toString()))
 
-        await this.providers.addProvider(cid, peerIdFromBytes(pi.id))
+        const multihash = Digest.decode(pi.id)
+
+        await this.providers.addProvider(cid, peerIdFromMultihash(multihash))
       })
     )
 

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

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface'
+import { InvalidMessageError } from '@libp2p/interface'
 import { protocols } from '@multiformats/multiaddr'
 import { equals as uint8ArrayEquals } from 'uint8arrays'
 import { MessageType } from '../../message/dht.js'
@@ -45,12 +45,12 @@ export class FindNodeHandler implements DHTMessageHandler {
     this.log('incoming request from %p for peers closer to %b', peerId, msg.key)
 
     if (msg.key == null) {
-      throw new CodeError('Invalid FIND_NODE message received - key was missing', 'ERR_INVALID_MESSAGE')
+      throw new InvalidMessageError('Invalid FIND_NODE message received - key was missing')
     }
 
     const closer: PeerInfo[] = await this.peerRouting.getCloserPeersOffline(msg.key, peerId)
 
-    if (uint8ArrayEquals(this.peerId.toBytes(), msg.key)) {
+    if (uint8ArrayEquals(this.peerId.toMultihash().bytes, msg.key)) {
       closer.push({
         id: this.peerId,
         multiaddrs: this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
@@ -64,7 +64,7 @@ export class FindNodeHandler implements DHTMessageHandler {
         .map(this.peerInfoMapper)
         .filter(({ multiaddrs }) => multiaddrs.length)
         .map(peerInfo => ({
-          id: peerInfo.id.toBytes(),
+          id: peerInfo.id.toMultihash().bytes,
           multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
         })),
       providers: []

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

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface'
+import { InvalidMessageError } from '@libp2p/interface'
 import { CID } from 'multiformats/cid'
 import { MessageType } from '../../message/dht.js'
 import type { PeerInfoMapper } from '../../index.js'
@@ -40,14 +40,14 @@ export class GetProvidersHandler implements DHTMessageHandler {
 
   async handle (peerId: PeerId, msg: Message): Promise<Message> {
     if (msg.key == null) {
-      throw new CodeError('Invalid GET_PROVIDERS message received - key was missing', 'ERR_INVALID_MESSAGE')
+      throw new InvalidMessageError('Invalid GET_PROVIDERS message received - key was missing')
     }
 
     let cid
     try {
       cid = CID.decode(msg.key)
     } catch (err: any) {
-      throw new CodeError('Invalid CID', 'ERR_INVALID_CID')
+      throw new InvalidMessageError('Invalid CID')
     }
 
     this.log('%p asking for providers for %s', peerId, cid)
@@ -67,14 +67,14 @@ export class GetProvidersHandler implements DHTMessageHandler {
         .map(this.peerInfoMapper)
         .filter(({ multiaddrs }) => multiaddrs.length)
         .map(peerInfo => ({
-          id: peerInfo.id.toBytes(),
+          id: peerInfo.id.toMultihash().bytes,
           multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
         })),
       providers: providerPeers
         .map(this.peerInfoMapper)
         .filter(({ multiaddrs }) => multiaddrs.length)
         .map(peerInfo => ({
-          id: peerInfo.id.toBytes(),
+          id: peerInfo.id.toMultihash().bytes,
           multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
         }))
     }
@@ -104,7 +104,7 @@ export class GetProvidersHandler implements DHTMessageHandler {
           output.push(peerAfterFilter)
         }
       } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
+        if (err.name !== 'NotFoundError') {
           throw err
         }
       }

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

@@ -1,4 +1,5 @@
-import { CodeError } from '@libp2p/interface'
+import { publicKeyToProtobuf } from '@libp2p/crypto/keys'
+import { InvalidMessageError, NotFoundError } from '@libp2p/interface'
 import { Libp2pRecord } from '@libp2p/record'
 import {
   MAX_RECORD_AGE
@@ -41,7 +42,7 @@ export class GetValueHandler implements DHTMessageHandler {
     this.log('%p asked for key %b', peerId, key)
 
     if (key == null || key.length === 0) {
-      throw new CodeError('Invalid key', 'ERR_INVALID_KEY')
+      throw new InvalidMessageError('Invalid key')
     }
 
     const response: Message = {
@@ -61,12 +62,12 @@ export class GetValueHandler implements DHTMessageHandler {
         const peer = await this.peerStore.get(idFromKey)
 
         if (peer.id.publicKey == null) {
-          throw new CodeError('No public key found in key book', 'ERR_NOT_FOUND')
+          throw new NotFoundError('No public key found in key book')
         }
 
-        pubKey = peer.id.publicKey
+        pubKey = publicKeyToProtobuf(peer.id.publicKey)
       } catch (err: any) {
-        if (err.code !== 'ERR_NOT_FOUND') {
+        if (err.name !== 'NotFoundError') {
           throw err
         }
       }
@@ -91,7 +92,7 @@ export class GetValueHandler implements DHTMessageHandler {
     if (closer.length > 0) {
       this.log('had %s closer peers in routing table', closer.length)
       response.closer = closer.map(peerInfo => ({
-        id: peerInfo.id.toBytes(),
+        id: peerInfo.id.toMultihash().bytes,
         multiaddrs: peerInfo.multiaddrs.map(ma => ma.bytes)
       }))
     }
@@ -114,7 +115,7 @@ export class GetValueHandler implements DHTMessageHandler {
     try {
       rawRecord = await this.datastore.get(dsKey)
     } catch (err: any) {
-      if (err.code === 'ERR_NOT_FOUND') {
+      if (err.name === 'NotFoundError') {
         return undefined
       }
       throw err
@@ -123,10 +124,6 @@ export class GetValueHandler implements DHTMessageHandler {
     // Create record from the returned bytes
     const record = Libp2pRecord.deserialize(rawRecord)
 
-    if (record == null) {
-      throw new CodeError('Invalid record', 'ERR_INVALID_RECORD')
-    }
-
     // Check validity: compare time received with max record age
     if (record.timeReceived == null ||
       Date.now() - record.timeReceived.getTime() > MAX_RECORD_AGE) {

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

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface'
+import { InvalidMessageError } from '@libp2p/interface'
 import { Libp2pRecord } from '@libp2p/record'
 import { verifyRecord } from '../../record/validators.js'
 import { bufferToRecordKey } from '../../utils.js'
@@ -39,7 +39,7 @@ export class PutValueHandler implements DHTMessageHandler {
       const errMsg = `Empty record from: ${peerId.toString()}`
 
       this.log.error(errMsg)
-      throw new CodeError(errMsg, 'ERR_EMPTY_RECORD')
+      throw new InvalidMessageError(errMsg)
     }
 
     try {

package/src/topology-listener.ts

@@ -1,4 +1,4 @@
-import { CustomEvent, TypedEventEmitter } from '@libp2p/interface'
+import { TypedEventEmitter } from '@libp2p/interface'
 import type { KadDHTComponents } from '.'
 import type { Logger, PeerId, Startable } from '@libp2p/interface'