libp2p 0.37.3-e6f646e → 0.38.0

package/src/fetch/pb/proto.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/export */
 /* eslint-disable @typescript-eslint/no-namespace */
 
-import { encodeMessage, decodeMessage, message, string, enumeration, bytes } from 'protons-runtime'
+import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
 
 export interface FetchRequest {
@@ -9,17 +10,59 @@ export interface FetchRequest {
 }
 
 export namespace FetchRequest {
+  let _codec: Codec<FetchRequest>
+
   export const codec = (): Codec<FetchRequest> => {
-    return message<FetchRequest>({
-      1: { name: 'identifier', codec: string }
-    })
+    if (_codec == null) {
+      _codec = message<FetchRequest>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.identifier != null) {
+          writer.uint32(10)
+          writer.string(obj.identifier)
+        } else {
+          throw new Error('Protocol error: required field "identifier" 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.identifier = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.identifier == null) {
+          throw new Error('Protocol error: value for required field "identifier" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: FetchRequest): Uint8Array => {
     return encodeMessage(obj, FetchRequest.codec())
   }
 
-  export const decode = (buf: Uint8Array): FetchRequest => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): FetchRequest => {
     return decodeMessage(buf, FetchRequest.codec())
   }
 }
@@ -44,22 +87,77 @@ export namespace FetchResponse {
 
   export namespace StatusCode {
     export const codec = () => {
-      return enumeration<typeof StatusCode>(__StatusCodeValues)
+      return enumeration<StatusCode>(__StatusCodeValues)
     }
   }
 
+  let _codec: Codec<FetchResponse>
+
   export const codec = (): Codec<FetchResponse> => {
-    return message<FetchResponse>({
-      1: { name: 'status', codec: FetchResponse.StatusCode.codec() },
-      2: { name: 'data', codec: bytes }
-    })
+    if (_codec == null) {
+      _codec = message<FetchResponse>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.status != null) {
+          writer.uint32(8)
+          FetchResponse.StatusCode.codec().encode(obj.status, writer)
+        } else {
+          throw new Error('Protocol error: required field "status" was not found in object')
+        }
+
+        if (obj.data != null) {
+          writer.uint32(18)
+          writer.bytes(obj.data)
+        } else {
+          throw new Error('Protocol error: required field "data" 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.status = FetchResponse.StatusCode.codec().decode(reader)
+              break
+            case 2:
+              obj.data = reader.bytes()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.status == null) {
+          throw new Error('Protocol error: value for required field "status" was not found in protobuf')
+        }
+
+        if (obj.data == null) {
+          throw new Error('Protocol error: value for required field "data" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: FetchResponse): Uint8Array => {
     return encodeMessage(obj, FetchResponse.codec())
   }
 
-  export const decode = (buf: Uint8Array): FetchResponse => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): FetchResponse => {
     return decodeMessage(buf, FetchResponse.codec())
   }
 }

package/src/identify/index.ts

@@ -26,13 +26,10 @@ import type { Components } from '@libp2p/components'
 import { TimeoutController } from 'timeout-abort-controller'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
-import type { Duplex } from 'it-stream-types'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:identify')
 
-// https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L48
-const IDENTIFY_TIMEOUT = 60000
-
 // https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L52
 const MAX_IDENTIFY_MESSAGE_SIZE = 1024 * 8
 
@@ -54,7 +51,7 @@ export interface IdentifyServiceInit {
   /**
    * How long we should wait for a remote peer to send their identify response
    */
-  timeout?: number
+  timeout: number
 
   /**
    * Identify responses larger than this in bytes will be rejected (default: 8192)
@@ -167,8 +164,13 @@ export class IdentifyService implements Startable {
     const protocols = await this.components.getPeerStore().protoBook.get(this.components.getPeerId())
 
     const pushes = connections.map(async connection => {
-      const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
       let stream: Stream | undefined
+      const timeoutController = new TimeoutController(this.init.timeout)
+
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
 
       try {
         stream = await connection.newStream([this.identifyPushProtocolStr], {
@@ -176,7 +178,7 @@ export class IdentifyService implements Startable {
         })
 
         // make stream abortable
-        const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
+        const source = abortableDuplex(stream, timeoutController.signal)
 
         await pipe(
           [Identify.encode({
@@ -229,21 +231,29 @@ export class IdentifyService implements Startable {
   }
 
   async _identify (connection: Connection, options: AbortOptions = {}): Promise<Identify> {
-    const stream = await connection.newStream([this.identifyProtocolStr], options)
-    let source: Duplex<Uint8Array> = stream
     let timeoutController
     let signal = options.signal
+    let stream: Stream | undefined
 
     // create a timeout if no abort signal passed
     if (signal == null) {
-      timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+      timeoutController = new TimeoutController(this.init.timeout)
       signal = timeoutController.signal
-    }
 
-    // make stream abortable if AbortSignal passed
-    source = abortableDuplex(stream, signal)
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
+    }
 
     try {
+      stream = await connection.newStream([this.identifyProtocolStr], {
+        signal
+      })
+
+      // make stream abortable
+      const source = abortableDuplex(stream, signal)
+
       const data = await pipe(
         [],
         source,
@@ -267,7 +277,9 @@ export class IdentifyService implements Startable {
         timeoutController.clear()
       }
 
-      stream.close()
+      if (stream != null) {
+        stream.close()
+      }
     }
   }
 
@@ -370,7 +382,12 @@ export class IdentifyService implements Startable {
    */
   async _handleIdentify (data: IncomingStreamData) {
     const { connection, stream } = data
-    const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+    const timeoutController = new TimeoutController(this.init.timeout)
+
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, timeoutController.signal)
+    } catch {}
 
     try {
       const publicKey = this.components.getPeerId().publicKey ?? new Uint8Array(0)
@@ -386,7 +403,7 @@ export class IdentifyService implements Startable {
 
         const envelope = await RecordEnvelope.seal(peerRecord, this.components.getPeerId())
         await this.components.getPeerStore().addressBook.consumePeerRecord(envelope)
-        signedPeerRecord = envelope.marshal()
+        signedPeerRecord = envelope.marshal().subarray()
       }
 
       const message = Identify.encode({
@@ -400,7 +417,7 @@ export class IdentifyService implements Startable {
       })
 
       // make stream abortable
-      const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
+      const source = abortableDuplex(stream, timeoutController.signal)
 
       await pipe(
         [message],
@@ -421,12 +438,17 @@ export class IdentifyService implements Startable {
    */
   async _handlePush (data: IncomingStreamData) {
     const { connection, stream } = data
-    const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+    const timeoutController = new TimeoutController(this.init.timeout)
+
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, timeoutController.signal)
+    } catch {}
 
     let message: Identify | undefined
     try {
       // make stream abortable
-      const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
+      const source = abortableDuplex(stream, timeoutController.signal)
 
       const data = await pipe(
         [],

package/src/identify/pb/message.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/export */
 /* eslint-disable @typescript-eslint/no-namespace */
 
-import { encodeMessage, decodeMessage, message, string, bytes } from 'protons-runtime'
+import { encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
 
 export interface Identify {
@@ -15,23 +16,122 @@ export interface Identify {
 }
 
 export namespace Identify {
+  let _codec: Codec<Identify>
+
   export const codec = (): Codec<Identify> => {
-    return message<Identify>({
-      5: { name: 'protocolVersion', codec: string, optional: true },
-      6: { name: 'agentVersion', codec: string, optional: true },
-      1: { name: 'publicKey', codec: bytes, optional: true },
-      2: { name: 'listenAddrs', codec: bytes, repeats: true },
-      4: { name: 'observedAddr', codec: bytes, optional: true },
-      3: { name: 'protocols', codec: string, repeats: true },
-      8: { name: 'signedPeerRecord', codec: bytes, optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<Identify>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.protocolVersion != null) {
+          writer.uint32(42)
+          writer.string(obj.protocolVersion)
+        }
+
+        if (obj.agentVersion != null) {
+          writer.uint32(50)
+          writer.string(obj.agentVersion)
+        }
+
+        if (obj.publicKey != null) {
+          writer.uint32(10)
+          writer.bytes(obj.publicKey)
+        }
+
+        if (obj.listenAddrs != null) {
+          for (const value of obj.listenAddrs) {
+            writer.uint32(18)
+            writer.bytes(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "listenAddrs" was not found in object')
+        }
+
+        if (obj.observedAddr != null) {
+          writer.uint32(34)
+          writer.bytes(obj.observedAddr)
+        }
+
+        if (obj.protocols != null) {
+          for (const value of obj.protocols) {
+            writer.uint32(26)
+            writer.string(value)
+          }
+        } else {
+          throw new Error('Protocol error: required field "protocols" was not found in object')
+        }
+
+        if (obj.signedPeerRecord != null) {
+          writer.uint32(66)
+          writer.bytes(obj.signedPeerRecord)
+        }
+
+        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 5:
+              obj.protocolVersion = reader.string()
+              break
+            case 6:
+              obj.agentVersion = reader.string()
+              break
+            case 1:
+              obj.publicKey = reader.bytes()
+              break
+            case 2:
+              obj.listenAddrs = obj.listenAddrs ?? []
+              obj.listenAddrs.push(reader.bytes())
+              break
+            case 4:
+              obj.observedAddr = reader.bytes()
+              break
+            case 3:
+              obj.protocols = obj.protocols ?? []
+              obj.protocols.push(reader.string())
+              break
+            case 8:
+              obj.signedPeerRecord = reader.bytes()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        obj.listenAddrs = obj.listenAddrs ?? []
+        obj.protocols = obj.protocols ?? []
+
+        if (obj.listenAddrs == null) {
+          throw new Error('Protocol error: value for required field "listenAddrs" was not found in protobuf')
+        }
+
+        if (obj.protocols == null) {
+          throw new Error('Protocol error: value for required field "protocols" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: Identify): Uint8Array => {
     return encodeMessage(obj, Identify.codec())
   }
 
-  export const decode = (buf: Uint8Array): Identify => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Identify => {
     return decodeMessage(buf, Identify.codec())
   }
 }

package/src/index.ts

@@ -50,6 +50,7 @@ export interface MetricsConfig {
 export interface HopConfig {
   enabled?: boolean
   active?: boolean
+  timeout: number
 }
 
 export interface RelayConfig {

package/src/insecure/index.ts

@@ -7,6 +7,7 @@ import type { PeerId } from '@libp2p/interface-peer-id'
 import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
 import type { Duplex } from 'it-stream-types'
+import map from 'it-map'
 
 const log = logger('libp2p:plaintext')
 const PROTOCOL = '/plaintext/2.0.0'
@@ -39,7 +40,7 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
         Type: type,
         Data: localId.publicKey ?? new Uint8Array(0)
       }
-    }).slice()
+    }).subarray()
   )
 
   log('write pubkey exchange to peer %p', remoteId)
@@ -47,7 +48,7 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
   // Get the Exchange message
   // @ts-expect-error needs to be generator
   const response = (await lp.decode.fromReader(shake.reader).next()).value
-  const id = Exchange.decode(response.slice())
+  const id = Exchange.decode(response)
   log('read pubkey exchange from peer %p', remoteId)
 
   let peerId
@@ -81,8 +82,12 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
   log('plaintext key exchange completed successfully with peer %p', peerId)
 
   shake.rest()
+
   return {
-    conn: shake.stream,
+    conn: {
+      sink: shake.stream.sink,
+      source: map(shake.stream.source, (buf) => buf.subarray())
+    },
     remotePeer: peerId,
     remoteEarlyData: new Uint8Array()
   }

package/src/insecure/pb/proto.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/export */
 /* eslint-disable @typescript-eslint/no-namespace */
 
-import { encodeMessage, decodeMessage, message, bytes, enumeration } from 'protons-runtime'
+import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
 
 export interface Exchange {
@@ -10,18 +11,61 @@ export interface Exchange {
 }
 
 export namespace Exchange {
+  let _codec: Codec<Exchange>
+
   export const codec = (): Codec<Exchange> => {
-    return message<Exchange>({
-      1: { name: 'id', codec: bytes, optional: true },
-      2: { name: 'pubkey', codec: PublicKey.codec(), optional: true }
-    })
+    if (_codec == null) {
+      _codec = message<Exchange>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.id != null) {
+          writer.uint32(10)
+          writer.bytes(obj.id)
+        }
+
+        if (obj.pubkey != null) {
+          writer.uint32(18)
+          PublicKey.codec().encode(obj.pubkey, 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.pubkey = PublicKey.codec().decode(reader, reader.uint32())
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: Exchange): Uint8Array => {
     return encodeMessage(obj, Exchange.codec())
   }
 
-  export const decode = (buf: Uint8Array): Exchange => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Exchange => {
     return decodeMessage(buf, Exchange.codec())
   }
 }
@@ -42,7 +86,7 @@ enum __KeyTypeValues {
 
 export namespace KeyType {
   export const codec = () => {
-    return enumeration<typeof KeyType>(__KeyTypeValues)
+    return enumeration<KeyType>(__KeyTypeValues)
   }
 }
 export interface PublicKey {
@@ -51,18 +95,73 @@ export interface PublicKey {
 }
 
 export namespace PublicKey {
+  let _codec: Codec<PublicKey>
+
   export const codec = (): Codec<PublicKey> => {
-    return message<PublicKey>({
-      1: { name: 'Type', codec: KeyType.codec() },
-      2: { name: 'Data', codec: bytes }
-    })
+    if (_codec == null) {
+      _codec = message<PublicKey>((obj, writer, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          writer.fork()
+        }
+
+        if (obj.Type != null) {
+          writer.uint32(8)
+          KeyType.codec().encode(obj.Type, writer)
+        } else {
+          throw new Error('Protocol error: required field "Type" was not found in object')
+        }
+
+        if (obj.Data != null) {
+          writer.uint32(18)
+          writer.bytes(obj.Data)
+        } else {
+          throw new Error('Protocol error: required field "Data" 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 = KeyType.codec().decode(reader)
+              break
+            case 2:
+              obj.Data = reader.bytes()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        if (obj.Type == null) {
+          throw new Error('Protocol error: value for required field "Type" was not found in protobuf')
+        }
+
+        if (obj.Data == null) {
+          throw new Error('Protocol error: value for required field "Data" was not found in protobuf')
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
   }
 
   export const encode = (obj: PublicKey): Uint8Array => {
     return encodeMessage(obj, PublicKey.codec())
   }
 
-  export const decode = (buf: Uint8Array): PublicKey => {
+  export const decode = (buf: Uint8Array | Uint8ArrayList): PublicKey => {
     return decodeMessage(buf, PublicKey.codec())
   }
 }

package/src/libp2p.ts

@@ -124,7 +124,8 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     // Set up the Upgrader
     this.components.setUpgrader(new DefaultUpgrader(this.components, {
       connectionEncryption: (init.connectionEncryption ?? []).map(component => this.configureComponent(component)),
-      muxers: (init.streamMuxers ?? []).map(component => this.configureComponent(component))
+      muxers: (init.streamMuxers ?? []).map(component => this.configureComponent(component)),
+      inboundUpgradeTimeout: init.connectionManager.inboundUpgradeTimeout
     }))
 
     // Create the Connection Manager
@@ -217,7 +218,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     })))
 
     if (init.relay.enabled) {
-      this.components.getTransportManager().add(this.configureComponent(new Circuit()))
+      this.components.getTransportManager().add(this.configureComponent(new Circuit(init.relay)))
 
       this.configureComponent(new Relay(this.components, {
         addressSorter: init.connectionManager.addressSorter,