@libp2p/config 0.0.0

package/README.md

@@ -0,0 +1,79 @@
+# @libp2p/config
+
+[![libp2p.io](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/)
+[![Discuss](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg?style=flat-square)](https://discuss.libp2p.io)
+[![codecov](https://img.shields.io/codecov/c/github/libp2p/js-libp2p.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p)
+[![CI](https://img.shields.io/github/actions/workflow/status/libp2p/js-libp2p/main.yml?branch=main\&style=flat-square)](https://github.com/libp2p/js-libp2p/actions/workflows/main.yml?query=branch%3Amain)
+
+> Helper functions to make dealing with libp2p config easier
+
+# About
+
+<!--
+
+!IMPORTANT!
+
+Everything in this README between "# About" and "# Install" is automatically
+generated and will be overwritten the next time the doc generator is run.
+
+To make changes to this section, please update the @packageDocumentation section
+of src/index.js or src/index.ts
+
+To experiment with formatting, please run "npm run docs" from the root of this
+repo and examine the changes made.
+
+-->
+
+## Example - Load or create the "self" private key in a datastore
+
+Most nodes will want to persist the same private key between restarts so this
+function helps you extract one from a datastore if it exists, otherwise it
+will create a new one and save it in the keystore.
+
+The options you pass to this function should be the same as those passed to
+the `@libp2p/keychain` service you configure your node with.
+
+```ts
+import { loadOrCreateSelfKey } from '@libp2p/config'
+import { keychain } from '@libp2p/keychain'
+import { LevelDatastore } from 'datastore-level'
+import { createLibp2p } from 'libp2p'
+
+const datastore = new LevelDatastore('/path/to/db')
+await datastore.open()
+
+const keychainInit = {
+ pass: 'yes-yes-very-secure'
+}
+
+const privateKey = await loadOrCreateSelfKey(datastore, keychainInit)
+
+const node = await createLibp2p({
+  privateKey,
+  services: {
+    datastore,
+    keychain: keychain(keychainInit)
+  }
+})
+```
+
+# Install
+
+```console
+$ npm i @libp2p/config
+```
+
+# API Docs
+
+- <https://libp2p.github.io/js-libp2p/modules/_libp2p_config.html>
+
+# License
+
+Licensed under either of
+
+- Apache 2.0, ([LICENSE-APACHE](https://github.com/libp2p/js-libp2p/blob/main/packages/config/LICENSE-APACHE) / <http://www.apache.org/licenses/LICENSE-2.0>)
+- MIT ([LICENSE-MIT](https://github.com/libp2p/js-libp2p/blob/main/packages/config/LICENSE-MIT) / <http://opensource.org/licenses/MIT>)
+
+# Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

package/dist/src/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation
+ *
+ * @example Load or create a private key in a datastore
+ *
+ * Most nodes will want to persist the same private key between restarts so this
+ * function helps you extract one from a datastore if it exists, otherwise it
+ * will create a new one and save it in the keystore.
+ *
+ * The options you pass to this function should be the same as those passed to
+ * the `@libp2p/keychain` service you configure your node with.
+ *
+ * ```ts
+ * import { loadOrCreateSelfKey } from '@libp2p/config'
+ * import { keychain } from '@libp2p/keychain'
+ * import { LevelDatastore } from 'datastore-level'
+ * import { createLibp2p } from 'libp2p'
+ *
+ * const datastore = new LevelDatastore('/path/to/db')
+ * await datastore.open()
+ *
+ * const keychainInit = {
+ *  pass: 'yes-yes-very-secure'
+ * }
+ *
+ * const privateKey = await loadOrCreateSelfKey(datastore, keychainInit)
+ *
+ * const node = await createLibp2p({
+ *   privateKey,
+ *   services: {
+ *     datastore,
+ *     keychain: keychain(keychainInit)
+ *   }
+ * })
+ * ```
+ */
+export { loadOrCreateSelfKey } from './load-private-key.js';
+export type { LoadOrCreateSelfKeyOptions } from './load-private-key.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAC3D,YAAY,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,38 @@
+/**
+ * @packageDocumentation
+ *
+ * @example Load or create a private key in a datastore
+ *
+ * Most nodes will want to persist the same private key between restarts so this
+ * function helps you extract one from a datastore if it exists, otherwise it
+ * will create a new one and save it in the keystore.
+ *
+ * The options you pass to this function should be the same as those passed to
+ * the `@libp2p/keychain` service you configure your node with.
+ *
+ * ```ts
+ * import { loadOrCreateSelfKey } from '@libp2p/config'
+ * import { keychain } from '@libp2p/keychain'
+ * import { LevelDatastore } from 'datastore-level'
+ * import { createLibp2p } from 'libp2p'
+ *
+ * const datastore = new LevelDatastore('/path/to/db')
+ * await datastore.open()
+ *
+ * const keychainInit = {
+ *  pass: 'yes-yes-very-secure'
+ * }
+ *
+ * const privateKey = await loadOrCreateSelfKey(datastore, keychainInit)
+ *
+ * const node = await createLibp2p({
+ *   privateKey,
+ *   services: {
+ *     datastore,
+ *     keychain: keychain(keychainInit)
+ *   }
+ * })
+ * ```
+ */
+export { loadOrCreateSelfKey } from './load-private-key.js';
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/src/load-private-key.d.ts

@@ -0,0 +1,13 @@
+import type { PrivateKey, KeyType } from '@libp2p/interface';
+import type { KeychainInit } from '@libp2p/keychain';
+import type { Datastore } from 'interface-datastore';
+export interface LoadOrCreateSelfKeyOptions extends KeychainInit {
+    /**
+     * If no private key is found in the datastore, create one with this type
+     *
+     * @default 'Ed25519'
+     */
+    keyType?: KeyType;
+}
+export declare function loadOrCreateSelfKey(datastore: Datastore, init?: LoadOrCreateSelfKeyOptions): Promise<PrivateKey>;
+//# sourceMappingURL=load-private-key.d.ts.map

package/dist/src/load-private-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-private-key.d.ts","sourceRoot":"","sources":["../../src/load-private-key.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEpD,MAAM,WAAW,0BAA2B,SAAQ,YAAY;IAC9D;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAsB,mBAAmB,CAAE,SAAS,EAAE,SAAS,EAAE,IAAI,GAAE,0BAA+B,GAAG,OAAO,CAAC,UAAU,CAAC,CAmB3H"}

package/dist/src/load-private-key.js

@@ -0,0 +1,22 @@
+import { generateKeyPair } from '@libp2p/crypto/keys';
+import { keychain } from '@libp2p/keychain';
+import { defaultLogger } from '@libp2p/logger';
+import { Key } from 'interface-datastore';
+export async function loadOrCreateSelfKey(datastore, init = {}) {
+    const chain = keychain(init)({
+        datastore,
+        logger: defaultLogger()
+    });
+    const selfKey = new Key('/pkcs8/self');
+    let privateKey;
+    if (await datastore.has(selfKey)) {
+        privateKey = await chain.exportKey('self');
+    }
+    else {
+        privateKey = await generateKeyPair(init.keyType ?? 'Ed25519');
+        // persist the peer id in the keychain for next time
+        await chain.importKey('self', privateKey);
+    }
+    return privateKey;
+}
+//# sourceMappingURL=load-private-key.js.map

package/dist/src/load-private-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-private-key.js","sourceRoot":"","sources":["../../src/load-private-key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AAczC,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAE,SAAoB,EAAE,OAAmC,EAAE;IACpG,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC3B,SAAS;QACT,MAAM,EAAE,aAAa,EAAE;KACxB,CAAC,CAAA;IAEF,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,CAAA;IACtC,IAAI,UAAU,CAAA;IAEd,IAAI,MAAM,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;QACjC,UAAU,GAAG,MAAM,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;IAC5C,CAAC;SAAM,CAAC;QACN,UAAU,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,OAAO,IAAI,SAAS,CAAC,CAAA;QAE7D,oDAAoD;QACpD,MAAM,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IAC3C,CAAC;IAED,OAAO,UAAU,CAAA;AACnB,CAAC"}

package/dist/typedoc-urls.json

@@ -0,0 +1,4 @@
+{
+  "LoadOrCreateSelfKeyOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_config.LoadOrCreateSelfKeyOptions.html",
+  "loadOrCreateSelfKey": "https://libp2p.github.io/js-libp2p/functions/_libp2p_config.loadOrCreateSelfKey.html"
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@libp2p/config",
+  "version": "0.0.0",
+  "description": "Helper functions to make dealing with libp2p config easier",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/config#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/js-libp2p.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "!dist/test",
+    "!**/*.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "project": true,
+      "sourceType": "module"
+    }
+  },
+  "scripts": {
+    "build": "aegir build --bundle false",
+    "test": "aegir test -t node",
+    "clean": "aegir clean",
+    "lint": "aegir lint",
+    "test:node": "aegir test -t node --cov",
+    "dep-check": "aegir dep-check",
+    "doc-check": "aegir doc-check"
+  },
+  "dependencies": {
+    "@libp2p/crypto": "^5.0.7",
+    "@libp2p/interface": "^2.3.0",
+    "@libp2p/keychain": "^5.0.10",
+    "@libp2p/logger": "^5.1.4",
+    "interface-datastore": "^8.3.1"
+  },
+  "devDependencies": {
+    "aegir": "^45.0.5",
+    "datastore-core": "^10.0.2"
+  },
+  "sideEffects": false
+}

package/src/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation
+ *
+ * @example Load or create the "self" private key in a datastore
+ *
+ * Most nodes will want to persist the same private key between restarts so this
+ * function helps you extract one from a datastore if it exists, otherwise it
+ * will create a new one and save it in the keystore.
+ *
+ * The options you pass to this function should be the same as those passed to
+ * the `@libp2p/keychain` service you configure your node with.
+ *
+ * ```ts
+ * import { loadOrCreateSelfKey } from '@libp2p/config'
+ * import { keychain } from '@libp2p/keychain'
+ * import { LevelDatastore } from 'datastore-level'
+ * import { createLibp2p } from 'libp2p'
+ *
+ * const datastore = new LevelDatastore('/path/to/db')
+ * await datastore.open()
+ *
+ * const keychainInit = {
+ *  pass: 'yes-yes-very-secure'
+ * }
+ *
+ * const privateKey = await loadOrCreateSelfKey(datastore, keychainInit)
+ *
+ * const node = await createLibp2p({
+ *   privateKey,
+ *   services: {
+ *     datastore,
+ *     keychain: keychain(keychainInit)
+ *   }
+ * })
+ * ```
+ */
+
+export { loadOrCreateSelfKey } from './load-private-key.js'
+export type { LoadOrCreateSelfKeyOptions } from './load-private-key.js'

package/src/load-private-key.ts

@@ -0,0 +1,37 @@
+import { generateKeyPair } from '@libp2p/crypto/keys'
+import { keychain } from '@libp2p/keychain'
+import { defaultLogger } from '@libp2p/logger'
+import { Key } from 'interface-datastore'
+import type { PrivateKey, KeyType } from '@libp2p/interface'
+import type { KeychainInit } from '@libp2p/keychain'
+import type { Datastore } from 'interface-datastore'
+
+export interface LoadOrCreateSelfKeyOptions extends KeychainInit {
+  /**
+   * If no private key is found in the datastore, create one with this type
+   *
+   * @default 'Ed25519'
+   */
+  keyType?: KeyType
+}
+
+export async function loadOrCreateSelfKey (datastore: Datastore, init: LoadOrCreateSelfKeyOptions = {}): Promise<PrivateKey> {
+  const chain = keychain(init)({
+    datastore,
+    logger: defaultLogger()
+  })
+
+  const selfKey = new Key('/pkcs8/self')
+  let privateKey
+
+  if (await datastore.has(selfKey)) {
+    privateKey = await chain.exportKey('self')
+  } else {
+    privateKey = await generateKeyPair(init.keyType ?? 'Ed25519')
+
+    // persist the peer id in the keychain for next time
+    await chain.importKey('self', privateKey)
+  }
+
+  return privateKey
+}