op-node: Add p2p utils (#3150)

* op-node: Add p2p utils

* Update op-node/cmd/p2p/cmd.go
Co-authored-by: Joshua Gutow <jgutow@optimism.io>

* Update op-node/cmd/p2p/cmd.go
Co-authored-by: Joshua Gutow <jgutow@optimism.io>

* lint

* fix devnet
Co-authored-by: Joshua Gutow <jgutow@optimism.io>

op-node/cmd/main.go

@@ -9,6 +9,8 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-node/cmd/p2p"
+
 	"github.com/ethereum-optimism/optimism/op-node/metrics"
 
 	opnode "github.com/ethereum-optimism/optimism/op-node"
@@ -53,13 +55,23 @@ func main() {
 	)
 
 	app := cli.NewApp()
-	app.Flags = flags.Flags
 	app.Version = VersionWithMeta
+	app.Flags = flags.GlobalFlags
 	app.Name = "opnode"
 	app.Usage = "Optimism Rollup Node"
 	app.Description = "The deposit only rollup node drives the L2 execution engine based on L1 deposits."
+	app.Commands = []cli.Command{
+		{
+			Name:        "p2p",
+			Subcommands: p2p.Subcommands,
+		},
+		{
+			Name:   "start",
+			Action: RollupNodeMain,
+			Flags:  flags.Flags,
+		},
+	}
 
-	app.Action = RollupNodeMain
 	err := app.Run(os.Args)
 	if err != nil {
 		log.Crit("Application failed", "message", err)

op-node/cmd/p2p/cmd.go

+package p2p
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/libp2p/go-libp2p-core/crypto"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/urfave/cli"
+)
+
+func Priv2PeerID(r io.Reader) (string, error) {
+	b, err := readHexData(r)
+	if err != nil {
+		return "", nil
+	}
+
+	p, err := crypto.UnmarshalSecp256k1PrivateKey(b)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse priv key from %d bytes: %w", len(b), err)
+	}
+
+	pid, err := peer.IDFromPrivateKey(p)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse peer ID from private key: %w", err)
+	}
+	return pid.String(), nil
+}
+
+func Pub2PeerID(r io.Reader) (string, error) {
+	b, err := readHexData(r)
+	if err != nil {
+		return "", nil
+	}
+
+	p, err := crypto.UnmarshalSecp256k1PublicKey(b)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse pub key from %d bytes: %w", len(b), err)
+	}
+
+	pid, err := peer.IDFromPublicKey(p)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse peer ID from public key: %w", err)
+	}
+
+	return pid.String(), nil
+}
+
+func readHexData(r io.Reader) ([]byte, error) {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	rawStr := strings.TrimSpace(string(data))
+	rawStr = strings.TrimPrefix(rawStr, "0x")
+	b, err := hex.DecodeString(rawStr)
+	if err != nil {
+		return nil, fmt.Errorf("p2p key is not formatted in hex chars: %w", err)
+	}
+	return b, nil
+}
+
+var Subcommands = cli.Commands{
+	{
+		Name:  "priv2id",
+		Usage: "Reads a private key from STDIN, and returns a peer ID",
+		Action: func(ctx *cli.Context) error {
+			key, err := Priv2PeerID(os.Stdin)
+			if err != nil {
+				return err
+			}
+			fmt.Println(key)
+			return nil
+		},
+	},
+	{
+		Name:  "pub2id",
+		Usage: "Reads a public key from STDIN, and returns a peer ID",
+		Action: func(ctx *cli.Context) error {
+			key, err := Pub2PeerID(os.Stdin)
+			if err != nil {
+				return err
+			}
+			fmt.Println(key)
+			return nil
+		},
+	},
+	{
+		Name:  "genkey",
+		Usage: "Generates a private key",
+		Action: func(ctx *cli.Context) error {
+			buf := make([]byte, 32)
+			if _, err := rand.Read(buf); err != nil {
+				return fmt.Errorf("failed to get entropy: %w", err)
+			}
+			fmt.Println(hex.EncodeToString(buf))
+			return nil
+		},
+	},
+}

op-node/cmd/p2p/cmd_test.go

+package p2p
+
+import (
+	"bytes"
+	"encoding/hex"
+	"testing"
+
+	"github.com/libp2p/go-libp2p-core/crypto"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPrivPub2PeerID(t *testing.T) {
+	priv, pub, err := crypto.GenerateKeyPair(crypto.Secp256k1, 32)
+	require.NoError(t, err)
+	privRaw, err := priv.Raw()
+	require.NoError(t, err)
+	pubRaw, err := pub.Raw()
+	require.NoError(t, err)
+
+	t.Run("with a private key", func(t *testing.T) {
+		privPidLib, err := peer.IDFromPrivateKey(priv)
+		require.NoError(t, err)
+		privPidImpl, err := Priv2PeerID(bytes.NewReader([]byte(hex.EncodeToString(privRaw))))
+		require.NoError(t, err)
+		require.Equal(t, privPidLib.String(), privPidImpl)
+	})
+	t.Run("with a public key", func(t *testing.T) {
+		pubPidLib, err := peer.IDFromPublicKey(pub)
+		require.NoError(t, err)
+		pubPidImpl, err := Pub2PeerID(bytes.NewReader([]byte(hex.EncodeToString(pubRaw))))
+		require.NoError(t, err)
+		require.Equal(t, pubPidLib.String(), pubPidImpl)
+	})
+}

op-node/flags/flags.go

@@ -150,9 +150,6 @@ var optionalFlags = append([]cli.Flag{
 	VerifierL1Confs,
 	SequencerEnabledFlag,
 	SequencerL1Confs,
-	LogLevelFlag,
-	LogFormatFlag,
-	LogColorFlag,
 	MetricsEnabledFlag,
 	MetricsAddrFlag,
 	MetricsPortFlag,
@@ -162,5 +159,12 @@ var optionalFlags = append([]cli.Flag{
 	SnapshotLog,
 }, p2pFlags...)
 
-// Flags contains the list of configuration options available to the binary.
+// GlobalFlags contains the list of configuration options available to every command.
+var GlobalFlags = []cli.Flag{
+	LogLevelFlag,
+	LogFormatFlag,
+	LogColorFlag,
+}
+
+// Flags contains the list of configuration options available to the start command.
 var Flags = append(requiredFlags, optionalFlags...)

ops-bedrock/docker-compose.yml

@@ -45,6 +45,7 @@ services:
       dockerfile: ./op-node/Dockerfile
     command: >
       op-node
+      start
       --l1=ws://l1:8546
       --l2=ws://l2:8546
       --l2.jwt-secret=/config/test-jwt-secret.txt