@libp2p/webrtc 1.1.9 → 1.1.11

package/src/sdp.ts

@@ -1,11 +1,10 @@
 import { logger } from '@libp2p/logger'
-import type { Multiaddr } from '@multiformats/multiaddr'
 import { bases } from 'multiformats/basics'
 import * as multihashes from 'multihashes'
-import type { HashCode, HashName } from 'multihashes'
-
 import { inappropriateMultiaddr, invalidArgument, invalidFingerprint, unsupportedHashAlgorithm } from './error.js'
 import { CERTHASH_CODE } from './transport.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { HashCode, HashName } from 'multihashes'
 
 const log = logger('libp2p:webrtc:sdp')
 
@@ -15,6 +14,37 @@ const log = logger('libp2p:webrtc:sdp')
 // @ts-expect-error - Not easy to combine these types.
 export const mbdecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
 
+export function getLocalFingerprint (pc: RTCPeerConnection): string | undefined {
+  // try to fetch fingerprint from local certificate
+  const localCert = pc.getConfiguration().certificates?.at(0)
+  if (localCert == null || localCert.getFingerprints == null) {
+    log.trace('fetching fingerprint from local SDP')
+    const localDescription = pc.localDescription
+    if (localDescription == null) {
+      return undefined
+    }
+    return getFingerprintFromSdp(localDescription.sdp)
+  }
+
+  log.trace('fetching fingerprint from local certificate')
+
+  if (localCert.getFingerprints().length === 0) {
+    return undefined
+  }
+
+  const fingerprint = localCert.getFingerprints()[0].value
+  if (fingerprint == null) {
+    throw invalidFingerprint('', 'no fingerprint on local certificate')
+  }
+
+  return fingerprint
+}
+
+const fingerprintRegex = /^a=fingerprint:(?:\w+-[0-9]+)\s(?<fingerprint>(:?[0-9a-fA-F]{2})+)$/m
+export function getFingerprintFromSdp (sdp: string): string | undefined {
+  const searchResult = sdp.match(fingerprintRegex)
+  return searchResult?.groups?.fingerprint
+}
 /**
  * Get base2 | identity decoders
  */

package/src/stream.ts

@@ -1,14 +1,13 @@
-import type { Stream, StreamStat, Direction } from '@libp2p/interface-connection'
 import { logger } from '@libp2p/logger'
 import * as lengthPrefixed from 'it-length-prefixed'
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
-import defer, { DeferredPromise } from 'p-defer'
-import type { Source } from 'it-stream-types'
+import defer, { type DeferredPromise } from 'p-defer'
 import { Uint8ArrayList } from 'uint8arraylist'
-
 import * as pb from '../proto_ts/message.js'
+import type { Stream, StreamStat, Direction } from '@libp2p/interface-connection'
+import type { Source } from 'it-stream-types'
 
 const log = logger('libp2p:webrtc:stream')
 
@@ -182,7 +181,7 @@ export class WebRTCStream implements Stream {
    * Read unwrapped protobuf data from the underlying datachannel.
    * _src is exposed to the user via the `source` getter to .
    */
-  private readonly _src: Source<Uint8ArrayList>
+  private readonly _src: AsyncGenerator<Uint8ArrayList, any, unknown>
 
   /**
    * push data from the underlying datachannel to the length prefix decoder
@@ -213,6 +212,7 @@ export class WebRTCStream implements Stream {
 
   constructor (opts: StreamInitOpts) {
     this.channel = opts.channel
+    this.channel.binaryType = 'arraybuffer'
     this.id = this.channel.label
 
     this.stat = opts.stat
@@ -281,9 +281,9 @@ export class WebRTCStream implements Stream {
   }
 
   // If user attempts to set a new source this should be a noop
-  set source (_src: Source<Uint8ArrayList>) { }
+  set source (_src: AsyncGenerator<Uint8ArrayList, any, unknown>) { }
 
-  get source (): Source<Uint8ArrayList> {
+  get source (): AsyncGenerator<Uint8ArrayList, any, unknown> {
     return this._src
   }
 

package/src/transport.ts

@@ -1,22 +1,22 @@
 import { noise as Noise } from '@chainsafe/libp2p-noise'
-import type { Connection } from '@libp2p/interface-connection'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import { CreateListenerOptions, Listener, symbol, Transport } from '@libp2p/interface-transport'
+import { type CreateListenerOptions, type Listener, symbol, type Transport } from '@libp2p/interface-transport'
 import { logger } from '@libp2p/logger'
 import * as p from '@libp2p/peer-id'
-import type { Multiaddr } from '@multiformats/multiaddr'
+import { protocols } from '@multiformats/multiaddr'
 import * as multihashes from 'multihashes'
-import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { concat } from 'uint8arrays/concat'
+import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { dataChannelError, inappropriateMultiaddr, unimplemented, invalidArgument } from './error.js'
 import { WebRTCMultiaddrConnection } from './maconn.js'
 import { DataChannelMuxerFactory } from './muxer.js'
-import type { WebRTCDialOptions } from './options.js'
+import { isFirefox } from './peer_transport/util.js'
 import * as sdp from './sdp.js'
 import { WebRTCStream } from './stream.js'
 import { genUfrag } from './util.js'
-import { protocols } from '@multiformats/multiaddr'
-import { isFirefox } from './peer_transport/util.js'
+import type { WebRTCDialOptions } from './options.js'
+import type { Connection } from '@libp2p/interface-connection'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:webrtc:transport')
 
@@ -83,16 +83,12 @@ export class WebRTCDirectTransport implements Transport {
   /**
    * Implement toString() for WebRTCTransport
    */
-  get [Symbol.toStringTag] (): string {
-    return '@libp2p/webrtc-direct'
-  }
+  readonly [Symbol.toStringTag] = '@libp2p/webrtc-direct'
 
   /**
    * Symbol.for('@libp2p/transport')
    */
-  get [symbol] (): true {
-    return true
-  }
+  readonly [symbol] = true
 
   /**
    * Connect to a peer using a multiaddr
@@ -118,6 +114,7 @@ export class WebRTCDirectTransport implements Transport {
       namedCurve: 'P-256',
       hash: sdp.toSupportedHashFunction(remoteCerthash.name)
     } as any)
+
     const peerConnection = new RTCPeerConnection({ certificates: [certificate] })
 
     // create data channel for running the noise handshake. Once the data channel is opened,
@@ -181,12 +178,24 @@ export class WebRTCDirectTransport implements Transport {
       source: {
         [Symbol.asyncIterator]: async function * () {
           for await (const list of wrappedChannel.source) {
-            yield list.subarray()
+            for (const buf of list) {
+              yield buf
+            }
           }
         }
       }
     }
 
+    // Creating the connection before completion of the noise
+    // handshake ensures that the stream opening callback is set up
+    const maConn = new WebRTCMultiaddrConnection({
+      peerConnection,
+      remoteAddr: ma,
+      timeline: {
+        open: Date.now()
+      }
+    })
+
     const eventListeningName = isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange'
 
     peerConnection.addEventListener(eventListeningName, () => {
@@ -206,23 +215,13 @@ export class WebRTCDirectTransport implements Transport {
       }
     }, { signal })
 
-    // Creating the connection before completion of the noise
-    // handshake ensures that the stream opening callback is set up
-    const maConn = new WebRTCMultiaddrConnection({
-      peerConnection,
-      remoteAddr: ma,
-      timeline: {
-        open: Date.now()
-      }
-    })
-
     const muxerFactory = new DataChannelMuxerFactory(peerConnection)
 
     // For outbound connections, the remote is expected to start the noise handshake.
     // Therefore, we need to secure an inbound noise connection from the remote.
     await noise.secureInbound(myPeerId, wrappedDuplex, theirPeerId)
 
-    return await options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
+    return options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
   }
 
   /**
@@ -234,19 +233,12 @@ export class WebRTCDirectTransport implements Transport {
       throw invalidArgument('no local certificate')
     }
 
-    const localCert = pc.getConfiguration().certificates?.at(0)
-
-    if (localCert === undefined || localCert.getFingerprints().length === 0) {
-      throw invalidArgument('no fingerprint on local certificate')
-    }
-
-    const localFingerprint = localCert.getFingerprints()[0]
-
-    if (localFingerprint.value === undefined) {
-      throw invalidArgument('no fingerprint on local certificate')
+    const localFingerprint = sdp.getLocalFingerprint(pc)
+    if (localFingerprint == null) {
+      throw invalidArgument('no local fingerprint found')
     }
 
-    const localFpString = localFingerprint.value.replace(/:/g, '')
+    const localFpString = localFingerprint.trim().toLowerCase().replaceAll(':', '')
     const localFpArray = uint8arrayFromString(localFpString, 'hex')
     const local = multihashes.encode(localFpArray, hashCode)
     const remote: Uint8Array = sdp.mbdecoder.decode(sdp.certhash(ma))

package/src/util.ts

@@ -1,6 +1,4 @@
-export const nopSource = {
-  async * [Symbol.asyncIterator] () {}
-}
+export const nopSource = async function * nop (): AsyncGenerator<Uint8Array, any, unknown> {}
 
 export const nopSink = async (_: any): Promise<void> => {}