libp2p 0.36.2-64bfcee → 0.36.2-c64a586

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.36.2-64bfcee",
+  "version": "0.36.2-c64a586",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p#readme",
@@ -76,36 +76,34 @@
     ]
   },
   "scripts": {
+    "clean": "aegir clean",
     "lint": "aegir lint",
-    "build": "tsc",
-    "postbuild": "mkdirp dist/src/circuit/pb dist/src/fetch/pb dist/src/identify/pb dist/src/insecure/pb && cp src/circuit/pb/*.js src/circuit/pb/*.d.ts dist/src/circuit/pb && cp src/fetch/pb/*.js src/fetch/pb/*.d.ts dist/src/fetch/pb && cp src/identify/pb/*.js src/identify/pb/*.d.ts dist/src/identify/pb && cp src/insecure/pb/*.js src/insecure/pb/*.d.ts dist/src/insecure/pb",
-    "generate": "run-s generate:proto:* generate:proto-types:*",
-    "generate:proto:circuit": "pbjs -t static-module -w es6 -r libp2p-circuit --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/circuit/protocol/index.js ./src/circuit/protocol/index.proto",
-    "generate:proto:fetch": "pbjs -t static-module -w es6 -r libp2p-fetch --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/fetch/proto.js ./src/fetch/proto.proto",
-    "generate:proto:identify": "pbjs -t static-module -w es6 -r libp2p-identify --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/identify/message.js ./src/identify/message.proto",
-    "generate:proto:plaintext": "pbjs -t static-module -w es6 -r libp2p-plaintext --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/insecure/proto.js ./src/insecure/proto.proto",
-    "generate:proto-types:circuit": "pbts -o src/circuit/protocol/index.d.ts src/circuit/protocol/index.js",
-    "generate:proto-types:fetch": "pbts -o src/fetch/proto.d.ts src/fetch/proto.js",
-    "generate:proto-types:identify": "pbts -o src/identify/message.d.ts src/identify/message.js",
-    "generate:proto-types:plaintext": "pbts -o src/insecure/proto.d.ts src/insecure/proto.js",
-    "pretest": "npm run build",
+    "dep-check": "aegir dep-check",
+    "build": "aegir build",
+    "generate": "run-s generate:proto:*",
+    "generate:proto:circuit": "protons ./src/circuit/pb/index.proto",
+    "generate:proto:fetch": "protons ./src/fetch/pb/proto.proto",
+    "generate:proto:identify": "protons ./src/identify/pb/message.proto",
+    "generate:proto:plaintext": "protons ./src/insecure/pb/proto.proto",
     "test": "aegir test",
-    "test:node": "npm run test -- -t node -f \"./dist/test/**/*.{node,spec}.js\" --cov",
-    "test:chrome": "npm run test -- -t browser -f \"./dist/test/**/*.spec.js\" --cov",
-    "test:chrome-webworker": "npm run test -- -t webworker -f \"./dist/test/**/*.spec.js\"",
-    "test:firefox": "npm run test -- -t browser -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
-    "test:firefox-webworker": "npm run test -- -t webworker -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
+    "test:node": "aegir test -t node -f \"./dist/test/**/*.{node,spec}.js\" --cov",
+    "test:chrome": "aegir test -t browser -f \"./dist/test/**/*.spec.js\" --cov",
+    "test:chrome-webworker": "aegir test -t webworker -f \"./dist/test/**/*.spec.js\"",
+    "test:firefox": "aegir test -t browser -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
+    "test:firefox-webworker": "aegir test -t webworker -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
     "test:examples": "cd examples && npm run test:all",
-    "test:interop": "npm run test -- -t node -f dist/test/interop.js"
+    "test:interop": "aegir test -t node -f dist/test/interop.js"
   },
   "dependencies": {
     "@achingbrain/nat-port-mapper": "^1.0.0",
     "@libp2p/connection": "^1.1.4",
     "@libp2p/crypto": "^0.22.9",
     "@libp2p/interfaces": "^1.3.17",
+    "@libp2p/logger": "^1.1.3",
     "@libp2p/multistream-select": "^1.0.3",
     "@libp2p/peer-id": "^1.1.8",
     "@libp2p/peer-id-factory": "^1.0.8",
+    "@libp2p/peer-record": "^1.0.8",
     "@libp2p/peer-store": "^1.0.6",
     "@libp2p/utils": "^1.0.9",
     "@multiformats/mafmt": "^11.0.2",
@@ -144,7 +142,7 @@
     "p-retry": "^5.0.0",
     "p-settle": "^5.0.0",
     "private-ip": "^2.3.3",
-    "protobufjs": "^6.11.2",
+    "protons-runtime": "^1.0.2",
     "retimer": "^3.0.0",
     "sanitize-filename": "^1.6.3",
     "set-delayed-interval": "^1.0.0",
@@ -165,11 +163,13 @@
     "@libp2p/delegated-peer-routing": "^1.0.2",
     "@libp2p/floodsub": "^1.0.2",
     "@libp2p/interface-compliance-tests": "^1.1.20",
-    "@libp2p/interop": "^1.0.0",
+    "@libp2p/interop": "^1.0.3",
     "@libp2p/kad-dht": "^1.0.3",
     "@libp2p/mdns": "^1.0.3",
     "@libp2p/mplex": "^1.0.1",
+    "@libp2p/pubsub": "^1.2.14",
     "@libp2p/tcp": "^1.0.6",
+    "@libp2p/topology": "^1.1.7",
     "@libp2p/tracked-map": "^1.0.4",
     "@libp2p/webrtc-star": "^1.0.3",
     "@libp2p/websockets": "^1.0.3",
@@ -179,10 +179,11 @@
     "@types/p-fifo": "^1.0.0",
     "@types/varint": "^6.0.0",
     "@types/xsalsa20": "^1.1.0",
-    "aegir": "^36.1.3",
+    "aegir": "^37.0.9",
     "buffer": "^6.0.3",
     "cborg": "^1.8.1",
     "delay": "^5.0.0",
+    "execa": "^6.1.0",
     "go-libp2p": "^0.0.6",
     "into-stream": "^7.0.0",
     "ipfs-http-client": "^56.0.1",
@@ -194,6 +195,7 @@
     "p-event": "^5.0.1",
     "p-times": "^4.0.0",
     "p-wait-for": "^4.1.0",
+    "protons": "^3.0.2",
     "rimraf": "^3.0.2",
     "sinon": "^13.0.1",
     "ts-sinon": "^2.0.2"

package/src/circuit/circuit/hop.ts

@@ -2,7 +2,7 @@ import { logger } from '@libp2p/logger'
 import errCode from 'err-code'
 import { validateAddrs } from './utils.js'
 import { StreamHandler } from './stream-handler.js'
-import { CircuitRelay as CircuitPB, ICircuitRelay } from '../pb/index.js'
+import { CircuitRelay as CircuitPB } from '../pb/index.js'
 import { pipe } from 'it-pipe'
 import { codes as Errors } from '../../errors.js'
 import { stop } from './stop.js'
@@ -17,7 +17,7 @@ const log = logger('libp2p:circuit:hop')
 
 export interface HopRequest {
   connection: Connection
-  request: ICircuitRelay
+  request: CircuitPB
   streamHandler: StreamHandler
   circuit: Circuit
   connectionManager: ConnectionManager
@@ -120,7 +120,7 @@ export async function handleHop (hopRequest: HopRequest) {
 
 export interface HopConfig {
   connection: Connection
-  request: ICircuitRelay
+  request: CircuitPB
 }
 
 /**
@@ -153,7 +153,7 @@ export async function hop (options: HopConfig): Promise<Duplex<Uint8Array>> {
   log('hop request failed with code %d, closing stream', response.code)
   streamHandler.close()
 
-  throw errCode(new Error(`HOP request failed with code ${response.code}`), Errors.ERR_HOP_REQUEST_FAILED)
+  throw errCode(new Error(`HOP request failed with code "${response.code ?? 'unknown'}"`), Errors.ERR_HOP_REQUEST_FAILED)
 }
 
 export interface CanHopOptions {

package/src/circuit/circuit/stop.ts

@@ -1,5 +1,5 @@
 import { logger } from '@libp2p/logger'
-import { CircuitRelay as CircuitPB, ICircuitRelay } from '../pb/index.js'
+import { CircuitRelay as CircuitPB } from '../pb/index.js'
 import { RELAY_CODEC } from '../multicodec.js'
 import { StreamHandler } from './stream-handler.js'
 import { validateAddrs } from './utils.js'
@@ -10,7 +10,7 @@ const log = logger('libp2p:circuit:stop')
 
 export interface HandleStopOptions {
   connection: Connection
-  request: ICircuitRelay
+  request: CircuitPB
   streamHandler: StreamHandler
 }
 
@@ -44,7 +44,7 @@ export function handleStop (options: HandleStopOptions): Duplex<Uint8Array> | un
 
 export interface StopOptions {
   connection: Connection
-  request: ICircuitRelay
+  request: CircuitPB
 }
 
 /**

package/src/circuit/circuit/stream-handler.ts

@@ -1,7 +1,7 @@
 import { logger } from '@libp2p/logger'
 import * as lp from 'it-length-prefixed'
 import { Handshake, handshake } from 'it-handshake'
-import { CircuitRelay, ICircuitRelay } from '../pb/index.js'
+import { CircuitRelay } from '../pb/index.js'
 import type { Stream } from '@libp2p/interfaces/connection'
 import type { Source } from 'it-stream-types'
 
@@ -53,10 +53,9 @@ export class StreamHandler {
   /**
    * Encode and write array of buffers
    */
-  write (msg: ICircuitRelay) {
+  write (msg: CircuitRelay) {
     log('write message type %s', msg.type)
-    // @ts-expect-error lp.encode expects type type 'Buffer | BufferList', not 'Uint8Array'
-    this.shake.write(lp.encode.single(CircuitRelay.encode(msg).finish()))
+    this.shake.write(lp.encode.single(CircuitRelay.encode(msg)).slice())
   }
 
   /**
@@ -68,9 +67,9 @@ export class StreamHandler {
   }
 
   /**
-   * @param {ICircuitRelay} msg - An unencoded CircuitRelay protobuf message
+   * @param {CircuitRelay} msg - An unencoded CircuitRelay protobuf message
    */
-  end (msg: ICircuitRelay) {
+  end (msg: CircuitRelay) {
     this.write(msg)
     this.close()
   }

package/src/circuit/circuit/utils.ts

@@ -1,5 +1,5 @@
 import { Multiaddr } from '@multiformats/multiaddr'
-import { CircuitRelay, ICircuitRelay } from '../pb/index.js'
+import { CircuitRelay } from '../pb/index.js'
 import type { StreamHandler } from './stream-handler.js'
 
 /**
@@ -15,7 +15,7 @@ function writeResponse (streamHandler: StreamHandler, status: CircuitRelay.Statu
 /**
  * Validate incomming HOP/STOP message
  */
-export function validateAddrs (msg: ICircuitRelay, streamHandler: StreamHandler) {
+export function validateAddrs (msg: CircuitRelay, streamHandler: StreamHandler) {
   try {
     if (msg.dstPeer?.addrs != null) {
       msg.dstPeer.addrs.forEach((addr) => {

package/src/circuit/pb/index.proto

@@ -1,4 +1,4 @@
-syntax = "proto2";
+syntax = "proto3";
 
 message CircuitRelay {
 

package/src/circuit/pb/index.ts

@@ -0,0 +1,88 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { enumeration, encodeMessage, decodeMessage, message, bytes } from 'protons-runtime'
+
+export interface CircuitRelay {
+  type?: CircuitRelay.Type
+  srcPeer?: CircuitRelay.Peer
+  dstPeer?: CircuitRelay.Peer
+  code?: CircuitRelay.Status
+}
+
+export namespace CircuitRelay {
+  export enum Status {
+    SUCCESS = 'SUCCESS',
+    HOP_SRC_ADDR_TOO_LONG = 'HOP_SRC_ADDR_TOO_LONG',
+    HOP_DST_ADDR_TOO_LONG = 'HOP_DST_ADDR_TOO_LONG',
+    HOP_SRC_MULTIADDR_INVALID = 'HOP_SRC_MULTIADDR_INVALID',
+    HOP_DST_MULTIADDR_INVALID = 'HOP_DST_MULTIADDR_INVALID',
+    HOP_NO_CONN_TO_DST = 'HOP_NO_CONN_TO_DST',
+    HOP_CANT_DIAL_DST = 'HOP_CANT_DIAL_DST',
+    HOP_CANT_OPEN_DST_STREAM = 'HOP_CANT_OPEN_DST_STREAM',
+    HOP_CANT_SPEAK_RELAY = 'HOP_CANT_SPEAK_RELAY',
+    HOP_CANT_RELAY_TO_SELF = 'HOP_CANT_RELAY_TO_SELF',
+    STOP_SRC_ADDR_TOO_LONG = 'STOP_SRC_ADDR_TOO_LONG',
+    STOP_DST_ADDR_TOO_LONG = 'STOP_DST_ADDR_TOO_LONG',
+    STOP_SRC_MULTIADDR_INVALID = 'STOP_SRC_MULTIADDR_INVALID',
+    STOP_DST_MULTIADDR_INVALID = 'STOP_DST_MULTIADDR_INVALID',
+    STOP_RELAY_REFUSED = 'STOP_RELAY_REFUSED',
+    MALFORMED_MESSAGE = 'MALFORMED_MESSAGE'
+  }
+
+  export namespace Status {
+    export const codec = () => {
+      return enumeration<typeof Status>(Status)
+    }
+  }
+  export enum Type {
+    HOP = 'HOP',
+    STOP = 'STOP',
+    STATUS = 'STATUS',
+    CAN_HOP = 'CAN_HOP'
+  }
+
+  export namespace Type {
+    export const codec = () => {
+      return enumeration<typeof Type>(Type)
+    }
+  }
+  export interface Peer {
+    id: Uint8Array
+    addrs: Uint8Array[]
+  }
+
+  export namespace Peer {
+    export const codec = () => {
+      return message<Peer>({
+        1: { name: 'id', codec: bytes },
+        2: { name: 'addrs', codec: bytes, repeats: true }
+      })
+    }
+
+    export const encode = (obj: Peer): Uint8Array => {
+      return encodeMessage(obj, Peer.codec())
+    }
+
+    export const decode = (buf: Uint8Array): Peer => {
+      return decodeMessage(buf, Peer.codec())
+    }
+  }
+
+  export const codec = () => {
+    return message<CircuitRelay>({
+      1: { name: 'type', codec: CircuitRelay.Type.codec(), optional: true },
+      2: { name: 'srcPeer', codec: CircuitRelay.Peer.codec(), optional: true },
+      3: { name: 'dstPeer', codec: CircuitRelay.Peer.codec(), optional: true },
+      4: { name: 'code', codec: CircuitRelay.Status.codec(), optional: true }
+    })
+  }
+
+  export const encode = (obj: CircuitRelay): Uint8Array => {
+    return encodeMessage(obj, CircuitRelay.codec())
+  }
+
+  export const decode = (buf: Uint8Array): CircuitRelay => {
+    return decodeMessage(buf, CircuitRelay.codec())
+  }
+}

package/src/fetch/index.ts

@@ -75,8 +75,7 @@ export class FetchService implements Startable {
     const shake = handshake(stream)
 
     // send message
-    const request = new FetchRequest({ identifier: key })
-    shake.write(lp.encode.single(FetchRequest.encode(request).finish()).slice())
+    shake.write(lp.encode.single(FetchRequest.encode({ identifier: key })).slice())
 
     // read response
     // @ts-expect-error fromReader returns a Source which has no .next method
@@ -109,21 +108,21 @@ export class FetchService implements Startable {
     // @ts-expect-error fromReader returns a Source which has no .next method
     const request = FetchRequest.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
 
-    let response
+    let response: FetchResponse
     const lookup = this._getLookupFunction(request.identifier)
     if (lookup != null) {
       const data = await lookup(request.identifier)
       if (data != null) {
-        response = new FetchResponse({ status: FetchResponse.StatusCode.OK, data })
+        response = { status: FetchResponse.StatusCode.OK, data }
       } else {
-        response = new FetchResponse({ status: FetchResponse.StatusCode.NOT_FOUND })
+        response = { status: FetchResponse.StatusCode.NOT_FOUND, data: new Uint8Array(0) }
       }
     } else {
       const errmsg = (new TextEncoder()).encode('No lookup function registered for key: ' + request.identifier)
-      response = new FetchResponse({ status: FetchResponse.StatusCode.ERROR, data: errmsg })
+      response = { status: FetchResponse.StatusCode.ERROR, data: errmsg }
     }
 
-    shake.write(lp.encode.single(FetchResponse.encode(response).finish()).slice())
+    shake.write(lp.encode.single(FetchResponse.encode(response)).slice())
   }
 
   /**

package/src/fetch/pb/proto.ts

@@ -0,0 +1,58 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { encodeMessage, decodeMessage, message, string, enumeration, bytes } from 'protons-runtime'
+
+export interface FetchRequest {
+  identifier: string
+}
+
+export namespace FetchRequest {
+  export const codec = () => {
+    return message<FetchRequest>({
+      1: { name: 'identifier', codec: string }
+    })
+  }
+
+  export const encode = (obj: FetchRequest): Uint8Array => {
+    return encodeMessage(obj, FetchRequest.codec())
+  }
+
+  export const decode = (buf: Uint8Array): FetchRequest => {
+    return decodeMessage(buf, FetchRequest.codec())
+  }
+}
+
+export interface FetchResponse {
+  status: FetchResponse.StatusCode
+  data: Uint8Array
+}
+
+export namespace FetchResponse {
+  export enum StatusCode {
+    OK = 'OK',
+    NOT_FOUND = 'NOT_FOUND',
+    ERROR = 'ERROR'
+  }
+
+  export namespace StatusCode {
+    export const codec = () => {
+      return enumeration<typeof StatusCode>(StatusCode)
+    }
+  }
+
+  export const codec = () => {
+    return message<FetchResponse>({
+      1: { name: 'status', codec: FetchResponse.StatusCode.codec() },
+      2: { name: 'data', codec: bytes }
+    })
+  }
+
+  export const encode = (obj: FetchResponse): Uint8Array => {
+    return encodeMessage(obj, FetchResponse.codec())
+  }
+
+  export const decode = (buf: Uint8Array): FetchResponse => {
+    return decodeMessage(buf, FetchResponse.codec())
+  }
+}

package/src/identify/index.ts

@@ -8,7 +8,7 @@ import drain from 'it-drain'
 import first from 'it-first'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { Multiaddr, protocols } from '@multiformats/multiaddr'
-import Message from './pb/message.js'
+import { Identify } from './pb/message.js'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import {
   MULTICODEC_IDENTIFY,
@@ -132,11 +132,11 @@ export class IdentifyService implements Startable {
         const { stream } = await connection.newStream([this.identifyPushProtocolStr])
 
         await pipe(
-          [Message.Identify.encode({
+          [Identify.encode({
             listenAddrs,
             signedPeerRecord,
             protocols
-          }).finish()],
+          })],
           lp.encode(),
           stream,
           drain
@@ -194,9 +194,9 @@ export class IdentifyService implements Startable {
       throw errCode(new Error('No data could be retrieved'), codes.ERR_CONNECTION_ENDED)
     }
 
-    let message
+    let message: Identify
     try {
-      message = Message.Identify.decode(data)
+      message = Identify.decode(data)
     } catch (err: any) {
       throw errCode(err, codes.ERR_INVALID_MESSAGE)
     }
@@ -325,7 +325,7 @@ export class IdentifyService implements Startable {
         signedPeerRecord = envelope.marshal()
       }
 
-      const message = Message.Identify.encode({
+      const message = Identify.encode({
         protocolVersion: this.host.protocolVersion,
         agentVersion: this.host.agentVersion,
         publicKey,
@@ -333,7 +333,7 @@ export class IdentifyService implements Startable {
         signedPeerRecord,
         observedAddr: connection.remoteAddr.bytes,
         protocols: peerData.protocols
-      }).finish()
+      })
 
       await pipe(
         [message],
@@ -352,7 +352,7 @@ export class IdentifyService implements Startable {
   async _handlePush (data: IncomingStreamData) {
     const { connection, stream } = data
 
-    let message
+    let message: Identify | undefined
     try {
       const data = await pipe(
         [],
@@ -362,7 +362,7 @@ export class IdentifyService implements Startable {
       )
 
       if (data != null) {
-        message = Message.Identify.decode(data)
+        message = Identify.decode(data)
       }
     } catch (err: any) {
       return log.error('received invalid message', err)
@@ -442,4 +442,4 @@ export const multicodecs = {
   IDENTIFY_PUSH: MULTICODEC_IDENTIFY_PUSH
 }
 
-export { Message }
+export const Message = { Identify }

package/src/identify/pb/message.ts

@@ -0,0 +1,36 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { encodeMessage, decodeMessage, message, string, bytes } from 'protons-runtime'
+
+export interface Identify {
+  protocolVersion?: string
+  agentVersion?: string
+  publicKey?: Uint8Array
+  listenAddrs: Uint8Array[]
+  observedAddr?: Uint8Array
+  protocols: string[]
+  signedPeerRecord?: Uint8Array
+}
+
+export namespace Identify {
+  export const codec = () => {
+    return message<Identify>({
+      5: { name: 'protocolVersion', codec: string, optional: true },
+      6: { name: 'agentVersion', codec: string, optional: true },
+      1: { name: 'publicKey', codec: bytes, optional: true },
+      2: { name: 'listenAddrs', codec: bytes, repeats: true },
+      4: { name: 'observedAddr', codec: bytes, optional: true },
+      3: { name: 'protocols', codec: string, repeats: true },
+      8: { name: 'signedPeerRecord', codec: bytes, optional: true }
+    })
+  }
+
+  export const encode = (obj: Identify): Uint8Array => {
+    return encodeMessage(obj, Identify.codec())
+  }
+
+  export const decode = (buf: Uint8Array): Identify => {
+    return decodeMessage(buf, Identify.codec())
+  }
+}

package/src/insecure/index.ts

@@ -2,7 +2,7 @@ import { logger } from '@libp2p/logger'
 import { handshake } from 'it-handshake'
 import * as lp from 'it-length-prefixed'
 import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interfaces/connection-encrypter/errors'
-import { Exchange, IExchange, KeyType } from './pb/proto.js'
+import { Exchange, KeyType } from './pb/proto.js'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interfaces/connection-encrypter'
@@ -11,8 +11,8 @@ import type { Duplex } from 'it-stream-types'
 const log = logger('libp2p:plaintext')
 const PROTOCOL = '/plaintext/2.0.0'
 
-function lpEncodeExchange (exchange: IExchange) {
-  const pb = Exchange.encode(exchange).finish()
+function lpEncodeExchange (exchange: Exchange) {
+  const pb = Exchange.encode(exchange)
 
   return lp.encode.single(pb)
 }
@@ -37,7 +37,7 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
       id: localId.toBytes(),
       pubkey: {
         Type: type,
-        Data: localId.publicKey
+        Data: localId.publicKey ?? new Uint8Array(0)
       }
     }).slice()
   )
@@ -52,6 +52,10 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
 
   let peerId
   try {
+    if (id.pubkey == null) {
+      throw new Error('Public key missing')
+    }
+
     if (id.pubkey.Data.length === 0) {
       throw new Error('Public key data too short')
     }

package/src/insecure/pb/proto.ts

@@ -0,0 +1,61 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { encodeMessage, decodeMessage, message, bytes, enumeration } from 'protons-runtime'
+
+export interface Exchange {
+  id?: Uint8Array
+  pubkey?: PublicKey
+}
+
+export namespace Exchange {
+  export const codec = () => {
+    return message<Exchange>({
+      1: { name: 'id', codec: bytes, optional: true },
+      2: { name: 'pubkey', codec: PublicKey.codec(), optional: true }
+    })
+  }
+
+  export const encode = (obj: Exchange): Uint8Array => {
+    return encodeMessage(obj, Exchange.codec())
+  }
+
+  export const decode = (buf: Uint8Array): Exchange => {
+    return decodeMessage(buf, Exchange.codec())
+  }
+}
+
+export enum KeyType {
+  RSA = 'RSA',
+  Ed25519 = 'Ed25519',
+  Secp256k1 = 'Secp256k1',
+  ECDSA = 'ECDSA'
+}
+
+export namespace KeyType {
+  export const codec = () => {
+    return enumeration<typeof KeyType>(KeyType)
+  }
+}
+
+export interface PublicKey {
+  Type: KeyType
+  Data: Uint8Array
+}
+
+export namespace PublicKey {
+  export const codec = () => {
+    return message<PublicKey>({
+      1: { name: 'Type', codec: KeyType.codec() },
+      2: { name: 'Data', codec: bytes }
+    })
+  }
+
+  export const encode = (obj: PublicKey): Uint8Array => {
+    return encodeMessage(obj, PublicKey.codec())
+  }
+
+  export const decode = (buf: Uint8Array): PublicKey => {
+    return decodeMessage(buf, PublicKey.codec())
+  }
+}

package/src/keychain/index.ts

@@ -171,7 +171,7 @@ export class KeyChain {
   /**
    * Generates the options for a keychain.  A random salt is produced.
    *
-   * @returns {Object}
+   * @returns {object}
    */
   static generateOptions (): KeyChainInit {
     const options = Object.assign({}, defaultOptions)
@@ -184,7 +184,7 @@ export class KeyChain {
    * Gets an object that can encrypt/decrypt protected data.
    * The default options for a keychain.
    *
-   * @returns {Object}
+   * @returns {object}
    */
   static get options () {
     return defaultOptions