Unexpected 68-byte Private Key Length Leads to privateKey not set Error & DHT Issues

[francescoguarino]

I'm encountering an issue where my Ed25519 private keys, when loaded from storage, are appearing as 68 bytes long instead of the expected 64 bytes (or 32 bytes for a seed). This subsequently leads to a privateKey not set error when the Identify service initializes, preventing my libp2p node and its Kademlia DHT from functioning correctly.

My primary goal is to establish a stable peer-to-peer network with a fully operational Kademlia DHT. This network is intended to support a blockchain application, so robust peer discovery and connectivity are crucial.

Context:
I'm using js-libp2p with the standard modules for TCP transport, Noise encryption, Mplex stream multiplexing, Bootstrap peer discovery, and kad-dht.
I have logic to create an Ed25519 PeerId or load it from persistent storage (a JSON file).
When a new PeerId is generated using @libp2p/peer-id-factory (createEd25519PeerId), its privateKey property (a Uint8Array) is correctly 64 bytes long.
This 64-byte key is then base64 encoded and saved.
Upon subsequent startups, the base64 string is loaded, decoded back into a Buffer, and this buffer is where I'm observing the 68-byte length.

// PeerId
import { createEd25519PeerId as createNewPeerId, createFromPrivKey } from '@libp2p/peer-id-factory'

import { unmarshalPrivateKey } from '@libp2p/crypto/keys'

import { createLibp2p } from 'libp2p'
import { tcp } from '@libp2p/tcp'
import { noise } from '@libp2p/noise'
import { mplex } from '@libp2p/mplex'
import { bootstrap } from '@libp2p/bootstrap'
import { pipe } from 'it-pipe'
import { multiaddr } from '@multiformats/multiaddr'
import { kadDHT } from '@libp2p/kad-dht'
import { identify } from '@libp2p/identify'

import { HelloProtocol } from './protocols/Hello.js'

import { fromString as uint8ArrayFromString, toString as uint8ArrayToString } from 'uint8arrays'
import { EventEmitter } from 'events'
import { peerIdFromString } from '@libp2p/peer-id';

//Utils
import { Logger } from '../utils/logger.js'
import { NodeStorage } from '../utils/NodeStorage.js'


const DEFAULTBOOTSTRAP_NODES = [' MY_BOOTSTRAP_NODE_ADDR'];

export class NetworkManager extends EventEmitter {
    constructor(config = {}) {
        super(),
            this.logger = new Logger('Manager-Network-Light');
        this.storage = new NodeStorage(config); // Richiede l'importazione di NodeStorage
        this.config = {
            port: 6001,
            bootstrapNodes: DEFAULTBOOTSTRAP_NODES,
            ...config
        }
        this.peers = new Set();
        this.stats = {
            peers: 0,
            messageSent: 0,
            messageReceived: 0,
        }
    }


    ma = multiaddr(' MY_BOOTSTRAP_NODE_ADDR');

    async loadOrCreatePeerId() {
        try {
            const nodeInfo = await this.storage.loadNodeInfo();

            if (nodeInfo && nodeInfo.peerId && typeof nodeInfo.peerId === 'object' && nodeInfo.peerId.privateKey) {
                this.logger.info('Trovato PeerId salvato in storage, tentativo di riutilizzo...');
                const privKeyStr = nodeInfo.peerId.privateKey;
                const privKeyBuffer = Buffer.from(privKeyStr, 'base64');
                this.logger.info(`Lunghezza di privKeyBuffer (da base64 caricata dallo storage): ${privKeyBuffer.length}`);


                try {
                    const cryptoPrivKey = await unmarshalPrivateKey(privKeyBuffer);
                    const peerId = await createFromPrivKey(cryptoPrivKey);
                    this.logger.info(`PeerId creato con successo da chiave salvata (64 byte): ${peerId.toString()}`);


                    if (peerId.toString() !== nodeInfo.peerId.id) {
                        this.logger.warn(`L'ID del PeerId ricostruito (${peerId.toString()}) non corrisponde all'ID salvato (${nodeInfo.peerId.id}). Aggiorno l'ID nello storage.`);
                        nodeInfo.peerId.id = peerId.toString();

                    }
                    return peerId;
                } catch (importError) {
                    this.logger.error(`Errore importazione chiave privata (era ${privKeyBuffer.length} byte): ${importError.message}. Genero un nuovo PeerId.`);
                    return await this.createAndSaveNewPeerId(nodeInfo.nodeId);
                }
            } else {
                this.logger.info('Nessun PeerId completo trovato nello storage o formato non riconosciuto. Creazione di un nuovo PeerId.');
                return await this.createAndSaveNewPeerId(nodeInfo?.nodeId); // Passa nodeId se esiste
            }
        } catch (error) {
            this.logger.error(`Errore generale in loadOrCreatePeerId: ${error.message}. Creazione di un nuovo PeerId.`);
            const existingInfo = await this.storage.loadNodeInfo().catch(() => null);
            return await this.createAndSaveNewPeerId(existingInfo?.nodeId);
        }
    }

    async createAndSaveNewPeerId(existingNodeId) {
        this.logger.info('Creazione e salvataggio di un nuovo PeerId corretto...');
        const newPeerId = await createNewPeerId(); // Crea Ed25519

      

        const peerIdDataToSave = {
            id: newPeerId.toString(),
            privateKey: Buffer.from(newPeerId.privateKey).toString('base64'),
            publicKey: Buffer.from(newPeerId.publicKey).toString('base64')
        };

        
        let existingNodeInfo = await this.storage.loadNodeInfo().catch(() => ({}));
        if (existingNodeId && !existingNodeInfo.nodeId) {
            existingNodeInfo.nodeId = existingNodeId;
        } else if (!existingNodeInfo.nodeId) {
            existingNodeInfo.nodeId = newPeerId.toString(); 
        }

        const newNodeInfoToPersist = {
            ...existingNodeInfo, 
            nodeId: existingNodeInfo.nodeId, 
            peerId: peerIdDataToSave     
        };

        await this.storage.saveNodeInfo(newNodeInfoToPersist);
        this.logger.info(`Nuovo PeerId ${newPeerId.toString()} (chiave 64 byte) salvato in node-info.json.`);
        return newPeerId;
    }



    setupHandlers() {


       
        this.node.addEventListener('peer:discovery', async evt => {
            const peerIdStr = evt.detail.id.toString()
            const addrs = evt.detail.multiaddrs 

            for (const ma of addrs) {
                this.logger.info(`Scoperto peer ${peerIdStr} su ${ma.toString()}: provo a connettermi…`)
                try {
                    // <-- dial con Multiaddr valido
                    await this.node.dial(ma)
                    this.logger.info(`Dial riuscito su ${ma.toString()}`)
                    break
                } catch (err) {
                    this.logger.warn(`Dial fallito su ${ma.toString()}: ${err.message}`)
                }
            }
        })


        this.node.addEventListener('peer:connect', async evt => {
            const peerIdStr = evt.detail.toString()
            const peerIdObj = peerIdFromString(peerIdStr)
            this.logger.info(`Connessione stabilita con ${peerIdStr}`)

            try {
                const stream = await this.node.dialProtocol(peerIdObj, '/MYAPP/hello/1.0.0')

                // invio
                await pipe(
                    [uint8ArrayFromString('Ciao dal Client!')],
                    stream.sink
                )
                this.logger.info('Messaggio inviato, in attesa di risposta…')

                // ricezione e decoding
                for await (const packet of stream.source) {
                    const chunk =
                        packet instanceof Uint8Array
                            ? packet
                            : packet && packet.data instanceof Uint8Array
                                ? packet.data
                                : packet && typeof packet.subarray === 'function'
                                    ? packet.subarray()
                                    : null

                    if (!chunk) {
                        this.logger.warn(`Skipping invalid packet: ${packet}`)
                        continue
                    }

                    const incoming = uint8ArrayToString(chunk)
                    this.logger.info(`Ricevuto risposta: ${incoming}`)
                    break
                }




            } catch (err) {
                this.logger.error(`Errore nello stream con ${peerIdStr}: ${err.message}`)
            }
        })



        this.node.addEventListener('peer:disconnect', async (evt) => {
            const peer = evt.detail.toString();
            this.logger.info(`Peer disconnesso: ${peer}`);
        }
        );

    }

    async stop() {
        try {
            this.logger.info('Arresto del NetworkManager...');
            await this.node.stop();
            this, this.peers.clear();
            this.stats = {
                peers: 0,
                messageSent: 0,
                messageReceived: 0,
                enrollmentChannel: "auto",

            }
            this.logger.info('NetworkManager arrestato con successo');
        } catch (error) {
            this.logger.error('Errore durante l\'arresto del NetworkManager:', error);
            throw error;
        }
    }

    async start() {
        try {
            this.logger.info('AVVIO DEL NETWORK MANAGER LIGHT...');

            let nodeInfo = await this.storage.loadNodeInfo();

            if (nodeInfo && nodeInfo.nodeId) {
                this.logger.info(`Caricate informazioni del nodo esistenti.....`);
                this.nodeId = nodeInfo.nodeId;


                if (nodeInfo.peerId) {
                    this.logger.info('PeerId trovato nelle informazioni salvate');
                    this.peerId = await this.loadOrCreatePeerId();

                }
            } else {
                this.logger.info('Nessuna informazione di storage trovata');
                this.peerId = await this.loadOrCreatePeerId();
            }


            this.node = await createLibp2p({
                peerId: this.peerId,
                addresses: {
                    listen: [`/ip4/0.0.0.0/tcp/${this.config.port}`]
                },
                transports: [
                    tcp(),
                    // webSockets(), da implementare
                    // webRTC(), da implementare 
                ],
                connectionEncryption: [
                    noise()
                ],
                streamMuxers: [
                    mplex()
                ],
                peerDiscovery: [
                    bootstrap({
                        interval: 20000,
                        enabled: true,
                        list: this.config.bootstrapNodes
                    })
                ],
                protocols: [
                    HelloProtocol()
                ],
                services: {
                     identify: identify(),
                    dht: kadDHT({
                        clientMode: false,
                        maxInboundStreams: 32,
                        maxOutboundStreams: 64,
                        // Abilita esplicitamente la modalità server DHT
                        kBucketSize: 20,
                        randomWalk: { enabled: true, interval: 30_000, timeout: 10_000 },
                        protocolPrefix: '/MYAPP/dht/1.0.0',
                        allowQueryWithZeroPeers: true,
                    })
                }

            })

            this.setupHandlers();
            await this.node.start();
            this.setupDHTMonitoring()
            await this.node.services.dht.start()


            setTimeout(() => {
                this.logger.info('Connessione ai peer della routing table...');
                this.connectToRoutingTablePeers();
            }, 60000);






            return true
        } catch (error) {
            this.logger.error("Errore durante l'avvio del NetworkManager:", error);
            throw error;

        }


    }


    setupDHTMonitoring() {
        const rt = this.node.services.dht.routingTable;


        if (!rt) {
            this.logger.error('Routing table non disponibile')
            return
        }

        // Log iniziale dello stato
        this.logRoutingTableStatus()

        // Gestione eventi della routing table
        rt.addEventListener('peer:added', (evt) => {
            const peerId = evt.detail.toString()
            this.logger.info(`📥 Peer aggiunto alla routing table: ${peerId}`)
            this.logRoutingTableStatus()

            // Verifica connessione attiva
            this.node.getConnections(peerId).then(connections => {
                if (connections.length === 0) {
                    this.logger.warn(`Peer ${peerId} in routing table ma nessuna connessione attiva`)
                }
            })
        })

        rt.addEventListener('peer:removed', (evt) => {
            const peerId = evt.detail.toString()
            this.logger.info(`📤 Peer rimosso dalla routing table: ${peerId}`)
            this.logRoutingTableStatus()
        })

        // Monitoraggio periodico
        this.dhtInterval = setInterval(() => {
            this.logRoutingTableStatus()
        }, 6000)
    }

    async logRoutingTableStatus() {
        const dht = this.node.services.dht;
        if (!dht) {
            this.logger.warn("⚠️ DHT non disponibile.");
            return;
        }

        try {
            const peersFromDHT = [];
            // Nota: dht.getClosestPeers() potrebbe restituire eventi di query, non solo PeerId diretti.
            for await (const itemFromDHT of dht.getClosestPeers(this.node.peerId.toBytes())) {
                peersFromDHT.push(itemFromDHT);
            }

            this.logger.info(`📡 Routing Table - Peers/Events processati: ${peersFromDHT.length}`);

            peersFromDHT.forEach((currentPeerObject, index) => {
                const peerIndex = index + 1;
                this.logger.info(`--- Debugging Peer/Event [${peerIndex}] ---`);

                if (currentPeerObject === null || currentPeerObject === undefined) {
                    this.logger.info(`DEBUG [${peerIndex}]: currentPeerObject is null or undefined.`);
                    this.logger.info(`--- End Debugging Peer/Event [${peerIndex}] ---`);
                    return; // Salta il resto per questo item
                }

                this.logger.info(`DEBUG [${peerIndex}]: typeof currentPeerObject = ${typeof currentPeerObject}`);
                this.logger.info(`DEBUG [${peerIndex}]: currentPeerObject.constructor.name = ${currentPeerObject.constructor ? currentPeerObject.constructor.name : 'N/A'}`);
                this.logger.info(`DEBUG [${peerIndex}]: Object.keys(currentPeerObject) = ${Object.keys(currentPeerObject).join(', ')}`);

                const isLibp2pPeerId = !!currentPeerObject[Symbol.for('peer-id')];
                this.logger.info(`DEBUG [${peerIndex}]: Is it a libp2p PeerId (Symbol check)? ${isLibp2pPeerId}`);

                try {
                    this.logger.info(`DEBUG [${peerIndex}]: JSON.stringify(currentPeerObject) = ${JSON.stringify(currentPeerObject)}`);
                } catch (e) {
                    this.logger.warn(`DEBUG [${peerIndex}]: JSON.stringify failed: ${e.message}`);
                }

                let successfullyLoggedPeerId = false;
                let extractedPeerId = null;

                // Strategia 1: Estrarre il PeerId basandosi sul campo 'name' (tipo di evento)
                if (typeof currentPeerObject.name === 'string') {
                    const eventName = currentPeerObject.name;
                    switch (eventName) {
                        case 'DIAL_PEER':
                            if (typeof currentPeerObject.peer === 'string') {
                                extractedPeerId = currentPeerObject.peer;
                                this.logger.info(`   [${peerIndex}] PeerId (da DIAL_PEER event '.peer'): ${extractedPeerId}`);
                                successfullyLoggedPeerId = true;
                            } else {
                                this.logger.warn(`   [${peerIndex}] Evento DIAL_PEER, ma la proprietà '.peer' non è una stringa o è mancante. Valore: ${currentPeerObject.peer}`);
                            }
                            break;
                        case 'SEND_QUERY':
                            if (typeof currentPeerObject.to === 'string') {
                                extractedPeerId = currentPeerObject.to;
                                this.logger.info(`   [${peerIndex}] PeerId (da SEND_QUERY event '.to'): ${extractedPeerId}`);
                                successfullyLoggedPeerId = true;
                            } else {
                                this.logger.warn(`   [${peerIndex}] Evento SEND_QUERY, ma la proprietà '.to' non è una stringa o è mancante. Valore: ${currentPeerObject.to}`);
                            }
                            break;
                        case 'FINAL_PEER':
                            if (currentPeerObject.peer) {
                                if (typeof currentPeerObject.peer.id === 'string') {
                                    extractedPeerId = currentPeerObject.peer.id;
                                    this.logger.info(`   [${peerIndex}] PeerId (da FINAL_PEER event '.peer.id'): ${extractedPeerId}`);
                                    successfullyLoggedPeerId = true;
                                } else if (typeof currentPeerObject.peer.toString === 'function') {
                                    // Nel caso .peer sia esso stesso un oggetto PeerId con un .toString() valido
                                    const peerObjToString = currentPeerObject.peer.toString();
                                    if (peerObjToString !== '[object Object]' && peerObjToString.startsWith('12D3KooW')) { // Verifica euristica per PeerId
                                        this.logger.info(`   [${peerIndex}] PeerId (da FINAL_PEER event '.peer.toString()'): ${peerObjToString}`);
                                        extractedPeerId = peerObjToString;
                                        successfullyLoggedPeerId = true;
                                    } else {
                                        this.logger.warn(`   [${peerIndex}] Evento FINAL_PEER: '.peer.toString()' ha restituito '${peerObjToString}' o '.peer.id' non è una stringa. Oggetto '.peer': ${JSON.stringify(currentPeerObject.peer)}`);
                                    }
                                } else {
                                    this.logger.warn(`   [${peerIndex}] Evento FINAL_PEER, ma '.peer.id' non è una stringa o '.peer' non ha un .toString() adeguato. Oggetto '.peer': ${JSON.stringify(currentPeerObject.peer)}`);
                                }
                            } else {
                                this.logger.warn(`   [${peerIndex}] Evento FINAL_PEER, ma la proprietà '.peer' è mancante.`);
                            }
                            break;
                        default:
                            this.logger.info(`   [${peerIndex}] Nome evento '${eventName}' non gestito specificamente. Tentativo di estrazione generica del PeerId.`);
                    }
                }

                // Strategia 2: Estrazione generica di fallback se non trovato tramite tipo di evento o se 'name' non è presente
                if (!successfullyLoggedPeerId) {
                    this.logger.info(`   [${peerIndex}] Tentativo di estrazione generica del PeerId...`);
                    if (currentPeerObject.peer && typeof currentPeerObject.peer.id === 'string' && currentPeerObject.peer.id.startsWith('12D3KooW')) { // Es. Peer 3
                        extractedPeerId = currentPeerObject.peer.id;
                        this.logger.info(`   [${peerIndex}] PeerId Generico (da '.peer.id'): ${extractedPeerId}`);
                        successfullyLoggedPeerId = true;
                    } else if (typeof currentPeerObject.peer === 'string' && currentPeerObject.peer.startsWith('12D3KooW')) { // Es. Peer 1
                        extractedPeerId = currentPeerObject.peer;
                        this.logger.info(`   [${peerIndex}] PeerId Generico (da '.peer'): ${extractedPeerId}`);
                        successfullyLoggedPeerId = true;
                    } else if (typeof currentPeerObject.to === 'string' && currentPeerObject.to.startsWith('12D3KooW')) { // Es. Peer 2
                        extractedPeerId = currentPeerObject.to;
                        this.logger.info(`   [${peerIndex}] PeerId Generico (da '.to'): ${extractedPeerId}`);
                        successfullyLoggedPeerId = true;
                    } else if (typeof currentPeerObject.id === 'string' && currentPeerObject.id.startsWith('12D3KooW')) { // Caso generico { id: "PeerId" }
                        extractedPeerId = currentPeerObject.id;
                        this.logger.info(`   [${peerIndex}] PeerId Generico (da '.id'): ${extractedPeerId}`);
                        successfullyLoggedPeerId = true;
                    } else if (typeof currentPeerObject.from === 'string' && currentPeerObject.from.startsWith('12D3KooW')) { // Proprietà 'from'
                        // 'from' potrebbe essere un PeerId, ma spesso indica l'origine dell'informazione.
                        // Lo logghiamo se nient'altro è stato trovato.
                        extractedPeerId = currentPeerObject.from;
                        this.logger.info(`   [${peerIndex}] Trovato potenziale PeerId in '.from' (spesso è la sorgente): ${extractedPeerId}`);
                        successfullyLoggedPeerId = true;
                    }
                }

                // Strategia 3: Fallback finale al .toString() dell'oggetto se nessun PeerId specifico è stato estratto
                if (!successfullyLoggedPeerId) {
                    if (currentPeerObject && typeof currentPeerObject.toString === 'function') {
                        const peerString = currentPeerObject.toString();
                        this.logger.info(`   [${peerIndex}] PeerId (fallback via .toString()): ${peerString}`);
                        if (peerString === '[object Object]') {
                            this.logger.warn(`   WARN [${peerIndex}]: .toString() ha restituito '[object Object]' e nessun campo PeerId specifico è stato trovato. L'oggetto completo è stato loggato precedentemente con JSON.stringify.`);
                        }
                    } else {
                        this.logger.warn(`   [${peerIndex}] PeerId: .toString non è una funzione o l'oggetto è null/undefined. Raw: ${String(currentPeerObject)}`);
                    }
                }

                this.logger.info(`--- End Debugging Peer/Event [${peerIndex}] ---`);
            });

        } catch (error) {
            this.logger.error(`Errore durante l'accesso/processamento dei peer dalla DHT: ${error.message}`);
            if (error.stack) { // Controlla se stack è definito
                this.logger.error(error.stack);
            }
        }
    }


    async connectToRoutingTablePeers() {
        const dht = this.node.services.dht;
        if (!dht) {
            this.logger.warn("⚠️ DHT non disponibile.");
            return;
        }

        const routingTable = dht.routingTable;
        if (!routingTable) {
            this.logger.warn("⚠️ Routing table non disponibile.");
            return;
        }

        const peerIds = dht.getClosestPeers(this.node.peerId.toBytes());

        for await (const peerId of peerIds) {
            const peerIdStr = peerId.toString();
            try {
                const peerInfo = await this.node.peerStore.get(peerId);
                if (peerInfo.addresses.length === 0) {
                    this.logger.warn(`⚠️ Nessun indirizzo disponibile per ${peerIdStr} nel peerStore.`);
                    // Tentativo di recuperare gli indirizzi tramite la DHT
                    try {
                        const foundPeer = await dht.findPeer(peerId);
                        if (foundPeer && foundPeer.multiaddrs.length > 0) {
                            for (const addr of foundPeer.multiaddrs) {
                                try {
                                    await this.node.dial(addr);
                                    this.logger.info(`✅ Connesso a ${peerIdStr} su ${addr.toString()}`);
                                    break;
                                } catch (err) {
                                    this.logger.warn(`❌ Impossibile connettersi a ${peerIdStr} su ${addr.toString()}: ${err.message}`);
                                }
                            }
                        } else {
                            this.logger.warn(`⚠️ Nessun indirizzo trovato per ${peerIdStr} tramite la DHT.`);
                        }
                    } catch (err) {
                        this.logger.warn(`⚠️ Errore durante la ricerca di ${peerIdStr} nella DHT: ${err.message}`);
                    }
                } else {
                    for (const addr of peerInfo.addresses) {
                        try {
                            await this.node.dial(addr.multiaddr);
                            this.logger.info(`✅ Connesso a ${peerIdStr} su ${addr.multiaddr.toString()}`);
                            break;
                        } catch (err) {
                            this.logger.warn(`❌ Impossibile connettersi a ${peerIdStr} su ${addr.multiaddr.toString()}: ${err.message}`);
                        }
                    }
                }
            } catch (err) {
                this.logger.warn(`⚠️ Informazioni sugli indirizzi non disponibili per ${peerIdStr}: ${err.message}`);
            }
        }
    }




}

I have no clear ideas on how to correctly populate the DHT and how to make the nodes connect automatically to each other, this attachment is the code of the NetworkManager of my node (normal), which connects to a bootstrap node and subsequently tries to connect to other nodes to start the network, the code of my bootstraop node is almost similar, or rather the basic logic for the peerId are those,
I thank in advance anyone who can enlighten me a little more as I have not found many answers for those who intend to create their network from scratch via libp2p with its protocols and services.

[achingbrain]

I can't run your example code since it's missing several imports, but I notice you're using older APIs than the current release, and that you have a custom storage implementation that's loading/storing node info. I can't tell if it's doing it correctly as the implementation is missing.

Anyway here's how to correctly serialize and deserialize private keys, hopefully you can adapt it for your app:

import { generateKeyPair, privateKeyToProtobuf, privateKeyFromProtobuf } from '@libp2p/crypto/keys'
import { peerIdFromPrivateKey } from '@libp2p/peer-id'

// create a private key
const key = await generateKeyPair('Ed25519')

// derive the peer id from the private key
const peerId = peerIdFromPrivateKey(key)

console.info('derived peer id', peerId.toString())

// serialize the private key
const serialized = privateKeyToProtobuf(key)

console.info('serialized key length', serialized.byteLength)
// length is 68 (e.g. key type + private key + public key

// deserialize private key
const deserializedKey = privateKeyFromProtobuf(serialized)

// derive peer id from deserialized private key
const deserializedPeerId = peerIdFromPrivateKey(deserializedKey)

// should match initial peer id
console.info('deserialized peer id', deserializedPeerId.toString())

[achingbrain]

To store the private key encrypted at rest, you can use a datastore implementation and the helper from @libp2p/config.

For example if you run this code multiple times, you should see a datastore directory appear in the current dir and it should show the same peer id each time:

import { loadOrCreateSelfKey } from '@libp2p/config'
import { FsDatastore } from 'datastore-fs'
import { createLibp2p } from 'libp2p'

const datastore = new FsDatastore('./datastore')
await datastore.open()

const privateKey = await loadOrCreateSelfKey(datastore, {
  keyType: 'Ed25519',
  pass: 'very secure, very secret password'
})

const libp2p = await createLibp2p({
  privateKey,
  // ... other options here
})

console.info(libp2p.peerId.toString())