@libp2p/keychain 0.6.2 → 1.0.1

package/src/index.ts

@@ -4,7 +4,7 @@ import { logger } from '@libp2p/logger'
 import sanitize from 'sanitize-filename'
 import mergeOptions from 'merge-options'
 import { Key } from 'interface-datastore/key'
-import errCode from 'err-code'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { codes } from './errors.js'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
@@ -50,7 +50,7 @@ const defaultOptions = {
   }
 }
 
-function validateKeyName (name: string) {
+function validateKeyName (name: string): boolean {
   if (name == null) {
     return false
   }
@@ -66,7 +66,7 @@ function validateKeyName (name: string) {
  * This assumes than an error indicates that the keychain is under attack. Delay returning an
  * error to make brute force attacks harder.
  */
-async function randomDelay () {
+async function randomDelay (): Promise<void> {
   const min = 200
   const max = 1000
   const delay = Math.random() * (max - min) + min
@@ -77,14 +77,14 @@ async function randomDelay () {
 /**
  * Converts a key name into a datastore name
  */
-function DsName (name: string) {
+function DsName (name: string): Key {
   return new Key(keyPrefix + name)
 }
 
 /**
  * Converts a key name into a datastore info name
  */
-function DsInfoName (name: string) {
+function DsInfoName (name: string): Key {
   return new Key(infoPrefix + name)
 }
 
@@ -155,7 +155,7 @@ export class DefaultKeyChain implements KeyChain {
    *
    * @returns {object}
    */
-  static get options () {
+  static get options (): typeof defaultOptions {
     return defaultOptions
   }
 
@@ -169,26 +169,26 @@ export class DefaultKeyChain implements KeyChain {
   async createKey (name: string, type: KeyType, size = 2048): Promise<KeyInfo> {
     if (!validateKeyName(name) || name === 'self') {
       await randomDelay()
-      throw errCode(new Error('Invalid key name'), codes.ERR_INVALID_KEY_NAME)
+      throw new CodeError('Invalid key name', codes.ERR_INVALID_KEY_NAME)
     }
 
     if (typeof type !== 'string') {
       await randomDelay()
-      throw errCode(new Error('Invalid key type'), codes.ERR_INVALID_KEY_TYPE)
+      throw new CodeError('Invalid key type', codes.ERR_INVALID_KEY_TYPE)
     }
 
     const dsname = DsName(name)
     const exists = await this.components.datastore.has(dsname)
     if (exists) {
       await randomDelay()
-      throw errCode(new Error('Key name already exists'), codes.ERR_KEY_ALREADY_EXISTS)
+      throw new CodeError('Key name already exists', codes.ERR_KEY_ALREADY_EXISTS)
     }
 
     switch (type.toLowerCase()) {
       case 'rsa':
         if (!Number.isSafeInteger(size) || size < 2048) {
           await randomDelay()
-          throw errCode(new Error('Invalid RSA key size'), codes.ERR_INVALID_KEY_SIZE)
+          throw new CodeError('Invalid RSA key size', codes.ERR_INVALID_KEY_SIZE)
         }
         break
       default:
@@ -202,13 +202,13 @@ export class DefaultKeyChain implements KeyChain {
       const cached = privates.get(this)
 
       if (cached == null) {
-        throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
+        throw new CodeError('dek missing', codes.ERR_INVALID_PARAMETERS)
       }
 
       const dek = cached.dek
       const pem = await keypair.export(dek)
       keyInfo = {
-        name: name,
+        name,
         id: kid
       }
       const batch = this.components.datastore.batch()
@@ -229,7 +229,7 @@ export class DefaultKeyChain implements KeyChain {
    *
    * @returns {Promise<KeyInfo[]>}
    */
-  async listKeys () {
+  async listKeys (): Promise<KeyInfo[]> {
     const query = {
       prefix: infoPrefix
     }
@@ -248,7 +248,13 @@ export class DefaultKeyChain implements KeyChain {
   async findKeyById (id: string): Promise<KeyInfo> {
     try {
       const keys = await this.listKeys()
-      return keys.find((k) => k.id === id)
+      const key = keys.find((k) => k.id === id)
+
+      if (key == null) {
+        throw new CodeError(`Key with id '${id}' does not exist.`, codes.ERR_KEY_NOT_FOUND)
+      }
+
+      return key
     } catch (err: any) {
       await randomDelay()
       throw err
@@ -264,7 +270,7 @@ export class DefaultKeyChain implements KeyChain {
   async findKeyByName (name: string): Promise<KeyInfo> {
     if (!validateKeyName(name)) {
       await randomDelay()
-      throw errCode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME)
+      throw new CodeError(`Invalid key name '${name}'`, codes.ERR_INVALID_KEY_NAME)
     }
 
     const dsname = DsInfoName(name)
@@ -274,7 +280,7 @@ export class DefaultKeyChain implements KeyChain {
     } catch (err: any) {
       await randomDelay()
       log.error(err)
-      throw errCode(new Error(`Key '${name}' does not exist.`), codes.ERR_KEY_NOT_FOUND)
+      throw new CodeError(`Key '${name}' does not exist.`, codes.ERR_KEY_NOT_FOUND)
     }
   }
 
@@ -284,10 +290,10 @@ export class DefaultKeyChain implements KeyChain {
    * @param {string} name - The local key name; must already exist.
    * @returns {Promise<KeyInfo>}
    */
-  async removeKey (name: string) {
+  async removeKey (name: string): Promise<KeyInfo> {
     if (!validateKeyName(name) || name === 'self') {
       await randomDelay()
-      throw errCode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME)
+      throw new CodeError(`Invalid key name '${name}'`, codes.ERR_INVALID_KEY_NAME)
     }
     const dsname = DsName(name)
     const keyInfo = await this.findKeyByName(name)
@@ -308,11 +314,11 @@ export class DefaultKeyChain implements KeyChain {
   async renameKey (oldName: string, newName: string): Promise<KeyInfo> {
     if (!validateKeyName(oldName) || oldName === 'self') {
       await randomDelay()
-      throw errCode(new Error(`Invalid old key name '${oldName}'`), codes.ERR_OLD_KEY_NAME_INVALID)
+      throw new CodeError(`Invalid old key name '${oldName}'`, codes.ERR_OLD_KEY_NAME_INVALID)
     }
     if (!validateKeyName(newName) || newName === 'self') {
       await randomDelay()
-      throw errCode(new Error(`Invalid new key name '${newName}'`), codes.ERR_NEW_KEY_NAME_INVALID)
+      throw new CodeError(`Invalid new key name '${newName}'`, codes.ERR_NEW_KEY_NAME_INVALID)
     }
     const oldDsname = DsName(oldName)
     const newDsname = DsName(newName)
@@ -322,7 +328,7 @@ export class DefaultKeyChain implements KeyChain {
     const exists = await this.components.datastore.has(newDsname)
     if (exists) {
       await randomDelay()
-      throw errCode(new Error(`Key '${newName}' already exists`), codes.ERR_KEY_ALREADY_EXISTS)
+      throw new CodeError(`Key '${newName}' already exists`, codes.ERR_KEY_ALREADY_EXISTS)
     }
 
     try {
@@ -347,14 +353,14 @@ export class DefaultKeyChain implements KeyChain {
   /**
    * Export an existing key as a PEM encrypted PKCS #8 string
    */
-  async exportKey (name: string, password: string) {
+  async exportKey (name: string, password: string): Promise<string> {
     if (!validateKeyName(name)) {
       await randomDelay()
-      throw errCode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME)
+      throw new CodeError(`Invalid key name '${name}'`, codes.ERR_INVALID_KEY_NAME)
     }
     if (password == null) {
       await randomDelay()
-      throw errCode(new Error('Password is required'), codes.ERR_PASSWORD_REQUIRED)
+      throw new CodeError('Password is required', codes.ERR_PASSWORD_REQUIRED)
     }
 
     const dsname = DsName(name)
@@ -364,7 +370,7 @@ export class DefaultKeyChain implements KeyChain {
       const cached = privates.get(this)
 
       if (cached == null) {
-        throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
+        throw new CodeError('dek missing', codes.ERR_INVALID_PARAMETERS)
       }
 
       const dek = cached.dek
@@ -379,7 +385,7 @@ export class DefaultKeyChain implements KeyChain {
   /**
    * Export an existing key as a PeerId
    */
-  async exportPeerId (name: string) {
+  async exportPeerId (name: string): Promise<PeerId> {
     const password = 'temporary-password'
     const pem = await this.exportKey(name, password)
     const privateKey = await importKey(pem, password)
@@ -398,17 +404,17 @@ export class DefaultKeyChain implements KeyChain {
   async importKey (name: string, pem: string, password: string): Promise<KeyInfo> {
     if (!validateKeyName(name) || name === 'self') {
       await randomDelay()
-      throw errCode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME)
+      throw new CodeError(`Invalid key name '${name}'`, codes.ERR_INVALID_KEY_NAME)
     }
     if (pem == null) {
       await randomDelay()
-      throw errCode(new Error('PEM encoded key is required'), codes.ERR_PEM_REQUIRED)
+      throw new CodeError('PEM encoded key is required', codes.ERR_PEM_REQUIRED)
     }
     const dsname = DsName(name)
     const exists = await this.components.datastore.has(dsname)
     if (exists) {
       await randomDelay()
-      throw errCode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS)
+      throw new CodeError(`Key '${name}' already exists`, codes.ERR_KEY_ALREADY_EXISTS)
     }
 
     let privateKey
@@ -416,7 +422,7 @@ export class DefaultKeyChain implements KeyChain {
       privateKey = await importKey(pem, password)
     } catch (err: any) {
       await randomDelay()
-      throw errCode(new Error('Cannot read the key, most likely the password is wrong'), codes.ERR_CANNOT_READ_KEY)
+      throw new CodeError('Cannot read the key, most likely the password is wrong', codes.ERR_CANNOT_READ_KEY)
     }
 
     let kid
@@ -425,7 +431,7 @@ export class DefaultKeyChain implements KeyChain {
       const cached = privates.get(this)
 
       if (cached == null) {
-        throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
+        throw new CodeError('dek missing', codes.ERR_INVALID_PARAMETERS)
       }
 
       const dek = cached.dek
@@ -436,7 +442,7 @@ export class DefaultKeyChain implements KeyChain {
     }
 
     const keyInfo = {
-      name: name,
+      name,
       id: kid
     }
     const batch = this.components.datastore.batch()
@@ -453,13 +459,13 @@ export class DefaultKeyChain implements KeyChain {
   async importPeer (name: string, peer: PeerId): Promise<KeyInfo> {
     try {
       if (!validateKeyName(name)) {
-        throw errCode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME)
+        throw new CodeError(`Invalid key name '${name}'`, codes.ERR_INVALID_KEY_NAME)
       }
       if (peer == null) {
-        throw errCode(new Error('PeerId is required'), codes.ERR_MISSING_PRIVATE_KEY)
+        throw new CodeError('PeerId is required', codes.ERR_MISSING_PRIVATE_KEY)
       }
       if (peer.privateKey == null) {
-        throw errCode(new Error('PeerId.privKey is required'), codes.ERR_MISSING_PRIVATE_KEY)
+        throw new CodeError('PeerId.privKey is required', codes.ERR_MISSING_PRIVATE_KEY)
       }
 
       const privateKey = await unmarshalPrivateKey(peer.privateKey)
@@ -468,19 +474,19 @@ export class DefaultKeyChain implements KeyChain {
       const exists = await this.components.datastore.has(dsname)
       if (exists) {
         await randomDelay()
-        throw errCode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS)
+        throw new CodeError(`Key '${name}' already exists`, codes.ERR_KEY_ALREADY_EXISTS)
       }
 
       const cached = privates.get(this)
 
       if (cached == null) {
-        throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
+        throw new CodeError('dek missing', codes.ERR_INVALID_PARAMETERS)
       }
 
       const dek = cached.dek
       const pem = await privateKey.export(dek)
       const keyInfo: KeyInfo = {
-        name: name,
+        name,
         id: peer.toString()
       }
       const batch = this.components.datastore.batch()
@@ -500,7 +506,7 @@ export class DefaultKeyChain implements KeyChain {
   async getPrivateKey (name: string): Promise<string> {
     if (!validateKeyName(name)) {
       await randomDelay()
-      throw errCode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME)
+      throw new CodeError(`Invalid key name '${name}'`, codes.ERR_INVALID_KEY_NAME)
     }
 
     try {
@@ -510,31 +516,31 @@ export class DefaultKeyChain implements KeyChain {
     } catch (err: any) {
       await randomDelay()
       log.error(err)
-      throw errCode(new Error(`Key '${name}' does not exist.`), codes.ERR_KEY_NOT_FOUND)
+      throw new CodeError(`Key '${name}' does not exist.`, codes.ERR_KEY_NOT_FOUND)
     }
   }
 
   /**
    * Rotate keychain password and re-encrypt all associated keys
    */
-  async rotateKeychainPass (oldPass: string, newPass: string) {
+  async rotateKeychainPass (oldPass: string, newPass: string): Promise<void> {
     if (typeof oldPass !== 'string') {
       await randomDelay()
-      throw errCode(new Error(`Invalid old pass type '${typeof oldPass}'`), codes.ERR_INVALID_OLD_PASS_TYPE)
+      throw new CodeError(`Invalid old pass type '${typeof oldPass}'`, codes.ERR_INVALID_OLD_PASS_TYPE)
     }
     if (typeof newPass !== 'string') {
       await randomDelay()
-      throw errCode(new Error(`Invalid new pass type '${typeof newPass}'`), codes.ERR_INVALID_NEW_PASS_TYPE)
+      throw new CodeError(`Invalid new pass type '${typeof newPass}'`, codes.ERR_INVALID_NEW_PASS_TYPE)
     }
     if (newPass.length < 20) {
       await randomDelay()
-      throw errCode(new Error(`Invalid pass length ${newPass.length}`), codes.ERR_INVALID_PASS_LENGTH)
+      throw new CodeError(`Invalid pass length ${newPass.length}`, codes.ERR_INVALID_PASS_LENGTH)
     }
     log('recreating keychain')
     const cached = privates.get(this)
 
     if (cached == null) {
-      throw errCode(new Error('dek missing'), codes.ERR_INVALID_PARAMETERS)
+      throw new CodeError('dek missing', codes.ERR_INVALID_PARAMETERS)
     }
 
     const oldDek = cached.dek

package/src/util.ts

@@ -8,7 +8,7 @@
  * @param {Array} array
  * @param {function(*)} asyncCompare - An async function that returns a boolean
  */
-export async function findAsync <T> (array: T[], asyncCompare: (val: T) => Promise<any>) {
+export async function findAsync <T> (array: T[], asyncCompare: (val: T) => Promise<any>): Promise<T | undefined> {
   const promises = array.map(asyncCompare)
   const results = await Promise.all(promises)
   const index = results.findIndex(result => result)