Merge pull request #67 from Permissionless-Software-Foundation/ct-unstable

Helia V5

bin/server.js

@@ -125,7 +125,9 @@ class Server {
       console.log('\nConfiguration:')
       console.log(`Circuit Relay: ${this.config.isCircuitRelay}`)
       console.log(`IPFS TCP port: ${this.config.ipfsTcpPort}`)
-      console.log(`IPFS WS port: ${this.config.ipfsWsPort}\n`)
+      console.log(`IPFS WS port: ${this.config.ipfsWsPort}`)
+      console.log(`IPFS WebRTC port: ${this.config.ipfsWebRtcPort}`)
+      console.log(`Connection preference: ${this.config.connectPref}\n`)
 
       return app
     } catch (err) {

config/env/common.js

@@ -131,6 +131,8 @@ export default {
   // IPFS Ports
   ipfsTcpPort: process.env.IPFS_TCP_PORT ? process.env.IPFS_TCP_PORT : 4101,
   ipfsWsPort: process.env.IPFS_WS_PORT ? process.env.IPFS_WS_PORT : 4103,
+  ipfsWebRtcPort: process.env.IPFS_WEB_RTC_PORT ? process.env.IPFS_WEB_RTC_PORT : 4105,
+  connectPref: process.env.CONNECT_PREF, // Used in helia-coord to select connection preference.
 
   // Settings for production, using external go-ipfs node.
   isProduction: process.env.SVC_ENV === 'prod' ? true : false,

config/system-user-dev.json

@@ -1,6 +1,6 @@
 {
-  "password": "jxR0kPRm6GI7RETZ36KW",
+  "password": "yKm2qMy2LkRNFJsCiD2B",
   "email": "system@system.com",
-  "id": "6796f3e8e473169ab68aa9b5",
-  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY3OTZmM2U4ZTQ3MzE2OWFiNjhhYTliNSIsImlhdCI6MTczNzk0NjA4OH0.q1Dy0WXO2E2Q5y2eNB2INq_YD3AnNirgX1vrk9KxkH0"
+  "id": "67bb5a07da0eb4a2e7fc7bde",
+  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjY3YmI1YTA3ZGEwZWI0YTJlN2ZjN2JkZSIsImlhdCI6MTc0MDMzMTUyN30.o-MDjJpoq2MNElzWQsrWjy-kL_wji2hxPrXLPomrw7I"
 }

index.js

@@ -1,4 +1,8 @@
 import Server from './bin/server.js'
 const server = new Server()
 
+process.on('unhandledRejection', (reason, promise) => {
+  console.log(`Handling ${reason.code} error. stack: `, reason)
+})
+
 server.startServer()

package.json

@@ -24,26 +24,28 @@
   },
   "repository": "Permissionless-Software-Foundation/ipfs-bch-wallet-consumer",
   "dependencies": {
-    "@chainsafe/libp2p-gossipsub": "13.1.1",
-    "@chainsafe/libp2p-noise": "15.1.1",
-    "@chainsafe/libp2p-yamux": "6.0.2",
-    "@helia/unixfs": "3.0.7",
-    "@libp2p/bootstrap": "10.1.5",
-    "@libp2p/circuit-relay-v2": "1.1.5",
-    "@libp2p/identify": "2.1.5",
-    "@libp2p/keychain": "4.1.5",
-    "@libp2p/logger": "4.0.20",
-    "@libp2p/tcp": "9.1.5",
-    "@libp2p/webrtc": "4.1.7",
-    "@libp2p/websockets": "8.2.0",
-    "@multiformats/multiaddr": "12.3.0",
+    "@chainsafe/libp2p-gossipsub": "14.1.0",
+    "@chainsafe/libp2p-noise": "16.0.1",
+    "@chainsafe/libp2p-yamux": "7.0.1",
+    "@helia/unixfs": "4.0.2",
+    "@libp2p/bootstrap": "11.0.26",
+    "@libp2p/circuit-relay-v2": "3.2.2",
+    "@libp2p/config": "1.1.0",
+    "@libp2p/identify": "3.0.22",
+    "@libp2p/keychain": "5.0.14",
+    "@libp2p/logger": "5.1.8",
+    "@libp2p/ping": "2.0.22",
+    "@libp2p/tcp": "10.1.2",
+    "@libp2p/webrtc": "5.2.2",
+    "@libp2p/websockets": "9.2.2",
+    "@multiformats/multiaddr": "12.3.5",
     "axios": "0.27.2",
     "bcryptjs": "2.4.3",
-    "blockstore-fs": "2.0.0",
-    "datastore-fs": "9.1.7",
+    "blockstore-fs": "2.0.2",
+    "datastore-fs": "10.0.2",
     "glob": "7.1.6",
-    "helia": "4.2.5",
-    "helia-coord": "1.5.15",
+    "helia": "5.2.1",
+    "helia-coord": "1.7.2",
     "jsonrpc-lite": "2.2.0",
     "jsonwebtoken": "8.5.1",
     "jwt-bch-lib": "1.3.0",
@@ -58,10 +60,10 @@
     "koa-router": "10.0.0",
     "koa-static": "5.0.0",
     "koa2-ratelimit": "0.9.1",
-    "libp2p": "1.9.1",
+    "libp2p": "2.7.2",
     "line-reader": "0.4.0",
     "mime-types": "2.1.35",
-    "minimal-slp-wallet": "5.12.0",
+    "minimal-slp-wallet": "5.13.2",
     "mongoose": "5.13.14",
     "node-fetch": "npm:@achingbrain/node-fetch@2.6.7",
     "nodemailer": "6.7.5",

production/docker/Dockerfile

@@ -66,9 +66,6 @@ RUN npm install
 # Generate the API docs
 RUN npm run docs
 
-# Expose the port the API will be served on.
-#EXPOSE 5010
-
 # Start the application.
 #COPY start-production.sh start-production.sh
 CMD ["./start-production.sh"]

production/docker/docker-compose.yml

@@ -26,9 +26,12 @@ services:
     links:
       - mongo-bch-consumer
     ports:
-      - '5015:5015' # <host port>:<container port>
-      - '4101:4101'
-      - '4103:4103'
+      # <host port>:<container port>
+      - '5015:5015' # REST API
+      - '4101:4101' # TCP
+      - '4103:4103' # Websockets
+      - '4105:4105' # WebRTC
+
     volumes:
       - ../data/ipfsdata:/home/safeuser/ipfs-bch-wallet-consumer/.ipfsdata
       - ./start-production.sh:/home/safeuser/ipfs-bch-wallet-consumer/start-production.sh

production/docker/start-production.sh

@@ -31,9 +31,15 @@ export IPFS_HOST=172.17.0.1
 export IPFS_API_PORT=5001
 export IPFS_TCP_PORT=4101
 export IPFS_WS_PORT=4103
+export IPFS_WEB_RTC_PORT=4105
 
 # Set the debug level for helia-coord. 0-3.
 # 0 = no debug logs. 3 = maximum debug logs.
 export DEBUG_LEVEL=0
 
+# Use this if the IPFS node has a publically accessible IP address.
+#export CONNECT_PREF=direct
+# Use this if the IPFS node is behind a NAT or Firewall and cannot be accessed directly.
+export CONNECT_PREF=cr
+
 npm start

src/adapters/ipfs/ipfs.js

@@ -19,17 +19,20 @@ import { noise } from '@chainsafe/libp2p-noise'
 import { yamux } from '@chainsafe/libp2p-yamux'
 // import { bootstrap } from '@libp2p/bootstrap'
 // import { identifyService } from 'libp2p/identify'
-import { identify } from '@libp2p/identify'
-// import { circuitRelayServer, circuitRelayTransport } from '@libp2p/circuit-relay-v2'
-import { circuitRelayServer } from '@libp2p/circuit-relay-v2'
+import { identify, identifyPush } from '@libp2p/identify'
+import { circuitRelayServer, circuitRelayTransport } from '@libp2p/circuit-relay-v2'
+// import { circuitRelayServer } from '@libp2p/circuit-relay-v2'
 import { gossipsub } from '@chainsafe/libp2p-gossipsub'
 import { webSockets } from '@libp2p/websockets'
 import { publicIpv4 } from 'public-ip'
 import { multiaddr } from '@multiformats/multiaddr'
-// import { webRTC } from '@libp2p/webrtc'
+import { webRTC, webRTCDirect } from '@libp2p/webrtc'
 import { keychain } from '@libp2p/keychain'
-import { defaultLogger } from '@libp2p/logger'
 import { unixfs } from '@helia/unixfs'
+// import { generateKeyPairFromSeed } from '@libp2p/crypto/keys'
+// import crypto from 'crypto'
+import { ping } from '@libp2p/ping'
+import { loadOrCreateSelfKey } from '@libp2p/config'
 
 // Local libraries
 import config from '../../../config/index.js'
@@ -64,8 +67,8 @@ class IpfsAdapter {
     this.createNode = this.createNode.bind(this)
     this.stop = this.stop.bind(this)
     this.ensureBlocksDir = this.ensureBlocksDir.bind(this)
+    // this.getPrivateKey = this.getPrivateKey.bind(this)
     this.getSeed = this.getSeed.bind(this)
-    this.getKeychain = this.getKeychain.bind(this)
   }
 
   // Start an IPFS node.
@@ -111,19 +114,6 @@ class IpfsAdapter {
     }
   }
 
-  async getKeychain (datastore) {
-    const keychainInit = {
-      pass: await this.getSeed()
-    }
-
-    const chain = this.keychain(keychainInit)({
-      datastore,
-      logger: defaultLogger()
-    })
-
-    return chain
-  }
-
   // This function creates an IPFS node using Helia.
   // It returns the node as an object.
   async createNode () {
@@ -132,44 +122,38 @@ class IpfsAdapter {
       const blockstore = new FsBlockstore(`${IPFS_DIR}/blockstore`)
       const datastore = new FsDatastore(`${IPFS_DIR}/datastore`)
 
-      // const keychainInit = {
-      //   pass: await this.getSeed()
-      // }
+      // Get the private key.
+      // const privateKey = await this.getPrivateKey()
+      // console.log('privateKey: ', privateKey)
 
       // Create an identity
-      let peerId
-      // console.log('this.keychain: ', this.keychain)
-      // const chain = this.keychain(keychainInit)({
-      //   datastore,
-      //   logger: defaultLogger()
-      // })
-      const chain = await this.getKeychain(datastore)
-      try {
-        peerId = await chain.exportPeerId('myKey')
-      } catch (err) {
-        await chain.createKey('myKey', 'Ed25519', 4096)
-        peerId = await chain.exportPeerId('myKey')
+      const keychainInit = {
+        selfKey: 'myKey',
+        pass: await this.getSeed()
       }
+      const privateKey = await loadOrCreateSelfKey(datastore, keychainInit)
 
       // Configure services
       const services = {
         identify: identify(),
-        pubsub: gossipsub({ allowPublishToZeroTopicPeers: true })
+        identifyPush: identifyPush(),
+        pubsub: gossipsub({ allowPublishToZeroTopicPeers: true }),
+        ping: ping(),
+        keychain: keychain(keychainInit)
       }
       if (this.config.isCircuitRelay) {
         console.log('Helia (IPFS) node IS configured as Circuit Relay')
         services.relay = circuitRelayServer({ // makes the node function as a relay server
           hopTimeout: 30 * 1000, // incoming relay requests must be resolved within this time limit
-          advertise: true,
           reservations: {
             maxReservations: 15, // how many peers are allowed to reserve relay slots on this server
             reservationClearInterval: 300 * 1000, // how often to reclaim stale reservations
             applyDefaultLimit: true, // whether to apply default data/duration limits to each relayed connection
             defaultDurationLimit: 2 * 60 * 1000, // the default maximum amount of time a relayed connection can be open for
-            defaultDataLimit: BigInt(2 << 7), // the default maximum number of bytes that can be transferred over a relayed connection
-            maxInboundHopStreams: 32, // how many inbound HOP streams are allow simultaneously
-            maxOutboundHopStreams: 64 // how many outbound HOP streams are allow simultaneously
-          }
+            defaultDataLimit: BigInt(2 << 7) // the default maximum number of bytes that can be transferred over a relayed connection
+          },
+          maxInboundHopStreams: 32, // how many inbound HOP streams are allow simultaneously
+          maxOutboundHopStreams: 64 // how many outbound HOP streams are allow simultaneously
         })
       } else {
         console.log('Helia (IPFS) node IS NOT configured as Circuit Relay')
@@ -177,28 +161,31 @@ class IpfsAdapter {
 
       const transports = [
         tcp(),
-        webSockets()
-        // circuitRelayTransport({
-        //   discoverRelays: 3,
-        //   reservationConcurrency: 3
-        // }),
-        // webRTC()
+        webSockets(),
+        circuitRelayTransport({
+          discoverRelays: 3,
+          reservationConcurrency: 3
+        }),
+        webRTC(),
+        webRTCDirect()
       ]
 
       // libp2p is the networking layer that underpins Helia
       const libp2p = await this.createLibp2p({
-        peerId,
+        // peerId,
+        privateKey,
         datastore,
         addresses: {
           listen: [
             '/ip4/127.0.0.1/tcp/0',
             `/ip4/0.0.0.0/tcp/${this.config.ipfsTcpPort}`,
-            `/ip4/0.0.0.0/tcp/${this.config.ipfsWsPort}/ws`
-            // '/webrtc'
+            `/ip4/0.0.0.0/tcp/${this.config.ipfsWsPort}/ws`,
+            '/webrtc',
+            '/p2p-circuit'
           ]
         },
         transports,
-        connectionEncryption: [
+        connectionEncrypters: [
           noise()
         ],
         streamMuxers: [
@@ -244,6 +231,8 @@ class IpfsAdapter {
 
       !this.fs.existsSync(`${IPFS_DIR}/datastore`) && this.fs.mkdirSync(`${IPFS_DIR}/datastore`)
 
+      !this.fs.existsSync(`${IPFS_DIR}/datastore/pkcs8`) && this.fs.mkdirSync(`${IPFS_DIR}/datastore/pkcs8`)
+
       // !fs.existsSync(`${IPFS_DIR}/datastore/peers`) && fs.mkdirSync(`${IPFS_DIR}/datastore/peers`)
 
       return true
@@ -280,6 +269,48 @@ class IpfsAdapter {
       throw err
     }
   }
+
+  // Get the private key from disk, or generate a new one and save it,
+  // if it doesn't exist.
+  // async getPrivateKey () {
+  //   try {
+  //     const filename = `${IPFS_DIR}/privkey.json`
+
+  //     let privKeyHex
+  //     try {
+  //       // Try to read the JSON file containing the seed.
+  //       privKeyHex = await this.jsonFiles.readJSON(filename)
+  //       // console.log('saved privKeyHex: ', privKeyHex)
+  //     } catch (err) {
+  //       // Generate a new private key and save it to disk.
+
+  //       // Generate a new private key and save it to disk.
+  //       const randomBuffer = crypto.randomBytes(32)
+  //       // console.log('randomBuffer: ', randomBuffer)
+
+  //       privKeyHex = randomBuffer.toString('hex')
+  //       // console.log('new privKeyHex: ', privKeyHex)
+
+  //       // Save the newly generated seed
+  //       await this.jsonFiles.writeJSON(privKeyHex, filename)
+  //     }
+
+  //     // Convert the saved hex string to a buffer.
+  //     const privKeyBuf = Buffer.from(privKeyHex, 'hex')
+
+  //     // Convert the buffer to a Uint8Array 'seed'
+  //     const seed = new Uint8Array(privKeyBuf.buffer, privKeyBuf.byteOffset, privKeyBuf.byteLength)
+  //     // console.log('seed: ', seed)
+
+  //     // Generate a ED25519 key pair.
+  //     const privKey = await generateKeyPairFromSeed('Ed25519', seed)
+
+  //     return privKey
+  //   } catch (err) {
+  //     console.error('Error in adapters/ipfs/ipfs.js/getPrivateKey(): ', err)
+  //     throw err
+  //   }
+  // }
 }
 
 export default IpfsAdapter

src/controllers/rest-api/ipfs/controller.js

@@ -39,6 +39,7 @@ class IpfsRESTControllerLib {
     this.getService = this.getService.bind(this)
     this.getFileInfo = this.getFileInfo.bind(this)
     this.getPins = this.getPins.bind(this)
+    this.cid2json = this.cid2json.bind(this)
   }
 
   /**
@@ -220,7 +221,7 @@ class IpfsRESTControllerLib {
       ctx.body = metadata
     } catch (err) {
       // wlogger.error('Error in ipfs/controller.js/viewFile(): ', err)
-      console.log('Error in ipfs/controller.js/getService(): ', err)
+      console.log('Error in ipfs/controller.js/getFileInfo(): ', err)
       this.handleError(ctx, err)
     }
   }
@@ -253,8 +254,37 @@ class IpfsRESTControllerLib {
     }
   }
 
+  /**
+   * @api {get} /ipfs/cid2json/:cid Given a CID, retrieve a JSON object
+   * @apiPermission public
+   * @apiName GetCid2Json
+   * @apiGroup REST IPFS
+   * @apiDescription Given a CID, retrieve a JSON object.
+   * If the CID does not resolves to a JSON file, then an error is thrown.
+   *
+   * @apiExample Example usage:
+   * curl -H "Content-Type: application/json" -X GET localhost:5015/ipfs/cid2json/bafkreigbgrvpagnmrqz2vhofifrqobigsxkdvnvikf5iqrkrbwrzirazhm
+   *
+   */
+  async cid2json (ctx) {
+    try {
+      const { cid } = ctx.params
+
+      const json = await this.useCases.ipfs.cid2json({ cid })
+
+      ctx.body = json
+    } catch (err) {
+      // wlogger.error('Error in ipfs/controller.js/viewFile(): ', err)
+      console.log('Error in ipfs/controller.js/cid2json(): ', err.message)
+      this.handleError(ctx, err)
+    }
+  }
+
   // DRY error handler
   handleError (ctx, err) {
+    // console.log('handleError() err.status: ', err.status)
+    // console.log('handleError() err.message: ', err.message)
+
     // If an HTTP status is specified by the buisiness logic, use that.
     if (err.status) {
       if (err.message) {
@@ -263,6 +293,7 @@ class IpfsRESTControllerLib {
         ctx.throw(err.status)
       }
     } else {
+      // console.log(`handleError() err.message: ${err.message}`)
       // By default use a 422 error if the HTTP status is not specified.
       ctx.throw(422, err.message)
     }

src/controllers/rest-api/ipfs/index.js

@@ -60,6 +60,7 @@ class IpfsRouter {
     this.router.get('/service', this.ipfsRESTController.getService)
     this.router.get('/file-info/:cid', this.ipfsRESTController.getFileInfo)
     this.router.get('/pins', this.ipfsRESTController.getPins)
+    this.router.get('/cid2json/:cid', this.ipfsRESTController.cid2json)
 
     // Attach the Controller routes to the Koa app.
     app.use(this.router.routes())

src/use-cases/ipfs-use-cases.js

@@ -33,6 +33,7 @@ class IpfsUseCases {
     this.downloadCid = this.downloadCid.bind(this)
     // this.downloadCid2 = this.downloadCid2.bind(this)
     this.getWritePrice = this.getWritePrice.bind(this)
+    this.cid2json = this.cid2json.bind(this)
 
     // State
     this.lastWritePriceUpdate = null // Used to periodically update write price.
@@ -151,6 +152,91 @@ class IpfsUseCases {
     }
   }
 
+  // Given a CID, this function will retrieve a JSON object from the
+  // ipfs-file-pin-service, using the IPFS JSON-RPC.
+  async cid2json (inObj = {}) {
+    try {
+      const { cid } = inObj
+      console.log('cid2json() cid: ', cid)
+
+      // Throw an error if ipfs-bch-wallet-consumer has not yet connected to an instance of ipfs-file-pin-service.
+      const ipfsFileProvider = this.adapters.ipfs.ipfsCoordAdapter.state.selectedIpfsFileProvider
+      if (!ipfsFileProvider) {
+        throw new Error('No IPFS File Provider Service is available yet. Try again in a few seconds.')
+      }
+
+      // Throw an error if ipfs-bch-wallet-consumer can not communicate with the ipfs-file-pin-service.
+      const ipfsFiles = this.adapters.ipfsFiles
+      const metadata = await ipfsFiles.getFileMetadata({ cid })
+      if (metadata.success === false) {
+        throw new Error(`Could not communicate with instance of ipfs-file-pin-service ${ipfsFileProvider}. Try again in a few seconds.`)
+      }
+
+      // Throw an error if the file is not pinned.
+      const fileMetadata = metadata.fileMetadata
+      if (!fileMetadata.dataPinned) {
+        throw new Error(`CID ${cid} has not been pinned by ipfs-file-pin-service instance ${ipfsFileProvider}`)
+      }
+      // console.log('fileMetadata: ', fileMetadata)
+
+      // Throw an error if this is not a JSON file
+      const filename = fileMetadata.filename
+      if (!filename.endsWith('.json')) {
+        throw new Error(`CID ${cid} does not resolve to a JSON file.`)
+      }
+      // Retrieve the CID content and store it in a Buffer.
+      const helia = this.adapters.ipfs.ipfs
+      const fileChunks = []
+
+      // list cid content. This is used to determine if the CID is a file or a directory.
+      const contentArray = []
+      for await (const file of helia.fs.ls(cid)) {
+        contentArray.push(file)
+      }
+      // console.log('contentArray: ', contentArray)
+
+      try {
+        // Handle CIDs that are files.
+        for await (const chunk of helia.fs.cat(cid)) {
+          fileChunks.push(chunk)
+        }
+      } catch (err) {
+        // Extra logic here to look at the filename of the first file and make sure
+        // it ends in .json.
+        const name = contentArray[0].name
+        if (!name.endsWith('.json')) {
+          throw new Error(`CID ${cid} is a directory and its first file does not resolve to a valid JSON file.`)
+        }
+
+        // Handle CIDs that are directorys containing a JSON file. (TokenTiger.com tokens)
+        for await (const chunk of helia.fs.cat(`${cid}/${name}`)) {
+          fileChunks.push(chunk)
+        }
+      }
+
+      const fileBuf = Buffer.concat(fileChunks)
+
+      // Convert the Buffer into a string.
+      const jsonStr = fileBuf.toString()
+
+      // Parse the string into a JSON object.
+      let json = null
+      try {
+        json = JSON.parse(jsonStr)
+      } catch (err) {
+        throw new Error(`CID ${cid} does not resolve to a valid JSON object.`)
+      }
+
+      return {
+        success: true,
+        json
+      }
+    } catch (err) {
+      console.error('Error in ipfs-use-cases.js/cid2json(): ', err.message)
+      throw err
+    }
+  }
+
   // async downloadCid2 (inObj = {}) {
   //   try {
   //     const { cid } = inObj

src/use-cases/usage-use-cases.js

@@ -113,7 +113,7 @@ function usageMiddleware () {
     try {
       await next()
 
-      console.log('ctx.request: ', ctx.request)
+      // console.log('ctx.request: ', ctx.request)
       const now = new Date()
 
       const reqObj = {
@@ -122,7 +122,7 @@ function usageMiddleware () {
         method: ctx.request.method,
         timestamp: now.getTime()
       }
-      console.log('reqObj: ', reqObj)
+      // console.log('reqObj: ', reqObj)
 
       restCalls.push(reqObj)
     } catch (err) {

test/unit/adapters/ipfs.adapter.unit.js

@@ -6,7 +6,7 @@
 import { assert } from 'chai'
 import sinon from 'sinon'
 import cloneDeep from 'lodash.clonedeep'
-import { peerIdFromString } from '@libp2p/peer-id'
+// import { peerIdFromString } from '@libp2p/peer-id'
 
 // Local libraries
 import IPFSLib from '../../../src/adapters/ipfs/ipfs.js'
@@ -165,17 +165,17 @@ describe('#IPFS-adapter', () => {
       uut.config.isCircuitRelay = false
 
       // Mock dependencies and force desired code path.
-      let beenCalled = false
-      sandbox.stub(uut, 'getKeychain').resolves({
-        exportPeerId: async () => {
-          if (!beenCalled) {
-            beenCalled = true
-            throw new Error('test error')
-          }
-          return peerIdFromString('12D3KooWSXF1PnEfiA8bCG8SJduCvzdwHtvhVPK4WC6zzDoto2XP')
-        },
-        createKey: async () => {}
-      })
+      // const beenCalled = false
+      // sandbox.stub(uut, 'getKeychain').resolves({
+      //   exportPeerId: async () => {
+      //     if (!beenCalled) {
+      //       beenCalled = true
+      //       throw new Error('test error')
+      //     }
+      //     return peerIdFromString('12D3KooWSXF1PnEfiA8bCG8SJduCvzdwHtvhVPK4WC6zzDoto2XP')
+      //   },
+      //   createKey: async () => {}
+      // })
       sandbox.stub(uut, 'createLibp2p').resolves()
       sandbox.stub(uut, 'createHelia').resolves({})