fix: remove node buffers

Replaces node buffers with browser-friendly `Uint8Array`s.

Previously we didn't want to do this because there's no equivalent
to node's `Buffer.allocUnsafe` which doesn't set all entries of
allocated buffers to 0.  The thing is we only actually use that in one
place so to address this I've isolated the use of `Buffer.allocUnsafe`
to the `alloc-unsafe.ts` file and used the `browser` field in package.json
to override it for browser use.

Running the benchmark suite in this module shows the performance
is comparable to or even slightly better than master (I think due to not
having to convert `Uint8Array`s to `Buffer`s any more):

Before:

```console
$ node benchmark.js
handshake x 59.95 ops/sec ±11.20% (75 runs sampled)
handshake x 54.68 ops/sec ±10.81% (68 runs sampled)
handshake x 50.42 ops/sec ±11.55% (65 runs sampled)
handshake x 53.41 ops/sec ±11.84% (68 runs sampled)
handshake x 50.25 ops/sec ±11.80% (66 runs sampled)
```

After:

```console
$ node ./benchmark.js
Initializing handshake benchmark
Init complete, running benchmark
handshake x 61.48 ops/sec ±11.71% (76 runs sampled)
handshake x 59.43 ops/sec ±11.13% (73 runs sampled)
handshake x 56.09 ops/sec ±12.02% (71 runs sampled)
handshake x 60.05 ops/sec ±11.69% (74 runs sampled)
handshake x 59.66 ops/sec ±10.59% (74 runs sampled)
```

Author: achingbrain

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainsafe/libp2p-noise",
-  "version": "4.1.1",
+  "version": "5.0.0",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "files": [
@@ -33,6 +33,7 @@
     "proto:gen": "pbjs -t static-module -r libp2p-noise -o ./src/proto/payload.js ./src/proto/payload.proto && pbts -o ./src/proto/payload.d.ts ./src/proto/payload.js && yarn run lint --fix"
   },
   "browser": {
+    "./dist/src/alloc-unsafe.js": "./dist/src/alloc-unsafe-browser.js",
     "util": false
   },
   "devDependencies": {
@@ -52,11 +53,12 @@
     "@stablelib/hkdf": "^1.0.1",
     "@stablelib/sha256": "^1.0.1",
     "@stablelib/x25519": "^1.0.1",
+    "bl": "^5.0.0",
     "debug": "^4.3.1",
     "it-buffer": "^0.1.3",
     "it-length-prefixed": "^5.0.3",
     "it-pair": "^1.0.0",
-    "it-pb-rpc": "^0.1.11",
+    "it-pb-rpc": "^0.1.12",
     "it-pipe": "^1.1.0",
     "peer-id": "^0.16.0",
     "protobufjs": "^6.11.2",

src/@types/basic.d.ts

@@ -1,8 +1,6 @@
-import { Buffer } from 'buffer'
-
-export type bytes = Buffer
-export type bytes32 = Buffer
-export type bytes16 = Buffer
+export type bytes = Uint8Array
+export type bytes32 = Uint8Array
+export type bytes16 = Uint8Array
 
 export type uint32 = number
 export type uint64 = number

src/@types/handshake-interface.d.ts

@@ -5,7 +5,7 @@ import PeerId from 'peer-id'
 export interface IHandshake {
   session: NoiseSession
   remotePeer: PeerId
-  remoteEarlyData: Buffer
+  remoteEarlyData: bytes
   encrypt: (plaintext: bytes, session: NoiseSession) => bytes
   decrypt: (ciphertext: bytes, session: NoiseSession) => {plaintext: bytes, valid: boolean}
 }

src/@types/it-length-prefixed/index.d.ts

@@ -1,20 +1,19 @@
 declare module 'it-length-prefixed' {
-  import BufferList from 'bl'
-  import { Buffer } from 'buffer'
+  import BufferList from 'bl/BufferList'
 
   interface LengthDecoderFunction {
-    (data: Buffer | BufferList): number
+    (data: Uint8Array | BufferList): number
     bytes: number
   }
 
   interface LengthEncoderFunction {
-    (value: number, target: Buffer, offset: number): number|Buffer
+    (value: number, target: Uint8Array, offset: number): number|Uint8Array
     bytes: number
   }
 
   interface Encoder {
-    (options?: Partial<{lengthEncoder: LengthEncoderFunction}>): AsyncGenerator<BufferList, Buffer>
-    single: (chunk: Buffer, options?: Partial<{lengthEncoder: LengthEncoderFunction}>) => BufferList
+    (options?: Partial<{lengthEncoder: LengthEncoderFunction}>): AsyncGenerator<BufferList, Uint8Array>
+    single: (chunk: Uint8Array, options?: Partial<{lengthEncoder: LengthEncoderFunction}>) => BufferList
     MIN_POOL_SIZE: number
     DEFAULT_POOL_SIZE: number
   }

src/@types/libp2p.d.ts

@@ -14,6 +14,6 @@ export interface INoiseConnection {
 
 export interface SecureOutbound {
   conn: any
-  remoteEarlyData: Buffer
+  remoteEarlyData: Uint8Array
   remotePeer: PeerId
 }

src/alloc-unsafe-browser.ts

@@ -0,0 +1,4 @@
+
+export default (size: number) => {
+  return new Uint8Array(size)
+}

src/alloc-unsafe.ts

@@ -0,0 +1,4 @@
+
+export default (size: number) => {
+  return Buffer.allocUnsafe(size)
+}

src/crypto.ts

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer'
 import { IHandshake } from './@types/handshake-interface'
 import { NOISE_MSG_MAX_LENGTH_BYTES, NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG } from './constants'
 
@@ -10,15 +9,13 @@ interface IReturnEncryptionWrapper {
 export function encryptStream (handshake: IHandshake): IReturnEncryptionWrapper {
   return async function * (source) {
     for await (const chunk of source) {
-      const chunkBuffer = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.length)
-
-      for (let i = 0; i < chunkBuffer.length; i += NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG) {
+      for (let i = 0; i < chunk.length; i += NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG) {
         let end = i + NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG
-        if (end > chunkBuffer.length) {
-          end = chunkBuffer.length
+        if (end > chunk.length) {
+          end = chunk.length
         }
 
-        const data = handshake.encrypt(chunkBuffer.slice(i, end), handshake.session)
+        const data = handshake.encrypt(chunk.slice(i, end), handshake.session)
         yield data
       }
     }
@@ -29,16 +26,13 @@ export function encryptStream (handshake: IHandshake): IReturnEncryptionWrapper
 export function decryptStream (handshake: IHandshake): IReturnEncryptionWrapper {
   return async function * (source) {
     for await (const chunk of source) {
-      const chunkBuffer = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.length)
-
-      for (let i = 0; i < chunkBuffer.length; i += NOISE_MSG_MAX_LENGTH_BYTES) {
+      for (let i = 0; i < chunk.length; i += NOISE_MSG_MAX_LENGTH_BYTES) {
         let end = i + NOISE_MSG_MAX_LENGTH_BYTES
-        if (end > chunkBuffer.length) {
-          end = chunkBuffer.length
+        if (end > chunk.length) {
+          end = chunk.length
         }
 
-        const chunk = chunkBuffer.slice(i, end)
-        const { plaintext: decrypted, valid } = await handshake.decrypt(chunk, handshake.session)
+        const { plaintext: decrypted, valid } = await handshake.decrypt(chunk.slice(i, end), handshake.session)
         if (!valid) {
           throw new Error('Failed to validate decrypted chunk')
         }

src/encoder.ts

@@ -1,33 +1,39 @@
-import { Buffer } from 'buffer'
 import { bytes } from './@types/basic'
 import { MessageBuffer } from './@types/handshake'
-import BufferList from 'bl'
+import BufferList from 'bl/BufferList'
+import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
+import allocUnsafe from './alloc-unsafe'
 
-export const uint16BEEncode = (value: number, target: Buffer, offset: number): Buffer => {
-  target = target || Buffer.allocUnsafe(2)
-  target.writeUInt16BE(value, offset)
+export const uint16BEEncode = (value: number, target: Uint8Array, offset: number): Uint8Array => {
+  target = target || allocUnsafe(2)
+  new DataView(target.buffer, target.byteOffset, target.byteLength).setUint16(offset, value, false)
   return target
 }
 uint16BEEncode.bytes = 2
 
-export const uint16BEDecode = (data: Buffer | BufferList): number => {
+export const uint16BEDecode = (data: Uint8Array | BufferList): number => {
   if (data.length < 2) throw RangeError('Could not decode int16BE')
-  return data.readUInt16BE(0)
+
+  if (data instanceof BufferList) {
+    return data.readUInt16BE(0)
+  }
+
+  return new DataView(data.buffer, data.byteOffset, data.byteLength).getUint16(0, false)
 }
 uint16BEDecode.bytes = 2
 
 // Note: IK and XX encoder usage is opposite (XX uses in stages encode0 where IK uses encode1)
 
 export function encode0 (message: MessageBuffer): bytes {
-  return Buffer.concat([message.ne, message.ciphertext])
+  return Buffer.from(uint8ArrayConcat([message.ne, message.ciphertext], message.ne.length + message.ciphertext.length))
 }
 
 export function encode1 (message: MessageBuffer): bytes {
-  return Buffer.concat([message.ne, message.ns, message.ciphertext])
+  return Buffer.from(uint8ArrayConcat([message.ne, message.ns, message.ciphertext], message.ne.length + message.ns.length + message.ciphertext.length))
 }
 
 export function encode2 (message: MessageBuffer): bytes {
-  return Buffer.concat([message.ns, message.ciphertext])
+  return Buffer.from(uint8ArrayConcat([message.ns, message.ciphertext], message.ns.length + message.ciphertext.length))
 }
 
 export function decode0 (input: bytes): MessageBuffer {

src/errors.ts

@@ -1,9 +1,9 @@
 import BufferList from 'bl'
 
 export class FailedIKError extends Error {
-  public initialMsg: string|BufferList|Buffer
+  public initialMsg: string|BufferList|Uint8Array
 
-  constructor (initialMsg: string|BufferList|Buffer, message?: string) {
+  constructor (initialMsg: string|BufferList|Uint8Array, message?: string) {
     super(message)
 
     this.initialMsg = initialMsg