dkg

var Cmd = &cobra.Command{
	Use:  "dkg",
	Long: `Distributed key generation for creating secret shares without any dealer.`,
	RunE: func(cmd *cobra.Command, args []string) error {
		yamlFile, err := os.ReadFile(viper.GetString("config"))
		if err != nil {
			return err
		}

		cfg := DKGConfig{}
		err = yaml.Unmarshal(yamlFile, &cfg)
		if err != nil {
			return err
		}

		rawIdentity, err := base64.StdEncoding.DecodeString(cfg.Identity)
		priv, err := crypto.UnmarshalPrivateKey(rawIdentity)
		if err != nil {
			log.Crit("Failed to unmarshal", "err", err)
		}

		host, err := node.MakeBasicHost(cfg.Port, priv)
		if err != nil {
			log.Crit("Failed to create a basic host", "err", err)
		}

		selfId := host.ID().String()

		log.Debug("my ID", "id", selfId, "addr", host.Addrs())

		pm := node.NewPeerManager(selfId, host, dkgProtocol)

		for _, p := range cfg.Peers {
			pm.AddPeer(p.Id, node.GetPeerAddr(p.Port, p.Id))
		}

		l := node.NewListener()

		dkgCore, err := dkg.NewDKG(utils.GetCurve(), pm, []byte(cfg.SessionId), cfg.Threshold, cfg.Rank, l)
		if err != nil {
			log.Warn("Cannot create a new DKG", "config", cfg, "err", err)
			return err
		}

		node := node.New[*dkg.Message, *dkg.Result](dkgCore, l, pm)
		if err != nil {
			log.Crit("Failed to new service", "err", err)
		}

		host.SetStreamHandler(dkgProtocol, func(s network.Stream) {
			node.Handle(s)
		})

		var (
			partialPublicKeys = map[string]*ecpointgrouplaw.ECPoint{}
			done              = make(chan struct{}, 1)
		)

		host.SetStreamHandler(exchangeProtocol, func(s network.Stream) {
			rawData, err := io.ReadAll(s)
			if err != nil {
				log.Warn("Cannot read message from peer", "err", err)
				return
			}
			s.Close()

			var msg ecpointgrouplaw.EcPointMessage

			err = proto.Unmarshal(rawData, &msg)
			if err != nil {
				log.Warn("Cannot unmarshal proto message", "err", err)
				return
			}

			p, err := msg.ToPoint()
			if err != nil {
				log.Warn("Cannot convert to EcPoint", "err", err)
				return
			}

			peerId := s.Conn().RemotePeer()

			partialPublicKeys[peerId.String()] = p

			log.Debug("Received partial public key", "peer", peerId, "point", p.String())

			if len(partialPublicKeys) == int(pm.NumPeers()+1) {
				done <- struct{}{}
			}
		})

		pm.EnsureAllConnected()

		result, err := node.Process()
		if err != nil {
			return err
		}

		myPartialPublicKey := ecpointgrouplaw.ScalarBaseMult(utils.GetCurve(), result.Share)
		partialPublicKeys[selfId] = myPartialPublicKey

		log.Debug("waitForPartialPublicKeys")

		err = waitForPartialPublicKeys(selfId, host, cfg, myPartialPublicKey, done)
		if err != nil {
			return err
		}

		dkgResult := &DKGResult{
			Share: result.Share.String(),
			Pubkey: config.Pubkey{
				X: result.PublicKey.GetX().String(),
				Y: result.PublicKey.GetY().String(),
			},
			BKs:               make(map[string]config.BK),
			Rid:               hex.EncodeToString(result.Rid),
			PartialPublicKeys: make(map[string]config.Pubkey),
		}
		for peerId, bk := range result.Bks {
			dkgResult.BKs[peerId] = config.BK{
				X:    bk.GetX().String(),
				Rank: bk.GetRank(),
			}
		}

		for peerId, partialPublicKey := range partialPublicKeys {
			dkgResult.PartialPublicKeys[peerId] = config.Pubkey{
				X: partialPublicKey.GetX().String(),
				Y: partialPublicKey.GetY().String(),
			}
		}

		fmt.Println()
		rawResult, _ := yaml.Marshal(dkgResult)
		fmt.Println(string(rawResult))

		var sigs = make(chan os.Signal, 1)
		defer close(sigs)

		signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
		defer signal.Stop(sigs)

		for sig := range sigs {
			log.Info("received signal", "sig", sig)
		}

		return nil
	},
}