@libp2p/noise 17.0.1-71e8ee163 → 17.0.1

package/dist/src/types.d.ts

@@ -1,5 +1,5 @@
-import type { Nonce } from './nonce.js';
-import type { NoiseExtensions, NoiseHandshakePayload } from './proto/payload.js';
+import type { Nonce } from './nonce.ts';
+import type { NoiseExtensions, NoiseHandshakePayload } from './proto/payload.ts';
 import type { ConnectionEncrypter, Logger, PrivateKey, PublicKey } from '@libp2p/interface';
 import type { LengthPrefixedStream } from '@libp2p/utils';
 import type { Uint8ArrayList } from 'uint8arraylist';

package/dist/src/utils.d.ts

@@ -1,7 +1,7 @@
 import { Uint8ArrayList } from 'uint8arraylist';
-import { NoiseHandshakePayload } from './proto/payload.js';
+import { NoiseHandshakePayload } from './proto/payload.ts';
 import type { MetricsRegistry } from './metrics.ts';
-import type { NoiseExtensions } from './proto/payload.js';
+import type { NoiseExtensions } from './proto/payload.ts';
 import type { HandshakeResult } from './types.ts';
 import type { MessageStream, PrivateKey, PublicKey } from '@libp2p/interface';
 export declare function createHandshakePayload(privateKey: PrivateKey, staticPublicKey: Uint8Array | Uint8ArrayList, extensions?: NoiseExtensions): Promise<Uint8Array | Uint8ArrayList>;

package/dist/src/utils.js

@@ -6,7 +6,7 @@ import { concat as uint8ArrayConcat } from 'uint8arrays/concat';
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string';
 import { CHACHA_TAG_LENGTH, NOISE_MSG_MAX_LENGTH_BYTES, NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG } from "./constants.js";
 import { uint16BEEncode, uint16BEDecode } from "./encoder.js";
-import { NoiseHandshakePayload } from './proto/payload.js';
+import { NoiseHandshakePayload } from "./proto/payload.js";
 export async function createHandshakePayload(privateKey, staticPublicKey, extensions) {
     const identitySig = await privateKey.sign(getSignaturePayload(staticPublicKey));
     return NoiseHandshakePayload.encode({

package/dist/typedoc-urls.json

@@ -0,0 +1,17 @@
+{
+  "asCrypto": "https://libp2p.github.io/js-libp2p/variables/_libp2p_noise.crypto.asCrypto.html",
+  "./crypto:asCrypto": "https://libp2p.github.io/js-libp2p/variables/_libp2p_noise.crypto.asCrypto.html",
+  "defaultCrypto": "https://libp2p.github.io/js-libp2p/variables/_libp2p_noise.crypto.defaultCrypto.html",
+  "./crypto:defaultCrypto": "https://libp2p.github.io/js-libp2p/variables/_libp2p_noise.crypto.defaultCrypto.html",
+  "nodeCrypto": "https://libp2p.github.io/js-libp2p/variables/_libp2p_noise.crypto.nodeCrypto.html",
+  "./crypto:nodeCrypto": "https://libp2p.github.io/js-libp2p/variables/_libp2p_noise.crypto.nodeCrypto.html",
+  "ICryptoInterface": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_noise.index.ICryptoInterface.html",
+  "KeyPair": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_noise.index.KeyPair.html",
+  "NoiseComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_noise.index.NoiseComponents.html",
+  ".:NoiseComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_noise.index.NoiseComponents.html",
+  "NoiseExtensions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_noise.index.NoiseExtensions.html",
+  "NoiseInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_noise.index.NoiseInit.html",
+  "pureJsCrypto": "https://libp2p.github.io/js-libp2p/variables/_libp2p_noise.index.pureJsCrypto.html",
+  "noise": "https://libp2p.github.io/js-libp2p/functions/_libp2p_noise.index.noise.html",
+  ".:noise": "https://libp2p.github.io/js-libp2p/functions/_libp2p_noise.index.noise.html"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/noise",
-  "version": "17.0.1-71e8ee163",
+  "version": "17.0.1",
   "description": "Noise libp2p handshake for js-libp2p",
   "author": "ChainSafe <info@chainsafe.io>",
   "license": "Apache-2.0 OR MIT",
@@ -23,6 +23,22 @@
   ],
   "type": "module",
   "types": "./dist/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
+      ],
+      "src/*": [
+        "*",
+        "dist/*",
+        "dist/src/*",
+        "dist/src/*/index"
+      ]
+    }
+  },
   "files": [
     "src",
     "dist",
@@ -32,63 +48,73 @@
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
+      "import": "./dist/src/index.js",
+      "module-sync": "./dist/src/index.js"
+    },
+    "./crypto": {
+      "types": "./dist/src/crypto/index.d.ts",
+      "import": "./dist/src/crypto/index.js",
+      "module-sync": "./dist/src/crypto/index.js"
     }
   },
   "scripts": {
-    "bench": "node benchmarks/benchmark.js",
     "clean": "aegir clean",
+    "lint": "aegir lint",
     "dep-check": "aegir dep-check",
+    "doc-check": "aegir doc-check",
     "build": "aegir build",
-    "lint": "aegir lint",
-    "lint:fix": "aegir lint --fix",
+    "bench": "node benchmarks/benchmark.js",
+    "generate": "protons ./src/proto/payload.proto",
     "test": "aegir test",
-    "test:node": "aegir test -t node",
-    "test:browser": "aegir test -t browser -t webworker",
+    "test:chrome": "aegir test -t browser --cov",
+    "test:chrome-webworker": "aegir test -t webworker",
+    "test:firefox": "aegir test -t browser -- --browser firefox",
+    "test:firefox-webworker": "aegir test -t webworker -- --browser firefox",
+    "test:node": "aegir test -t node --cov",
     "test:electron-main": "aegir test -t electron-main",
-    "test:interop": "aegir test -t node -f dist/test/interop.js",
-    "docs": "aegir docs",
-    "proto:gen": "protons ./src/proto/payload.proto",
-    "prepublish": "npm run build"
+    "test:interop": "aegir test -t node -f dist/test/interop.js"
   },
   "dependencies": {
     "@chainsafe/as-chacha20poly1305": "^0.1.0",
     "@chainsafe/as-sha256": "^1.2.0",
-    "@libp2p/crypto": "5.1.10-71e8ee163",
-    "@libp2p/interface": "3.0.0-71e8ee163",
-    "@libp2p/peer-id": "6.0.1-71e8ee163",
-    "@libp2p/utils": "7.0.1-71e8ee163",
+    "@libp2p/crypto": "^5.1.23",
+    "@libp2p/interface": "^3.3.0",
+    "@libp2p/peer-id": "^6.0.15",
+    "@libp2p/utils": "^7.4.1",
     "@noble/ciphers": "^2.0.1",
     "@noble/curves": "^2.0.1",
     "@noble/hashes": "^2.0.1",
-    "protons-runtime": "^5.6.0",
-    "uint8arraylist": "^2.4.8",
-    "uint8arrays": "^5.1.0",
+    "protons-runtime": "^7.0.0",
+    "uint8arraylist": "^3.0.2",
+    "uint8arrays": "^6.1.1",
     "wherearewe": "^2.0.1"
   },
   "devDependencies": {
-    "@libp2p/daemon-client": "10.0.1-71e8ee163",
-    "@libp2p/daemon-server": "9.0.1-71e8ee163",
-    "@libp2p/interface-compliance-tests": "7.0.1-71e8ee163",
-    "@libp2p/interop": "14.0.1-71e8ee163",
-    "@libp2p/logger": "6.0.1-71e8ee163",
-    "@libp2p/tcp": "11.0.1-71e8ee163",
-    "@libp2p/yamux": "8.0.1-71e8ee163",
-    "@multiformats/multiaddr": "^13.0.1",
-    "@types/sinon": "^17.0.4",
-    "aegir": "^47.0.22",
-    "execa": "^9.6.0",
-    "go-libp2p": "^1.6.0",
+    "@libp2p/daemon-client": "^10.0.38",
+    "@libp2p/daemon-server": "^9.0.38",
+    "@libp2p/interface-compliance-tests": "^7.0.31",
+    "@libp2p/interop": "^14.0.38",
+    "@libp2p/logger": "^6.2.13",
+    "@libp2p/tcp": "^11.0.28",
+    "@libp2p/yamux": "^8.0.2",
+    "@multiformats/multiaddr": "^13.0.3",
+    "@types/sinon": "^22.0.0",
+    "aegir": "^48.1.1",
+    "benchmark": "^2.1.4",
+    "execa": "^10.0.0",
+    "go-libp2p": "^1.7.0",
     "iso-random-stream": "^2.0.2",
-    "libp2p": "3.0.1-71e8ee163",
+    "it-pair": "^2.0.6",
+    "libp2p": "^3.3.10",
     "mkdirp": "^3.0.1",
-    "multiformats": "^13.4.0",
+    "multiformats": "^14.0.0",
     "p-defer": "^4.0.1",
-    "protons": "^7.7.0",
-    "sinon": "^21.0.0",
+    "protons": "^9.0.1",
+    "sinon": "^22.0.0",
     "sinon-ts": "^2.0.0"
   },
   "browser": {
     "./dist/src/crypto/index.js": "./dist/src/crypto/index.browser.js"
-  }
+  },
+  "sideEffects": false
 }

package/src/crypto/index.browser.ts

@@ -1,3 +1,3 @@
-import { pureJsCrypto } from './js.js'
+import { pureJsCrypto } from './js.ts'
 
 export const defaultCrypto = pureJsCrypto

package/src/crypto/index.ts

@@ -3,16 +3,19 @@ import { newInstance, ChaCha20Poly1305 } from '@chainsafe/as-chacha20poly1305'
 import { digest } from '@chainsafe/as-sha256'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { isElectronMain } from 'wherearewe'
-import { pureJsCrypto } from './js.js'
-import type { ICryptoInterface } from '../crypto.js'
-import type { KeyPair } from '../types.js'
+import { pureJsCrypto } from './js.ts'
+import type { ICryptoInterface } from '../crypto.ts'
+import type { KeyPair } from '../types.ts'
 
 const ctx = newInstance()
 const asImpl = new ChaCha20Poly1305(ctx)
 const CHACHA_POLY1305 = 'chacha20-poly1305'
 const PKCS8_PREFIX = Buffer.from([0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e, 0x04, 0x22, 0x04, 0x20])
 const X25519_PREFIX = Buffer.from([0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x6e, 0x03, 0x21, 0x00])
-const nodeCrypto: Pick<ICryptoInterface, 'hashSHA256' | 'chaCha20Poly1305Encrypt' | 'chaCha20Poly1305Decrypt'> = {
+
+export { pureJsCrypto }
+
+export const nodeCrypto: Pick<ICryptoInterface, 'hashSHA256' | 'chaCha20Poly1305Encrypt' | 'chaCha20Poly1305Decrypt'> = {
   hashSHA256 (data) {
     const hash = crypto.createHash('sha256')
 
@@ -104,7 +107,7 @@ const nodeCrypto: Pick<ICryptoInterface, 'hashSHA256' | 'chaCha20Poly1305Encrypt
   }
 }
 
-const asCrypto: Pick<ICryptoInterface, 'hashSHA256' | 'chaCha20Poly1305Encrypt' | 'chaCha20Poly1305Decrypt'> = {
+export const asCrypto: Pick<ICryptoInterface, 'hashSHA256' | 'chaCha20Poly1305Encrypt' | 'chaCha20Poly1305Decrypt'> = {
   hashSHA256 (data) {
     return digest(data.subarray())
   },

package/src/crypto/js.ts

@@ -2,8 +2,8 @@ import { chacha20poly1305 } from '@noble/ciphers/chacha.js'
 import { x25519 } from '@noble/curves/ed25519.js'
 import { extract, expand } from '@noble/hashes/hkdf.js'
 import { sha256 } from '@noble/hashes/sha2.js'
-import type { ICryptoInterface } from '../crypto.js'
-import type { KeyPair } from '../types.js'
+import type { ICryptoInterface } from '../crypto.ts'
+import type { KeyPair } from '../types.ts'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 export const pureJsCrypto: ICryptoInterface = {

package/src/crypto.ts

@@ -1,4 +1,4 @@
-import type { ICrypto, KeyPair } from './types.js'
+import type { ICrypto, KeyPair } from './types.ts'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 /** Underlying crypto implementation, meant to be overridable */

package/src/index.ts

@@ -3,27 +3,38 @@
  *
  * This repository contains TypeScript implementation of noise protocol, an encryption protocol used in libp2p.
  *
+ * Formerly published as [`@chainsafe/libp2p-noise`](https://www.npmjs.com/package/@chainsafe/libp2p-noise).
+ *
  * ## Usage
  *
- * Install with `yarn add @libp2p/noise` or `npm i @libp2p/noise`.
+ * Install with `npm i @libp2p/noise`.
  *
  * Example of using default noise configuration and passing it to the libp2p config:
  *
  * ```ts
- * import {createLibp2p} from "libp2p"
- * import {noise} from "@libp2p/noise"
- *
- * //custom noise configuration, pass it instead of `noise()`
- * //x25519 private key
- * const n = noise({ staticNoiseKey });
+ * import { createLibp2p } from 'libp2p'
+ * import { noise } from '@libp2p/noise'
  *
  * const libp2p = await createLibp2p({
  *   connectionEncrypters: [noise()],
- *   //... other options
+ *   // ... other options
  * })
  * ```
  *
- * See the [NoiseInit](https://github.com/ChainSafe/js-libp2p-noise/blob/master/src/noise.ts#L22-L30) interface for noise configuration options.
+ * See the [NoiseInit](https://github.com/libp2p/js-libp2p/blob/main/packages/connection-encrypter-noise/src/noise.ts) interface for noise configuration options.
+ *
+ * To use a fixed x25519 static key instead of generating one per session, pass it as `staticNoiseKey`:
+ *
+ * ```ts
+ * import { createLibp2p } from 'libp2p'
+ * import { noise, pureJsCrypto } from '@libp2p/noise'
+ *
+ * const staticNoiseKey = pureJsCrypto.generateX25519KeyPair().privateKey
+ *
+ * const node = await createLibp2p({
+ *   connectionEncrypters: [noise({ staticNoiseKey })]
+ * })
+ * ```
  *
  * ## API
  *
@@ -33,16 +44,16 @@
  *
  * You can provide a custom crypto implementation (instead of the default, based on [@noble](https://paulmillr.com/noble/)) by adding a `crypto` field to the init argument passed to the `Noise` factory.
  *
- * The implementation must conform to the `ICryptoInterface`, defined in <https://github.com/ChainSafe/js-libp2p-noise/blob/master/src/crypto.ts>
+ * The implementation must conform to the `ICryptoInterface`, defined in <https://github.com/libp2p/js-libp2p/blob/main/packages/connection-encrypter-noise/src/crypto.ts>
  */
 
-import { Noise } from './noise.js'
-import type { NoiseInit, NoiseExtensions } from './noise.js'
-import type { KeyPair } from './types.js'
+import { Noise } from './noise.ts'
+import type { NoiseInit, NoiseExtensions } from './noise.ts'
+import type { KeyPair } from './types.ts'
 import type { ComponentLogger, ConnectionEncrypter, Metrics, PeerId, PrivateKey, Upgrader } from '@libp2p/interface'
 
-export { pureJsCrypto } from './crypto/js.js'
-export type { ICryptoInterface } from './crypto.js'
+export { pureJsCrypto } from './crypto/js.ts'
+export type { ICryptoInterface } from './crypto.ts'
 export type { NoiseInit, NoiseExtensions, KeyPair }
 
 export interface NoiseComponents {

package/src/logger.ts

@@ -1,7 +1,7 @@
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { DUMP_SESSION_KEYS } from './constants.js'
-import type { CipherState } from './protocol.js'
-import type { KeyPair } from './types.js'
+import { DUMP_SESSION_KEYS } from './constants.ts'
+import type { CipherState } from './protocol.ts'
+import type { KeyPair } from './types.ts'
 import type { Logger } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 

package/src/noise.ts

@@ -3,17 +3,17 @@ import { InvalidCryptoExchangeError, serviceCapabilities } from '@libp2p/interfa
 import { peerIdFromPublicKey } from '@libp2p/peer-id'
 import { lpStream } from '@libp2p/utils'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
-import { NOISE_MSG_MAX_LENGTH_BYTES } from './constants.js'
-import { defaultCrypto } from './crypto/index.js'
-import { wrapCrypto } from './crypto.js'
-import { uint16BEDecode, uint16BEEncode } from './encoder.js'
-import { registerMetrics } from './metrics.js'
-import { performHandshakeInitiator, performHandshakeResponder } from './performHandshake.js'
+import { NOISE_MSG_MAX_LENGTH_BYTES } from './constants.ts'
+import { defaultCrypto } from './crypto/index.ts'
+import { wrapCrypto } from './crypto.ts'
+import { uint16BEDecode, uint16BEEncode } from './encoder.ts'
+import { registerMetrics } from './metrics.ts'
+import { performHandshakeInitiator, performHandshakeResponder } from './performHandshake.ts'
 import { toMessageStream } from './utils.ts'
-import type { ICryptoInterface } from './crypto.js'
-import type { NoiseComponents } from './index.js'
-import type { MetricsRegistry } from './metrics.js'
-import type { HandshakeResult, ICrypto, INoiseConnection, INoiseExtensions, KeyPair } from './types.js'
+import type { ICryptoInterface } from './crypto.ts'
+import type { NoiseComponents } from './index.ts'
+import type { MetricsRegistry } from './metrics.ts'
+import type { HandshakeResult, ICrypto, INoiseConnection, INoiseExtensions, KeyPair } from './types.ts'
 import type { SecuredConnection, PrivateKey, PublicKey, StreamMuxerFactory, SecureConnectionOptions, Logger, MessageStream } from '@libp2p/interface'
 import type { LengthPrefixedStream } from '@libp2p/utils'
 

package/src/nonce.ts

@@ -9,7 +9,7 @@ export const MIN_NONCE = 0
 // this MAX_NONCE is still a large number of messages, so the practical effect of this is negligible.
 export const MAX_NONCE = 0xffffffff
 
-const ERR_MAX_NONCE = 'Cipher state has reached maximum n, a new handshake must be performed'
+const ERR_MAX_NONCE = 'Cipherstate has reached maximum n, a new handshake must be performed'
 
 /**
  * The nonce is an uint that's increased over time.

package/src/performHandshake.ts

@@ -4,10 +4,10 @@ import {
   logRemoteEphemeralKey,
   logRemoteStaticKey,
   logCipherState
-} from './logger.js'
-import { ZEROLEN, XXHandshakeState } from './protocol.js'
-import { createHandshakePayload, decodeHandshakePayload } from './utils.js'
-import type { HandshakeResult, HandshakeParams } from './types.js'
+} from './logger.ts'
+import { ZEROLEN, XXHandshakeState } from './protocol.ts'
+import { createHandshakePayload, decodeHandshakePayload } from './utils.ts'
+import type { HandshakeResult, HandshakeParams } from './types.ts'
 import type { AbortOptions } from '@libp2p/interface'
 
 export async function performHandshakeInitiator (init: HandshakeParams, options?: AbortOptions): Promise<HandshakeResult> {

package/src/proto/payload.ts

@@ -1,4 +1,4 @@
-import { decodeMessage, encodeMessage, MaxLengthError, message } from 'protons-runtime'
+import { decodeMessage, encodeMessage, MaxLengthError, message, streamMessage } from 'protons-runtime'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
 import type { Codec, DecodeOptions } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -18,14 +18,14 @@ export namespace NoiseExtensions {
           w.fork()
         }
 
-        if (obj.webtransportCerthashes != null) {
+        if (obj.webtransportCerthashes != null && obj.webtransportCerthashes.length > 0) {
           for (const value of obj.webtransportCerthashes) {
             w.uint32(10)
             w.bytes(value)
           }
         }
 
-        if (obj.streamMuxers != null) {
+        if (obj.streamMuxers != null && obj.streamMuxers.length > 0) {
           for (const value of obj.streamMuxers) {
             w.uint32(18)
             w.string(value)
@@ -49,7 +49,7 @@ export namespace NoiseExtensions {
           switch (tag >>> 3) {
             case 1: {
               if (opts.limits?.webtransportCerthashes != null && obj.webtransportCerthashes.length === opts.limits.webtransportCerthashes) {
-                throw new MaxLengthError('Decode error - map field "webtransportCerthashes" had too many elements')
+                throw new MaxLengthError('Decode error - repeated field "webtransportCerthashes" had too many elements')
               }
 
               obj.webtransportCerthashes.push(reader.bytes())
@@ -57,7 +57,7 @@ export namespace NoiseExtensions {
             }
             case 2: {
               if (opts.limits?.streamMuxers != null && obj.streamMuxers.length === opts.limits.streamMuxers) {
-                throw new MaxLengthError('Decode error - map field "streamMuxers" had too many elements')
+                throw new MaxLengthError('Decode error - repeated field "streamMuxers" had too many elements')
               }
 
               obj.streamMuxers.push(reader.string())
@@ -71,19 +71,83 @@ export namespace NoiseExtensions {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const obj = {
+          webtransportCerthashes: 0,
+          streamMuxers: 0
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              if (opts.limits?.webtransportCerthashes != null && obj.webtransportCerthashes === opts.limits.webtransportCerthashes) {
+                throw new MaxLengthError('Streaming decode error - repeated field "webtransportCerthashes" had too many elements')
+              }
+
+              yield {
+                field: `${prefix}.webtransportCerthashes[]`,
+                index: obj.webtransportCerthashes,
+                value: reader.bytes()
+              }
+
+              obj.webtransportCerthashes++
+
+              break
+            }
+            case 2: {
+              if (opts.limits?.streamMuxers != null && obj.streamMuxers === opts.limits.streamMuxers) {
+                throw new MaxLengthError('Streaming decode error - repeated field "streamMuxers" had too many elements')
+              }
+
+              yield {
+                field: `${prefix}.streamMuxers[]`,
+                index: obj.streamMuxers,
+                value: reader.string()
+              }
+
+              obj.streamMuxers++
+
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<NoiseExtensions>): Uint8Array => {
+  export interface NoiseExtensionsWebtransportCerthashesFieldEvent {
+    field: '$.webtransportCerthashes[]'
+    index: number
+    value: Uint8Array
+  }
+
+  export interface NoiseExtensionsStreamMuxersFieldEvent {
+    field: '$.streamMuxers[]'
+    index: number
+    value: string
+  }
+
+  export function encode (obj: Partial<NoiseExtensions>): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, NoiseExtensions.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<NoiseExtensions>): NoiseExtensions => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<NoiseExtensions>): NoiseExtensions {
     return decodeMessage(buf, NoiseExtensions.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<NoiseExtensions>): Generator<NoiseExtensionsWebtransportCerthashesFieldEvent | NoiseExtensionsStreamMuxersFieldEvent> {
+    return streamMessage(buf, NoiseExtensions.codec(), opts)
+  }
 }
 
 export interface NoiseHandshakePayload {
@@ -154,17 +218,77 @@ export namespace NoiseHandshakePayload {
         }
 
         return obj
+      }, function * (reader, length, prefix, opts = {}) {
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1: {
+              yield {
+                field: `${prefix}.identityKey`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 2: {
+              yield {
+                field: `${prefix}.identitySig`,
+                value: reader.bytes()
+              }
+              break
+            }
+            case 4: {
+              yield * NoiseExtensions.codec().stream(reader, reader.uint32(), `${prefix}.extensions`, {
+                limits: opts.limits?.extensions
+              })
+
+              break
+            }
+            default: {
+              reader.skipType(tag & 7)
+              break
+            }
+          }
+        }
       })
     }
 
     return _codec
   }
 
-  export const encode = (obj: Partial<NoiseHandshakePayload>): Uint8Array => {
+  export interface NoiseHandshakePayloadIdentityKeyFieldEvent {
+    field: '$.identityKey'
+    value: Uint8Array
+  }
+
+  export interface NoiseHandshakePayloadIdentitySigFieldEvent {
+    field: '$.identitySig'
+    value: Uint8Array
+  }
+
+  export interface NoiseHandshakePayloadExtensionsWebtransportCerthashesFieldEvent {
+    field: '$.extensions.webtransportCerthashes[]'
+    index: number
+    value: Uint8Array
+  }
+
+  export interface NoiseHandshakePayloadExtensionsStreamMuxersFieldEvent {
+    field: '$.extensions.streamMuxers[]'
+    index: number
+    value: string
+  }
+
+  export function encode (obj: Partial<NoiseHandshakePayload>): Uint8Array<ArrayBuffer> {
     return encodeMessage(obj, NoiseHandshakePayload.codec())
   }
 
-  export const decode = (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<NoiseHandshakePayload>): NoiseHandshakePayload => {
+  export function decode (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<NoiseHandshakePayload>): NoiseHandshakePayload {
     return decodeMessage(buf, NoiseHandshakePayload.codec(), opts)
   }
+
+  export function stream (buf: Uint8Array | Uint8ArrayList, opts?: DecodeOptions<NoiseHandshakePayload>): Generator<NoiseHandshakePayloadIdentityKeyFieldEvent | NoiseHandshakePayloadIdentitySigFieldEvent | NoiseHandshakePayloadExtensionsWebtransportCerthashesFieldEvent | NoiseHandshakePayloadExtensionsStreamMuxersFieldEvent> {
+    return streamMessage(buf, NoiseHandshakePayload.codec(), opts)
+  }
 }

package/src/protocol.ts

@@ -1,9 +1,9 @@
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays'
 import { alloc as uint8ArrayAlloc } from 'uint8arrays/alloc'
-import { InvalidCryptoExchangeError } from './errors.js'
-import { Nonce } from './nonce.js'
-import type { ICipherState, ISymmetricState, IHandshakeState, KeyPair, ICrypto } from './types.js'
+import { InvalidCryptoExchangeError } from './errors.ts'
+import { Nonce } from './nonce.ts'
+import type { ICipherState, ISymmetricState, IHandshakeState, KeyPair, ICrypto } from './types.ts'
 
 // Code in this file is a direct translation of a subset of the noise protocol https://noiseprotocol.org/noise.html,
 // agnostic to libp2p's usage of noise

package/src/types.ts

@@ -1,5 +1,5 @@
-import type { Nonce } from './nonce.js'
-import type { NoiseExtensions, NoiseHandshakePayload } from './proto/payload.js'
+import type { Nonce } from './nonce.ts'
+import type { NoiseExtensions, NoiseHandshakePayload } from './proto/payload.ts'
 import type { ConnectionEncrypter, Logger, PrivateKey, PublicKey } from '@libp2p/interface'
 import type { LengthPrefixedStream } from '@libp2p/utils'
 import type { Uint8ArrayList } from 'uint8arraylist'

package/src/utils.ts

@@ -6,9 +6,9 @@ import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { CHACHA_TAG_LENGTH, NOISE_MSG_MAX_LENGTH_BYTES, NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG } from './constants.ts'
 import { uint16BEEncode, uint16BEDecode } from './encoder.ts'
-import { NoiseHandshakePayload } from './proto/payload.js'
+import { NoiseHandshakePayload } from './proto/payload.ts'
 import type { MetricsRegistry } from './metrics.ts'
-import type { NoiseExtensions } from './proto/payload.js'
+import type { NoiseExtensions } from './proto/payload.ts'
 import type { HandshakeResult } from './types.ts'
 import type { AbortOptions, MessageStream, PrivateKey, PublicKey, StreamCloseEvent } from '@libp2p/interface'
 import type { SendResult } from '@libp2p/utils'