fix: fix externally defined webtransport addresses

config/config.go

@@ -37,6 +37,7 @@ import (
 
 	ma "github.com/multiformats/go-multiaddr"
 	madns "github.com/multiformats/go-multiaddr-dns"
+	mc "github.com/multiformats/go-multicodec"
 	"go.uber.org/fx"
 	"go.uber.org/fx/fxevent"
 )
@@ -328,6 +329,50 @@ func (cfg *Config) NewNode() (host.Host, error) {
 		return nil, err
 	}
 
+	type netTptForDialinger interface {
+		TransportForDialing(a ma.Multiaddr) transport.Transport
+	}
+	if n, ok := h.Network().(netTptForDialinger); ok {
+		bogusWebTransportMa, err := ma.NewMultiaddr("/ip4/1.2.3.4/udp/1234/quic-v1/webtransport")
+		if err != nil {
+			panic(fmt.Errorf("builtin constant test webtransport address no longer parses"))
+		}
+		if foundTpt := n.TransportForDialing(bogusWebTransportMa); foundTpt != nil {
+			oldFactory := h.AddrsFactory
+			h.AddrsFactory = func(addrs []ma.Multiaddr) []ma.Multiaddr {
+				processedAddrs := oldFactory(addrs)
+				var indicesForIncompleteWebTransportMultiaddrs []int
+				for i := 0; i < len(processedAddrs); i++ {
+					protos := processedAddrs[i].Protocols()
+					lastProto := protos[len(protos)-1]
+					if lastProto.Code == int(mc.Webtransport) {
+						indicesForIncompleteWebTransportMultiaddrs = append(indicesForIncompleteWebTransportMultiaddrs, i)
+					}
+				}
+				// Found some webtransport addresses that do not have certhashes attached
+				if len(indicesForIncompleteWebTransportMultiaddrs) > 0 {
+					// get the certhashes
+					// we could get them from the webtransport code ourselves but that's inaccessible from here
+					// so instead we use the roundabout method
+					for _, a := range addrs {
+						comps := ma.Split(a)
+						nc := len(comps)
+						if nc > 3 && comps[nc-1].Protocols()[0].Code == int(mc.Certhash) &&
+							comps[nc-2].Protocols()[0].Code == int(mc.Certhash) &&
+							comps[nc-3].Protocols()[0].Code == int(mc.Webtransport) {
+							// we found some certhashes to use, let's use them
+							for _, idxToModify := range indicesForIncompleteWebTransportMultiaddrs {
+								processedAddrs[idxToModify] = processedAddrs[idxToModify].Encapsulate(comps[nc-2]).Encapsulate(comps[nc-1])
+							}
+							break
+						}
+					}
+				}
+				return processedAddrs
+			}
+		}
+	}
+
 	// TODO: This method succeeds if listening on one address succeeds. We
 	// should probably fail if listening on *any* addr fails.
 	if err := h.Network().Listen(cfg.ListenAddrs...); err != nil {

libp2p_test.go

@@ -17,8 +17,10 @@ import (
 	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"
+	webtransport "github.com/libp2p/go-libp2p/p2p/transport/webtransport"
 
 	ma "github.com/multiformats/go-multiaddr"
+	mc "github.com/multiformats/go-multicodec"
 	"github.com/stretchr/testify/require"
 )
 
@@ -197,13 +199,51 @@ func TestTransportConstructorQUIC(t *testing.T) {
 	require.Contains(t, err.Error(), swarm.ErrNoTransport.Error())
 }
 
+func TestTransportConstructorWebTransport(t *testing.T) {
+	h, err := New(
+		Transport(webtransport.New),
+		DisableRelay(),
+	)
+	require.NoError(t, err)
+	defer h.Close()
+	require.NoError(t, h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport")))
+	err = h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/"))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), swarm.ErrNoTransport.Error())
+}
+
+func TestTransportCustomAddressWebTransport(t *testing.T) {
+	customAddr, err := ma.NewMultiaddr("/ip4/1.2.3.4/udp/1234/quic-v1/webtransport")
+	if err != nil {
+		t.Fatal(err)
+	}
+	h, err := New(
+		Transport(webtransport.New),
+		DisableRelay(),
+		AddrsFactory(func(multiaddrs []ma.Multiaddr) []ma.Multiaddr {
+			return []ma.Multiaddr{customAddr}
+		}),
+	)
+	require.NoError(t, err)
+	defer h.Close()
+	require.NoError(t, h.Network().Listen(ma.StringCast("/ip4/127.0.0.1/udp/0/quic-v1/webtransport")))
+	addrs := h.Addrs()
+	require.Len(t, addrs, 1)
+	require.NotEqual(t, addrs[0], customAddr)
+	restOfAddr, lastComp := ma.SplitLast(addrs[0])
+	restOfAddr, secondToLastComp := ma.SplitLast(restOfAddr)
+	require.Equal(t, lastComp.Protocol().Code, int(mc.Certhash))
+	require.Equal(t, secondToLastComp.Protocol().Code, int(mc.Certhash))
+	require.True(t, restOfAddr.Equal(customAddr))
+}
+
 type mockTransport struct{}
 
 func (m mockTransport) Dial(context.Context, ma.Multiaddr, peer.ID) (transport.CapableConn, error) {
 	panic("implement me")
 }
 
-func (m mockTransport) CanDial(ma.Multiaddr) bool                       { panic("implement me") }
+func (m mockTransport) CanDial(ma.Multiaddr) bool                       { return false }
 func (m mockTransport) Listen(ma.Multiaddr) (transport.Listener, error) { panic("implement me") }
 func (m mockTransport) Protocols() []int                                { return []int{1337} }
 func (m mockTransport) Proxy() bool                                     { panic("implement me") }