Completely rewrite key package to be smoother

global/global.go

@@ -24,7 +24,10 @@ func InitAndStartServices(ctx context.Context) {
 	s := config.Secret
 	h := host.New()
 	if config.Secret != "" {
-		id := key.CreateIdentity(s)
+		id, err := key.DecodePrivKey(s)
+		if err != nil {
+			log.Fatal(err)
+		}
 		h.AddOption(libp2p.Identity(id))
 	}
 

global/pubsub.go

@@ -9,7 +9,7 @@ import (
 	"github.com/bahner/go-myspace/p2p/pubsub"
 )
 
-func initPubSubService(ctx context.Context, wg *sync.WaitGroup, host *host.P2pHost) {
+func initPubSubService(ctx context.Context, wg *sync.WaitGroup, host *host.Host) {
 
 	defer wg.Done()
 

go.mod

@@ -5,6 +5,7 @@ go 1.20
 require (
 	github.com/ergo-services/ergo v1.999.224
 	github.com/hashicorp/vault/api v1.9.2
+	github.com/ipfs/boxo v0.11.0
 	github.com/libp2p/go-libp2p v0.29.2
 	github.com/libp2p/go-libp2p-kad-dht v0.24.3
 	github.com/libp2p/go-libp2p-pubsub v0.9.3
@@ -54,7 +55,6 @@ require (
 	github.com/hashicorp/golang-lru/v2 v2.0.2 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/huin/goupnp v1.2.0 // indirect
-	github.com/ipfs/boxo v0.10.0 // indirect
 	github.com/ipfs/go-cid v0.4.1 // indirect
 	github.com/ipfs/go-datastore v0.6.0 // indirect
 	github.com/ipfs/go-log v1.0.5 // indirect

go.sum

@@ -199,8 +199,8 @@ github.com/hashicorp/vault/api v1.9.2 h1:YjkZLJ7K3inKgMZ0wzCU9OHqc+UqMQyXsPXnf3C
 github.com/hashicorp/vault/api v1.9.2/go.mod h1:jo5Y/ET+hNyz+JnKDt8XLAdKs+AM0G5W0Vp1IrFI8N8=
 github.com/huin/goupnp v1.2.0 h1:uOKW26NG1hsSSbXIZ1IR7XP9Gjd1U8pnLaCMgntmkmY=
 github.com/huin/goupnp v1.2.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8=
-github.com/ipfs/boxo v0.10.0 h1:tdDAxq8jrsbRkYoF+5Rcqyeb91hgWe2hp7iLu7ORZLY=
-github.com/ipfs/boxo v0.10.0/go.mod h1:Fg+BnfxZ0RPzR0nOodzdIq3A7KgoWAOWsEIImrIQdBM=
+github.com/ipfs/boxo v0.11.0 h1:urMxhZ3xoF4HssJVD3+0ssGT9pptEfHfbL8DYdoWFlg=
+github.com/ipfs/boxo v0.11.0/go.mod h1:8IfDmp+FzFGcF4zjAgHMVPpwYw4AjN9ePEzDfkaYJ1w=
 github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s=
 github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk=
 github.com/ipfs/go-datastore v0.6.0 h1:JKyz+Gvz1QEZw0LsX1IBn+JFCJQH4SJVFtM4uWU0Myk=

p2p/host/host.go

@@ -9,22 +9,22 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
-type P2pHost struct {
+type Host struct {
 	Node    host.Host
 	Options []libp2p.Option
 }
 
-func New(options ...libp2p.Option) *P2pHost {
-	return &P2pHost{
+func New(options ...libp2p.Option) *Host {
+	return &Host{
 		Options: options,
 	}
 }
 
-func (h *P2pHost) AddOption(opt libp2p.Option) {
+func (h *Host) AddOption(opt libp2p.Option) {
 	h.Options = append(h.Options, opt)
 }
 
-func (h *P2pHost) Init(ctx context.Context) {
+func (h *Host) Init(ctx context.Context) {
 
 	var err error
 	log.Info("Starting libp2p node...")
@@ -35,7 +35,7 @@ func (h *P2pHost) Init(ctx context.Context) {
 	log.Info("libp2p node created: ", h.Node.ID().Pretty())
 }
 
-func (h *P2pHost) StartPeerDiscovery(ctx context.Context, rendezvous string, serviceName string) {
+func (h *Host) StartPeerDiscovery(ctx context.Context, rendezvous string, serviceName string) {
 
 	log.Debug("Starting peer discovery...")
 

p2p/key/key.go

@@ -7,68 +7,149 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
+	"github.com/ipfs/boxo/ipns"
 	"github.com/libp2p/go-libp2p/core/crypto"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/mr-tron/base58"
 )
 
-func PrintEd25519KeyAndExit() {
+type Key struct {
+	PrivKey        crypto.PrivKey
+	PublicKey      crypto.PubKey
+	EncodedPrivKey string
+	IPNSName       ipns.Name
+}
 
-	privKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
+func New() (*Key, error) {
+	privKey, pubKey, err := generateEd25519KeyPair()
 	if err != nil {
-		log.Fatalf("Failed to generate private key: %v", err)
+		return nil, err
 	}
-	marshalledPrivKey, err := crypto.MarshalPrivateKey(privKey)
+
+	encodedPrivKey, err := EncodePrivKey(privKey)
 	if err != nil {
-		log.Fatalf("Failed to marshal private key: %v", err)
+		return nil, err
 	}
-	encodedPrivKey := base58.Encode(marshalledPrivKey)
+
+	ipnsName, err := ipnsNameFromPublicKey(pubKey)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Key{
+		PrivKey:        privKey,
+		PublicKey:      pubKey,
+		EncodedPrivKey: encodedPrivKey,
+		IPNSName:       ipnsName,
+	}, nil
+}
+func NewFromEncodedPrivKey(encodedPrivKey string) (*Key, error) {
+	privKey, pubKey, err := keyPairFromEncodedPrivkey(encodedPrivKey)
+	if err != nil {
+		return nil, err
+	}
+
+	ipnsName, err := ipnsNameFromPublicKey(pubKey)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Key{
+		PrivKey:        privKey,
+		PublicKey:      pubKey,
+		EncodedPrivKey: encodedPrivKey,
+		IPNSName:       ipnsName,
+	}, nil
+}
+
+func PrintEd25519KeyAndExit() {
+
+	encodedPrivKey, err := GenerateEncodedKey()
+	if err != nil {
+		log.Fatalf("Failed to generate encoded private key: %v", err)
+	}
+
 	fmt.Println(encodedPrivKey)
 
 	os.Exit(0)
 
 }
 
-func GenerateSecretKey() string {
+func GenerateEncodedKey() (string, error) {
 
-	privKey, _, err := crypto.GenerateEd25519Key(rand.Reader)
+	pk, _, err := generateEd25519KeyPair()
 	if err != nil {
-		log.Fatalf("Failed to generate private key: %v", err)
+		return "", err
 	}
-	marshalledPrivKey, err := crypto.MarshalPrivateKey(privKey)
+	encodedPrivKey, err := EncodePrivKey(pk)
 	if err != nil {
-		log.Fatalf("Failed to marshal private key: %v", err)
+		return "", err
+
 	}
-	encodedPrivKey := base58.Encode(marshalledPrivKey)
 
-	return encodedPrivKey
+	return encodedPrivKey, nil
 }
 
-func CreateIdentity(privKey string) crypto.PrivKey {
+func DecodePrivKey(privKey string) (crypto.PrivKey, error) {
 
 	// Decode the secret key
 	decoded, err := base58.Decode(privKey)
 	if err != nil {
-		log.Fatalf("Failed to decode base58 secret key: %v", err)
+		log.Errorf("Failed to decode base58 secret key: %v", err)
+		return nil, err
 	}
 	p, err := crypto.UnmarshalPrivateKey(decoded)
 	if err != nil {
-		log.Fatalf("Failed to unmarshal private key: %v", err)
+		log.Errorf("Failed to unmarshal private key: %v", err)
+		return nil, err
 	}
 
-	return p
+	return p, nil
 
 }
 
-func ExtractSecretKey(privKey string) crypto.PrivKey {
+func EncodePrivKey(privKey crypto.PrivKey) (string, error) {
 
-	decodedPrivKey, err := base58.Decode(privKey)
+	marshalledPrivKey, err := crypto.MarshalPrivateKey(privKey)
 	if err != nil {
-		log.Errorf("Failed to decode base58 secret key: %v", err)
+		log.Errorf("Failed to marshal private key: %v", err)
+		return "", err
 	}
-	unmarshalledPrivKey, err := crypto.UnmarshalPrivateKey(decodedPrivKey)
+	encodedPrivKey := base58.Encode(marshalledPrivKey)
+
+	return encodedPrivKey, nil
+}
+
+func generateEd25519KeyPair() (crypto.PrivKey, crypto.PubKey, error) {
+
+	privKey, pubKey, err := crypto.GenerateEd25519Key(rand.Reader)
 	if err != nil {
-		log.Errorf("Failed to unmarshal private key: %v", err)
+		log.Errorf("Failed to generate private key: %v", err)
+		return nil, nil, err
+	}
+
+	return privKey, pubKey, nil
+}
+
+func ipnsNameFromPublicKey(pubKey crypto.PubKey) (ipns.Name, error) {
+
+	pid, err := peer.IDFromPublicKey(pubKey)
+	if err != nil {
+		log.Errorf("Failed to generate peer ID from public key: %v", err)
+		return ipns.Name{}, err
+	}
+	ipnsName := ipns.NameFromPeer(pid)
+
+	return ipnsName, nil
+}
+
+func keyPairFromEncodedPrivkey(encodedPrivKey string) (crypto.PrivKey, crypto.PubKey, error) {
+
+	privKey, err := DecodePrivKey(encodedPrivKey)
+	if err != nil {
+		return nil, nil, err
 	}
 
-	return unmarshalledPrivKey
+	return crypto.KeyPairFromStdKey(privKey)
+
 }

p2p/pubsub/service.go

@@ -10,10 +10,10 @@ import (
 
 type Service struct {
 	Sub  *pubsub.PubSub
-	Host *host.P2pHost
+	Host *host.Host
 }
 
-func New(host *host.P2pHost) *Service {
+func New(host *host.Host) *Service {
 	return &Service{
 		Host: host,
 	}