@libp2p/interface 0.1.2 → 0.1.3

package/src/peer-routing/index.ts

@@ -34,7 +34,7 @@ export interface PeerRouting {
    * const peer = await peerRouting.findPeer(peerId, options)
    * ```
    */
-  findPeer: (peerId: PeerId, options?: AbortOptions) => Promise<PeerInfo>
+  findPeer(peerId: PeerId, options?: AbortOptions): Promise<PeerInfo>
 
   /**
    * Search the network for peers that are closer to the passed key. Peer
@@ -49,5 +49,5 @@ export interface PeerRouting {
    * }
    * ```
    */
-  getClosestPeers: (key: Uint8Array, options?: AbortOptions) => AsyncIterable<PeerInfo>
+  getClosestPeers(key: Uint8Array, options?: AbortOptions): AsyncIterable<PeerInfo>
 }

package/src/peer-store/index.ts

@@ -156,7 +156,7 @@ export interface PeerStore {
    * })
    * ```
    */
-  forEach: (fn: (peer: Peer) => void, query?: PeerQuery) => Promise<void>
+  forEach(fn: (peer: Peer) => void, query?: PeerQuery): Promise<void>
 
   /**
    * Returns all peers in the peer store.
@@ -169,7 +169,7 @@ export interface PeerStore {
    * }
    * ```
    */
-  all: (query?: PeerQuery) => Promise<Peer[]>
+  all(query?: PeerQuery): Promise<Peer[]>
 
   /**
    * Delete all data stored for the passed peer
@@ -187,7 +187,7 @@ export interface PeerStore {
    * // []
    * ```
    */
-  delete: (peerId: PeerId) => Promise<void>
+  delete(peerId: PeerId): Promise<void>
 
   /**
    * Returns true if the passed PeerId is in the peer store
@@ -202,7 +202,7 @@ export interface PeerStore {
    * // true
    * ```
    */
-  has: (peerId: PeerId) => Promise<boolean>
+  has(peerId: PeerId): Promise<boolean>
 
   /**
    * Returns all data stored for the passed PeerId
@@ -214,7 +214,7 @@ export interface PeerStore {
    * // { .. }
    * ```
    */
-  get: (peerId: PeerId) => Promise<Peer>
+  get(peerId: PeerId): Promise<Peer>
 
   /**
    * Adds a peer to the peer store, overwriting any existing data
@@ -227,7 +227,7 @@ export interface PeerStore {
    * })
    * ```
    */
-  save: (id: PeerId, data: PeerData) => Promise<Peer>
+  save(id: PeerId, data: PeerData): Promise<Peer>
 
   /**
    * Adds a peer to the peer store, overwriting only the passed fields
@@ -240,7 +240,7 @@ export interface PeerStore {
    * })
    * ```
    */
-  patch: (id: PeerId, data: PeerData) => Promise<Peer>
+  patch(id: PeerId, data: PeerData): Promise<Peer>
 
   /**
    * Adds a peer to the peer store, deeply merging any existing data.
@@ -253,7 +253,7 @@ export interface PeerStore {
    * })
    * ```
    */
-  merge: (id: PeerId, data: PeerData) => Promise<Peer>
+  merge(id: PeerId, data: PeerData): Promise<Peer>
 
   /**
    * Unmarshal and verify a signed peer record, extract the multiaddrs and
@@ -268,5 +268,5 @@ export interface PeerStore {
    * await peerStore.consumePeerRecord(buf, expectedPeer)
    * ```
    */
-  consumePeerRecord: (buf: Uint8Array, expectedPeer?: PeerId) => Promise<boolean>
+  consumePeerRecord(buf: Uint8Array, expectedPeer?: PeerId): Promise<boolean>
 }

package/src/pubsub/index.ts

@@ -72,10 +72,10 @@ export interface PeerStreams extends EventEmitter<PeerStreamEvents> {
   inboundStream?: AsyncIterable<Uint8ArrayList>
   isWritable: boolean
 
-  close: () => void
-  write: (buf: Uint8Array | Uint8ArrayList) => void
-  attachInboundStream: (stream: Stream) => AsyncIterable<Uint8ArrayList>
-  attachOutboundStream: (stream: Stream) => Promise<Pushable<Uint8ArrayList>>
+  close(): void
+  write(buf: Uint8Array | Uint8ArrayList): void
+  attachInboundStream(stream: Stream): AsyncIterable<Uint8ArrayList>
+  attachOutboundStream(stream: Stream): Promise<Pushable<Uint8ArrayList>>
 }
 
 export interface PubSubInit {
@@ -189,7 +189,7 @@ export interface PubSub<Events extends Record<string, any> = PubSubEvents> exten
    */
   topicValidators: Map<string, TopicValidatorFn>
 
-  getPeers: () => PeerId[]
+  getPeers(): PeerId[]
 
   /**
    * Gets a list of topics the node is subscribed to.
@@ -198,7 +198,7 @@ export interface PubSub<Events extends Record<string, any> = PubSubEvents> exten
    * const topics = libp2p.pubsub.getTopics()
    * ```
    */
-  getTopics: () => string[]
+  getTopics(): string[]
 
   /**
    * Subscribes to a pubsub topic.
@@ -217,7 +217,7 @@ export interface PubSub<Events extends Record<string, any> = PubSubEvents> exten
    * libp2p.pubsub.subscribe(topic)
    * ```
    */
-  subscribe: (topic: string) => void
+  subscribe(topic: string): void
 
   /**
    * Unsubscribes from a pubsub topic.
@@ -234,7 +234,7 @@ export interface PubSub<Events extends Record<string, any> = PubSubEvents> exten
    * libp2p.pubsub.unsubscribe(topic)
    * ```
    */
-  unsubscribe: (topic: string) => void
+  unsubscribe(topic: string): void
 
   /**
    * Gets a list of the PeerIds that are subscribed to one topic.
@@ -245,7 +245,7 @@ export interface PubSub<Events extends Record<string, any> = PubSubEvents> exten
    * const peerIds = libp2p.pubsub.getSubscribers(topic)
    * ```
    */
-  getSubscribers: (topic: string) => PeerId[]
+  getSubscribers(topic: string): PeerId[]
 
   /**
    * Publishes messages to the given topic.
@@ -259,7 +259,7 @@ export interface PubSub<Events extends Record<string, any> = PubSubEvents> exten
    * await libp2p.pubsub.publish(topic, data)
    * ```
    */
-  publish: (topic: string, data: Uint8Array) => Promise<PublishResult>
+  publish(topic: string, data: Uint8Array): Promise<PublishResult>
 }
 
 export interface PeerStreamEvents {

package/src/record/index.ts

@@ -16,11 +16,11 @@ export interface Record {
   /**
    * Marshal a record to be used in an envelope.
    */
-  marshal: () => Uint8Array
+  marshal(): Uint8Array
   /**
    * Verifies if the other provided Record is identical to this one.
    */
-  equals: (other: Record) => boolean
+  equals(other: Record): boolean
 }
 
 export interface Envelope {
@@ -29,7 +29,7 @@ export interface Envelope {
   payload: Uint8Array
   signature: Uint8Array | Uint8ArrayList
 
-  marshal: () => Uint8Array
-  validate: (domain: string) => Promise<boolean>
-  equals: (other: Envelope) => boolean
+  marshal(): Uint8Array
+  validate(domain: string): Promise<boolean>
+  equals(other: Envelope): boolean
 }

package/src/startable.ts

@@ -2,49 +2,49 @@
  * Implemented by components that have a lifecycle
  */
 export interface Startable {
-  isStarted: () => boolean
+  isStarted(): boolean
 
   /**
    * If implemented, this method will be invoked before the start method.
    *
    * It should not assume any other components have been started.
    */
-  beforeStart?: () => void | Promise<void>
+  beforeStart?(): void | Promise<void>
 
   /**
    * This method will be invoked to start the component.
    *
    * It should not assume that any other components have been started.
    */
-  start: () => void | Promise<void>
+  start(): void | Promise<void>
 
   /**
    * If implemented, this method will be invoked after the start method.
    *
    * All other components will have had their start method invoked before this method is called.
    */
-  afterStart?: () => void | Promise<void>
+  afterStart?(): void | Promise<void>
 
   /**
    * If implemented, this method will be invoked before the stop method.
    *
    * Any other components will still be running when this method is called.
    */
-  beforeStop?: () => void | Promise<void>
+  beforeStop?(): void | Promise<void>
 
   /**
    * This method will be invoked to stop the component.
    *
    * It should not assume any other components are running when it is called.
    */
-  stop: () => void | Promise<void>
+  stop(): void | Promise<void>
 
   /**
    * If implemented, this method will be invoked after the stop method.
    *
    * All other components will have had their stop method invoked before this method is called.
    */
-  afterStop?: () => void | Promise<void>
+  afterStop?(): void | Promise<void>
 }
 
 export function isStartable (obj: any): obj is Startable {

package/src/stream-muxer/index.ts

@@ -12,7 +12,7 @@ export interface StreamMuxerFactory {
   /**
    * Creates a new stream muxer to be used with a new connection
    */
-  createStreamMuxer: (init?: StreamMuxerInit) => StreamMuxer
+  createStreamMuxer(init?: StreamMuxerInit): StreamMuxer
 }
 
 /**
@@ -32,29 +32,29 @@ export interface StreamMuxer extends Duplex<AsyncGenerator<Uint8Array>, Source<U
    * Initiate a new stream with the given name. If no name is
    * provided, the id of the stream will be used.
    */
-  newStream: (name?: string) => Stream | Promise<Stream>
+  newStream(name?: string): Stream | Promise<Stream>
 
   /**
    * Close or abort all tracked streams and stop the muxer
    */
-  close: (options?: AbortOptions) => Promise<void>
+  close(options?: AbortOptions): Promise<void>
 
   /**
    * Close or abort all tracked streams and stop the muxer
    */
-  abort: (err: Error) => void
+  abort(err: Error): void
 }
 
 export interface StreamMuxerInit {
   /**
    * A callback function invoked every time an incoming stream is opened
    */
-  onIncomingStream?: (stream: Stream) => void
+  onIncomingStream?(stream: Stream): void
 
   /**
    * A callback function invoke every time a stream ends
    */
-  onStreamEnd?: (stream: Stream) => void
+  onStreamEnd?(stream: Stream): void
 
   /**
    * Outbound stream muxers are opened by the local node, inbound stream muxers are opened by the remote

package/src/stream-muxer/stream.ts

@@ -1,21 +1,24 @@
 import { abortableSource } from 'abortable-iterator'
 import { type Pushable, pushable } from 'it-pushable'
 import defer, { type DeferredPromise } from 'p-defer'
+import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { CodeError } from '../errors.js'
 import type { Direction, ReadStatus, Stream, StreamStatus, StreamTimeline, WriteStatus } from '../connection/index.js'
 import type { AbortOptions } from '../index.js'
 import type { Source } from 'it-stream-types'
 
+// copied from @libp2p/logger to break a circular dependency
 interface Logger {
   (formatter: any, ...args: any[]): void
-  error: (formatter: any, ...args: any[]) => void
-  trace: (formatter: any, ...args: any[]) => void
+  error(formatter: any, ...args: any[]): void
+  trace(formatter: any, ...args: any[]): void
   enabled: boolean
 }
 
 const ERR_STREAM_RESET = 'ERR_STREAM_RESET'
 const ERR_SINK_INVALID_STATE = 'ERR_SINK_INVALID_STATE'
+const DEFAULT_SEND_CLOSE_WRITE_TIMEOUT = 5000
 
 export interface AbstractStreamInit {
   /**
@@ -41,33 +44,39 @@ export interface AbstractStreamInit {
   /**
    * Invoked when the stream ends
    */
-  onEnd?: (err?: Error | undefined) => void
+  onEnd?(err?: Error | undefined): void
 
   /**
    * Invoked when the readable end of the stream is closed
    */
-  onCloseRead?: () => void
+  onCloseRead?(): void
 
   /**
    * Invoked when the writable end of the stream is closed
    */
-  onCloseWrite?: () => void
+  onCloseWrite?(): void
 
   /**
    * Invoked when the the stream has been reset by the remote
    */
-  onReset?: () => void
+  onReset?(): void
 
   /**
    * Invoked when the the stream has errored
    */
-  onAbort?: (err: Error) => void
+  onAbort?(err: Error): void
 
   /**
    * How long to wait in ms for stream data to be written to the underlying
    * connection when closing the writable end of the stream. (default: 500)
    */
   closeTimeout?: number
+
+  /**
+   * After the stream sink has closed, a limit on how long it takes to send
+   * a close-write message to the remote peer.
+   */
+  sendCloseWriteTimeout?: number
 }
 
 function isPromise (res?: any): res is Promise<void> {
@@ -94,6 +103,7 @@ export abstract class AbstractStream implements Stream {
   private readonly onCloseWrite?: () => void
   private readonly onReset?: () => void
   private readonly onAbort?: (err: Error) => void
+  private readonly sendCloseWriteTimeout: number
 
   protected readonly log: Logger
 
@@ -113,6 +123,7 @@ export abstract class AbstractStream implements Stream {
     this.timeline = {
       open: Date.now()
     }
+    this.sendCloseWriteTimeout = init.sendCloseWriteTimeout ?? DEFAULT_SEND_CLOSE_WRITE_TIMEOUT
 
     this.onEnd = init.onEnd
     this.onCloseRead = init?.onCloseRead
@@ -128,7 +139,6 @@ export abstract class AbstractStream implements Stream {
           this.log.trace('source ended')
         }
 
-        this.readStatus = 'closed'
         this.onSourceEnd(err)
       }
     })
@@ -173,11 +183,19 @@ export abstract class AbstractStream implements Stream {
         }
       }
 
-      this.log.trace('sink finished reading from source')
-      this.writeStatus = 'done'
+      this.log.trace('sink finished reading from source, write status is "%s"', this.writeStatus)
+
+      if (this.writeStatus === 'writing') {
+        this.writeStatus = 'closing'
+
+        this.log.trace('send close write to remote')
+        await this.sendCloseWrite({
+          signal: AbortSignal.timeout(this.sendCloseWriteTimeout)
+        })
+
+        this.writeStatus = 'closed'
+      }
 
-      this.log.trace('sink calling closeWrite')
-      await this.closeWrite(options)
       this.onSinkEnd()
     } catch (err: any) {
       this.log.trace('sink ended with error, calling abort with error', err)
@@ -196,6 +214,7 @@ export abstract class AbstractStream implements Stream {
     }
 
     this.timeline.closeRead = Date.now()
+    this.readStatus = 'closed'
 
     if (err != null && this.endErr == null) {
       this.endErr = err
@@ -207,6 +226,10 @@ export abstract class AbstractStream implements Stream {
       this.log.trace('source and sink ended')
       this.timeline.close = Date.now()
 
+      if (this.status !== 'aborted' && this.status !== 'reset') {
+        this.status = 'closed'
+      }
+
       if (this.onEnd != null) {
         this.onEnd(this.endErr)
       }
@@ -221,6 +244,7 @@ export abstract class AbstractStream implements Stream {
     }
 
     this.timeline.closeWrite = Date.now()
+    this.writeStatus = 'closed'
 
     if (err != null && this.endErr == null) {
       this.endErr = err
@@ -232,6 +256,10 @@ export abstract class AbstractStream implements Stream {
       this.log.trace('sink and source ended')
       this.timeline.close = Date.now()
 
+      if (this.status !== 'aborted' && this.status !== 'reset') {
+        this.status = 'closed'
+      }
+
       if (this.onEnd != null) {
         this.onEnd(this.endErr)
       }
@@ -266,16 +294,16 @@ export abstract class AbstractStream implements Stream {
     const readStatus = this.readStatus
     this.readStatus = 'closing'
 
-    if (readStatus === 'ready') {
-      this.log.trace('ending internal source queue')
-      this.streamSource.end()
-    }
-
     if (this.status !== 'reset' && this.status !== 'aborted' && this.timeline.closeRead == null) {
       this.log.trace('send close read to remote')
       await this.sendCloseRead(options)
     }
 
+    if (readStatus === 'ready') {
+      this.log.trace('ending internal source queue')
+      this.streamSource.end()
+    }
+
     this.log.trace('closed readable end of stream')
   }
 
@@ -286,16 +314,13 @@ export abstract class AbstractStream implements Stream {
 
     this.log.trace('closing writable end of stream with starting write status "%s"', this.writeStatus)
 
-    const writeStatus = this.writeStatus
-
     if (this.writeStatus === 'ready') {
       this.log.trace('sink was never sunk, sink an empty array')
-      await this.sink([])
-    }
 
-    this.writeStatus = 'closing'
+      await raceSignal(this.sink([]), options.signal)
+    }
 
-    if (writeStatus === 'writing') {
+    if (this.writeStatus === 'writing') {
       // stop reading from the source passed to `.sink` in the microtask queue
       // - this lets any data queued by the user in the current tick get read
       // before we exit
@@ -303,16 +328,12 @@ export abstract class AbstractStream implements Stream {
         queueMicrotask(() => {
           this.log.trace('aborting source passed to .sink')
           this.sinkController.abort()
-          this.sinkEnd.promise.then(resolve, reject)
+          raceSignal(this.sinkEnd.promise, options.signal)
+            .then(resolve, reject)
         })
       })
     }
 
-    if (this.status !== 'reset' && this.status !== 'aborted' && this.timeline.closeWrite == null) {
-      this.log.trace('send close write to remote')
-      await this.sendCloseWrite(options)
-    }
-
     this.writeStatus = 'closed'
 
     this.log.trace('closed writable end of stream')
@@ -357,6 +378,7 @@ export abstract class AbstractStream implements Stream {
     const err = new CodeError('stream reset', ERR_STREAM_RESET)
 
     this.status = 'reset'
+    this.timeline.reset = Date.now()
     this._closeSinkAndSource(err)
     this.onReset?.()
   }
@@ -423,7 +445,7 @@ export abstract class AbstractStream implements Stream {
       return
     }
 
-    this.log.trace('muxer destroyed')
+    this.log.trace('stream destroyed')
 
     this._closeSinkAndSource()
   }

package/src/topology/index.ts

@@ -5,6 +5,6 @@ export interface Topology {
   min?: number
   max?: number
 
-  onConnect?: (peerId: PeerId, conn: Connection) => void
-  onDisconnect?: (peerId: PeerId) => void
+  onConnect?(peerId: PeerId, conn: Connection): void
+  onDisconnect?(peerId: PeerId): void
 }

package/src/transport/index.ts

@@ -15,17 +15,17 @@ export interface Listener extends EventEmitter<ListenerEvents> {
   /**
    * Start a listener
    */
-  listen: (multiaddr: Multiaddr) => Promise<void>
+  listen(multiaddr: Multiaddr): Promise<void>
   /**
    * Get listen addresses
    */
-  getAddrs: () => Multiaddr[]
+  getAddrs(): Multiaddr[]
   /**
    * Close listener
    *
    * @returns {Promise<void>}
    */
-  close: () => Promise<void>
+  close(): Promise<void>
 }
 
 export const symbol = Symbol.for('@libp2p/transport')
@@ -60,12 +60,12 @@ export interface Transport {
   /**
    * Dial a given multiaddr.
    */
-  dial: (ma: Multiaddr, options: DialOptions) => Promise<Connection>
+  dial(ma: Multiaddr, options: DialOptions): Promise<Connection>
 
   /**
    * Create transport listeners.
    */
-  createListener: (options: CreateListenerOptions) => Listener
+  createListener(options: CreateListenerOptions): Listener
 
   /**
    * Takes a list of `Multiaddr`s and returns only valid addresses for the transport
@@ -108,10 +108,10 @@ export interface Upgrader {
   /**
    * Upgrades an outbound connection on `transport.dial`.
    */
-  upgradeOutbound: (maConn: MultiaddrConnection, opts?: UpgraderOptions) => Promise<Connection>
+  upgradeOutbound(maConn: MultiaddrConnection, opts?: UpgraderOptions): Promise<Connection>
 
   /**
    * Upgrades an inbound connection on transport listener.
    */
-  upgradeInbound: (maConn: MultiaddrConnection, opts?: UpgraderOptions) => Promise<Connection>
+  upgradeInbound(maConn: MultiaddrConnection, opts?: UpgraderOptions): Promise<Connection>
 }