chore: add types for @hyperswarm/secret-stream

lib/discovery/index.js

@@ -1,14 +1,14 @@
 import net from 'net'
 
 import { TypedEmitter } from 'tiny-typed-emitter'
-import SecretStream from '@hyperswarm/secret-stream'
+import NoiseSecretStream from '@hyperswarm/secret-stream'
 import Hyperswarm from 'hyperswarm'
 import { MdnsDiscovery } from 'multicast-service-discovery'
 import base32 from 'base32.js'
 
 /**
  * @typedef {Object} DiscoveryEvents
- * @property {(connection: NoiseSecretStream, info: PeerInfo) => void} connection
+ * @property {(connection: NoiseSecretStream<RawConnectionStream>, info: PeerInfo) => void} connection
  * @property {(topicStatus: { topic: TopicString, mdns: TopicServiceStatus, dht: TopicServiceStatus }) => void} topicStatus
  * @property {(peerStatus: { status: String, peer: PeerInfo }) => void} peerStatus
  * @property {(error: Error) => void} error
@@ -247,8 +247,7 @@ export class Discovery extends TypedEmitter {
       throw new Error('Socket not connected')
     }
 
-    /** @type {ConnectionStream} */
-    const connection = new SecretStream(false, socket)
+    const connection = new NoiseSecretStream(false, socket)
 
     connection.on('error', (error) => {
       console.error('Error on mdns client connection', error)
@@ -298,7 +297,7 @@ export class Discovery extends TypedEmitter {
    * Handle connection that occur via the Hyperswarm DHT
    *
    * @private
-   * @param {ConnectionStream} connection
+   * @param {NoiseSecretStream<RawDHTConnectionStream>} connection
    * @param {HyperswarmPeerInfo} info
    * @returns {Promise<void>}
    */
@@ -594,7 +593,7 @@ export class Discovery extends TypedEmitter {
    *
    * @private
    * @param {Address} options
-   * @returns {ConnectionStream}
+   * @returns {NoiseSecretStream<net.Socket>}
    */
   _connect(options) {
     const { host, port } = options
@@ -604,7 +603,7 @@ export class Discovery extends TypedEmitter {
       allowHalfOpen: true,
     })
 
-    const connection = new SecretStream(true, stream, {
+    const connection = new NoiseSecretStream(true, stream, {
       keyPair: this.#identityKeyPair,
     })
 
@@ -832,7 +831,7 @@ export class PeerInfo extends TypedEmitter {
    * @typedef {Object} PeerInfoOptions
    * @property {IdentityPublicKeyString} identityPublicKey
    * @property {('dht'|'mdns')} discoveryType
-   * @property {ConnectionStream} connection
+   * @property {NoiseSecretStream<RawConnectionStream>} connection
    * @property {HyperswarmPeerInfo} [dhtPeerInfo]
    * @property {TopicString[]} [topics]
    * @property {string} [host]
@@ -889,7 +888,7 @@ export class PeerInfo extends TypedEmitter {
    * @param {Object} options
    * @param {IdentityPublicKeyString} [options.identityPublicKey]
    * @param {('dht'|'mdns')} [options.discoveryType]
-   * @param {ConnectionStream} [options.connection]
+   * @param {NoiseSecretStream<RawConnectionStream>} [options.connection]
    * @param {HyperswarmPeerInfo} [options.dhtPeerInfo]
    * @param {TopicString[]} [options.topics]
    * @param {string} [options.host]

lib/types.js

@@ -52,24 +52,13 @@
  * @typedef {Buffer} Block
  */
 
+// TODO: Figure out where those extra fields come from and find more elegant way to represent this
 /**
- * @typedef {Object} NoiseSecretStream
- * @property {Buffer} remotePublicKey
- * @property {number} remotePort
- * @property {string} remoteHost
- * @property {import('net').Socket} rawStream
- * @property {function} end
+ * @typedef {import('streamx').Duplex & {remoteAddress: string, remotePort:number}} RawDHTConnectionStream
  */
 
 /**
- * @typedef {import('streamx').Stream<any, false, false, ConnectionStreamEvents> & NoiseSecretStream} ConnectionStream
- */
-
-/**
- * @typedef {Object} ConnectionStreamEvents
- * @property {(connect: void) => void} connect
- * @property {(close: void) => void} close
- * @property {(error: Error) => void} error
+ * @typedef {import('net').Socket | RawDHTConnectionStream} RawConnectionStream
  */
 
 /**

types/modules.d.ts

@@ -1,6 +1,62 @@
 // TODO: create types for these modules
 declare module 'hyperswarm'
-declare module '@hyperswarm/secret-stream'
+declare module '@hyperswarm/secret-stream' {
+  import { Duplex as NodeDuplex } from 'stream'
+  import { Duplex, DuplexEvents } from 'streamx'
+
+  interface Opts {
+    autostart?: boolean
+    // TODO: Use https://github.com/chm-diederichs/noise-handshake/blob/main/noise.js for specific patterns
+    pattern?: string
+    remotePublicKey?: Buffer
+    keyPair?: { publicKey: Buffer; secretKey: Buffer }
+    handshake?: {
+      tx: Buffer
+      rx: Buffer
+      hash: Buffer
+      publicKey: Buffer
+      remotePublicKey: Buffer
+    }
+  }
+
+  type NoiseStreamEvents = {
+    connect: () => void
+  }
+
+  class NoiseSecretStream<
+    RawStream extends NodeDuplex | Duplex = Duplex
+  > extends Duplex<
+    any,
+    any,
+    any,
+    any,
+    true,
+    true,
+    DuplexEvents<any, any> & NoiseStreamEvents
+  > {
+    readonly publicKey: Buffer
+    readonly remotePublicKey: Buffer
+    readonly handshakeHash: Buffer
+    readonly rawStream: RawStream
+    readonly isInitiator: boolean
+    readonly noiseStream: this
+    readonly opened: Promise<boolean>
+    readonly userData: any
+
+    constructor(isInitiator: boolean, rawStream?: RawStream, opts?: Opts)
+
+    static keyPair(seed?: Buffer): {
+      publicKey: Buffer
+      secretKey: Buffer
+    }
+
+    start(rawStream?: NodeDuplex, opts?: Opts): void
+    setTimeout(ms?: number): void
+    setKeepAlive(ms?: number): void
+  }
+
+  export = NoiseSecretStream
+}
 declare module '@hyperswarm/testnet'
 declare module 'base32.js'
 declare module '@mapeo/crypto'