chore: release version v0.14.0

* fix: replace node buffers with uint8arrays

Replaces all uses of node Buffers with Uint8Arrays

BREAKING CHANGES:

- Where node Buffers were returned, now Uint8Arrays are

* chore: remove gh dep

.aegir.js

@@ -0,0 +1,7 @@
+'use strict'
+
+module.exports = {
+  bundlesize: {
+    maxSize: '140kB'
+  }
+}

CHANGELOG.md

@@ -1,3 +1,90 @@
+<a name="0.14.0"></a>
+# [0.14.0](https://github.com/libp2p/js-peer-id/compare/v0.13.13...v0.14.0) (2020-08-07)
+
+
+### Bug Fixes
+
+* replace node buffers with uint8arrays ([#127](https://github.com/libp2p/js-peer-id/issues/127)) ([d16ce9c](https://github.com/libp2p/js-peer-id/commit/d16ce9c))
+
+
+### BREAKING CHANGES
+
+* - Where node Buffers were returned, now Uint8Arrays are
+
+* chore: remove gh dep
+
+
+
+<a name="0.13.13"></a>
+## [0.13.13](https://github.com/libp2p/js-peer-id/compare/v0.13.12...v0.13.13) (2020-06-23)
+
+
+
+<a name="0.13.12"></a>
+## [0.13.12](https://github.com/libp2p/js-peer-id/compare/v0.13.11...v0.13.12) (2020-04-22)
+
+
+### Features
+
+* **cli:** add support for specifying type and size ([#122](https://github.com/libp2p/js-peer-id/issues/122)) ([8cd9dfb](https://github.com/libp2p/js-peer-id/commit/8cd9dfb))
+
+
+
+<a name="0.13.11"></a>
+## [0.13.11](https://github.com/libp2p/js-peer-id/compare/v0.13.10...v0.13.11) (2020-03-26)
+
+
+
+<a name="0.13.10"></a>
+## [0.13.10](https://github.com/libp2p/js-peer-id/compare/v0.13.9...v0.13.10) (2020-03-18)
+
+
+### Bug Fixes
+
+* add buffer ([#120](https://github.com/libp2p/js-peer-id/issues/120)) ([c305c36](https://github.com/libp2p/js-peer-id/commit/c305c36))
+
+
+
+<a name="0.13.9"></a>
+## [0.13.9](https://github.com/libp2p/js-peer-id/compare/v0.13.8...v0.13.9) (2020-02-19)
+
+
+
+<a name="0.13.8"></a>
+## [0.13.8](https://github.com/libp2p/js-peer-id/compare/v0.13.6...v0.13.8) (2020-02-18)
+
+
+### Bug Fixes
+
+* remove use of assert module ([#117](https://github.com/libp2p/js-peer-id/issues/117)) ([f44645e](https://github.com/libp2p/js-peer-id/commit/f44645e))
+
+
+### Features
+
+* adds typescript types + type tests ([#110](https://github.com/libp2p/js-peer-id/issues/110)) ([a5070ae](https://github.com/libp2p/js-peer-id/commit/a5070ae))
+
+
+
+<a name="0.13.7"></a>
+## [0.13.7](https://github.com/libp2p/js-peer-id/compare/v0.13.6...v0.13.7) (2020-01-27)
+
+
+### Features
+
+* adds typescript types + type tests ([#110](https://github.com/libp2p/js-peer-id/issues/110)) ([a5070ae](https://github.com/libp2p/js-peer-id/commit/a5070ae))
+
+
+
+<a name="0.13.6"></a>
+## [0.13.6](https://github.com/libp2p/js-peer-id/compare/v0.13.5...v0.13.6) (2019-12-18)
+
+
+### Bug Fixes
+
+* catch errors thrown by multihash decode ([#109](https://github.com/libp2p/js-peer-id/issues/109)) ([65e0b74](https://github.com/libp2p/js-peer-id/commit/65e0b74))
+
+
+
 <a name="0.13.5"></a>
 ## [0.13.5](https://github.com/libp2p/js-peer-id/compare/v0.13.4...v0.13.5) (2019-11-12)
 

README.md

@@ -28,6 +28,7 @@
   - [Node.js](#nodejs)
   - [Browser: Browserify, Webpack, other bundlers](#browser-browserify-webpack-other-bundlers)
   - [Browser: `<script>` Tag](#browser-script-tag)
+- [CLI](#cli)
 - [API](#api)
   - [Create](#create)
     - [`new PeerId(id[, privKey, pubKey])`](#new-peeridid-privkey-pubkey)
@@ -117,6 +118,14 @@ the global namespace.
 <script src="https://unpkg.com/peer-id/dist/index.js"></script>
 ```
 
+# CLI
+
+After installing `peer-id`, `npm install peer-id`, you can leverage the cli to generate keys exported as JSON. You can specify the type for the key and size, as detailed in [`create([opts])`](#createopts). The defaults are shown here.
+
+```sh
+> peer-id --type rsa --bits 2048
+```
+
 # API
 
 ```js
@@ -127,7 +136,7 @@ const PeerId = require('peer-id')
 
 ### `new PeerId(id[, privKey, pubKey])`
 
-- `id: Buffer` - The multihash of the publick key as `Buffer`
+- `id: Buffer` - The multihash of the public key as `Buffer`
 - `privKey: RsaPrivateKey` - The private key
 - `pubKey: RsaPublicKey` - The public key
 
@@ -137,7 +146,8 @@ The key format is detailed in [libp2p-crypto](https://github.com/libp2p/js-libp2
 
 Generates a new Peer ID, complete with public/private keypair.
 
-- `opts: Object`: Default: `{bits: 2048, keyType: 'rsa'}`
+- `opts.bits: number` - The size of the key. Default: `2048`
+- `opts.keyType: string` - The key type, one of: `['rsa', 'ed25519', 'secp256k1']`. Default: `rsa`
 
 Returns `Promise<PeerId>`.
 

package.json

@@ -1,9 +1,10 @@
 {
   "name": "peer-id",
-  "version": "0.13.5",
+  "version": "0.14.0",
   "description": "IPFS Peer Id implementation in Node.js",
   "leadMaintainer": "Vasco Santos <santos.vasco10@gmail.com>",
   "main": "src/index.js",
+  "types": "src/index.d.ts",
   "bin": "src/bin.js",
   "scripts": {
     "lint": "aegir lint",
@@ -11,11 +12,12 @@
     "test": "aegir test",
     "test:node": "aegir test -t node",
     "test:browser": "aegir test -t browser -t webworker",
+    "test:types": "npx tsc",
     "release": "aegir release",
     "release-minor": "aegir release --type minor",
     "release-major": "aegir release --type major",
     "coverage": "aegir coverage",
-    "size": "bundlesize -f dist/index.min.js -s 140kB"
+    "size": "aegir build -b"
   },
   "files": [
     "src",
@@ -34,46 +36,48 @@
   },
   "homepage": "https://github.com/libp2p/js-peer-id",
   "devDependencies": {
-    "aegir": "^20.0.0",
-    "bundlesize": "~0.18.0",
-    "chai": "^4.2.0",
-    "dirty-chai": "^2.0.1"
+    "@types/chai": "^4.2.7",
+    "@types/dirty-chai": "^2.0.2",
+    "@types/mocha": "^8.0.1",
+    "aegir": "^25.0.0"
   },
   "dependencies": {
-    "cids": "~0.7.1",
+    "cids": "^1.0.0",
     "class-is": "^1.1.0",
-    "libp2p-crypto": "~0.17.0",
-    "multihashes": "~0.4.15",
-    "protons": "^1.0.1"
+    "libp2p-crypto": "^0.18.0",
+    "minimist": "^1.2.5",
+    "multihashes": "^3.0.1",
+    "protons": "^2.0.0",
+    "uint8arrays": "^1.1.0"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/libp2p/js-peer-id.git"
   },
   "contributors": [
-    "Arve Knudsen <arve.knudsen@gmail.com>",
     "David Dias <daviddias.p@gmail.com>",
-    "David Dias <mail@daviddias.me>",
-    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
-    "Henrique Dias <hacdias@gmail.com>",
-    "Hugo Dias <hugomrdias@gmail.com>",
+    "Vasco Santos <vasco.santos@moxy.studio>",
+    "nginnever <ginneversource@gmail.com>",
+    "dignifiedquire <dignifiedquire@gmail.com>",
     "Jacob Heun <jacobheun@gmail.com>",
-    "Maciej Krüger <mkg20001@gmail.com>",
-    "Marcin Rataj <lidel@lidel.org>",
-    "Michael Garvin <gar+gh@danger.computer>",
-    "Nate Foss <npfoss@gmail.com>",
     "Pedro Teixeira <i@pgte.me>",
-    "Prashanth Chandra <coolshanth94@gmail.com>",
+    "Stephen Whitmore <stephen.whitmore@gmail.com>",
+    "Hugo Dias <hugomrdias@gmail.com>",
+    "Maciej Krüger <mkg20001@gmail.com>",
+    "Alex Potsides <alex@achingbrain.net>",
+    "Robert Kiel <robert.kiel@validitylabs.org>",
+    "Nate Foss <npfoss@gmail.com>",
+    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
     "Richard Littauer <richard.littauer@gmail.com>",
     "Richard Schneider <makaretu@gmail.com>",
-    "Stephen Whitmore <stephen.whitmore@gmail.com>",
+    "Marcin Rataj <lidel@lidel.org>",
     "Topper Bowers <topper@quorumcontrol.com>",
-    "Vasco Santos <vasco.santos@moxy.studio>",
-    "Vasco Santos <vasco.santos@ua.pt>",
+    "Henrique Dias <hacdias@gmail.com>",
     "Yahya <ya7yaz@gmail.com>",
-    "greenkeeperio-bot <support@greenkeeper.io>",
-    "nginnever <ginneversource@gmail.com>",
-    "npmcdn-to-unpkg-bot <npmcdn-to-unpkg-bot@users.noreply.github.com>",
-    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>"
+    "Christian Paul <info@jaller.de>",
+    "Carson Farmer <carson.farmer@gmail.com>",
+    "Arve Knudsen <arve.knudsen@gmail.com>",
+    "Michael Garvin <gar+gh@danger.computer>",
+    "Prashanth Chandra <coolshanth94@gmail.com>"
   ]
 }

src/bin.js

@@ -3,9 +3,13 @@
 'use strict'
 
 const PeerId = require('./index.js')
+const argv = require('minimist')(process.argv.slice(2))
 
 async function main () {
-  const id = await PeerId.create()
+  const id = await PeerId.create({
+    keyType: argv.type,
+    bits: argv.bits
+  })
   console.log(JSON.stringify(id.toJSON(), null, 2)) // eslint-disable-line no-console
 }
 

src/index.d.ts

@@ -0,0 +1,188 @@
+import { PrivateKey, PublicKey, KeyType } from "libp2p-crypto";
+import CID from 'cids'
+
+declare namespace PeerId {
+  /**
+   * Options for PeerId creation.
+   */
+  type CreateOptions = {
+    /**
+     * The number of bits to use.
+     */
+    bits?: number;
+    /**
+     * The type of key to use.
+     */
+    keyType?: KeyType;
+  };
+
+  /**
+   * PeerId JSON format.
+   */
+  type JSONPeerId = {
+    /**
+     * String representation of PeerId.
+     */
+    id: string;
+    /**
+     * Public key.
+     */
+    pubKey?: string;
+    /**
+     * Private key.
+     */
+    privKey: string;
+  };
+
+  /**
+   * Checks if a value is an instance of PeerId.
+   * @param id The value to check.
+   */
+  function isPeerId(id: any): id is PeerId
+
+  /**
+   * Create a new PeerId.
+   * @param opts Options.
+   */
+  function create(opts?: PeerId.CreateOptions): Promise<PeerId>;
+
+  /**
+   * Create PeerId from hex string.
+   * @param str The input hex string.
+   */
+  function createFromHexString(str: string): PeerId;
+
+  /**
+   * Create PeerId from raw bytes.
+   * @param buf The raw bytes.
+   */
+  function createFromBytes(buf: Uint8Array): PeerId;
+
+  /**
+   * Create PeerId from base58-encoded string.
+   * @param str The base58-encoded string.
+   */
+  function createFromB58String(str: string): PeerId;
+
+  /**
+   * Create PeerId from CID.
+   * @param cid The CID.
+   */
+  function createFromCID(cid: CID | Uint8Array | string | object): PeerId;
+
+  /**
+   * Create PeerId from public key.
+   * @param key Public key, as Uint8Array or base64-encoded string.
+   */
+  function createFromPubKey(key: Uint8Array | string): Promise<PeerId>;
+
+  /**
+   * Create PeerId from private key.
+   * @param key Private key, as Uint8Array or base64-encoded string.
+   */
+  function createFromPrivKey(key: Uint8Array | string): Promise<PeerId>;
+
+  /**
+   * Create PeerId from PeerId JSON formatted object.
+   * @see {@link PeerId#toJSON}
+   * @param json PeerId in JSON format.
+   */
+  function createFromJSON(json: JSONPeerId): Promise<PeerId>;
+
+  /**
+   * Create PeerId from Protobuf bytes.
+   * @param buf Protobuf bytes, as Uint8Array or hex-encoded string.
+   */
+  function createFromProtobuf(buf: Uint8Array | string): Promise<PeerId>;
+}
+
+/**
+ * PeerId is an object representation of a peer identifier.
+ */
+declare class PeerId {
+  constructor(id: Uint8Array | string, privKey?: PrivateKey, pubKey?: PublicKey);
+
+  /**
+   * Raw id.
+   */
+  readonly id: Uint8Array;
+
+  /**
+   * Private key.
+   */
+  privKey: PrivateKey;
+
+  /**
+   * Public key.
+   */
+  pubKey: PublicKey;
+
+  /**
+   * Return the protobuf version of the public key, matching go ipfs formatting.
+   */
+  marshalPubKey(): Uint8Array;
+
+  /**
+   * Return the protobuf version of the private key, matching go ipfs formatting.
+   */
+  marshalPrivKey(): Uint8Array;
+
+  /**
+   * Return the protobuf version of the peer-id.
+   * @param excludePriv Whether to exclude the private key information from the output.
+   */
+  marshal(excludePriv?: boolean): Uint8Array;
+
+  /**
+   * String representation.
+   */
+  toPrint(): string;
+
+  /**
+   * Return the jsonified version of the key.
+   * Matches the formatting of go-ipfs for its config file.
+   * @see {@link PeerId.createFromJSON}
+   */
+  toJSON(): PeerId.JSONPeerId;
+
+  /**
+   * Encode to hex.
+   */
+  toHexString(): string;
+
+  /**
+   * Return raw id bytes.
+   */
+  toBytes(): Uint8Array;
+
+  /**
+   * Encode to base58 string.
+   */
+  toB58String(): string;
+
+  /**
+   * Return self-describing string representation.
+   * Uses default format from RFC 0001: https://github.com/libp2p/specs/pull/209
+   */
+  toString(): string;
+
+  /**
+   * Checks the equality of `this` peer against a given PeerId.
+   * @param id The other PeerId.
+   */
+  equals(id: PeerId | Uint8Array): boolean;
+
+  /**
+   * Checks the equality of `this` peer against a given PeerId.
+   * @deprecated Use {.equals}
+   * @param id The other PeerId.
+   */
+  isEqual(id: PeerId | Uint8Array): boolean;
+
+  /**
+   * Check if this PeerId instance is valid (privKey -> pubKey -> Id)
+   */
+  isValid(): boolean;
+}
+
+export = PeerId;

src/index.js

@@ -7,16 +7,20 @@
 const mh = require('multihashes')
 const CID = require('cids')
 const cryptoKeys = require('libp2p-crypto/src/keys')
-const assert = require('assert')
 const withIs = require('class-is')
 const { PeerIdProto } = require('./proto')
+const uint8ArrayEquals = require('uint8arrays/equals')
+const uint8ArrayFromString = require('uint8arrays/from-string')
+const uint8ArrayToString = require('uint8arrays/to-string')
 
 class PeerId {
   constructor (id, privKey, pubKey) {
-    assert(Buffer.isBuffer(id), 'invalid id provided')
+    if (!(id instanceof Uint8Array)) {
+      throw new Error('invalid id provided')
+    }
 
-    if (privKey && pubKey) {
-      assert(privKey.public.bytes.equals(pubKey.bytes), 'inconsistent arguments')
+    if (privKey && pubKey && !uint8ArrayEquals(privKey.public.bytes, pubKey.bytes)) {
+      throw new Error('inconsistent arguments')
     }
 
     this._id = id
@@ -50,12 +54,17 @@ class PeerId {
       return this._privKey.public
     }
 
+    try {
       const decoded = mh.decode(this.id)
 
       if (decoded.name === 'identity') {
         this._pubKey = cryptoKeys.unmarshalPublicKey(decoded.digest)
-      return this._pubKey
       }
+    } catch (_) {
+      // Ignore, there is no valid public key
+    }
+
+    return this._pubKey
   }
 
   set pubKey (pubKey) {
@@ -135,14 +144,14 @@ class PeerId {
 
   /**
    * Checks the equality of `this` peer against a given PeerId.
-   * @param {Buffer|PeerId} id
+   * @param {Uint8Array|PeerId} id
    * @returns {boolean}
    */
   equals (id) {
-    if (Buffer.isBuffer(id)) {
-      return this.id.equals(id)
+    if (id instanceof Uint8Array) {
+      return uint8ArrayEquals(this.id, id)
     } else if (id.id) {
-      return this.id.equals(id.id)
+      return uint8ArrayEquals(this.id, id.id)
     } else {
       throw new Error('not valid Id')
     }
@@ -151,7 +160,7 @@ class PeerId {
   /**
    * Checks the equality of `this` peer against a given PeerId.
    * @deprecated Use `.equals`
-   * @param {Buffer|PeerId} id
+   * @param {Uint8Array|PeerId} id
    * @returns {boolean}
    */
   isEqual (id) {
@@ -166,8 +175,8 @@ class PeerId {
     return Boolean(this.privKey &&
       this.privKey.public &&
       this.privKey.public.bytes &&
-      Buffer.isBuffer(this.pubKey.bytes) &&
-      this.privKey.public.bytes.equals(this.pubKey.bytes))
+      this.pubKey.bytes instanceof Uint8Array &&
+        uint8ArrayEquals(this.privKey.public.bytes, this.pubKey.bytes))
   }
 }
 
@@ -224,16 +233,16 @@ exports.createFromCID = (cid) => {
   return new PeerIdWithIs(cid.multihash)
 }
 
-// Public Key input will be a buffer
+// Public Key input will be a Uint8Array
 exports.createFromPubKey = async (key) => {
   let buf = key
 
   if (typeof buf === 'string') {
-    buf = Buffer.from(key, 'base64')
+    buf = uint8ArrayFromString(key, 'base64pad')
   }
 
-  if (!Buffer.isBuffer(buf)) {
-    throw new Error('Supplied key is neither a base64 string nor a buffer')
+  if (!(buf instanceof Uint8Array)) {
+    throw new Error('Supplied key is neither a base64 string nor a Uint8Array')
   }
 
   const pubKey = await cryptoKeys.unmarshalPublicKey(buf)
@@ -242,24 +251,22 @@ exports.createFromPubKey = async (key) => {
 
 // Private key input will be a string
 exports.createFromPrivKey = async (key) => {
-  let buf = key
-
-  if (typeof buf === 'string') {
-    buf = Buffer.from(key, 'base64')
+  if (typeof key === 'string') {
+    key = uint8ArrayFromString(key, 'base64pad')
   }
 
-  if (!Buffer.isBuffer(buf)) {
-    throw new Error('Supplied key is neither a base64 string nor a buffer')
+  if (!(key instanceof Uint8Array)) {
+    throw new Error('Supplied key is neither a base64 string nor a Uint8Array')
   }
 
-  const privKey = await cryptoKeys.unmarshalPrivateKey(buf)
+  const privKey = await cryptoKeys.unmarshalPrivateKey(key)
   return computePeerId(privKey, privKey.public)
 }
 
 exports.createFromJSON = async (obj) => {
   const id = mh.fromB58String(obj.id)
-  const rawPrivKey = obj.privKey && Buffer.from(obj.privKey, 'base64')
-  const rawPubKey = obj.pubKey && Buffer.from(obj.pubKey, 'base64')
+  const rawPrivKey = obj.privKey && uint8ArrayFromString(obj.privKey, 'base64pad')
+  const rawPubKey = obj.pubKey && uint8ArrayFromString(obj.pubKey, 'base64pad')
   const pub = rawPubKey && await cryptoKeys.unmarshalPublicKey(rawPubKey)
 
   if (!rawPrivKey) {
@@ -275,11 +282,11 @@ exports.createFromJSON = async (obj) => {
     pubDigest = await computeDigest(pub)
   }
 
-  if (pub && !privDigest.equals(pubDigest)) {
+  if (pub && !uint8ArrayEquals(privDigest, pubDigest)) {
     throw new Error('Public and private key do not match')
   }
 
-  if (id && !privDigest.equals(id)) {
+  if (id && !uint8ArrayEquals(privDigest, id)) {
     throw new Error('Id and private key do not match')
   }
 
@@ -288,7 +295,7 @@ exports.createFromJSON = async (obj) => {
 
 exports.createFromProtobuf = async (buf) => {
   if (typeof buf === 'string') {
-    buf = Buffer.from(buf, 'hex')
+    buf = uint8ArrayFromString(buf, 'base16')
   }
 
   let { id, privKey, pubKey } = PeerIdProto.decode(buf)
@@ -309,7 +316,7 @@ exports.createFromProtobuf = async (buf) => {
 
   if (privKey) {
     if (pubKey) {
-      if (!privDigest.equals(pubDigest)) {
+      if (!uint8ArrayEquals(privDigest, pubDigest)) {
         throw new Error('Public and private key do not match')
       }
     }
@@ -337,6 +344,6 @@ exports.isPeerId = (peerId) => {
 
 function toB64Opt (val) {
   if (val) {
-    return val.toString('base64')
+    return uint8ArrayToString(val, 'base64pad')
   }
 }

test/peer-id.spec.js

@@ -2,13 +2,12 @@
 /* eslint-env mocha */
 'use strict'
 
-const chai = require('chai')
-const dirtyChai = require('dirty-chai')
-chai.use(dirtyChai)
-const expect = chai.expect
+const { expect } = require('aegir/utils/chai')
 const crypto = require('libp2p-crypto')
 const mh = require('multihashes')
 const CID = require('cids')
+const uint8ArrayFromString = require('uint8arrays/from-string')
+const uint8ArrayToString = require('uint8arrays/to-string')
 
 const PeerId = require('../src')
 
@@ -55,14 +54,15 @@ describe('PeerId', () => {
     const id = await PeerId.create(testOpts)
     expect(PeerId.isPeerId(id)).to.equal(true)
     expect(PeerId.isPeerId('aaa')).to.equal(false)
-    expect(PeerId.isPeerId(Buffer.from('batatas'))).to.equal(false)
+    expect(PeerId.isPeerId(uint8ArrayFromString('batatas'))).to.equal(false)
   })
 
   it('throws on changing the id', async () => {
     const id = await PeerId.create(testOpts)
     expect(id.toB58String().length).to.equal(46)
     expect(() => {
-      id.id = Buffer.from('hello')
+      // @ts-ignore
+      id.id = uint8ArrayFromString('hello')
     }).to.throw(/immutable/)
   })
 
@@ -71,7 +71,7 @@ describe('PeerId', () => {
     expect(testIdBytes).to.deep.equal(id.toBytes())
   })
 
-  it('recreate from a Buffer', () => {
+  it('recreate from a Uint8Array', () => {
     const id = PeerId.createFromBytes(testIdBytes)
     expect(testId.id).to.equal(id.toHexString())
     expect(testIdBytes).to.deep.equal(id.toBytes())
@@ -112,8 +112,8 @@ describe('PeerId', () => {
     expect(testIdBytes).to.deep.equal(id.toBytes())
   })
 
-  it('recreate from CID Buffer', () => {
-    const id = PeerId.createFromCID(testIdCID.buffer)
+  it('recreate from CID Uint8Array', () => {
+    const id = PeerId.createFromCID(testIdCID.bytes)
     expect(testIdCIDString).to.equal(id.toString())
     expect(testIdBytes).to.deep.equal(id.toBytes())
   })
@@ -158,7 +158,7 @@ describe('PeerId', () => {
   it('recreate from a Private Key', async () => {
     const id = await PeerId.createFromPrivKey(testId.privKey)
     expect(testIdB58String).to.equal(id.toB58String())
-    const encoded = Buffer.from(testId.privKey, 'base64')
+    const encoded = uint8ArrayFromString(testId.privKey, 'base64pad')
     const id2 = await PeerId.createFromPrivKey(encoded)
     expect(testIdB58String).to.equal(id2.toB58String())
     expect(id.marshalPubKey()).to.deep.equal(id2.marshalPubKey())
@@ -167,11 +167,11 @@ describe('PeerId', () => {
   it('recreate from Protobuf', async () => {
     const id = await PeerId.createFromProtobuf(testId.marshaled)
     expect(testIdB58String).to.equal(id.toB58String())
-    const encoded = Buffer.from(testId.privKey, 'base64')
+    const encoded = uint8ArrayFromString(testId.privKey, 'base64pad')
     const id2 = await PeerId.createFromPrivKey(encoded)
     expect(testIdB58String).to.equal(id2.toB58String())
     expect(id.marshalPubKey()).to.deep.equal(id2.marshalPubKey())
-    expect(id.marshal().toString('hex')).to.deep.equal(testId.marshaled)
+    expect(uint8ArrayToString(id.marshal(), 'base16')).to.deep.equal(testId.marshaled)
   })
 
   it('can be created from a Secp256k1 public key', async () => {
@@ -216,7 +216,7 @@ describe('PeerId', () => {
 
   it('toBytes', () => {
     const id = PeerId.createFromHexString(testIdHex)
-    expect(id.toBytes().toString('hex')).to.equal(testIdBytes.toString('hex'))
+    expect(uint8ArrayToString(id.toBytes(), 'base16')).to.equal(uint8ArrayToString(testIdBytes, 'base16'))
   })
 
   it('isEqual', async () => {
@@ -271,33 +271,37 @@ describe('PeerId', () => {
 
   it('set privKey (valid)', async () => {
     const peerId = await PeerId.create(testOpts)
+    // @ts-ignore
     peerId.privKey = peerId._privKey
     expect(peerId.isValid()).to.equal(true)
   })
 
   it('set pubKey (valid)', async () => {
     const peerId = await PeerId.create(testOpts)
+    // @ts-ignore
     peerId.pubKey = peerId._pubKey
     expect(peerId.isValid()).to.equal(true)
   })
 
   it('set privKey (invalid)', async () => {
     const peerId = await PeerId.create(testOpts)
-    peerId.privKey = Buffer.from('bufff')
+    // @ts-ignore
+    peerId.privKey = uint8ArrayFromString('bufff')
     expect(peerId.isValid()).to.equal(false)
   })
 
   it('set pubKey (invalid)', async () => {
     const peerId = await PeerId.create(testOpts)
-    peerId.pubKey = Buffer.from('bufff')
+    // @ts-ignore
+    peerId.pubKey = uint8ArrayFromString('bufff')
     expect(peerId.isValid()).to.equal(false)
   })
 
   describe('returns error via cb instead of crashing', () => {
     const garbage = [
-      Buffer.from('00010203040506070809', 'hex'),
+      uint8ArrayFromString('00010203040506070809', 'base16'),
       {}, null, false, undefined, true, 1, 0,
-      Buffer.from(''), 'aGVsbG93b3JsZA==', 'helloworld', ''
+      uint8ArrayFromString(''), 'aGVsbG93b3JsZA==', 'helloworld', ''
     ]
 
     const fncs = ['createFromPubKey', 'createFromPrivKey', 'createFromJSON', 'createFromProtobuf']

tsconfig.json

@@ -0,0 +1,37 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "target": "ES5",
+        "noImplicitAny": false,
+        "noImplicitThis": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "esModuleInterop": true,
+        "resolveJsonModule": true,
+        "allowJs": true,
+        "checkJs": true,
+        "baseUrl": ".",
+        "paths": {
+            "peer-id": [
+                "./src",
+                "../src",
+            ]
+        },
+        "types": [
+            "node",
+            "mocha",
+            "chai"
+        ],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "./src/index.d.ts",
+    ],
+    "include": [
+        "./test/**/*.spec.js"
+    ]
+}