[RFC] WASM

default_not_browser.go

@@ -0,0 +1,42 @@
+//go:build !js
+
+package libp2p
+
+import (
+	quic "github.com/libp2p/go-libp2p/p2p/transport/quic"
+	"github.com/libp2p/go-libp2p/p2p/transport/tcp"
+	ws "github.com/libp2p/go-libp2p/p2p/transport/websocket"
+	webtransport "github.com/libp2p/go-libp2p/p2p/transport/webtransport"
+)
+
+// DefaultTransports are the default libp2p transports.
+//
+// Use this option when you want to *extend* the set of transports used by
+// libp2p instead of replacing them.
+var DefaultTransports = ChainOptions(
+	Transport(tcp.NewTCPTransport),
+	Transport(quic.NewTransport),
+	Transport(ws.New),
+	Transport(webtransport.New),
+)
+
+// DefaultPrivateTransports are the default libp2p transports when a PSK is supplied.
+//
+// Use this option when you want to *extend* the set of transports used by
+// libp2p instead of replacing them.
+var DefaultPrivateTransports = ChainOptions(
+	Transport(tcp.NewTCPTransport),
+	Transport(ws.New),
+)
+
+// DefaultListenAddrs configures libp2p to use default listen address.
+var DefaultListenAddrs = makeDefaultListenAddrs(
+	"/ip4/0.0.0.0/tcp/0",
+	"/ip4/0.0.0.0/udp/0/quic",
+	"/ip4/0.0.0.0/udp/0/quic-v1",
+	"/ip4/0.0.0.0/udp/0/quic-v1/webtransport",
+	"/ip6/::/tcp/0",
+	"/ip6/::/udp/0/quic",
+	"/ip6/::/udp/0/quic-v1",
+	"/ip6/::/udp/0/quic-v1/webtransport",
+)

defaults.go

@@ -1,6 +1,6 @@
 package libp2p
 
-// This file contains all the default configuration options.
+// This file contains all the platform independant default configuration options.
 
 import (
 	"crypto/rand"
@@ -12,10 +12,6 @@ import (
 	"github.com/libp2p/go-libp2p/p2p/net/connmgr"
 	"github.com/libp2p/go-libp2p/p2p/security/noise"
 	tls "github.com/libp2p/go-libp2p/p2p/security/tls"
-	quic "github.com/libp2p/go-libp2p/p2p/transport/quic"
-	"github.com/libp2p/go-libp2p/p2p/transport/tcp"
-	ws "github.com/libp2p/go-libp2p/p2p/transport/websocket"
-	webtransport "github.com/libp2p/go-libp2p/p2p/transport/webtransport"
 	"github.com/prometheus/client_golang/prometheus"
 
 	"github.com/multiformats/go-multiaddr"
@@ -37,26 +33,6 @@ var DefaultSecurity = ChainOptions(
 // libp2p instead of replacing them.
 var DefaultMuxers = Muxer(yamux.ID, yamux.DefaultTransport)
 
-// DefaultTransports are the default libp2p transports.
-//
-// Use this option when you want to *extend* the set of transports used by
-// libp2p instead of replacing them.
-var DefaultTransports = ChainOptions(
-	Transport(tcp.NewTCPTransport),
-	Transport(quic.NewTransport),
-	Transport(ws.New),
-	Transport(webtransport.New),
-)
-
-// DefaultPrivateTransports are the default libp2p transports when a PSK is supplied.
-//
-// Use this option when you want to *extend* the set of transports used by
-// libp2p instead of replacing them.
-var DefaultPrivateTransports = ChainOptions(
-	Transport(tcp.NewTCPTransport),
-	Transport(ws.New),
-)
-
 // DefaultPeerstore configures libp2p to use the default peerstore.
 var DefaultPeerstore Option = func(cfg *Config) error {
 	ps, err := pstoremem.NewPeerstore()
@@ -75,29 +51,6 @@ var RandomIdentity = func(cfg *Config) error {
 	return cfg.Apply(Identity(priv))
 }
 
-// DefaultListenAddrs configures libp2p to use default listen address.
-var DefaultListenAddrs = func(cfg *Config) error {
-	addrs := []string{
-		"/ip4/0.0.0.0/tcp/0",
-		"/ip4/0.0.0.0/udp/0/quic",
-		"/ip4/0.0.0.0/udp/0/quic-v1",
-		"/ip4/0.0.0.0/udp/0/quic-v1/webtransport",
-		"/ip6/::/tcp/0",
-		"/ip6/::/udp/0/quic",
-		"/ip6/::/udp/0/quic-v1",
-		"/ip6/::/udp/0/quic-v1/webtransport",
-	}
-	listenAddrs := make([]multiaddr.Multiaddr, 0, len(addrs))
-	for _, s := range addrs {
-		addr, err := multiaddr.NewMultiaddr(s)
-		if err != nil {
-			return err
-		}
-		listenAddrs = append(listenAddrs, addr)
-	}
-	return cfg.Apply(ListenAddrs(listenAddrs...))
-}
-
 // DefaultEnableRelay enables relay dialing and listening by default.
 var DefaultEnableRelay = func(cfg *Config) error {
 	return cfg.Apply(EnableRelay())
@@ -218,3 +171,17 @@ var FallbackDefaults Option = func(cfg *Config) error {
 	}
 	return nil
 }
+
+func makeDefaultListenAddrs(addrs ...string) func(*Config) error {
+	return func(cfg *Config) error {
+		listenAddrs := make([]multiaddr.Multiaddr, 0, len(addrs))
+		for _, s := range addrs {
+			addr, err := multiaddr.NewMultiaddr(s)
+			if err != nil {
+				return err
+			}
+			listenAddrs = append(listenAddrs, addr)
+		}
+		return cfg.Apply(ListenAddrs(listenAddrs...))
+	}
+}

defaults_browser.go

@@ -0,0 +1,23 @@
+//go:build js
+
+package libp2p
+
+import (
+	ws "github.com/libp2p/go-libp2p/p2p/transport/websocket"
+	webtransport "github.com/libp2p/go-libp2p/p2p/transport/webtransport"
+)
+
+// DefaultTransport has been trimmed down to what works in the browser.
+var DefaultTransports = ChainOptions(
+	// TODO(@Jorropo): If the wasm experiment is doing good, write shims for webrtc.
+	Transport(ws.New),
+	Transport(webtransport.New),
+)
+
+// DefaultPrivateTransports has been trimmed down to what works in the browser.
+var DefaultPrivateTransports = ChainOptions(
+	Transport(ws.New),
+)
+
+// DefaultListenAddrs is sadly empty, we could maybe prop it up if webrtc in browser support is added.
+var DefaultListenAddrs = makeDefaultListenAddrs()

examples/chat-wasm-browser/.gitignore

@@ -0,0 +1,2 @@
+main.wasm
+wasm_exec.js

examples/chat-wasm-browser/build.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+set -e +x
+
+cd "$(dirname "$0")"
+
+set -x
+
+GOOS=js GOARCH=wasm go build -o main.wasm .
+cp "$(go env GOROOT)/misc/wasm/wasm_exec.js" wasm_exec.js

examples/chat-wasm-browser/index.html

@@ -0,0 +1,18 @@
+<html>
+	<head>
+		<meta charset="utf-8"/>
+		<script src="wasm_exec.js"></script>
+		<script defer>
+			const go = new Go();
+			WebAssembly.instantiateStreaming(fetch("main.wasm"), go.importObject).then((result) => {
+				go.run(result.instance);
+			});
+		</script>
+	</head>
+	<body>
+		<input type="text" id="maddr" placeholder="/ip4/1.2.3.4/tcp/1337/ws/p2p/Qmfoo"/>
+		<button type="button" id="connect">Connect</button>
+		<p id="self"></p>
+		<div id="chats"></div>
+		<p id="output"></p>
+</html>

examples/chat-wasm-browser/main.go

@@ -0,0 +1,128 @@
+//go:build js
+
+package main
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"strings"
+	"syscall/js"
+
+	"github.com/libp2p/go-libp2p"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/core/peerstore"
+)
+
+const chatProtocol = "/chat/1.0.0"
+
+func main() {
+	g := js.Global()
+	out := g.Get("output")
+	maddr := g.Get("maddr")
+	connect := g.Get("connect")
+	document := g.Get("document")
+	selfp := g.Get("self")
+	chats := g.Get("chats")
+
+	h, err := libp2p.New()
+	if err != nil {
+		out.Set("innerText", "Error starting libp2p, check the console !")
+		panic(err)
+	}
+	self := h.ID().String()
+	selfp.Set("innerText", self)
+
+	connect.Set("onclick", js.FuncOf(func(_ js.Value, _ []js.Value) any {
+		m := maddr.Get("value").String()
+		maddr.Set("value", "")
+		out.Set("innerText", "Contacting "+m)
+		// Start a new goroutine because are about to do IO and we don't want to block JS's event loop.
+		go func() {
+			err := func() error {
+				info, err := peer.AddrInfoFromString(m)
+				if err != nil {
+					return fmt.Errorf("parsing maddr: %w", err)
+				}
+
+				h.Peerstore().AddAddrs(info.ID, info.Addrs, peerstore.PermanentAddrTTL)
+				s, err := h.NewStream(context.Background(), info.ID, chatProtocol)
+				if err != nil {
+					return fmt.Errorf("NewStream: %w", err)
+				}
+
+				anchor := document.Call("createElement", "div")
+				peerid := document.Call("createElement", "p")
+				them := info.ID.Pretty()
+				peerid.Set("innerText", "Connected with: "+them)
+				anchor.Call("appendChild", peerid)
+
+				text := document.Call("createElement", "div")
+				addLine := func(strs ...string) {
+					line := document.Call("createElement", "p")
+					var textBuf strings.Builder
+					for _, s := range strs {
+						textBuf.WriteString(s)
+					}
+					line.Set("innerText", textBuf.String())
+					text.Call("appendChild", line)
+				}
+				anchor.Call("appendChild", text)
+
+				entry := document.Call("createElement", "input")
+				entry.Set("onkeyup", js.FuncOf(func(_ js.Value, args []js.Value) any {
+					if len(args) != 1 {
+						panic("expected 1 argument callback from onkeyup")
+					}
+					event := args[0]
+
+					if event.Get("key").String() != "Enter" {
+						return nil
+					}
+					toSend := entry.Get("value").String()
+					entry.Set("value", "")
+					go func() {
+						_, err := strings.NewReader(toSend).WriteTo(s)
+						if err != nil {
+							addLine("Error sending: ", err.Error())
+							return
+						}
+						_, err = strings.NewReader("\n").WriteTo(s)
+						if err != nil {
+							addLine("Error sending: ", err.Error())
+							return
+						}
+						addLine(self, "> ", toSend)
+					}()
+					return nil
+				}))
+				anchor.Call("appendChild", entry)
+
+				chats.Call("appendChild", anchor)
+
+				scanner := bufio.NewScanner(s)
+				for scanner.Scan() {
+					message := strings.Trim(scanner.Text(), " \n")
+					if message == "" {
+						continue
+					}
+					addLine(them, "> ", message)
+				}
+				if err := scanner.Err(); err != nil {
+					addLine("Error receiving: ", err.Error())
+				}
+
+				return nil
+			}()
+			if err != nil {
+				s := "error contacting " + m + ": " + err.Error()
+				fmt.Println(s)
+				out.Set("innerText", s)
+			}
+		}()
+
+		return nil
+	}))
+
+	select {}
+}

examples/chat-wasm-browser/serve.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+set -e +x
+
+cd "$(dirname "$0")"
+
+. ./build.sh
+
+go run github.com/Jorropo/jhttp

examples/chat-wasm-browser/tool.go

@@ -0,0 +1,7 @@
+//go:build tools
+
+package tools
+
+import (
+	_ "github.com/Jorropo/jhttp"
+)