@libp2p/multistream-select 4.0.6-05b52d69c → 4.0.6-3dee5df4d

package/dist/src/select.js

@@ -1,93 +1,133 @@
 import { CodeError } from '@libp2p/interface/errors';
-import { handshake } from 'it-handshake';
-import merge from 'it-merge';
-import { pushable } from 'it-pushable';
-import { reader } from 'it-reader';
-import { Uint8ArrayList } from 'uint8arraylist';
+import { lpStream } from 'it-length-prefixed-stream';
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
+import { MAX_PROTOCOL_LENGTH } from './constants.js';
 import * as multistream from './multistream.js';
 import { PROTOCOL_ID } from './index.js';
+/**
+ * Negotiate a protocol to use from a list of protocols.
+ *
+ * @param stream - A duplex iterable stream to dial on
+ * @param protocols - A list of protocols (or single protocol) to negotiate with. Protocols are attempted in order until a match is made.
+ * @param options - An options object containing an AbortSignal and an optional boolean `writeBytes` - if this is true, `Uint8Array`s will be written into `duplex`, otherwise `Uint8ArrayList`s will
+ * @returns A stream for the selected protocol and the protocol that was selected from the list of protocols provided to `select`.
+ * @example
+ *
+ * ```js
+ * import { pipe } from 'it-pipe'
+ * import * as mss from '@libp2p/multistream-select'
+ * import { Mplex } from '@libp2p/mplex'
+ *
+ * const muxer = new Mplex()
+ * const muxedStream = muxer.newStream()
+ *
+ * // mss.select(protocol(s))
+ * // Select from one of the passed protocols (in priority order)
+ * // Returns selected stream and protocol
+ * const { stream: dhtStream, protocol } = await mss.select(muxedStream, [
+ *   // This might just be different versions of DHT, but could be different impls
+ *   '/ipfs-dht/2.0.0', // Most of the time this will probably just be one item.
+ *   '/ipfs-dht/1.0.0'
+ * ])
+ *
+ * // Typically this stream will be passed back to the caller of libp2p.dialProtocol
+ * //
+ * // ...it might then do something like this:
+ * // try {
+ * //   await pipe(
+ * //     [uint8ArrayFromString('Some DHT data')]
+ * //     dhtStream,
+ * //     async source => {
+ * //       for await (const chunk of source)
+ * //         // DHT response data
+ * //     }
+ * //   )
+ * // } catch (err) {
+ * //   // Error in stream
+ * // }
+ * ```
+ */
 export async function select(stream, protocols, options) {
     protocols = Array.isArray(protocols) ? [...protocols] : [protocols];
-    const { reader, writer, rest, stream: shakeStream } = handshake(stream);
+    const lp = lpStream(stream, {
+        maxDataLength: MAX_PROTOCOL_LENGTH
+    });
     const protocol = protocols.shift();
     if (protocol == null) {
         throw new Error('At least one protocol must be specified');
     }
     options?.log.trace('select: write ["%s", "%s"]', PROTOCOL_ID, protocol);
-    const p1 = uint8ArrayFromString(PROTOCOL_ID);
-    const p2 = uint8ArrayFromString(protocol);
-    multistream.writeAll(writer, [p1, p2], options);
-    let response = await multistream.readString(reader, options);
+    const p1 = uint8ArrayFromString(`${PROTOCOL_ID}\n`);
+    const p2 = uint8ArrayFromString(`${protocol}\n`);
+    await multistream.writeAll(lp, [p1, p2], options);
+    options?.log.trace('select: reading multistream-select header');
+    let response = await multistream.readString(lp, options);
     options?.log.trace('select: read "%s"', response);
     // Read the protocol response if we got the protocolId in return
     if (response === PROTOCOL_ID) {
-        response = await multistream.readString(reader, options);
+        options?.log.trace('select: reading protocol response');
+        response = await multistream.readString(lp, options);
         options?.log.trace('select: read "%s"', response);
     }
     // We're done
     if (response === protocol) {
-        rest();
-        return { stream: shakeStream, protocol };
+        return { stream: lp.unwrap(), protocol };
     }
     // We haven't gotten a valid ack, try the other protocols
     for (const protocol of protocols) {
         options?.log.trace('select: write "%s"', protocol);
-        multistream.write(writer, uint8ArrayFromString(protocol), options);
-        const response = await multistream.readString(reader, options);
+        await multistream.write(lp, uint8ArrayFromString(`${protocol}\n`), options);
+        options?.log.trace('select: reading protocol response');
+        const response = await multistream.readString(lp, options);
         options?.log.trace('select: read "%s" for "%s"', response, protocol);
         if (response === protocol) {
-            rest(); // End our writer so others can start writing to stream
-            return { stream: shakeStream, protocol };
+            return { stream: lp.unwrap(), protocol };
         }
     }
-    rest();
     throw new CodeError('protocol selection failed', 'ERR_UNSUPPORTED_PROTOCOL');
 }
-export function lazySelect(stream, protocol) {
-    // This is a signal to write the multistream headers if the consumer tries to
-    // read from the source
-    const negotiateTrigger = pushable();
-    let negotiated = false;
+/**
+ * Lazily negotiates a protocol.
+ *
+ * It *does not* block writes waiting for the other end to respond. Instead, it
+ * simply assumes the negotiation went successfully and starts writing data.
+ *
+ * Use when it is known that the receiver supports the desired protocol.
+ */
+export function lazySelect(stream, protocol, options) {
+    const originalSink = stream.sink.bind(stream);
+    const originalSource = stream.source;
+    const lp = lpStream({
+        sink: originalSink,
+        source: originalSource
+    }, {
+        maxDataLength: MAX_PROTOCOL_LENGTH
+    });
+    stream.sink = async (source) => {
+        options?.log.trace('lazy: write ["%s", "%s"]', PROTOCOL_ID, protocol);
+        await lp.writeV([
+            uint8ArrayFromString(`${PROTOCOL_ID}\n`),
+            uint8ArrayFromString(`${protocol}\n`)
+        ]);
+        options?.log.trace('lazy: writing rest of "%s" stream', protocol);
+        await lp.unwrap().sink(source);
+    };
+    stream.source = (async function* () {
+        options?.log.trace('lazy: reading multistream select header');
+        let response = await multistream.readString(lp, options);
+        options?.log.trace('lazy: read multistream select header "%s"', response);
+        if (response === PROTOCOL_ID) {
+            response = await multistream.readString(lp, options);
+        }
+        options?.log.trace('lazy: read protocol "%s", expecting "%s"', response, protocol);
+        if (response !== protocol) {
+            throw new CodeError('protocol selection failed', 'ERR_UNSUPPORTED_PROTOCOL');
+        }
+        options?.log.trace('lazy: reading rest of "%s" stream', protocol);
+        yield* lp.unwrap().source;
+    })();
     return {
-        stream: {
-            sink: async (source) => {
-                await stream.sink((async function* () {
-                    let first = true;
-                    for await (const chunk of merge(source, negotiateTrigger)) {
-                        if (first) {
-                            first = false;
-                            negotiated = true;
-                            negotiateTrigger.end();
-                            const p1 = uint8ArrayFromString(PROTOCOL_ID);
-                            const p2 = uint8ArrayFromString(protocol);
-                            const list = new Uint8ArrayList(multistream.encode(p1), multistream.encode(p2));
-                            if (chunk.length > 0)
-                                list.append(chunk);
-                            yield* list;
-                        }
-                        else {
-                            yield chunk;
-                        }
-                    }
-                })());
-            },
-            source: (async function* () {
-                if (!negotiated)
-                    negotiateTrigger.push(new Uint8Array());
-                const byteReader = reader(stream.source);
-                let response = await multistream.readString(byteReader);
-                if (response === PROTOCOL_ID) {
-                    response = await multistream.readString(byteReader);
-                }
-                if (response !== protocol) {
-                    throw new CodeError('protocol selection failed', 'ERR_UNSUPPORTED_PROTOCOL');
-                }
-                for await (const chunk of byteReader) {
-                    yield* chunk;
-                }
-            })()
-        },
+        stream,
         protocol
     };
 }

package/dist/src/select.js.map

@@ -1 +1 @@
-{"version":3,"file":"select.js","sourceRoot":"","sources":["../../src/select.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"select.js","sourceRoot":"","sources":["../../src/select.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@libp2p/multistream-select",
-  "version": "4.0.6-05b52d69c",
+  "version": "4.0.6-3dee5df4d",
   "description": "JavaScript implementation of multistream-select",
   "license": "Apache-2.0 OR MIT",
-  "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/multistream-select#readme",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/multistream-select#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/libp2p/js-libp2p.git"
@@ -53,26 +53,20 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/interface": "0.1.6-05b52d69c",
-    "abortable-iterator": "^5.0.1",
-    "it-first": "^3.0.3",
-    "it-handshake": "^4.1.3",
+    "@libp2p/interface": "0.1.6-3dee5df4d",
     "it-length-prefixed": "^9.0.3",
-    "it-merge": "^3.0.0",
+    "it-length-prefixed-stream": "^1.1.1",
     "it-pipe": "^3.0.1",
-    "it-pushable": "^3.2.1",
-    "it-reader": "^6.0.1",
     "it-stream-types": "^2.0.1",
-    "uint8-varint": "^2.0.0",
     "uint8arraylist": "^2.4.3",
     "uint8arrays": "^4.0.6"
   },
   "devDependencies": {
-    "@libp2p/logger": "3.1.0-05b52d69c",
+    "@libp2p/logger": "3.1.0-3dee5df4d",
     "aegir": "^41.0.2",
     "iso-random-stream": "^2.0.2",
     "it-all": "^3.0.3",
-    "it-map": "^3.0.3",
+    "it-drain": "^3.0.5",
     "it-pair": "^2.0.6",
     "p-timeout": "^6.0.0"
   }

package/src/handle.ts

@@ -1,10 +1,11 @@
-import { handshake } from 'it-handshake'
+import { encode } from 'it-length-prefixed'
+import { lpStream } from 'it-length-prefixed-stream'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { PROTOCOL_ID } from './constants.js'
+import { MAX_PROTOCOL_LENGTH, PROTOCOL_ID } from './constants.js'
 import * as multistream from './multistream.js'
-import type { ByteArrayInit, ByteListInit, MultistreamSelectInit, ProtocolStream } from './index.js'
-import type { Duplex, Source } from 'it-stream-types'
+import type { MultistreamSelectInit, ProtocolStream } from './index.js'
+import type { Duplex } from 'it-stream-types'
 
 /**
  * Handle multistream protocol selections for the given list of protocols.
@@ -52,38 +53,43 @@ import type { Duplex, Source } from 'it-stream-types'
  * })
  * ```
  */
-export async function handle (stream: Duplex<Source<Uint8Array>, Source<Uint8Array>>, protocols: string | string[], options: ByteArrayInit): Promise<ProtocolStream<Uint8Array>>
-export async function handle (stream: Duplex<Source<Uint8ArrayList | Uint8Array>, Source<Uint8ArrayList | Uint8Array>>, protocols: string | string[], options?: ByteListInit): Promise<ProtocolStream<Uint8ArrayList, Uint8ArrayList | Uint8Array>>
-export async function handle (stream: any, protocols: string | string[], options?: MultistreamSelectInit): Promise<ProtocolStream<any>> {
+export async function handle <Stream extends Duplex<any, any, any>> (stream: Stream, protocols: string | string[], options: MultistreamSelectInit): Promise<ProtocolStream<Stream>> {
   protocols = Array.isArray(protocols) ? protocols : [protocols]
-  const { writer, reader, rest, stream: shakeStream } = handshake(stream)
+  const lp = lpStream(stream, {
+    maxDataLength: MAX_PROTOCOL_LENGTH
+  })
 
   while (true) {
-    const protocol = await multistream.readString(reader, options)
-    options?.log.trace('read "%s"', protocol)
+    options.log.trace('handle - available protocols %s', protocols)
+    const protocol = await multistream.readString(lp, options)
+    options.log.trace('read "%s"', protocol)
 
     if (protocol === PROTOCOL_ID) {
-      options?.log.trace('respond with "%s" for "%s"', PROTOCOL_ID, protocol)
-      multistream.write(writer, uint8ArrayFromString(PROTOCOL_ID), options)
+      options.log.trace('respond with "%s" for "%s"', PROTOCOL_ID, protocol)
+      await multistream.write(lp, uint8ArrayFromString(`${PROTOCOL_ID}\n`), options)
       continue
     }
 
     if (protocols.includes(protocol)) {
-      multistream.write(writer, uint8ArrayFromString(protocol), options)
-      options?.log.trace('respond with "%s" for "%s"', protocol, protocol)
-      rest()
-      return { stream: shakeStream, protocol }
+      options.log.trace('respond with "%s" for "%s"', protocol, protocol)
+      await multistream.write(lp, uint8ArrayFromString(`${protocol}\n`), options)
+
+      return { stream: lp.unwrap(), protocol }
     }
 
     if (protocol === 'ls') {
       // <varint-msg-len><varint-proto-name-len><proto-name>\n<varint-proto-name-len><proto-name>\n\n
-      multistream.write(writer, new Uint8ArrayList(...protocols.map(p => multistream.encode(uint8ArrayFromString(p)))), options)
-      // multistream.writeAll(writer, protocols.map(p => uint8ArrayFromString(p)))
-      options?.log.trace('respond with "%s" for %s', protocols, protocol)
+      const protos = new Uint8ArrayList(
+        ...protocols.map(p => encode.single(uint8ArrayFromString(`${p}\n`))),
+        uint8ArrayFromString('\n')
+      )
+
+      await multistream.write(lp, protos, options)
+      options.log.trace('respond with "%s" for %s', protocols, protocol)
       continue
     }
 
-    multistream.write(writer, uint8ArrayFromString('na'), options)
-    options?.log('respond with "na" for "%s"', protocol)
+    options.log('respond with "na" for "%s"', protocol)
+    await multistream.write(lp, uint8ArrayFromString('na\n'), options)
   }
 }

package/src/index.ts

@@ -22,25 +22,16 @@
 
 import { PROTOCOL_ID } from './constants.js'
 import type { AbortOptions, LoggerOptions } from '@libp2p/interface'
-import type { Duplex, Source } from 'it-stream-types'
 
 export { PROTOCOL_ID }
 
-export interface ProtocolStream<TSource, TSink = TSource, RSink = Promise<void>> {
-  stream: Duplex<AsyncGenerator<TSource>, Source<TSink>, RSink>
+export interface ProtocolStream<Stream> {
+  stream: Stream
   protocol: string
 }
 
-export interface ByteArrayInit extends AbortOptions, LoggerOptions {
-  writeBytes: true
-}
-
-export interface ByteListInit extends AbortOptions, LoggerOptions {
-  writeBytes?: false
-}
-
 export interface MultistreamSelectInit extends AbortOptions, LoggerOptions {
-  writeBytes?: boolean
+
 }
 
 export { select, lazySelect } from './select.js'

package/src/multistream.ts

@@ -1,95 +1,46 @@
 import { CodeError } from '@libp2p/interface/errors'
-import { abortableSource } from 'abortable-iterator'
-import first from 'it-first'
-import * as lp from 'it-length-prefixed'
-import { pipe } from 'it-pipe'
-import { Uint8ArrayList } from 'uint8arraylist'
+import { type Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { MAX_PROTOCOL_LENGTH } from './constants.js'
 import type { MultistreamSelectInit } from '.'
 import type { AbortOptions, LoggerOptions } from '@libp2p/interface'
-import type { Pushable } from 'it-pushable'
-import type { Reader } from 'it-reader'
-import type { Source } from 'it-stream-types'
+import type { LengthPrefixedStream } from 'it-length-prefixed-stream'
+import type { Duplex, Source } from 'it-stream-types'
 
 const NewLine = uint8ArrayFromString('\n')
 
-export function encode (buffer: Uint8Array | Uint8ArrayList): Uint8ArrayList {
-  const list = new Uint8ArrayList(buffer, NewLine)
-
-  return lp.encode.single(list)
-}
-
 /**
  * `write` encodes and writes a single buffer
  */
-export function write (writer: Pushable<any>, buffer: Uint8Array | Uint8ArrayList, options?: MultistreamSelectInit): void {
-  const encoded = encode(buffer)
-
-  if (options?.writeBytes === true) {
-    writer.push(encoded.subarray())
-  } else {
-    writer.push(encoded)
-  }
+export async function write (writer: LengthPrefixedStream<Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>>>, buffer: Uint8Array | Uint8ArrayList, options?: MultistreamSelectInit): Promise<void> {
+  await writer.write(buffer, options)
 }
 
 /**
  * `writeAll` behaves like `write`, except it encodes an array of items as a single write
  */
-export function writeAll (writer: Pushable<any>, buffers: Uint8Array[], options?: MultistreamSelectInit): void {
-  const list = new Uint8ArrayList()
-
-  for (const buf of buffers) {
-    list.append(encode(buf))
-  }
-
-  if (options?.writeBytes === true) {
-    writer.push(list.subarray())
-  } else {
-    writer.push(list)
-  }
+export async function writeAll (writer: LengthPrefixedStream<Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>>>, buffers: Uint8Array[], options?: MultistreamSelectInit): Promise<void> {
+  await writer.writeV(buffers, options)
 }
 
-export async function read (reader: Reader, options?: AbortOptions & LoggerOptions): Promise<Uint8ArrayList> {
-  let byteLength = 1 // Read single byte chunks until the length is known
-  const varByteSource = { // No return impl - we want the reader to remain readable
-    [Symbol.asyncIterator]: () => varByteSource,
-    next: async () => reader.next(byteLength)
-  }
-
-  let input: Source<Uint8ArrayList> = varByteSource
-
-  // If we have been passed an abort signal, wrap the input source in an abortable
-  // iterator that will throw if the operation is aborted
-  if (options?.signal != null) {
-    input = abortableSource(varByteSource, options.signal)
-  }
-
-  // Once the length has been parsed, read chunk for that length
-  const onLength = (l: number): void => {
-    byteLength = l
-  }
-
-  const buf = await pipe(
-    input,
-    (source) => lp.decode(source, { onLength, maxDataLength: MAX_PROTOCOL_LENGTH }),
-    async (source) => first(source)
-  )
-
-  if (buf == null || buf.length === 0) {
-    throw new CodeError('no buffer returned', 'ERR_INVALID_MULTISTREAM_SELECT_MESSAGE')
-  }
+/**
+ * Read a length-prefixed buffer from the passed stream, stripping the final newline character
+ */
+export async function read (reader: LengthPrefixedStream<Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>, Source<Uint8Array>>>, options?: AbortOptions & LoggerOptions): Promise<Uint8ArrayList> {
+  const buf = await reader.read(options)
 
-  if (buf.get(buf.byteLength - 1) !== NewLine[0]) {
-    options?.log.error('Invalid mss message - missing newline - %s', buf.subarray())
+  if (buf.byteLength === 0 || buf.get(buf.byteLength - 1) !== NewLine[0]) {
+    options?.log.error('Invalid mss message - missing newline', buf)
     throw new CodeError('missing newline', 'ERR_INVALID_MULTISTREAM_SELECT_MESSAGE')
   }
 
   return buf.sublist(0, -1) // Remove newline
 }
 
-export async function readString (reader: Reader, options?: AbortOptions & LoggerOptions): Promise<string> {
+/**
+ * Read a length-prefixed string from the passed stream, stripping the final newline character
+ */
+export async function readString (reader: LengthPrefixedStream<Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>, Source<Uint8Array>>>, options?: AbortOptions & LoggerOptions): Promise<string> {
   const buf = await read(reader, options)
 
   return uint8ArrayToString(buf.subarray())