feat: seed-based automatic peering

go.mod

@@ -25,6 +25,7 @@ require (
 	github.com/libp2p/go-libp2p-kad-dht v0.25.2
 	github.com/libp2p/go-libp2p-record v0.2.0
 	github.com/libp2p/go-libp2p-routing-helpers v0.7.3
+	github.com/libp2p/go-libp2p-testing v0.12.0
 	github.com/mitchellh/go-server-timing v1.0.1
 	github.com/mr-tron/base58 v1.2.0
 	github.com/multiformats/go-multiaddr v0.12.2

keys.go

@@ -9,6 +9,7 @@ import (
 	"io"
 
 	libp2p "github.com/libp2p/go-libp2p/core/crypto"
+	peer "github.com/libp2p/go-libp2p/core/peer"
 	"github.com/mr-tron/base58"
 	"golang.org/x/crypto/hkdf"
 )
@@ -25,7 +26,7 @@ func newSeed() (string, error) {
 	return base58.Encode(bs), nil
 }
 
-// derive derives libp2p keys from a b58-encoded seed.
+// deriveKey derives libp2p keys from a b58-encoded seed.
 func deriveKey(b58secret string, info []byte) (libp2p.PrivKey, error) {
 	secret, err := base58.Decode(b58secret)
 	if err != nil {
@@ -45,6 +46,32 @@ func deriveKey(b58secret string, info []byte) (libp2p.PrivKey, error) {
 	return libp2p.UnmarshalEd25519PrivateKey(key)
 }
 
+// derivePeerIDs derives the peer IDs of all the peers with the same seed up to
+// maxIndex. Our peer ID (with index 'ourIndex') is not generated.
+func derivePeerIDs(seed string, ourIndex int, maxIndex int) ([]peer.ID, error) {
+	peerIDs := []peer.ID{}
+
+	for i := 0; i <= maxIndex; i++ {
+		if i == ourIndex {
+			continue
+		}
+
+		peerPriv, err := deriveKey(seed, deriveKeyInfo(i))
+		if err != nil {
+			return nil, err
+		}
+
+		pid, err := peer.IDFromPrivateKey(peerPriv)
+		if err != nil {
+			return nil, err
+		}
+
+		peerIDs = append(peerIDs, pid)
+	}
+
+	return peerIDs, nil
+}
+
 func deriveKeyInfo(index int) []byte {
 	return []byte(fmt.Sprintf("rainbow-%d", index))
 }

main.go

@@ -91,6 +91,18 @@ Generate an identity seed and launch a gateway:
 			EnvVars: []string{"RAINBOW_SEED_INDEX"},
 			Usage:   "Index to derivate the peerID (needs --seed)",
 		},
+		&cli.BoolFlag{
+			Name:    "seed-peering",
+			Value:   false,
+			EnvVars: []string{"RAINBOW_SEED_PEERING"},
+			Usage:   "Automatic peering with peers with the same seed (requires --seed and --seed-index). Runs a separate light DHT for peer routing with the main host if --dht-routing or --dht-shared-host are disabled",
+		},
+		&cli.UintFlag{
+			Name:    "seed-peering-max-index",
+			Value:   100,
+			EnvVars: []string{"RAINBOW_SEED_PEERING_MAX_INDEX"},
+			Usage:   "Largest index to derive automatic peering peer IDs for",
+		},
 		&cli.StringSliceFlag{
 			Name:    "gateway-domains",
 			Value:   cli.NewStringSlice(),
@@ -315,6 +327,24 @@ share the same seed as long as the indexes are different.
 			peeringAddrs = append(peeringAddrs, *ai)
 		}
 
+		if cctx.Bool("seed-peering") {
+			if !cctx.IsSet("seed") || !cctx.IsSet("seed-index") {
+				return errors.New("--seed and --seed-index must be explicitly defined when --seed-peering is enabled")
+			}
+
+			maxIndex := cctx.Uint("seed-peering-max-index")
+			peeringIDs, err := derivePeerIDs(seed, index, int(maxIndex))
+			if err != nil {
+				return err
+			}
+
+			for _, pid := range peeringIDs {
+				// The peering module will automatically perform lookups to find the
+				// addresses of the given peers.
+				peeringAddrs = append(peeringAddrs, peer.AddrInfo{ID: pid})
+			}
+		}
+
 		cfg := Config{
 			DataDir:                 ddir,
 			BlockstoreType:          cctx.String("blockstore"),
@@ -334,6 +364,7 @@ share the same seed as long as the indexes are different.
 			DenylistSubs:            cctx.StringSlice("denylists"),
 			Peering:                 peeringAddrs,
 			PeeringCache:            cctx.Bool("peering-shared-cache"),
+			SeedPeering:             cctx.Bool("seed-peering"),
 			GCInterval:              cctx.Duration("gc-interval"),
 			GCThreshold:             cctx.Float64("gc-threshold"),
 		}