@libp2p/identify 2.1.5 → 3.0.0-18dd3cb26

package/src/identify.ts

@@ -1,7 +1,8 @@
 /* eslint-disable complexity */
 
-import { CodeError, serviceCapabilities, setMaxListeners } from '@libp2p/interface'
-import { peerIdFromKeys } from '@libp2p/peer-id'
+import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
+import { InvalidMessageError, serviceCapabilities, setMaxListeners } from '@libp2p/interface'
+import { peerIdFromCID } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import { protocols } from '@multiformats/multiaddr'
 import { IP_OR_DOMAIN } from '@multiformats/multiaddr-matcher'
@@ -53,7 +54,7 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
     try {
       stream = await connection.newStream(this.protocol, {
         ...options,
-        runOnTransientConnection: this.runOnTransientConnection
+        runOnLimitedConnection: this.runOnLimitedConnection
       })
 
       const pb = pbStream(stream, {
@@ -81,17 +82,18 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
     } = message
 
     if (publicKey == null) {
-      throw new CodeError('public key was missing from identify message', 'ERR_MISSING_PUBLIC_KEY')
+      throw new InvalidMessageError('public key was missing from identify message')
     }
 
-    const id = await peerIdFromKeys(publicKey)
+    const key = publicKeyFromProtobuf(publicKey)
+    const id = peerIdFromCID(key.toCID())
 
     if (!connection.remotePeer.equals(id)) {
-      throw new CodeError('identified peer does not match the expected peer', 'ERR_INVALID_PEER')
+      throw new InvalidMessageError('identified peer does not match the expected peer')
     }
 
     if (this.peerId.equals(id)) {
-      throw new CodeError('identified peer is our own peer id?', 'ERR_INVALID_PEER')
+      throw new InvalidMessageError('identified peer is our own peer id?')
     }
 
     // Get the observedAddr if there is one
@@ -121,7 +123,6 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
     setMaxListeners(Infinity, signal)
 
     try {
-      const publicKey = this.peerId.publicKey ?? new Uint8Array(0)
       const peerData = await this.peerStore.get(this.peerId)
       const multiaddrs = this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
       let signedPeerRecord = peerData.peerRecordEnvelope
@@ -132,7 +133,7 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
           multiaddrs
         })
 
-        const envelope = await RecordEnvelope.seal(peerRecord, this.peerId)
+        const envelope = await RecordEnvelope.seal(peerRecord, this.privateKey)
         signedPeerRecord = envelope.marshal().subarray()
       }
 
@@ -147,7 +148,7 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
       await pb.write({
         protocolVersion: this.host.protocolVersion,
         agentVersion: this.host.agentVersion,
-        publicKey,
+        publicKey: publicKeyToProtobuf(this.privateKey.publicKey),
         listenAddrs: multiaddrs.map(addr => addr.bytes),
         signedPeerRecord,
         observedAddr,

package/src/index.ts

@@ -43,7 +43,7 @@
 
 import { IdentifyPush as IdentifyPushClass } from './identify-push.js'
 import { Identify as IdentifyClass } from './identify.js'
-import type { AbortOptions, IdentifyResult, Libp2pEvents, ComponentLogger, NodeInfo, TypedEventTarget, PeerId, PeerStore, Connection } from '@libp2p/interface'
+import type { AbortOptions, IdentifyResult, Libp2pEvents, ComponentLogger, NodeInfo, TypedEventTarget, PeerId, PeerStore, Connection, PrivateKey } from '@libp2p/interface'
 import type { AddressManager, ConnectionManager, Registrar } from '@libp2p/interface-internal'
 
 export interface IdentifyInit {
@@ -99,7 +99,7 @@ export interface IdentifyInit {
    *
    * @default true
    */
-  runOnTransientConnection?: boolean
+  runOnLimitedConnection?: boolean
 
   /**
    * Whether to automatically run identify on newly opened connections
@@ -127,6 +127,7 @@ export interface IdentifyPushInit extends Omit<IdentifyInit, 'runOnConnectionOpe
 
 export interface IdentifyComponents {
   peerId: PeerId
+  privateKey: PrivateKey
   peerStore: PeerStore
   registrar: Registrar
   addressManager: AddressManager

package/src/pb/message.ts

@@ -4,8 +4,7 @@
 /* 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 Codec, decodeMessage, type DecodeOptions, encodeMessage, MaxLengthError, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Identify {
@@ -70,7 +69,7 @@ export namespace Identify {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {
           listenAddrs: [],
           protocols: []
@@ -82,30 +81,46 @@ export namespace Identify {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 5:
+            case 5: {
               obj.protocolVersion = reader.string()
               break
-            case 6:
+            }
+            case 6: {
               obj.agentVersion = reader.string()
               break
-            case 1:
+            }
+            case 1: {
               obj.publicKey = reader.bytes()
               break
-            case 2:
+            }
+            case 2: {
+              if (opts.limits?.listenAddrs != null && obj.listenAddrs.length === opts.limits.listenAddrs) {
+                throw new MaxLengthError('Decode error - map field "listenAddrs" had too many elements')
+              }
+
               obj.listenAddrs.push(reader.bytes())
               break
-            case 4:
+            }
+            case 4: {
               obj.observedAddr = reader.bytes()
               break
-            case 3:
+            }
+            case 3: {
+              if (opts.limits?.protocols != null && obj.protocols.length === opts.limits.protocols) {
+                throw new MaxLengthError('Decode error - map field "protocols" had too many elements')
+              }
+
               obj.protocols.push(reader.string())
               break
-            case 8:
+            }
+            case 8: {
               obj.signedPeerRecord = reader.bytes()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -120,7 +135,7 @@ export namespace Identify {
     return encodeMessage(obj, Identify.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Identify => {
-    return decodeMessage(buf, Identify.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Identify>): Identify => {
+    return decodeMessage(buf, Identify.codec(), opts)
   }
 }

package/src/utils.ts

@@ -1,5 +1,6 @@
-import { CodeError } from '@libp2p/interface'
-import { peerIdFromKeys } from '@libp2p/peer-id'
+import { publicKeyFromProtobuf } from '@libp2p/crypto/keys'
+import { InvalidMessageError } from '@libp2p/interface'
+import { peerIdFromCID, peerIdFromPublicKey } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
@@ -7,7 +8,7 @@ import { isNode, isBrowser, isWebWorker, isElectronMain, isElectronRenderer, isR
 import { IDENTIFY_PROTOCOL_VERSION, MAX_IDENTIFY_MESSAGE_SIZE, MAX_PUSH_CONCURRENCY } from './consts.js'
 import type { IdentifyComponents, IdentifyInit } from './index.js'
 import type { Identify as IdentifyMessage } from './pb/message.js'
-import type { Libp2pEvents, IdentifyResult, SignedPeerRecord, Logger, Connection, TypedEventTarget, Peer, PeerData, PeerStore, NodeInfo, Startable, PeerId, IncomingStreamData } from '@libp2p/interface'
+import type { Libp2pEvents, IdentifyResult, SignedPeerRecord, Logger, Connection, TypedEventTarget, Peer, PeerData, PeerStore, NodeInfo, Startable, PeerId, IncomingStreamData, PrivateKey } from '@libp2p/interface'
 import type { AddressManager, Registrar } from '@libp2p/interface-internal'
 
 export const defaultValues = {
@@ -19,7 +20,7 @@ export const defaultValues = {
   maxMessageSize: MAX_IDENTIFY_MESSAGE_SIZE,
   runOnConnectionOpen: true,
   runOnSelfUpdate: true,
-  runOnTransientConnection: true,
+  runOnLimitedConnection: true,
   concurrency: MAX_PUSH_CONCURRENCY
 }
 
@@ -56,7 +57,7 @@ export async function consumeIdentifyMessage (peerStore: PeerStore, events: Type
   log('received identify from %p', connection.remotePeer)
 
   if (message == null) {
-    throw new CodeError('message was null or undefined', 'ERR_INVALID_MESSAGE')
+    throw new InvalidMessageError('message was null or undefined')
   }
 
   const peer: PeerData = {}
@@ -73,13 +74,14 @@ export async function consumeIdentifyMessage (peerStore: PeerStore, events: Type
   }
 
   if (message.publicKey != null) {
-    peer.publicKey = message.publicKey
-
-    const peerId = await peerIdFromKeys(message.publicKey)
+    const publicKey = publicKeyFromProtobuf(message.publicKey)
+    const peerId = peerIdFromPublicKey(publicKey)
 
     if (!peerId.equals(connection.remotePeer)) {
-      throw new CodeError('public key did not match remote PeerId', 'ERR_INVALID_PUBLIC_KEY')
+      throw new InvalidMessageError('public key did not match remote PeerId')
     }
+
+    peer.publicKey = publicKey
   }
 
   let output: SignedPeerRecord | undefined
@@ -91,15 +93,16 @@ export async function consumeIdentifyMessage (peerStore: PeerStore, events: Type
     let peerRecordEnvelope = message.signedPeerRecord
     const envelope = await RecordEnvelope.openAndCertify(peerRecordEnvelope, PeerRecord.DOMAIN)
     let peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
+    const envelopePeer = peerIdFromCID(envelope.publicKey.toCID())
 
     // Verify peerId
-    if (!peerRecord.peerId.equals(envelope.peerId)) {
-      throw new CodeError('signing key does not match PeerId in the PeerRecord', 'ERR_INVALID_SIGNING_KEY')
+    if (!peerRecord.peerId.equals(envelopePeer)) {
+      throw new InvalidMessageError('signing key does not match PeerId in the PeerRecord')
     }
 
     // Make sure remote peer is the one sending the record
     if (!connection.remotePeer.equals(peerRecord.peerId)) {
-      throw new CodeError('signing key does not match remote PeerId', 'ERR_INVALID_PEER_RECORD_KEY')
+      throw new InvalidMessageError('signing key does not match remote PeerId')
     }
 
     let existingPeer: Peer | undefined
@@ -107,7 +110,7 @@ export async function consumeIdentifyMessage (peerStore: PeerStore, events: Type
     try {
       existingPeer = await peerStore.get(peerRecord.peerId)
     } catch (err: any) {
-      if (err.code !== 'ERR_NOT_FOUND') {
+      if (err.name !== 'NotFoundError') {
         throw err
       }
     }
@@ -199,6 +202,7 @@ export abstract class AbstractIdentify implements Startable {
   protected started: boolean
   protected readonly timeout: number
   protected readonly peerId: PeerId
+  protected readonly privateKey: PrivateKey
   protected readonly peerStore: PeerStore
   protected readonly registrar: Registrar
   protected readonly addressManager: AddressManager
@@ -207,13 +211,14 @@ export abstract class AbstractIdentify implements Startable {
   protected readonly maxMessageSize: number
   protected readonly maxObservedAddresses: number
   protected readonly events: TypedEventTarget<Libp2pEvents>
-  protected readonly runOnTransientConnection: boolean
+  protected readonly runOnLimitedConnection: boolean
   protected readonly log: Logger
 
   constructor (components: IdentifyComponents, init: AbstractIdentifyInit) {
     this.protocol = init.protocol
     this.started = false
     this.peerId = components.peerId
+    this.privateKey = components.privateKey
     this.peerStore = components.peerStore
     this.registrar = components.registrar
     this.addressManager = components.addressManager
@@ -225,7 +230,7 @@ export abstract class AbstractIdentify implements Startable {
     this.maxOutboundStreams = init.maxOutboundStreams ?? defaultValues.maxOutboundStreams
     this.maxMessageSize = init.maxMessageSize ?? defaultValues.maxMessageSize
     this.maxObservedAddresses = init.maxObservedAddresses ?? defaultValues.maxObservedAddresses
-    this.runOnTransientConnection = init.runOnTransientConnection ?? defaultValues.runOnTransientConnection
+    this.runOnLimitedConnection = init.runOnLimitedConnection ?? defaultValues.runOnLimitedConnection
 
     // Store self host metadata
     this.host = {
@@ -257,7 +262,7 @@ export abstract class AbstractIdentify implements Startable {
     }, {
       maxInboundStreams: this.maxInboundStreams,
       maxOutboundStreams: this.maxOutboundStreams,
-      runOnTransientConnection: this.runOnTransientConnection
+      runOnLimitedConnection: this.runOnLimitedConnection
     })
 
     this.started = true

package/dist/typedoc-urls.json

@@ -1,18 +0,0 @@
-{
-  "Identify": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.Identify.html",
-  ".:Identify": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.Identify.html",
-  "IdentifyComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyComponents.html",
-  ".:IdentifyComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyComponents.html",
-  "IdentifyInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyInit.html",
-  ".:IdentifyInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyInit.html",
-  "IdentifyPush": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPush.html",
-  ".:IdentifyPush": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPush.html",
-  "IdentifyPushComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPushComponents.html",
-  ".:IdentifyPushComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPushComponents.html",
-  "IdentifyPushInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPushInit.html",
-  ".:IdentifyPushInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPushInit.html",
-  "identify": "https://libp2p.github.io/js-libp2p/functions/_libp2p_identify.identify-1.html",
-  ".:identify": "https://libp2p.github.io/js-libp2p/functions/_libp2p_identify.identify-1.html",
-  "identifyPush": "https://libp2p.github.io/js-libp2p/functions/_libp2p_identify.identifyPush-1.html",
-  ".:identifyPush": "https://libp2p.github.io/js-libp2p/functions/_libp2p_identify.identifyPush-1.html"
-}