op-node: Add p2p utils

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,22 @@ func main() {
 	)
 
 	app := cli.NewApp()
-	app.Flags = flags.Flags
 	app.Version = VersionWithMeta
 	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

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,35 @@
+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)
+	})
+}

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