multiaddr | Composable and future-proof network addresses | Networking library

Due to browser’s security policies you cannot establish unencrypted connection from secure context (e.g. page loaded via HTTPS). You can read about it at MDN Secure Context. So you should make your server to use SSL and then replace ws:// with wss://. The simplest thing to do would be to setup SSL with nginx. You’ll need to setup a domain name for the cert too. You can also look on some documentation on how to setup libp2p/IPFS with SSL on this PR.

You can also use webrtc-star instead of websockets. However, while you can use both, each one of them have particularities that are better for certain scenarios. If you need peer discovery, webrtc-star should be used at the moment and you can check https://github.com/libp2p/js-libp2p/tree/master/examples/libp2p-in-the-browser and https://github.com/ipfs/js-ipfs/tree/master/examples/browser-exchange-files . If you do not need to rely on peer discovery and the other peer is a well known peer you can use bootstrap and connect via websockets.

I had the same issue. As I was trying to install the rusty-rlp package itself downloading the files from the web, I realized there is no option (wheel or zip file) for 32-bit python installations. I'm on a 64-bit windows PC but for some reason I had a Python-32bit version running so, I Installed Python38-64bit and runned Pip again and the issue with web3 disappeared.

Try it and let me know if you need more info!

Looking at your config, it seems that you did not configure any swarm address. A swarm address must be configured for your peer to be diable from other peers in the network.

Some context, in this specific case, you are dealing with a browser environment. Currently, Browsers do not allow listening for connections. One of the limitations is actually that a browser does not provide an "IP Address" that someone can use to reach to it. They are designed in a client-server model where the server IP Address is known and the client will establish the connection with it.

As one of the ways to solve the issue above, there is libp2p-webrtc-star transport. It basically uses a server that will be responsible for listening for connections on behalf of browser nodes. You can use one of the available servers for experimenting https://github.com/libp2p/js-libp2p-webrtc-star#hosted-rendezvous-server. Basically, you should add to your swarm addresses, a multiaddr such as /dns4/wrtc-star1.par.dwebops.pub/tcp/443/wss/p2p-webrtc-star. Once your node starts, your browser node will establish a connection with the server and the server will inform all the other peers about the peer who joined. These peers can dial your peer via this star server and the multiaddrs will look something like: /dns4/wrtc-star1.par.dwebops.pub/tcp/443/wss/p2p-webrtc-star/p2p/QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM.

With this setup, you should be able to open multiple browsers and peers discover and connect to each other. If you run the ipfs.swarm.peers you should see the addresses of the other nodes peers via the star server.

I hope this helps you move forward. I also highly recommend you to check the following examples:

• https://github.com/ipfs/js-ipfs/tree/master/examples/browser-exchange-files
• https://github.com/libp2p/js-libp2p/blob/master/examples/libp2p-in-the-browser

As a complement, there are a few new features being worked on that aim to improve the browser experience in this regard. You can follow the developments on: https://github.com/libp2p/js-libp2p/issues/703

Multicast is not a trivial thing. From what you are describing, the following happens:

When you perform

SO_ORIGINAL_DST is only used to get the original destination IP address of a redirected socket. The redirection itself must be done with iptables.

PeerInfo is a struct that encapsulates a peer ID and its multiaddrs. To build a PeerInfo from a Host easily, you can simply do the following: