bellbind · August 14, 2024 22:40
diff --git a/00readme.md b/00readme.md
diff --git a/browser.js b/browser.js
 import {createHelia} from "helia";
 import {unixfs} from "@helia/unixfs";
 import {CID} from "multiformats/cid";
 import {multiaddr} from "@multiformats/multiaddr";
 import {peerIdFromString} from "@libp2p/peer-id";
 import {createTopology} from "@libp2p/topology";
 import {mplex} from "@libp2p/mplex";
 import {yamux} from "@chainsafe/libp2p-yamux";
 import {bootstrap} from "@libp2p/bootstrap";
 import {pubsubPeerDiscovery} from "@libp2p/pubsub-peer-discovery";
 import {circuitRelayTransport, circuitRelayServer} from "libp2p/circuit-relay";
 import {webRTC, webRTCDirect} from "@libp2p/webrtc";
 import {webTransport} from "@libp2p/webtransport";
 import {webSockets} from "@libp2p/websockets";
 import {all} from "@libp2p/websockets/filters";
 import {identifyService} from "libp2p/identify";
 import {autoNATService} from "libp2p/autonat";
 import {gossipsub} from "@chainsafe/libp2p-gossipsub";
 import {kadDHT} from "@libp2p/kad-dht";
 import {ipnsSelector} from "ipns/selector";
 import {ipnsValidator} from "ipns/validator";

 export const createHeliaFromMultiaddrs = async multiaddrs => {
  // browser helia node which bootstrap target is localhost helia node
  const bootstrapConfig = {list: multiaddrs};
  const node = await createHelia({
    libp2p: {
      // https://github.com/ipfs/helia/blob/main/packages/helia/src/utils/libp2p-defaults.browser.ts#L27
      addresses: {
        listen: [
          "/webrtc", "/wss", "/ws",
        ],
      },
      transports: [
        webSockets({filter: all}),
        webRTC(), webRTCDirect(),
        webTransport(),
        // https://github.com/libp2p/js-libp2p-websockets#libp2p-usage-example
        circuitRelayTransport({discoverRelays: 3}),
      ],
      //streamMuxers: [mplex()],
      streamMuxers: [yamux()],
      peerDiscovery: [bootstrap(bootstrapConfig), pubsubPeerDiscovery()],
      services: {
        identify: identifyService(),
        autoNAT: autoNATService(),
        //pubsub: gossipsub({allowPublishToZeroPeers: true, emitSelf: false, canRelayMessage: true}),
        pubsub: gossipsub({allowPublishToZeroPeers: true, emitSelf: true, canRelayMessage: true}),
        dht: kadDHT({
          clientMode: true,
          validators: {ipns: ipnsValidator},
          selectors: {ipns: ipnsSelector},
        }),
      },
      // https://github.com/libp2p/js-libp2p/blob/master/doc/CONFIGURATION.md#configuring-connection-gater
      connectionGater: {denyDialMultiaddr: async (...args) => false},
    },
  });

  // print peer connecting info
  node.libp2p.addEventListener("peer:connect", ev => {
    console.log(`[peer:connect on ${node.libp2p.peerId}]`, ev.detail.toString());
  });
  // js-ipfs-bitswap/src/network.ts
  await node.libp2p.register("/ipfs/bitswap/1.2.0", createTopology({
    onConnect: (peerId, conn) => {console.log(`[/ipfs/bitswap/1.2.0 on ${node.libp2p.peerId}] onConnect`, `${peerId}`);},
    onDisconnect: peerId => {console.log(`[/ipfs/bitswap/1.2.0 on ${node.libp2p.peerId}] onDisconnect`, `${peerId}`);},
  }));
  
  // wait to connect bootstrap
  while (node.libp2p.getMultiaddrs().length === 0) await new Promise(f => setTimeout(f, 500));
  const nodefs = unixfs(node);
  return {node, nodefs, CID, peerIdFromString, multiaddr}; // returns helia node and imported utils
 };
diff --git a/case-b2b.mjs b/case-b2b.mjs
 // Example of indirect connect of 2 helia noeds between browser and browser connected to same helia on nodejs
 // resolve cid from browser to browser
 import {CID} from "multiformats/cid";
 import {unixfs} from "@helia/unixfs";

 import {chromium} from "playwright";
 import {createServer} from "http-server";

 import {createNode} from "./nodejs.js";

 // [1. nodejs helia node]
 const node = await createNode();
 console.log("[peerId on nodejs]", `${node.libp2p.peerId}`);

 // [2. http server for url to playwright]
 const httpServer = createServer();
 await new Promise(f => httpServer.server.listen(f));
 const pageUrl = `http://localhost:${httpServer.server.address().port}/index.html`; // importmap only html
 console.log("[page server url]", pageUrl);

 // [3. helia node on playwright]
 const browser = await chromium.launch();
 const page1 = await browser.newPage();
 await page1.goto(pageUrl);
 page1.on("console", msg => {
  if (msg.type() === "log") console.log(msg.location(), msg.text());
  //if (msg.type() === "error") console.log(msg.location(), msg.text());
 });
 const page2 = await browser.newPage();
 await page2.goto(pageUrl);
 page2.on("console", msg => {
  if (msg.type() === "log") console.log(msg.location(), msg.text());
  //if (msg.type() === "error") console.log(msg.location(), msg.text());
 });

 const cidStr = await page1.evaluate(({multiaddrs}) => (async () => {
  const {createHeliaFromMultiaddrs} = await import("./browser.js");
  
  globalThis.ctx = await createHeliaFromMultiaddrs(multiaddrs);
  console.log("[peerId on browser1]", `${ctx.node.libp2p.peerId}`);

  // [4. serve content on browser helia node]
  const cid = await ctx.nodefs.addBytes(new TextEncoder().encode("Hello from browser"));
  try {ctx.node.pins.add(cid);} catch (error) {}
  return `${cid}`;
 })(), {multiaddrs: node.libp2p.getMultiaddrs().map(ma => `${ma}`)});
 console.log("[serving cid on browser1]", cidStr);

 await page2.evaluate(({multiaddrs}) => (async () => {
  const {createHeliaFromMultiaddrs} = await import("./browser.js");
  
  globalThis.ctx = await createHeliaFromMultiaddrs(multiaddrs);
  console.log("[peerId on browser2]", `${ctx.node.libp2p.peerId}`);
  
 })(), {multiaddrs: node.libp2p.getMultiaddrs().map(ma => `${ma}`)});

 // [5. dialProtocol from browser2 to browser1] required before access on helia-2.0.1
 const multiaddrs = await await page1.evaluate(() => (async () => {
  return ctx.node.libp2p.getMultiaddrs().map(ma => `${ma}`);
 })());
 console.log("[browser1 multiaddrs]", multiaddrs);
 await page2.evaluate(({multiaddrs}) => (async () => {
  for (const ma of multiaddrs) {
    try {
      const stream = await ctx.node.libp2p.dialProtocol(ctx.multiaddr(ma), "/ipfs/bitswap/1.2.0", {runOnTransientConnection: true});
      const isWebRTCStream = stream.constructor.name === "WebRTCStream";
      console.log("[dialProtocol from browser2 to browser1]", ma, stream, stream.constructor.name);
      //await stream.close();
      break;
    } catch (error) {
      console.log("[dialProtocol error]", error);
      //TBD: how to set runOnTransientConnection = true?
    }
  }
 })(), {multiaddrs});

 // [6. access cid from browser to browser]
 await page2.evaluate(({cidStr}) => (async () => {
  const cid = ctx.CID.parse(cidStr);
  // print result of findProviders(cid)
  for await (const peer of ctx.node.libp2p.contentRouting.findProviders(cid)) {
    console.log("[findProviders peer.id]", `${peer.id}`);
    console.log("[findProviders peer.multiaddrs.length]", peer.multiaddrs.length);
    for (const ma of peer.multiaddrs) console.log("[findProviders peer.multiaddrs]", `${ma}`);
    console.log("[findProviders peer.protocolss.length]", peer.protocols.length);
    for (const proto of peer.protocols) console.log("[findProviders peer.protocols]", `${proto}`);
    break;
  }
  
  const stat = await ctx.nodefs.stat(cid); // halt 
  console.log("[stat of cid from other browser]", stat);
  const decoder = new TextDecoder();
  const texts = [];
  for await (const chunk of ctx.nodefs.cat(cid)) {
    texts.push(decoder.decode(chunk, {stream: true}));
  }
  console.log("[text of cid from other browser]", texts.join(""));

 })(), {cidStr});

 // [7. closing]
 console.log("[closing...]");
 await page1.evaluate(() => ctx.node.stop());
 await page2.evaluate(() => ctx.node.stop());
 await browser.close();
 await new Promise(f => httpServer.server.close(f));
 await node.stop();
diff --git a/index.html b/index.html
 <!doctype html>
 <html>
  <head>
    <meta charset="utf-8" />
    <script type="importmap">
 {
  "imports": {
    "helia": "./npm-browser.js",
    "libp2p/circuit-relay": "./npm-browser.js",
    "@libp2p/peer-id": "./npm-browser.js",
    "@libp2p/topology": "./npm-browser.js",
    "@libp2p/mplex": "./npm-browser.js",
    "@chainsafe/libp2p-yamux": "./npm-browser.js",
    "@libp2p/bootstrap": "./npm-browser.js",
    "@libp2p/pubsub-peer-discovery": "./npm-browser.js",
    "@libp2p/webtransport": "./npm-browser.js",
    "@libp2p/webrtc": "./npm-browser.js",
    "@libp2p/websockets": "./npm-browser.js",
    "@libp2p/websockets/filters": "./npm-browser.js",
    "@libp2p/circuit-relay": "./npm-browser.js",
    "libp2p/identify": "./npm-browser.js",
    "libp2p/autonat": "./npm-browser.js",
    "@chainsafe/libp2p-gossipsub": "./npm-browser.js",
    "@libp2p/kad-dht": "./npm-browser.js",
    "ipns/selector": "./npm-browser.js",
    "ipns/validator":  "./npm-browser.js",
    "@multiformats/multiaddr": "./npm-browser.js",
    "multiformats/cid": "./npm-browser.js",
    "@helia/unixfs": "./npm-browser.js"
  }
 }
    </script>
    <link rel="icon" href="data:image/x-icon;" />
  </head>
  <body></body>
 </html>
diff --git a/nodejs.js b/nodejs.js
 import * as http from "node:http";

 import {createHelia} from "helia";
 import {createTopology} from "@libp2p/topology";
 import {mplex} from "@libp2p/mplex";
 import {yamux} from "@chainsafe/libp2p-yamux";
 import {tcp} from "@libp2p/tcp";
 import {webSockets} from "@libp2p/websockets";
 import {webRTC, webRTCDirect} from "@libp2p/webrtc";
 import {circuitRelayTransport, circuitRelayServer} from "libp2p/circuit-relay";
 import {mdns} from "@libp2p/mdns";
 import {bootstrap} from "@libp2p/bootstrap";
 import {pubsubPeerDiscovery} from "@libp2p/pubsub-peer-discovery";
 import {ipniContentRouting} from "@libp2p/ipni-content-routing";
 import {identifyService} from "libp2p/identify";
 import {autoNATService} from "libp2p/autonat";
 import {uPnPNATService} from "libp2p/upnp-nat";
 import {gossipsub} from "@chainsafe/libp2p-gossipsub";
 import {kadDHT} from "@libp2p/kad-dht";
 import {ipnsSelector} from "ipns/selector";
 import {ipnsValidator} from "ipns/validator";

 export const createNode = async () => {
  // localhost helia node for using bootstrap target from browser helia
  const node = await createHelia({
    libp2p: {
      addresses: {
        listen: [
          "/ip4/0.0.0.0/tcp/0",
          "/ip4/0.0.0.0/tcp/0/ws",
          "/webrtc",
        ]
      },
      transports: [
        tcp(),
        webSockets({websocket: {rejectUnauthorized: false}}),
        circuitRelayTransport({discoverRelays: 3}),
        webRTC(),
        webRTCDirect(),
      ],
      //streamMuxers: [mplex()],
      //streamMuxers: [yamux()],
      services: {
        identify: identifyService(),
        autoNAT: autoNATService(),
        upnp: uPnPNATService(),
        pubsub: gossipsub({allowPublishToZeroPeers: true, emitSelf: true, canRelayMessage: true}),
        dht: kadDHT({
          validators: {ipns: ipnsValidator},
          selectors: {ipns: ipnsSelector},
        }),
        relay: circuitRelayServer({advertise: true}),
      },
    },
  });
  
  // uncomment for print peer connecting info
  node.libp2p.addEventListener("peer:connect", ev => {
    //console.log("[peer:connect]", ev.detail);
  });
  node.libp2p.addEventListener("peer:discovery", ev => {
    //console.log("[peer:discovery]", ev.detail);
  });
  await node.libp2p.register("/ipfs/bitswap/1.2.0", createTopology({
    onConnect: (peerId, conn) => {
      //console.log("[/ipfs/bitswap/1.2.0] onConnect", peerId);
    },
    onDisonnect: peerId => {
      //console.log("[/ipfs/bitswap/1.2.0] onDisonnect", peerId);
    },
  }));
  return node;
 };
diff --git a/npm-libs.js b/npm-libs.js
 // esbuild to single js file for mapping each module by importmap in HTML
 export {createHelia} from "helia";
 export {unixfs} from "@helia/unixfs";
 export {CID} from "multiformats/cid";
 export {multiaddr} from "@multiformats/multiaddr";
 export {peerIdFromString} from "@libp2p/peer-id";
 export {createTopology} from "@libp2p/topology";
 export {mplex} from "@libp2p/mplex";
 export {yamux} from "@chainsafe/libp2p-yamux";

 export {bootstrap} from "@libp2p/bootstrap";
 export {pubsubPeerDiscovery} from "@libp2p/pubsub-peer-discovery";
 export {circuitRelayTransport, circuitRelayServer} from "libp2p/circuit-relay";
 export {webRTC, webRTCDirect} from "@libp2p/webrtc";
 export {webTransport} from "@libp2p/webtransport";
 export {webSockets} from "@libp2p/websockets";
 export {all} from "@libp2p/websockets/filters";

 // services
 export {identifyService} from "libp2p/identify";
 export {autoNATService} from "libp2p/autonat";
 export {gossipsub} from "@chainsafe/libp2p-gossipsub";
 export {kadDHT} from "@libp2p/kad-dht";
 export {ipnsSelector} from "ipns/selector";
 export {ipnsValidator} from "ipns/validator";
diff --git a/package.json b/package.json
 {
  "type": "module",
  "dependencies": {
    "@helia/unixfs": "^1.4.1",
    "@libp2p/pubsub-peer-discovery": "^8.0.4",
    "esbuild": "^0.19.2",
    "helia": "^2.0.1",
    "http-server": "^14.1.1",
    "playwright": "^1.37.1"
  },
  "scripts": {
    "b2b": "node case-b2b.mjs",
    "build": "esbuild npm-libs.js --bundle --sourcemap=inline --format=esm --target=chrome115 --define:global=globalThis --define:process.env.NODE_DEBUG=false --outfile=npm-browser.js"
  }
 }
	import {createHelia} from "helia";
	import {unixfs} from "@helia/unixfs";
	import {CID} from "multiformats/cid";
	import {multiaddr} from "@multiformats/multiaddr";
	import {peerIdFromString} from "@libp2p/peer-id";
	import {createTopology} from "@libp2p/topology";
	import {mplex} from "@libp2p/mplex";
	import {yamux} from "@chainsafe/libp2p-yamux";
	import {bootstrap} from "@libp2p/bootstrap";
	import {pubsubPeerDiscovery} from "@libp2p/pubsub-peer-discovery";
	import {circuitRelayTransport, circuitRelayServer} from "libp2p/circuit-relay";
	import {webRTC, webRTCDirect} from "@libp2p/webrtc";
	import {webTransport} from "@libp2p/webtransport";
	import {webSockets} from "@libp2p/websockets";
	import {all} from "@libp2p/websockets/filters";
	import {identifyService} from "libp2p/identify";
	import {autoNATService} from "libp2p/autonat";
	import {gossipsub} from "@chainsafe/libp2p-gossipsub";
	import {kadDHT} from "@libp2p/kad-dht";
	import {ipnsSelector} from "ipns/selector";
	import {ipnsValidator} from "ipns/validator";

	export const createHeliaFromMultiaddrs = async multiaddrs => {
	// browser helia node which bootstrap target is localhost helia node
	const bootstrapConfig = {list: multiaddrs};
	const node = await createHelia({
	libp2p: {
	// https://github.com/ipfs/helia/blob/main/packages/helia/src/utils/libp2p-defaults.browser.ts#L27
	addresses: {
	listen: [
	"/webrtc", "/wss", "/ws",
	],
	},
	transports: [
	webSockets({filter: all}),
	webRTC(), webRTCDirect(),
	webTransport(),
	// https://github.com/libp2p/js-libp2p-websockets#libp2p-usage-example
	circuitRelayTransport({discoverRelays: 3}),
	],
	//streamMuxers: [mplex()],
	streamMuxers: [yamux()],
	peerDiscovery: [bootstrap(bootstrapConfig), pubsubPeerDiscovery()],
	services: {
	identify: identifyService(),
	autoNAT: autoNATService(),
	//pubsub: gossipsub({allowPublishToZeroPeers: true, emitSelf: false, canRelayMessage: true}),
	pubsub: gossipsub({allowPublishToZeroPeers: true, emitSelf: true, canRelayMessage: true}),
	dht: kadDHT({
	clientMode: true,
	validators: {ipns: ipnsValidator},
	selectors: {ipns: ipnsSelector},
	}),
	},
	// https://github.com/libp2p/js-libp2p/blob/master/doc/CONFIGURATION.md#configuring-connection-gater
	connectionGater: {denyDialMultiaddr: async (...args) => false},
	},
	});

	// print peer connecting info
	node.libp2p.addEventListener("peer:connect", ev => {
	console.log(`[peer:connect on ${node.libp2p.peerId}]`, ev.detail.toString());
	});
	// js-ipfs-bitswap/src/network.ts
	await node.libp2p.register("/ipfs/bitswap/1.2.0", createTopology({
	onConnect: (peerId, conn) => {console.log(`[/ipfs/bitswap/1.2.0 on ${node.libp2p.peerId}] onConnect`, `${peerId}`);},
	onDisconnect: peerId => {console.log(`[/ipfs/bitswap/1.2.0 on ${node.libp2p.peerId}] onDisconnect`, `${peerId}`);},
	}));

	// wait to connect bootstrap
	while (node.libp2p.getMultiaddrs().length === 0) await new Promise(f => setTimeout(f, 500));
	const nodefs = unixfs(node);
	return {node, nodefs, CID, peerIdFromString, multiaddr}; // returns helia node and imported utils
	};
	// Example of indirect connect of 2 helia noeds between browser and browser connected to same helia on nodejs
	// resolve cid from browser to browser
	import {CID} from "multiformats/cid";
	import {unixfs} from "@helia/unixfs";

	import {chromium} from "playwright";
	import {createServer} from "http-server";

	import {createNode} from "./nodejs.js";

	// [1. nodejs helia node]
	const node = await createNode();
	console.log("[peerId on nodejs]", `${node.libp2p.peerId}`);

	// [2. http server for url to playwright]
	const httpServer = createServer();
	await new Promise(f => httpServer.server.listen(f));
	const pageUrl = `http://localhost:${httpServer.server.address().port}/index.html`; // importmap only html
	console.log("[page server url]", pageUrl);

	// [3. helia node on playwright]
	const browser = await chromium.launch();
	const page1 = await browser.newPage();
	await page1.goto(pageUrl);
	page1.on("console", msg => {
	if (msg.type() === "log") console.log(msg.location(), msg.text());
	//if (msg.type() === "error") console.log(msg.location(), msg.text());
	});
	const page2 = await browser.newPage();
	await page2.goto(pageUrl);
	page2.on("console", msg => {
	if (msg.type() === "log") console.log(msg.location(), msg.text());
	//if (msg.type() === "error") console.log(msg.location(), msg.text());
	});

	const cidStr = await page1.evaluate(({multiaddrs}) => (async () => {
	const {createHeliaFromMultiaddrs} = await import("./browser.js");

	globalThis.ctx = await createHeliaFromMultiaddrs(multiaddrs);
	console.log("[peerId on browser1]", `${ctx.node.libp2p.peerId}`);

	// [4. serve content on browser helia node]
	const cid = await ctx.nodefs.addBytes(new TextEncoder().encode("Hello from browser"));
	try {ctx.node.pins.add(cid);} catch (error) {}
	return `${cid}`;
	})(), {multiaddrs: node.libp2p.getMultiaddrs().map(ma => `${ma}`)});
	console.log("[serving cid on browser1]", cidStr);

	await page2.evaluate(({multiaddrs}) => (async () => {
	const {createHeliaFromMultiaddrs} = await import("./browser.js");

	globalThis.ctx = await createHeliaFromMultiaddrs(multiaddrs);
	console.log("[peerId on browser2]", `${ctx.node.libp2p.peerId}`);

	})(), {multiaddrs: node.libp2p.getMultiaddrs().map(ma => `${ma}`)});

	// [5. dialProtocol from browser2 to browser1] required before access on helia-2.0.1
	const multiaddrs = await await page1.evaluate(() => (async () => {
	return ctx.node.libp2p.getMultiaddrs().map(ma => `${ma}`);
	})());
	console.log("[browser1 multiaddrs]", multiaddrs);
	await page2.evaluate(({multiaddrs}) => (async () => {
	for (const ma of multiaddrs) {
	try {
	const stream = await ctx.node.libp2p.dialProtocol(ctx.multiaddr(ma), "/ipfs/bitswap/1.2.0", {runOnTransientConnection: true});
	const isWebRTCStream = stream.constructor.name === "WebRTCStream";
	console.log("[dialProtocol from browser2 to browser1]", ma, stream, stream.constructor.name);
	//await stream.close();
	break;
	} catch (error) {
	console.log("[dialProtocol error]", error);
	//TBD: how to set runOnTransientConnection = true?
	}
	}
	})(), {multiaddrs});

	// [6. access cid from browser to browser]
	await page2.evaluate(({cidStr}) => (async () => {
	const cid = ctx.CID.parse(cidStr);
	// print result of findProviders(cid)
	for await (const peer of ctx.node.libp2p.contentRouting.findProviders(cid)) {
	console.log("[findProviders peer.id]", `${peer.id}`);
	console.log("[findProviders peer.multiaddrs.length]", peer.multiaddrs.length);
	for (const ma of peer.multiaddrs) console.log("[findProviders peer.multiaddrs]", `${ma}`);
	console.log("[findProviders peer.protocolss.length]", peer.protocols.length);
	for (const proto of peer.protocols) console.log("[findProviders peer.protocols]", `${proto}`);
	break;
	}

	const stat = await ctx.nodefs.stat(cid); // halt
	console.log("[stat of cid from other browser]", stat);
	const decoder = new TextDecoder();
	const texts = [];
	for await (const chunk of ctx.nodefs.cat(cid)) {
	texts.push(decoder.decode(chunk, {stream: true}));
	}
	console.log("[text of cid from other browser]", texts.join(""));

	})(), {cidStr});

	// [7. closing]
	console.log("[closing...]");
	await page1.evaluate(() => ctx.node.stop());
	await page2.evaluate(() => ctx.node.stop());
	await browser.close();
	await new Promise(f => httpServer.server.close(f));
	await node.stop();
	<!doctype html>
	<html>
	<head>
	<meta charset="utf-8" />
	<script type="importmap">
	{
	"imports": {
	"helia": "./npm-browser.js",
	"libp2p/circuit-relay": "./npm-browser.js",
	"@libp2p/peer-id": "./npm-browser.js",
	"@libp2p/topology": "./npm-browser.js",
	"@libp2p/mplex": "./npm-browser.js",
	"@chainsafe/libp2p-yamux": "./npm-browser.js",
	"@libp2p/bootstrap": "./npm-browser.js",
	"@libp2p/pubsub-peer-discovery": "./npm-browser.js",
	"@libp2p/webtransport": "./npm-browser.js",
	"@libp2p/webrtc": "./npm-browser.js",
	"@libp2p/websockets": "./npm-browser.js",
	"@libp2p/websockets/filters": "./npm-browser.js",
	"@libp2p/circuit-relay": "./npm-browser.js",
	"libp2p/identify": "./npm-browser.js",
	"libp2p/autonat": "./npm-browser.js",
	"@chainsafe/libp2p-gossipsub": "./npm-browser.js",
	"@libp2p/kad-dht": "./npm-browser.js",
	"ipns/selector": "./npm-browser.js",
	"ipns/validator": "./npm-browser.js",
	"@multiformats/multiaddr": "./npm-browser.js",
	"multiformats/cid": "./npm-browser.js",
	"@helia/unixfs": "./npm-browser.js"
	}
	}
	</script>
	<link rel="icon" href="data:image/x-icon;" />
	</head>
	<body></body>
	</html>
	import * as http from "node:http";

	import {createHelia} from "helia";
	import {createTopology} from "@libp2p/topology";
	import {mplex} from "@libp2p/mplex";
	import {yamux} from "@chainsafe/libp2p-yamux";
	import {tcp} from "@libp2p/tcp";
	import {webSockets} from "@libp2p/websockets";
	import {webRTC, webRTCDirect} from "@libp2p/webrtc";
	import {circuitRelayTransport, circuitRelayServer} from "libp2p/circuit-relay";
	import {mdns} from "@libp2p/mdns";
	import {bootstrap} from "@libp2p/bootstrap";
	import {pubsubPeerDiscovery} from "@libp2p/pubsub-peer-discovery";
	import {ipniContentRouting} from "@libp2p/ipni-content-routing";
	import {identifyService} from "libp2p/identify";
	import {autoNATService} from "libp2p/autonat";
	import {uPnPNATService} from "libp2p/upnp-nat";
	import {gossipsub} from "@chainsafe/libp2p-gossipsub";
	import {kadDHT} from "@libp2p/kad-dht";
	import {ipnsSelector} from "ipns/selector";
	import {ipnsValidator} from "ipns/validator";

	export const createNode = async () => {
	// localhost helia node for using bootstrap target from browser helia
	const node = await createHelia({
	libp2p: {
	addresses: {
	listen: [
	"/ip4/0.0.0.0/tcp/0",
	"/ip4/0.0.0.0/tcp/0/ws",
	"/webrtc",
	]
	},
	transports: [
	tcp(),
	webSockets({websocket: {rejectUnauthorized: false}}),
	circuitRelayTransport({discoverRelays: 3}),
	webRTC(),
	webRTCDirect(),
	],
	//streamMuxers: [mplex()],
	//streamMuxers: [yamux()],
	services: {
	identify: identifyService(),
	autoNAT: autoNATService(),
	upnp: uPnPNATService(),
	pubsub: gossipsub({allowPublishToZeroPeers: true, emitSelf: true, canRelayMessage: true}),
	dht: kadDHT({
	validators: {ipns: ipnsValidator},
	selectors: {ipns: ipnsSelector},
	}),
	relay: circuitRelayServer({advertise: true}),
	},
	},
	});

	// uncomment for print peer connecting info
	node.libp2p.addEventListener("peer:connect", ev => {
	//console.log("[peer:connect]", ev.detail);
	});
	node.libp2p.addEventListener("peer:discovery", ev => {
	//console.log("[peer:discovery]", ev.detail);
	});
	await node.libp2p.register("/ipfs/bitswap/1.2.0", createTopology({
	onConnect: (peerId, conn) => {
	//console.log("[/ipfs/bitswap/1.2.0] onConnect", peerId);
	},
	onDisonnect: peerId => {
	//console.log("[/ipfs/bitswap/1.2.0] onDisonnect", peerId);
	},
	}));
	return node;
	};
	// esbuild to single js file for mapping each module by importmap in HTML
	export {createHelia} from "helia";
	export {unixfs} from "@helia/unixfs";
	export {CID} from "multiformats/cid";
	export {multiaddr} from "@multiformats/multiaddr";
	export {peerIdFromString} from "@libp2p/peer-id";
	export {createTopology} from "@libp2p/topology";
	export {mplex} from "@libp2p/mplex";
	export {yamux} from "@chainsafe/libp2p-yamux";

	export {bootstrap} from "@libp2p/bootstrap";
	export {pubsubPeerDiscovery} from "@libp2p/pubsub-peer-discovery";
	export {circuitRelayTransport, circuitRelayServer} from "libp2p/circuit-relay";
	export {webRTC, webRTCDirect} from "@libp2p/webrtc";
	export {webTransport} from "@libp2p/webtransport";
	export {webSockets} from "@libp2p/websockets";
	export {all} from "@libp2p/websockets/filters";

	// services
	export {identifyService} from "libp2p/identify";
	export {autoNATService} from "libp2p/autonat";
	export {gossipsub} from "@chainsafe/libp2p-gossipsub";
	export {kadDHT} from "@libp2p/kad-dht";
	export {ipnsSelector} from "ipns/selector";
	export {ipnsValidator} from "ipns/validator";
	{
	"type": "module",
	"dependencies": {
	"@helia/unixfs": "^1.4.1",
	"@libp2p/pubsub-peer-discovery": "^8.0.4",
	"esbuild": "^0.19.2",
	"helia": "^2.0.1",
	"http-server": "^14.1.1",
	"playwright": "^1.37.1"
	},
	"scripts": {
	"b2b": "node case-b2b.mjs",
	"build": "esbuild npm-libs.js --bundle --sourcemap=inline --format=esm --target=chrome115 --define:global=globalThis --define:process.env.NODE_DEBUG=false --outfile=npm-browser.js"
	}
	}