github.com/ethereum-optimism/optimism@v1.7.2/op-node/cmd/p2p/cmd.go (about)

     1  package p2p
     2  
     3  import (
     4  	"crypto/rand"
     5  	"encoding/hex"
     6  	"fmt"
     7  	"io"
     8  	"os"
     9  	"strings"
    10  
    11  	"github.com/libp2p/go-libp2p/core/crypto"
    12  	"github.com/libp2p/go-libp2p/core/peer"
    13  	"github.com/urfave/cli/v2"
    14  )
    15  
    16  func Priv2PeerID(r io.Reader) (string, error) {
    17  	b, err := readHexData(r)
    18  	if err != nil {
    19  		return "", err
    20  	}
    21  
    22  	p, err := crypto.UnmarshalSecp256k1PrivateKey(b)
    23  	if err != nil {
    24  		return "", fmt.Errorf("failed to parse priv key from %d bytes: %w", len(b), err)
    25  	}
    26  
    27  	pid, err := peer.IDFromPrivateKey(p)
    28  	if err != nil {
    29  		return "", fmt.Errorf("failed to parse peer ID from private key: %w", err)
    30  	}
    31  	return pid.String(), nil
    32  }
    33  
    34  func Pub2PeerID(r io.Reader) (string, error) {
    35  	b, err := readHexData(r)
    36  	if err != nil {
    37  		return "", err
    38  	}
    39  
    40  	p, err := crypto.UnmarshalSecp256k1PublicKey(b)
    41  	if err != nil {
    42  		return "", fmt.Errorf("failed to parse pub key from %d bytes: %w", len(b), err)
    43  	}
    44  
    45  	pid, err := peer.IDFromPublicKey(p)
    46  	if err != nil {
    47  		return "", fmt.Errorf("failed to parse peer ID from public key: %w", err)
    48  	}
    49  
    50  	return pid.String(), nil
    51  }
    52  
    53  func readHexData(r io.Reader) ([]byte, error) {
    54  	data, err := io.ReadAll(r)
    55  	if err != nil {
    56  		return nil, err
    57  	}
    58  
    59  	rawStr := strings.TrimSpace(string(data))
    60  	rawStr = strings.TrimPrefix(rawStr, "0x")
    61  	b, err := hex.DecodeString(rawStr)
    62  	if err != nil {
    63  		return nil, fmt.Errorf("p2p key is not formatted in hex chars: %w", err)
    64  	}
    65  	return b, nil
    66  }
    67  
    68  var Subcommands = cli.Commands{
    69  	{
    70  		Name:  "priv2id",
    71  		Usage: "Reads a private key from STDIN, and returns a peer ID",
    72  		Action: func(ctx *cli.Context) error {
    73  			key, err := Priv2PeerID(os.Stdin)
    74  			if err != nil {
    75  				return err
    76  			}
    77  			fmt.Println(key)
    78  			return nil
    79  		},
    80  	},
    81  	{
    82  		Name:  "pub2id",
    83  		Usage: "Reads a public key from STDIN, and returns a peer ID",
    84  		Action: func(ctx *cli.Context) error {
    85  			key, err := Pub2PeerID(os.Stdin)
    86  			if err != nil {
    87  				return err
    88  			}
    89  			fmt.Println(key)
    90  			return nil
    91  		},
    92  	},
    93  	{
    94  		Name:  "genkey",
    95  		Usage: "Generates a private key",
    96  		Action: func(ctx *cli.Context) error {
    97  			buf := make([]byte, 32)
    98  			if _, err := rand.Read(buf); err != nil {
    99  				return fmt.Errorf("failed to get entropy: %w", err)
   100  			}
   101  			fmt.Println(hex.EncodeToString(buf))
   102  			return nil
   103  		},
   104  	},
   105  }