How to connect to the private network / pnet ?

[qq1012827513]

I'm running a small 3-node swarm in Docker. I modified the code based on 301-networking.js. Here is my code:

/* eslint-disable no-console */
// @ts-check

import { noise } from "@chainsafe/libp2p-noise";
import { yamux } from "@chainsafe/libp2p-yamux";
import { unixfs } from "@helia/unixfs";
import { bootstrap } from "@libp2p/bootstrap";
import { identify } from "@libp2p/identify";
import { preSharedKey, generateKey } from "@libp2p/pnet";
import { tcp } from "@libp2p/tcp";
import { MemoryBlockstore } from "blockstore-core";
import { MemoryDatastore } from "datastore-core";
import { createHelia } from "helia";
import { createLibp2p } from "libp2p";

async function createNode() {
  const swarmKey = new Uint8Array(95);
  generateKey(swarmKey);
  // the blockstore is where we store the blocks that make up files
  const blockstore = new MemoryBlockstore();

  // application-specific data lives in the datastore
  const datastore = new MemoryDatastore()

  // libp2p is the networking layer that underpins Helia
  const libp2p = await createLibp2p({
    datastore,
    addresses: {
      listen: [
        '/ip4/0.0.0.0/tcp/0'
      ]
    },
    transports: [tcp()],
    connectionEncrypters: [noise()],
    streamMuxers: [yamux()],
    peerDiscovery: [
      bootstrap({
        list: [
          "/ip4/43.142.208.76/tcp/4001/p2p/12D3KooWCoeDA19ZdY3qJX5zKTtyjDzNnTT1piS8hqQQi82X5c4c"
        ],
        timeout: 1000000,
        tagTTL: Number.NEGATIVE_INFINITY, // never expire tags
      }),
    ],
    connectionProtector: preSharedKey({
      psk: swarmKey
    }),
    services: {
      identify: identify()
    }
  })

  return await createHelia({
    datastore,
    blockstore,
    libp2p
  })
}

// create two helia nodes
const node1 = await createNode()
const node2 = await createNode()

// connect them together
const multiaddrs = node2.libp2p.getMultiaddrs()
await node1.libp2p.dial(multiaddrs)

// create a filesystem on top of Helia, in this case it's UnixFS
const fs = unixfs(node1)

// we will use this TextEncoder to turn strings into Uint8Arrays
const encoder = new TextEncoder()

// add the bytes to your node and receive a unique content identifier
const cid = await fs.addBytes(encoder.encode('Hello World 301'))

console.log('Added file:', cid.toString())

// create a filesystem on top of the second Helia node
const fs2 = unixfs(node2)

// this decoder will turn Uint8Arrays into strings
const decoder = new TextDecoder()
let text = ''

// use the second Helia node to fetch the file from the first Helia node
for await (const chunk of fs2.cat(cid)) {
  text += decoder.decode(chunk, {
    stream: true
  })
}

console.log('Fetched file contents:', text)

await node1.stop()
await node2.stop()

finally i run the code, i got :

---

How do I connect to my private network using Helia?

[2color]

You probably want to set the swarmKey outside the createNode function to make sure that both Helia nodes you instantiate share the same key.

To debug, run this with more verbose logging using the DEBUG env var.

You can start of by setting it to DEBUG="*" and then narrow down the logs to identify what the source of the problem may.

[2color]

I opened a PR to add a new example showing how to do this: ipfs-examples/helia-examples#515

Check it out.