diff --git a/package.json b/package.json
index 337f0db..38f808d 100644
--- a/package.json
+++ b/package.json
@@ -69,10 +69,9 @@
   "dependencies": {
     "@chainsafe/as-chacha20poly1305": "^0.1.0",
     "@chainsafe/as-sha256": "^0.4.1",
-    "@libp2p/crypto": "next",
-    "@libp2p/interface": "next",
-    "@libp2p/logger": "next",
-    "@libp2p/peer-id": "next",
+    "@libp2p/crypto": "^3.0.0",
+    "@libp2p/interface": "^1.0.0",
+    "@libp2p/peer-id": "^4.0.0",
     "@noble/ciphers": "^0.4.0",
     "@noble/curves": "^1.1.0",
     "@noble/hashes": "^1.3.1",
@@ -88,13 +87,14 @@
     "wherearewe": "^2.0.1"
   },
   "devDependencies": {
-    "@chainsafe/libp2p-yamux": "^5.0.0",
+    "@chainsafe/libp2p-yamux": "^6.0.0",
     "@libp2p/daemon-client": "^7.0.0",
     "@libp2p/daemon-server": "^6.0.0",
-    "@libp2p/interface-compliance-tests": "next",
+    "@libp2p/interface-compliance-tests": "^5.0.0",
     "@libp2p/interop": "^9.0.0",
-    "@libp2p/peer-id-factory": "next",
-    "@libp2p/tcp": "8.0.13-4a474d54d",
+    "@libp2p/logger": "^4.0.0",
+    "@libp2p/peer-id-factory": "^3.0.9",
+    "@libp2p/tcp": "^9.0.0",
     "@multiformats/multiaddr": "^12.1.0",
     "@types/sinon": "^17.0.1",
     "aegir": "^40.0.8",
diff --git a/src/@types/handshake-interface.ts b/src/@types/handshake-interface.ts
index a67b44d..e966ed2 100644
--- a/src/@types/handshake-interface.ts
+++ b/src/@types/handshake-interface.ts
@@ -1,6 +1,6 @@
 import type { NoiseSession } from './handshake.js'
 import type { NoiseExtensions } from '../proto/payload.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerId } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface IHandshake {
diff --git a/src/@types/libp2p.ts b/src/@types/libp2p.ts
index c20fe93..055b753 100644
--- a/src/@types/libp2p.ts
+++ b/src/@types/libp2p.ts
@@ -1,6 +1,6 @@
 import type { bytes32 } from './basic.js'
 import type { NoiseExtensions } from '../proto/payload.js'
-import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
+import type { ConnectionEncrypter } from '@libp2p/interface'
 
 export interface KeyPair {
   publicKey: bytes32
diff --git a/src/errors.ts b/src/errors.ts
new file mode 100644
index 0000000..2e1aa43
--- /dev/null
+++ b/src/errors.ts
@@ -0,0 +1,21 @@
+export class UnexpectedPeerError extends Error {
+  public code: string
+
+  constructor (message = 'Unexpected Peer') {
+    super(message)
+    this.code = UnexpectedPeerError.code
+  }
+
+  static readonly code = 'ERR_UNEXPECTED_PEER'
+}
+
+export class InvalidCryptoExchangeError extends Error {
+  public code: string
+
+  constructor (message = 'Invalid crypto exchange') {
+    super(message)
+    this.code = InvalidCryptoExchangeError.code
+  }
+
+  static readonly code = 'ERR_INVALID_CRYPTO_EXCHANGE'
+}
diff --git a/src/handshake-xx.ts b/src/handshake-xx.ts
index d438a41..8307025 100644
--- a/src/handshake-xx.ts
+++ b/src/handshake-xx.ts
@@ -1,9 +1,8 @@
-import { InvalidCryptoExchangeError, UnexpectedPeerError } from '@libp2p/interface/errors'
+import { InvalidCryptoExchangeError, UnexpectedPeerError } from './errors.js'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import { decode0, decode1, decode2, encode0, encode1, encode2 } from './encoder.js'
 import { XX } from './handshakes/xx.js'
 import {
-  logger,
   logLocalStaticKeys,
   logLocalEphemeralKeys,
   logRemoteEphemeralKey,
@@ -20,8 +19,9 @@ import type { IHandshake } from './@types/handshake-interface.js'
 import type { CipherState, NoiseSession } from './@types/handshake.js'
 import type { KeyPair } from './@types/libp2p.js'
 import type { ICryptoInterface } from './crypto.js'
+import type { NoiseComponents } from './index.js'
 import type { NoiseExtensions } from './proto/payload.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Logger, PeerId } from '@libp2p/interface'
 import type { LengthPrefixedStream } from 'it-length-prefixed-stream'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -37,8 +37,10 @@ export class XXHandshake implements IHandshake {
   protected staticKeypair: KeyPair
 
   private readonly prologue: bytes32
+  private readonly log: Logger
 
   constructor (
+    components: NoiseComponents,
     isInitiator: boolean,
     payload: bytes,
     prologue: bytes32,
@@ -48,6 +50,7 @@ export class XXHandshake implements IHandshake {
     remotePeer?: PeerId,
     handshake?: XX
   ) {
+    this.log = components.logger.forComponent('libp2p:noise:xxhandshake')
     this.isInitiator = isInitiator
     this.payload = payload
     this.prologue = prologue
@@ -56,45 +59,45 @@ export class XXHandshake implements IHandshake {
     if (remotePeer) {
       this.remotePeer = remotePeer
     }
-    this.xx = handshake ?? new XX(crypto)
+    this.xx = handshake ?? new XX(components, crypto)
     this.session = this.xx.initSession(this.isInitiator, this.prologue, this.staticKeypair)
   }
 
   // stage 0
   public async propose (): Promise<void> {
-    logLocalStaticKeys(this.session.hs.s)
+    logLocalStaticKeys(this.session.hs.s, this.log)
     if (this.isInitiator) {
-      logger.trace('Stage 0 - Initiator starting to send first message.')
+      this.log.trace('Stage 0 - Initiator starting to send first message.')
       const messageBuffer = this.xx.sendMessage(this.session, uint8ArrayAlloc(0))
       await this.connection.write(encode0(messageBuffer))
-      logger.trace('Stage 0 - Initiator finished sending first message.')
-      logLocalEphemeralKeys(this.session.hs.e)
+      this.log.trace('Stage 0 - Initiator finished sending first message.')
+      logLocalEphemeralKeys(this.session.hs.e, this.log)
     } else {
-      logger.trace('Stage 0 - Responder waiting to receive first message...')
+      this.log.trace('Stage 0 - Responder waiting to receive first message...')
       const receivedMessageBuffer = decode0((await this.connection.read()).subarray())
       const { valid } = this.xx.recvMessage(this.session, receivedMessageBuffer)
       if (!valid) {
         throw new InvalidCryptoExchangeError('xx handshake stage 0 validation fail')
       }
-      logger.trace('Stage 0 - Responder received first message.')
-      logRemoteEphemeralKey(this.session.hs.re)
+      this.log.trace('Stage 0 - Responder received first message.')
+      logRemoteEphemeralKey(this.session.hs.re, this.log)
     }
   }
 
   // stage 1
   public async exchange (): Promise<void> {
     if (this.isInitiator) {
-      logger.trace('Stage 1 - Initiator waiting to receive first message from responder...')
+      this.log.trace('Stage 1 - Initiator waiting to receive first message from responder...')
       const receivedMessageBuffer = decode1((await this.connection.read()).subarray())
       const { plaintext, valid } = this.xx.recvMessage(this.session, receivedMessageBuffer)
       if (!valid) {
         throw new InvalidCryptoExchangeError('xx handshake stage 1 validation fail')
       }
-      logger.trace('Stage 1 - Initiator received the message.')
-      logRemoteEphemeralKey(this.session.hs.re)
-      logRemoteStaticKey(this.session.hs.rs)
+      this.log.trace('Stage 1 - Initiator received the message.')
+      logRemoteEphemeralKey(this.session.hs.re, this.log)
+      logRemoteStaticKey(this.session.hs.rs, this.log)
 
-      logger.trace("Initiator going to check remote's signature...")
+      this.log.trace("Initiator going to check remote's signature...")
       try {
         const decodedPayload = decodePayload(plaintext)
         this.remotePeer = this.remotePeer || await getPeerIdFromPayload(decodedPayload)
@@ -104,31 +107,31 @@ export class XXHandshake implements IHandshake {
         const err = e as Error
         throw new UnexpectedPeerError(`Error occurred while verifying signed payload: ${err.message}`)
       }
-      logger.trace('All good with the signature!')
+      this.log.trace('All good with the signature!')
     } else {
-      logger.trace('Stage 1 - Responder sending out first message with signed payload and static key.')
+      this.log.trace('Stage 1 - Responder sending out first message with signed payload and static key.')
       const messageBuffer = this.xx.sendMessage(this.session, this.payload)
       await this.connection.write(encode1(messageBuffer))
-      logger.trace('Stage 1 - Responder sent the second handshake message with signed payload.')
-      logLocalEphemeralKeys(this.session.hs.e)
+      this.log.trace('Stage 1 - Responder sent the second handshake message with signed payload.')
+      logLocalEphemeralKeys(this.session.hs.e, this.log)
     }
   }
 
   // stage 2
   public async finish (): Promise<void> {
     if (this.isInitiator) {
-      logger.trace('Stage 2 - Initiator sending third handshake message.')
+      this.log.trace('Stage 2 - Initiator sending third handshake message.')
       const messageBuffer = this.xx.sendMessage(this.session, this.payload)
       await this.connection.write(encode2(messageBuffer))
-      logger.trace('Stage 2 - Initiator sent message with signed payload.')
+      this.log.trace('Stage 2 - Initiator sent message with signed payload.')
     } else {
-      logger.trace('Stage 2 - Responder waiting for third handshake message...')
+      this.log.trace('Stage 2 - Responder waiting for third handshake message...')
       const receivedMessageBuffer = decode2((await this.connection.read()).subarray())
       const { plaintext, valid } = this.xx.recvMessage(this.session, receivedMessageBuffer)
       if (!valid) {
         throw new InvalidCryptoExchangeError('xx handshake stage 2 validation fail')
       }
-      logger.trace('Stage 2 - Responder received the message, finished handshake.')
+      this.log.trace('Stage 2 - Responder received the message, finished handshake.')
 
       try {
         const decodedPayload = decodePayload(plaintext)
@@ -140,7 +143,7 @@ export class XXHandshake implements IHandshake {
         throw new UnexpectedPeerError(`Error occurred while verifying signed payload: ${err.message}`)
       }
     }
-    logCipherState(this.session)
+    logCipherState(this.session, this.log)
   }
 
   public encrypt (plaintext: Uint8Array | Uint8ArrayList, session: NoiseSession): Uint8Array | Uint8ArrayList {
diff --git a/src/handshakes/abstract-handshake.ts b/src/handshakes/abstract-handshake.ts
index cbe3a55..9e34a61 100644
--- a/src/handshakes/abstract-handshake.ts
+++ b/src/handshakes/abstract-handshake.ts
@@ -2,11 +2,12 @@ import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { logger } from '../logger.js'
 import { Nonce } from '../nonce.js'
 import type { bytes, bytes32 } from '../@types/basic.js'
 import type { CipherState, MessageBuffer, SymmetricState } from '../@types/handshake.js'
 import type { ICryptoInterface } from '../crypto.js'
+import type { NoiseComponents } from '../index.js'
+import type { Logger } from '@libp2p/interface'
 
 export interface DecryptedResult {
   plaintext: Uint8ArrayList | Uint8Array
@@ -20,8 +21,10 @@ export interface SplitState {
 
 export abstract class AbstractHandshake {
   public crypto: ICryptoInterface
+  private readonly log: Logger
 
-  constructor (crypto: ICryptoInterface) {
+  constructor (components: NoiseComponents, crypto: ICryptoInterface) {
+    this.log = components.logger.forComponent('libp2p:noise:abstract-handshake')
     this.crypto = crypto
   }
 
@@ -113,7 +116,7 @@ export abstract class AbstractHandshake {
       return derivedU8.subarray(0, 32)
     } catch (e) {
       const err = e as Error
-      logger.error(err)
+      this.log.error('error deriving shared key', err)
       return uint8ArrayAlloc(32)
     }
   }
diff --git a/src/index.ts b/src/index.ts
index 3a42c89..9533b32 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,10 +1,16 @@
 import { Noise } from './noise.js'
 import type { NoiseInit } from './noise.js'
 import type { NoiseExtensions } from './proto/payload.js'
-import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
+import type { ComponentLogger } from '@libp2p/interface'
+import type { ConnectionEncrypter, Metrics } from '@libp2p/interface'
 export type { ICryptoInterface } from './crypto.js'
 export { pureJsCrypto } from './crypto/js.js'
 
-export function noise (init: NoiseInit = {}): () => ConnectionEncrypter<NoiseExtensions> {
-  return () => new Noise(init)
+export interface NoiseComponents {
+  logger: ComponentLogger
+  metrics?: Metrics
+}
+
+export function noise (init: NoiseInit = {}): (components: NoiseComponents) => ConnectionEncrypter<NoiseExtensions> {
+  return (components: NoiseComponents) => new Noise(components, init)
 }
diff --git a/src/logger.ts b/src/logger.ts
index 1a70d14..c57b456 100644
--- a/src/logger.ts
+++ b/src/logger.ts
@@ -1,27 +1,12 @@
-import { type Logger, logger } from '@libp2p/logger'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { DUMP_SESSION_KEYS } from './constants.js'
 import type { NoiseSession } from './@types/handshake.js'
 import type { KeyPair } from './@types/libp2p.js'
+import type { Logger } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-const log = logger('libp2p:noise')
-
-export { log as logger }
-
-let keyLogger: Logger
-if (DUMP_SESSION_KEYS) {
-  keyLogger = log
-} else {
-  keyLogger = Object.assign(() => { /* do nothing */ }, {
-    enabled: false,
-    trace: () => {},
-    error: () => {}
-  })
-}
-
-export function logLocalStaticKeys (s: KeyPair): void {
-  if (!keyLogger.enabled) {
+export function logLocalStaticKeys (s: KeyPair, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
     return
   }
 
@@ -29,8 +14,8 @@ export function logLocalStaticKeys (s: KeyPair): void {
   keyLogger(`LOCAL_STATIC_PRIVATE_KEY ${uint8ArrayToString(s.privateKey, 'hex')}`)
 }
 
-export function logLocalEphemeralKeys (e: KeyPair | undefined): void {
-  if (!keyLogger.enabled) {
+export function logLocalEphemeralKeys (e: KeyPair | undefined, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
     return
   }
 
@@ -42,24 +27,24 @@ export function logLocalEphemeralKeys (e: KeyPair | undefined): void {
   }
 }
 
-export function logRemoteStaticKey (rs: Uint8Array | Uint8ArrayList): void {
-  if (!keyLogger.enabled) {
+export function logRemoteStaticKey (rs: Uint8Array | Uint8ArrayList, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
     return
   }
 
   keyLogger(`REMOTE_STATIC_PUBLIC_KEY ${uint8ArrayToString(rs.subarray(), 'hex')}`)
 }
 
-export function logRemoteEphemeralKey (re: Uint8Array | Uint8ArrayList): void {
-  if (!keyLogger.enabled) {
+export function logRemoteEphemeralKey (re: Uint8Array | Uint8ArrayList, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
     return
   }
 
   keyLogger(`REMOTE_EPHEMERAL_PUBLIC_KEY ${uint8ArrayToString(re.subarray(), 'hex')}`)
 }
 
-export function logCipherState (session: NoiseSession): void {
-  if (!keyLogger.enabled) {
+export function logCipherState (session: NoiseSession, keyLogger: Logger): void {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
     return
   }
 
diff --git a/src/metrics.ts b/src/metrics.ts
index 8d0b3a4..3733d41 100644
--- a/src/metrics.ts
+++ b/src/metrics.ts
@@ -1,4 +1,4 @@
-import type { Counter, Metrics } from '@libp2p/interface/metrics'
+import type { Counter, Metrics } from '@libp2p/interface'
 
 export type MetricsRegistry = Record<string, Counter>
 
diff --git a/src/noise.ts b/src/noise.ts
index 7996ef2..1313691 100644
--- a/src/noise.ts
+++ b/src/noise.ts
@@ -14,11 +14,9 @@ import type { bytes } from './@types/basic.js'
 import type { IHandshake } from './@types/handshake-interface.js'
 import type { INoiseConnection, KeyPair } from './@types/libp2p.js'
 import type { ICryptoInterface } from './crypto.js'
+import type { NoiseComponents } from './index.js'
 import type { NoiseExtensions } from './proto/payload.js'
-import type { MultiaddrConnection } from '@libp2p/interface/connection'
-import type { SecuredConnection } from '@libp2p/interface/connection-encrypter'
-import type { Metrics } from '@libp2p/interface/metrics'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { MultiaddrConnection, SecuredConnection, PeerId } from '@libp2p/interface'
 import type { Duplex } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -37,7 +35,6 @@ export interface NoiseInit {
   extensions?: NoiseExtensions
   crypto?: ICryptoInterface
   prologueBytes?: Uint8Array
-  metrics?: Metrics
 }
 
 export class Noise implements INoiseConnection {
@@ -48,10 +45,13 @@ export class Noise implements INoiseConnection {
   private readonly staticKeys: KeyPair
   private readonly extensions?: NoiseExtensions
   private readonly metrics?: MetricsRegistry
+  private readonly components: NoiseComponents
 
-  constructor (init: NoiseInit = {}) {
-    const { staticNoiseKey, extensions, crypto, prologueBytes, metrics } = init
+  constructor (components: NoiseComponents, init: NoiseInit = {}) {
+    const { staticNoiseKey, extensions, crypto, prologueBytes } = init
+    const { metrics } = components
 
+    this.components = components
     this.crypto = crypto ?? defaultCrypto
     this.extensions = extensions
     this.metrics = metrics ? registerMetrics(metrics) : undefined
@@ -154,6 +154,7 @@ export class Noise implements INoiseConnection {
   ): Promise<XXHandshake> {
     const { isInitiator, remotePeer, connection } = params
     const handshake = new XXHandshake(
+      this.components,
       isInitiator,
       payload,
       this.prologue,
diff --git a/src/utils.ts b/src/utils.ts
index 4c65577..d6fc849 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -5,7 +5,7 @@ import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { type NoiseExtensions, NoiseHandshakePayload } from './proto/payload.js'
 import type { bytes } from './@types/basic.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerId } from '@libp2p/interface'
 
 export async function getPayload (
   localPeer: PeerId,
diff --git a/test/compliance.spec.ts b/test/compliance.spec.ts
index e97dc0a..bbda027 100644
--- a/test/compliance.spec.ts
+++ b/test/compliance.spec.ts
@@ -1,10 +1,11 @@
 import tests from '@libp2p/interface-compliance-tests/connection-encryption'
+import { defaultLogger } from '@libp2p/logger'
 import { Noise } from '../src/noise.js'
 
 describe('spec compliance tests', function () {
   tests({
     async setup () {
-      return new Noise()
+      return new Noise({ logger: defaultLogger() })
     },
     async teardown () {}
   })
diff --git a/test/handshakes/xx.spec.ts b/test/handshakes/xx.spec.ts
index 387af08..40e1deb 100644
--- a/test/handshakes/xx.spec.ts
+++ b/test/handshakes/xx.spec.ts
@@ -1,4 +1,5 @@
 import { Buffer } from 'buffer'
+import { defaultLogger } from '@libp2p/logger'
 import { expect, assert } from 'aegir/chai'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
@@ -14,7 +15,7 @@ describe('XX Handshake', () => {
 
   it('Test creating new XX session', async () => {
     try {
-      const xx = new XX(pureJsCrypto)
+      const xx = new XX({ logger: defaultLogger() }, pureJsCrypto)
 
       const kpInitiator: KeyPair = pureJsCrypto.generateX25519KeyPair()
 
@@ -107,7 +108,7 @@ describe('XX Handshake', () => {
 
   it('Test handshake', async () => {
     try {
-      const xx = new XX(pureJsCrypto)
+      const xx = new XX({ logger: defaultLogger() }, pureJsCrypto)
       await doHandshake(xx)
     } catch (e) {
       const err = e as Error
@@ -117,7 +118,7 @@ describe('XX Handshake', () => {
 
   it('Test symmetric encrypt and decrypt', async () => {
     try {
-      const xx = new XX(pureJsCrypto)
+      const xx = new XX({ logger: defaultLogger() }, pureJsCrypto)
       const { nsInit, nsResp } = await doHandshake(xx)
       const ad = Buffer.from('authenticated')
       const message = Buffer.from('HelloCrypto')
@@ -139,7 +140,7 @@ describe('XX Handshake', () => {
   })
 
   it('Test multiple messages encryption and decryption', async () => {
-    const xx = new XX(pureJsCrypto)
+    const xx = new XX({ logger: defaultLogger() }, pureJsCrypto)
     const { nsInit, nsResp } = await doHandshake(xx)
     const ad = Buffer.from('authenticated')
     const message = Buffer.from('ethereum1')
diff --git a/test/index.spec.ts b/test/index.spec.ts
index bcf185f..89d17e5 100644
--- a/test/index.spec.ts
+++ b/test/index.spec.ts
@@ -1,3 +1,4 @@
+import { defaultLogger } from '@libp2p/logger'
 import { expect } from 'aegir/chai'
 import { lpStream } from 'it-length-prefixed-stream'
 import { duplexPair } from 'it-pair/duplex'
@@ -18,7 +19,7 @@ function createCounterSpy (): ReturnType<typeof sinon.spy> {
 
 describe('Index', () => {
   it('should expose class with tag and required functions', () => {
-    const noiseInstance = noise()()
+    const noiseInstance = noise()({ logger: defaultLogger() })
     expect(noiseInstance.protocol).to.equal('/noise')
     expect(typeof (noiseInstance.secureInbound)).to.equal('function')
     expect(typeof (noiseInstance.secureOutbound)).to.equal('function')
@@ -34,8 +35,8 @@ describe('Index', () => {
         return counter
       }
     }
-    const noiseInit = new Noise({ metrics: metrics as any as Metrics })
-    const noiseResp = new Noise({})
+    const noiseInit = new Noise({ logger: defaultLogger(), metrics: metrics as any as Metrics })
+    const noiseResp = new Noise({ logger: defaultLogger() })
 
     const [inboundConnection, outboundConnection] = duplexPair<Uint8Array | Uint8ArrayList>()
     const [outbound, inbound] = await Promise.all([
diff --git a/test/interop.ts b/test/interop.ts
index 16adbfa..2d89cc9 100644
--- a/test/interop.ts
+++ b/test/interop.ts
@@ -77,7 +77,6 @@ async function createJsPeer (options: SpawnOptions): Promise<Daemon> {
       listen: ['/ip4/0.0.0.0/tcp/0']
     },
     transports: [tcp()],
-    // @ts-expect-error yamux needs updating
     streamMuxers: [yamux()],
     connectionEncryption: [noise()]
   }
diff --git a/test/noise.spec.ts b/test/noise.spec.ts
index 9e9abf1..25f0046 100644
--- a/test/noise.spec.ts
+++ b/test/noise.spec.ts
@@ -1,4 +1,5 @@
 import { Buffer } from 'buffer'
+import { defaultLogger } from '@libp2p/logger'
 import { assert, expect } from 'aegir/chai'
 import { randomBytes } from 'iso-random-stream'
 import { byteStream } from 'it-byte-stream'
@@ -34,8 +35,8 @@ describe('Noise', () => {
 
   it('should communicate through encrypted streams without noise pipes', async () => {
     try {
-      const noiseInit = new Noise({ staticNoiseKey: undefined, extensions: undefined })
-      const noiseResp = new Noise({ staticNoiseKey: undefined, extensions: undefined })
+      const noiseInit = new Noise({ logger: defaultLogger() }, { staticNoiseKey: undefined, extensions: undefined })
+      const noiseResp = new Noise({ logger: defaultLogger() }, { staticNoiseKey: undefined, extensions: undefined })
 
       const [inboundConnection, outboundConnection] = duplexPair<Uint8Array | Uint8ArrayList>()
       const [outbound, inbound] = await Promise.all([
@@ -55,7 +56,7 @@ describe('Noise', () => {
   })
 
   it('should test that secureOutbound is spec compliant', async () => {
-    const noiseInit = new Noise({ staticNoiseKey: undefined })
+    const noiseInit = new Noise({ logger: defaultLogger() }, { staticNoiseKey: undefined })
     const [inboundConnection, outboundConnection] = duplexPair<Uint8Array | Uint8ArrayList>()
 
     const [outbound, { wrapped, handshake }] = await Promise.all([
@@ -71,10 +72,10 @@ describe('Noise', () => {
         )
         const prologue = Buffer.alloc(0)
         const staticKeys = pureJsCrypto.generateX25519KeyPair()
-        const xx = new XX(pureJsCrypto)
+        const xx = new XX({ logger: defaultLogger() }, pureJsCrypto)
 
         const payload = await getPayload(remotePeer, staticKeys.publicKey)
-        const handshake = new XXHandshake(false, payload, prologue, pureJsCrypto, staticKeys, wrapped, localPeer, xx)
+        const handshake = new XXHandshake({ logger: defaultLogger() }, false, payload, prologue, pureJsCrypto, staticKeys, wrapped, localPeer, xx)
 
         let receivedMessageBuffer = decode0((await wrapped.read()).slice())
         // The first handshake message contains the initiator's ephemeral public key
@@ -110,8 +111,8 @@ describe('Noise', () => {
   it('should test large payloads', async function () {
     this.timeout(10000)
     try {
-      const noiseInit = new Noise({ staticNoiseKey: undefined })
-      const noiseResp = new Noise({ staticNoiseKey: undefined })
+      const noiseInit = new Noise({ logger: defaultLogger() }, { staticNoiseKey: undefined })
+      const noiseResp = new Noise({ logger: defaultLogger() }, { staticNoiseKey: undefined })
 
       const [inboundConnection, outboundConnection] = duplexPair<Uint8Array | Uint8ArrayList>()
       const [outbound, inbound] = await Promise.all([
@@ -135,9 +136,9 @@ describe('Noise', () => {
   it('should working without remote peer provided in incoming connection', async () => {
     try {
       const staticKeysInitiator = pureJsCrypto.generateX25519KeyPair()
-      const noiseInit = new Noise({ staticNoiseKey: staticKeysInitiator.privateKey })
+      const noiseInit = new Noise({ logger: defaultLogger() }, { staticNoiseKey: staticKeysInitiator.privateKey })
       const staticKeysResponder = pureJsCrypto.generateX25519KeyPair()
-      const noiseResp = new Noise({ staticNoiseKey: staticKeysResponder.privateKey })
+      const noiseResp = new Noise({ logger: defaultLogger() }, { staticNoiseKey: staticKeysResponder.privateKey })
 
       const [inboundConnection, outboundConnection] = duplexPair<Uint8Array | Uint8ArrayList>()
       const [outbound, inbound] = await Promise.all([
@@ -168,10 +169,10 @@ describe('Noise', () => {
     try {
       const certhashInit = Buffer.from('certhash data from init')
       const staticKeysInitiator = pureJsCrypto.generateX25519KeyPair()
-      const noiseInit = new Noise({ staticNoiseKey: staticKeysInitiator.privateKey, extensions: { webtransportCerthashes: [certhashInit] } })
+      const noiseInit = new Noise({ logger: defaultLogger() }, { staticNoiseKey: staticKeysInitiator.privateKey, extensions: { webtransportCerthashes: [certhashInit] } })
       const staticKeysResponder = pureJsCrypto.generateX25519KeyPair()
       const certhashResp = Buffer.from('certhash data from respon')
-      const noiseResp = new Noise({ staticNoiseKey: staticKeysResponder.privateKey, extensions: { webtransportCerthashes: [certhashResp] } })
+      const noiseResp = new Noise({ logger: defaultLogger() }, { staticNoiseKey: staticKeysResponder.privateKey, extensions: { webtransportCerthashes: [certhashResp] } })
 
       const [inboundConnection, outboundConnection] = duplexPair<Uint8Array | Uint8ArrayList>()
       const [outbound, inbound] = await Promise.all([
@@ -189,8 +190,8 @@ describe('Noise', () => {
 
   it('should accept a prologue', async () => {
     try {
-      const noiseInit = new Noise({ staticNoiseKey: undefined, crypto: pureJsCrypto, prologueBytes: Buffer.from('Some prologue') })
-      const noiseResp = new Noise({ staticNoiseKey: undefined, crypto: pureJsCrypto, prologueBytes: Buffer.from('Some prologue') })
+      const noiseInit = new Noise({ logger: defaultLogger() }, { staticNoiseKey: undefined, crypto: pureJsCrypto, prologueBytes: Buffer.from('Some prologue') })
+      const noiseResp = new Noise({ logger: defaultLogger() }, { staticNoiseKey: undefined, crypto: pureJsCrypto, prologueBytes: Buffer.from('Some prologue') })
 
       const [inboundConnection, outboundConnection] = duplexPair<Uint8Array | Uint8ArrayList>()
       const [outbound, inbound] = await Promise.all([
diff --git a/test/xx-handshake.spec.ts b/test/xx-handshake.spec.ts
index 70a3757..56d0958 100644
--- a/test/xx-handshake.spec.ts
+++ b/test/xx-handshake.spec.ts
@@ -1,4 +1,5 @@
 import { Buffer } from 'buffer'
+import { defaultLogger } from '@libp2p/logger'
 import { assert, expect } from 'aegir/chai'
 import { lpStream } from 'it-length-prefixed-stream'
 import { duplexPair } from 'it-pair/duplex'
@@ -27,10 +28,10 @@ describe('XX Handshake', () => {
       const staticKeysResponder = defaultCrypto.generateX25519KeyPair()
 
       const initPayload = await getPayload(peerA, staticKeysInitiator.publicKey)
-      const handshakeInitiator = new XXHandshake(true, initPayload, prologue, defaultCrypto, staticKeysInitiator, connectionFrom, peerB)
+      const handshakeInitiator = new XXHandshake({ logger: defaultLogger() }, true, initPayload, prologue, defaultCrypto, staticKeysInitiator, connectionFrom, peerB)
 
       const respPayload = await getPayload(peerB, staticKeysResponder.publicKey)
-      const handshakeResponder = new XXHandshake(false, respPayload, prologue, defaultCrypto, staticKeysResponder, connectionTo, peerA)
+      const handshakeResponder = new XXHandshake({ logger: defaultLogger() }, false, respPayload, prologue, defaultCrypto, staticKeysResponder, connectionTo, peerA)
 
       await Promise.all([
         handshakeInitiator.propose(),
@@ -80,10 +81,10 @@ describe('XX Handshake', () => {
       const staticKeysResponder = defaultCrypto.generateX25519KeyPair()
 
       const initPayload = await getPayload(peerA, staticKeysInitiator.publicKey)
-      const handshakeInitiator = new XXHandshake(true, initPayload, prologue, defaultCrypto, staticKeysInitiator, connectionFrom, fakePeer)
+      const handshakeInitiator = new XXHandshake({ logger: defaultLogger() }, true, initPayload, prologue, defaultCrypto, staticKeysInitiator, connectionFrom, fakePeer)
 
       const respPayload = await getPayload(peerB, staticKeysResponder.publicKey)
-      const handshakeResponder = new XXHandshake(false, respPayload, prologue, defaultCrypto, staticKeysResponder, connectionTo, peerA)
+      const handshakeResponder = new XXHandshake({ logger: defaultLogger() }, false, respPayload, prologue, defaultCrypto, staticKeysResponder, connectionTo, peerA)
 
       await Promise.all([
         handshakeInitiator.propose(),
@@ -113,10 +114,10 @@ describe('XX Handshake', () => {
       const staticKeysResponder = defaultCrypto.generateX25519KeyPair()
 
       const initPayload = await getPayload(peerA, staticKeysInitiator.publicKey)
-      const handshakeInitiator = new XXHandshake(true, initPayload, prologue, defaultCrypto, staticKeysInitiator, connectionFrom, peerB)
+      const handshakeInitiator = new XXHandshake({ logger: defaultLogger() }, true, initPayload, prologue, defaultCrypto, staticKeysInitiator, connectionFrom, peerB)
 
       const respPayload = await getPayload(peerB, staticKeysResponder.publicKey)
-      const handshakeResponder = new XXHandshake(false, respPayload, prologue, defaultCrypto, staticKeysResponder, connectionTo, fakePeer)
+      const handshakeResponder = new XXHandshake({ logger: defaultLogger() }, false, respPayload, prologue, defaultCrypto, staticKeysResponder, connectionTo, fakePeer)
 
       await Promise.all([
         handshakeInitiator.propose(),