@libp2p/webrtc 4.1.9 → 4.1.10-2bbaf4361

package/src/error.ts

@@ -1,122 +1,76 @@
-import { CodeError } from '@libp2p/interface'
-import type { Direction } from '@libp2p/interface'
-
-export enum codes {
-  ERR_ALREADY_ABORTED = 'ERR_ALREADY_ABORTED',
-  ERR_DATA_CHANNEL = 'ERR_DATA_CHANNEL',
-  ERR_CONNECTION_CLOSED = 'ERR_CONNECTION_CLOSED',
-  ERR_HASH_NOT_SUPPORTED = 'ERR_HASH_NOT_SUPPORTED',
-  ERR_INVALID_MULTIADDR = 'ERR_INVALID_MULTIADDR',
-  ERR_INVALID_FINGERPRINT = 'ERR_INVALID_FINGERPRINT',
-  ERR_INVALID_PARAMETERS = 'ERR_INVALID_PARAMETERS',
-  ERR_NOT_IMPLEMENTED = 'ERR_NOT_IMPLEMENTED',
-  ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS',
-  ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS',
+export class WebRTCTransportError extends Error {
+  constructor (msg: string) {
+    super(`WebRTC transport error: ${msg}`)
+    this.name = 'WebRTCTransportError'
+  }
 }
 
-export class WebRTCTransportError extends CodeError {
-  constructor (msg: string, code?: string) {
-    super(`WebRTC transport error: ${msg}`, code ?? '')
-    this.name = 'WebRTCTransportError'
+export class SDPHandshakeFailedError extends WebRTCTransportError {
+  constructor (message = 'SDP handshake failed') {
+    super(message)
+    this.name = 'SDPHandshakeFailedError'
   }
 }
 
 export class ConnectionClosedError extends WebRTCTransportError {
   constructor (state: RTCPeerConnectionState, msg: string) {
-    super(`peerconnection moved to state: ${state}: ${msg}`, codes.ERR_CONNECTION_CLOSED)
+    super(`peerconnection moved to state: ${state}: ${msg}`)
     this.name = 'WebRTC/ConnectionClosed'
   }
 }
 
-export function connectionClosedError (state: RTCPeerConnectionState, msg: string): ConnectionClosedError {
-  return new ConnectionClosedError(state, msg)
-}
-
 export class DataChannelError extends WebRTCTransportError {
   constructor (streamLabel: string, msg: string) {
-    super(`[stream: ${streamLabel}] data channel error: ${msg}`, codes.ERR_DATA_CHANNEL)
+    super(`[stream: ${streamLabel}] data channel error: ${msg}`)
     this.name = 'WebRTC/DataChannelError'
   }
 }
 
-export function dataChannelError (streamLabel: string, msg: string): DataChannelError {
-  return new DataChannelError(streamLabel, msg)
-}
-
 export class InappropriateMultiaddrError extends WebRTCTransportError {
   constructor (msg: string) {
-    super(`There was a problem with the Multiaddr which was passed in: ${msg}`, codes.ERR_INVALID_MULTIADDR)
+    super(`There was a problem with the Multiaddr which was passed in: ${msg}`)
     this.name = 'WebRTC/InappropriateMultiaddrError'
   }
 }
 
-export function inappropriateMultiaddr (msg: string): InappropriateMultiaddrError {
-  return new InappropriateMultiaddrError(msg)
-}
-
 export class InvalidArgumentError extends WebRTCTransportError {
   constructor (msg: string) {
-    super(`There was a problem with a provided argument: ${msg}`, codes.ERR_INVALID_PARAMETERS)
+    super(`There was a problem with a provided argument: ${msg}`)
     this.name = 'WebRTC/InvalidArgumentError'
   }
 }
 
-export function invalidArgument (msg: string): InvalidArgumentError {
-  return new InvalidArgumentError(msg)
-}
-
 export class InvalidFingerprintError extends WebRTCTransportError {
   constructor (fingerprint: string, source: string) {
-    super(`Invalid fingerprint "${fingerprint}" within ${source}`, codes.ERR_INVALID_FINGERPRINT)
+    super(`Invalid fingerprint "${fingerprint}" within ${source}`)
     this.name = 'WebRTC/InvalidFingerprintError'
   }
 }
 
-export function invalidFingerprint (fingerprint: string, source: string): InvalidFingerprintError {
-  return new InvalidFingerprintError(fingerprint, source)
-}
-
 export class OperationAbortedError extends WebRTCTransportError {
   constructor (context: string, abortReason: string) {
-    super(`Signalled to abort because (${abortReason}}) ${context}`, codes.ERR_ALREADY_ABORTED)
+    super(`Signalled to abort because (${abortReason}}) ${context}`)
     this.name = 'WebRTC/OperationAbortedError'
   }
 }
 
-export function operationAborted (context: string, reason: string): OperationAbortedError {
-  return new OperationAbortedError(context, reason)
-}
-
 export class OverStreamLimitError extends WebRTCTransportError {
   constructor (msg: string) {
-    const code = msg.startsWith('inbound') ? codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS : codes.ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS
-    super(msg, code)
+    super(msg)
     this.name = 'WebRTC/OverStreamLimitError'
   }
 }
 
-export function overStreamLimit (dir: Direction, proto: string): OverStreamLimitError {
-  return new OverStreamLimitError(`${dir} stream limit reached for protocol - ${proto}`)
-}
-
 export class UnimplementedError extends WebRTCTransportError {
   constructor (methodName: string) {
-    super(`A method (${methodName}) was called though it has been intentionally left unimplemented.`, codes.ERR_NOT_IMPLEMENTED)
+    super(`A method (${methodName}) was called though it has been intentionally left unimplemented.`)
     this.name = 'WebRTC/UnimplementedError'
   }
 }
 
-export function unimplemented (methodName: string): UnimplementedError {
-  return new UnimplementedError(methodName)
-}
-
 export class UnsupportedHashAlgorithmError extends WebRTCTransportError {
   constructor (algo: number) {
-    super(`unsupported hash algorithm code: ${algo} please see the codes at https://github.com/multiformats/multicodec/blob/master/table.csv `, codes.ERR_HASH_NOT_SUPPORTED)
+    super(`unsupported hash algorithm code: ${algo} please see the codes at https://github.com/multiformats/multicodec/blob/master/table.csv `)
     this.name = 'WebRTC/UnsupportedHashAlgorithmError'
   }
 }
-
-export function unsupportedHashAlgorithmCode (code: number): UnsupportedHashAlgorithmError {
-  return new UnsupportedHashAlgorithmError(code)
-}

package/src/index.ts

@@ -61,7 +61,7 @@
  *   transports: [
  *     webSockets({filter: filters.all})
  *   ],
- *   connectionEncryption: [noise()],
+ *   connectionEncrypters: [noise()],
  *   streamMuxers: [yamux()],
  *   services: {
  *     identify: identify(),
@@ -83,7 +83,7 @@
  *       discoverRelays: 1
  *     })
  *   ],
- *   connectionEncryption: [noise()],
+ *   connectionEncrypters: [noise()],
  *   streamMuxers: [yamux()],
  *   services: {
  *     identify: identify(),
@@ -120,7 +120,7 @@
  *     webRTC(),
  *     circuitRelayTransport()
  *   ],
- *   connectionEncryption: [noise()],
+ *   connectionEncrypters: [noise()],
  *   streamMuxers: [yamux()],
  *   services: {
  *     identify: identify(),
@@ -166,7 +166,7 @@
  *   transports: [
  *     webRTCDirect()
  *   ],
- *   connectionEncryption: [
+ *   connectionEncrypters: [
  *     noise()
  *   ]
  * })

package/src/pb/message.ts

@@ -4,8 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, enumeration, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Message {
@@ -56,7 +55,7 @@ export namespace Message {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -65,15 +64,18 @@ export namespace Message {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.flag = Message.Flag.codec().decode(reader)
               break
-            case 2:
+            }
+            case 2: {
               obj.message = reader.bytes()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -88,7 +90,7 @@ export namespace Message {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
-    return decodeMessage(buf, Message.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message => {
+    return decodeMessage(buf, Message.codec(), opts)
   }
 }

package/src/private-to-private/initiate-connection.ts

@@ -1,7 +1,8 @@
-import { CodeError } from '@libp2p/interface'
+import { InvalidParametersError } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { pbStream } from 'it-protobuf-stream'
 import { CustomProgressEvent } from 'progress-events'
+import { SDPHandshakeFailedError } from '../error.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
@@ -41,7 +42,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
   const relayPeer = baseAddr.getPeerId()
 
   if (relayPeer == null) {
-    throw new CodeError('Relay peer was missing', 'ERR_INVALID_ADDRESS')
+    throw new InvalidParametersError('Relay peer was missing')
   }
 
   const connections = connectionManager.getConnections(peerIdFromString(relayPeer))
@@ -72,7 +73,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
     const stream = await connection.newStream(SIGNALING_PROTO_ID, {
       signal,
-      runOnTransientConnection: true
+      runOnLimitedConnection: true
     })
 
     const messageStream = pbStream(stream).pb(Message)
@@ -117,7 +118,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       // create an offer
       const offerSdp = await peerConnection.createOffer().catch(err => {
         log.error('could not execute createOffer', err)
-        throw new CodeError('Failed to set createOffer', 'ERR_SDP_HANDSHAKE_FAILED')
+        throw new SDPHandshakeFailedError('Failed to set createOffer')
       })
 
       log.trace('initiator send SDP offer %s', offerSdp.sdp)
@@ -132,26 +133,28 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       // set offer as local description
       await peerConnection.setLocalDescription(offerSdp).catch(err => {
         log.error('could not execute setLocalDescription', err)
-        throw new CodeError('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+        throw new SDPHandshakeFailedError('Failed to set localDescription')
       })
 
       onProgress?.(new CustomProgressEvent('webrtc:read-sdp-answer'))
 
+      log.trace('initiator read SDP answer')
+
       // read answer
       const answerMessage = await messageStream.read({
         signal
       })
 
       if (answerMessage.type !== Message.Type.SDP_ANSWER) {
-        throw new CodeError('Remote should send an SDP answer', 'ERR_SDP_HANDSHAKE_FAILED')
+        throw new SDPHandshakeFailedError('Remote should send an SDP answer')
       }
 
-      log.trace('initiator receive SDP answer %s', answerMessage.data)
+      log.trace('initiator received SDP answer %s', answerMessage.data)
 
       const answerSdp = new RTCSessionDescription({ type: 'answer', sdp: answerMessage.data })
       await peerConnection.setRemoteDescription(answerSdp).catch(err => {
         log.error('could not execute setRemoteDescription', err)
-        throw new CodeError('Failed to set remoteDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+        throw new SDPHandshakeFailedError('Failed to set remoteDescription')
       })
 
       log.trace('initiator read candidates until connected')

package/src/private-to-private/pb/message.ts

@@ -4,8 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 
-import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
-import type { Codec } from 'protons-runtime'
+import { type Codec, decodeMessage, type DecodeOptions, encodeMessage, enumeration, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Message {
@@ -54,7 +53,7 @@ export namespace Message {
         if (opts.lengthDelimited !== false) {
           w.ldelim()
         }
-      }, (reader, length) => {
+      }, (reader, length, opts = {}) => {
         const obj: any = {}
 
         const end = length == null ? reader.len : reader.pos + length
@@ -63,15 +62,18 @@ export namespace Message {
           const tag = reader.uint32()
 
           switch (tag >>> 3) {
-            case 1:
+            case 1: {
               obj.type = Message.Type.codec().decode(reader)
               break
-            case 2:
+            }
+            case 2: {
               obj.data = reader.string()
               break
-            default:
+            }
+            default: {
               reader.skipType(tag & 7)
               break
+            }
           }
         }
 
@@ -86,7 +88,7 @@ export namespace Message {
     return encodeMessage(obj, Message.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
-    return decodeMessage(buf, Message.codec())
+  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<Message>): Message => {
+    return decodeMessage(buf, Message.codec(), opts)
   }
 }

package/src/private-to-private/signaling-stream-handler.ts

@@ -1,6 +1,6 @@
-import { CodeError } from '@libp2p/interface'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
+import { SDPHandshakeFailedError } from '../error.js'
 import { type RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import { readCandidatesUntilConnected } from './util.js'
@@ -40,16 +40,18 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
         })
     }
 
+    log.trace('recipient read SDP offer')
+
     // read an SDP offer
     const pbOffer = await messageStream.read({
       signal
     })
 
     if (pbOffer.type !== Message.Type.SDP_OFFER) {
-      throw new CodeError(`expected message type SDP_OFFER, received: ${pbOffer.type ?? 'undefined'} `, 'ERR_SDP_HANDSHAKE_FAILED')
+      throw new SDPHandshakeFailedError(`expected message type SDP_OFFER, received: ${pbOffer.type ?? 'undefined'} `)
     }
 
-    log.trace('recipient receive SDP offer %s', pbOffer.data)
+    log.trace('recipient received SDP offer %s', pbOffer.data)
 
     const offer = new RTCSessionDescription({
       type: 'offer',
@@ -58,13 +60,13 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
 
     await peerConnection.setRemoteDescription(offer).catch(err => {
       log.error('could not execute setRemoteDescription', err)
-      throw new CodeError('Failed to set remoteDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+      throw new SDPHandshakeFailedError('Failed to set remoteDescription')
     })
 
     // create and write an SDP answer
     const answer = await peerConnection.createAnswer().catch(err => {
       log.error('could not execute createAnswer', err)
-      throw new CodeError('Failed to create answer', 'ERR_SDP_HANDSHAKE_FAILED')
+      throw new SDPHandshakeFailedError('Failed to create answer')
     })
 
     log.trace('recipient send SDP answer %s', answer.sdp)
@@ -76,7 +78,7 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
 
     await peerConnection.setLocalDescription(answer).catch(err => {
       log.error('could not execute setLocalDescription', err)
-      throw new CodeError('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED')
+      throw new SDPHandshakeFailedError('Failed to set localDescription')
     })
 
     log.trace('recipient read candidates until connected')

package/src/private-to-private/transport.ts

@@ -1,8 +1,7 @@
-import { CodeError, serviceCapabilities, serviceDependencies, setMaxListeners, transportSymbol } from '@libp2p/interface'
+import { InvalidParametersError, serviceCapabilities, serviceDependencies, setMaxListeners, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
-import { codes } from '../error.js'
 import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { getRtcConfiguration } from '../util.js'
@@ -108,7 +107,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     await this.components.registrar.handle(SIGNALING_PROTO_ID, (data: IncomingStreamData) => {
       this._onProtocol(data).catch(err => { this.log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err) })
     }, {
-      runOnTransientConnection: true
+      runOnLimitedConnection: true
     })
     this._started = true
   }
@@ -247,11 +246,11 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
 export function splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId } {
   const addrs = ma.toString().split(WEBRTC_TRANSPORT + '/')
   if (addrs.length !== 2) {
-    throw new CodeError('webrtc protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR)
+    throw new InvalidParametersError('webrtc protocol was not present in multiaddr')
   }
 
   if (!addrs[0].includes(CIRCUIT_RELAY_TRANSPORT)) {
-    throw new CodeError('p2p-circuit protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR)
+    throw new InvalidParametersError('p2p-circuit protocol was not present in multiaddr')
   }
 
   // look for remote peerId
@@ -260,12 +259,12 @@ export function splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId
 
   const destinationIdString = destination.getPeerId()
   if (destinationIdString == null) {
-    throw new CodeError('destination peer id was missing', codes.ERR_INVALID_MULTIADDR)
+    throw new InvalidParametersError('destination peer id was missing')
   }
 
   const lastProtoInRemote = remoteAddr.protos().pop()
   if (lastProtoInRemote === undefined) {
-    throw new CodeError('invalid multiaddr', codes.ERR_INVALID_MULTIADDR)
+    throw new InvalidParametersError('invalid multiaddr')
   }
   if (lastProtoInRemote.name !== 'p2p') {
     remoteAddr = remoteAddr.encapsulate(`/p2p/${destinationIdString}`)

package/src/private-to-private/util.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface'
+import { ConnectionFailedError, InvalidMessageError } from '@libp2p/interface'
 import pDefer from 'p-defer'
 import { CustomProgressEvent } from 'progress-events'
 import { isFirefox } from '../util.js'
@@ -38,7 +38,7 @@ export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream
       }
 
       if (message.type !== Message.Type.ICE_CANDIDATE) {
-        throw new CodeError('ICE candidate message expected', 'ERR_NOT_ICE_CANDIDATE')
+        throw new InvalidMessageError('ICE candidate message expected')
       }
 
       const candidateInit = JSON.parse(message.data ?? 'null')
@@ -86,7 +86,7 @@ function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<voi
       case 'failed':
       case 'disconnected':
       case 'closed':
-        promise.reject(new CodeError('RTCPeerConnection was closed', 'ERR_CONNECTION_CLOSED_BEFORE_CONNECTED'))
+        promise.reject(new ConnectionFailedError('RTCPeerConnection was closed'))
         break
       default:
         break

package/src/private-to-public/sdp.ts

@@ -1,6 +1,7 @@
+import { InvalidParametersError } from '@libp2p/interface'
 import { type Multiaddr } from '@multiformats/multiaddr'
 import { bases, digest } from 'multiformats/basics'
-import { inappropriateMultiaddr, invalidArgument, invalidFingerprint, unsupportedHashAlgorithmCode } from '../error.js'
+import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../error.js'
 import { MAX_MESSAGE_SIZE } from '../stream.js'
 import { CERTHASH_CODE } from './transport.js'
 import type { LoggerOptions } from '@libp2p/interface'
@@ -32,7 +33,7 @@ export function getLocalFingerprint (pc: RTCPeerConnection, options: LoggerOptio
 
   const fingerprint = localCert.getFingerprints()[0].value
   if (fingerprint == null) {
-    throw invalidFingerprint('', 'no fingerprint on local certificate')
+    throw new InvalidFingerprintError('', 'no fingerprint on local certificate')
   }
 
   return fingerprint
@@ -63,7 +64,7 @@ export function certhash (ma: Multiaddr): string {
   const certhash = tups.filter((tup) => tup[0] === CERTHASH_CODE).map((tup) => tup[1])[0]
 
   if (certhash === undefined || certhash === '') {
-    throw inappropriateMultiaddr(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`)
+    throw new InvalidParametersError(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`)
   }
 
   return certhash
@@ -86,7 +87,7 @@ export function ma2Fingerprint (ma: Multiaddr): string[] {
   const sdp = fingerprint.match(/.{1,2}/g)
 
   if (sdp == null) {
-    throw invalidFingerprint(fingerprint, ma.toString())
+    throw new InvalidFingerprintError(fingerprint, ma.toString())
   }
 
   return [`${prefix} ${sdp.join(':').toUpperCase()}`, fingerprint]
@@ -104,7 +105,7 @@ export function toSupportedHashFunction (code: number): 'SHA-1' | 'SHA-256' | 'S
     case 0x13:
       return 'SHA-512'
     default:
-      throw unsupportedHashAlgorithmCode(code)
+      throw new UnsupportedHashAlgorithmError(code)
   }
 }
 
@@ -148,7 +149,7 @@ export function fromMultiAddr (ma: Multiaddr, ufrag: string): RTCSessionDescript
  */
 export function munge (desc: RTCSessionDescriptionInit, ufrag: string): RTCSessionDescriptionInit {
   if (desc.sdp === undefined) {
-    throw invalidArgument("Can't munge a missing SDP")
+    throw new InvalidParametersError("Can't munge a missing SDP")
   }
 
   desc.sdp = desc.sdp

package/src/private-to-public/transport.ts

@@ -1,12 +1,12 @@
 import { noise } from '@chainsafe/libp2p-noise'
-import { transportSymbol, serviceCapabilities } from '@libp2p/interface'
+import { transportSymbol, serviceCapabilities, InvalidParametersError } from '@libp2p/interface'
 import * as p from '@libp2p/peer-id'
 import { protocols } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import * as Digest from 'multiformats/hashes/digest'
 import { concat } from 'uint8arrays/concat'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
-import { dataChannelError, inappropriateMultiaddr, unimplemented, invalidArgument } from '../error.js'
+import { DataChannelError, InappropriateMultiaddrError, UnimplementedError } from '../error.js'
 import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { createStream } from '../stream.js'
@@ -16,7 +16,7 @@ import * as sdp from './sdp.js'
 import { genUfrag } from './util.js'
 import type { WebRTCDialOptions } from './options.js'
 import type { DataChannelOptions } from '../index.js'
-import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId } from '@libp2p/interface'
+import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId, PrivateKey } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**
@@ -43,6 +43,7 @@ export const CERTHASH_CODE: number = protocols('certhash').code
  */
 export interface WebRTCDirectTransportComponents {
   peerId: PeerId
+  privateKey: PrivateKey
   metrics?: Metrics
   logger: ComponentLogger
 }
@@ -96,7 +97,7 @@ export class WebRTCDirectTransport implements Transport {
    * Create transport listeners no supported by browsers
    */
   createListener (options: CreateListenerOptions): Listener {
-    throw unimplemented('WebRTCTransport.createListener')
+    throw new UnimplementedError('WebRTCTransport.createListener')
   }
 
   /**
@@ -122,7 +123,7 @@ export class WebRTCDirectTransport implements Transport {
 
     const remotePeerString = ma.getPeerId()
     if (remotePeerString === null) {
-      throw inappropriateMultiaddr("we need to have the remote's PeerId")
+      throw new InappropriateMultiaddrError("we need to have the remote's PeerId")
     }
     const theirPeerId = p.peerIdFromString(remotePeerString)
 
@@ -153,7 +154,7 @@ export class WebRTCDirectTransport implements Transport {
           const error = `Data channel was never opened: state: ${handshakeDataChannel.readyState}`
           this.log.error(error)
           this.metrics?.dialerEvents.increment({ open_error: true })
-          reject(dataChannelError('data', error))
+          reject(new DataChannelError('data', error))
         }, HANDSHAKE_TIMEOUT_MS)
 
         handshakeDataChannel.onopen = (_) => {
@@ -169,7 +170,7 @@ export class WebRTCDirectTransport implements Transport {
           this.log.error(error)
           // NOTE: We use unknown error here but this could potentially be considered a reset by some standards.
           this.metrics?.dialerEvents.increment({ unknown_error: true })
-          reject(dataChannelError('data', error))
+          reject(new DataChannelError('data', error))
         }
       })
 
@@ -190,8 +191,6 @@ export class WebRTCDirectTransport implements Transport {
       // wait for peerconnection.onopen to fire, or for the datachannel to open
       const handshakeDataChannel = await dataChannelOpenPromise
 
-      const myPeerId = this.components.peerId
-
       // Do noise handshake.
       // Set the Noise Prologue to libp2p-webrtc-noise:<FINGERPRINTS> before starting the actual Noise handshake.
       // <FINGERPRINTS> is the concatenation of the of the two TLS fingerprints of A and B in their multihash byte representation, sorted in ascending order.
@@ -260,7 +259,10 @@ export class WebRTCDirectTransport implements Transport {
 
       // 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 connectionEncrypter.secureInbound(myPeerId, wrappedDuplex, theirPeerId)
+      await connectionEncrypter.secureInbound(wrappedDuplex, {
+        signal,
+        remotePeer: theirPeerId
+      })
 
       return await options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
     } catch (err) {
@@ -275,14 +277,14 @@ export class WebRTCDirectTransport implements Transport {
    */
   private generateNoisePrologue (pc: RTCPeerConnection, hashCode: number, ma: Multiaddr): Uint8Array {
     if (pc.getConfiguration().certificates?.length === 0) {
-      throw invalidArgument('no local certificate')
+      throw new InvalidParametersError('no local certificate')
     }
 
     const localFingerprint = sdp.getLocalFingerprint(pc, {
       log: this.log
     })
     if (localFingerprint == null) {
-      throw invalidArgument('no local fingerprint found')
+      throw new InvalidParametersError('no local fingerprint found')
     }
 
     const localFpString = localFingerprint.trim().toLowerCase().replaceAll(':', '')