Merge pull request #39 from depools/fix/for-demo

Reading QR from camera fix, chunk size, show_finished_dkg command

airgapped/airgapped.go

@@ -279,7 +279,7 @@ func (am *AirgappedMachine) HandleQR() ([]string, error) {
 		qrPath := fmt.Sprintf("%s/%s_%s_%s-%d.png", resultQRFolder, resultOperation.Type, resultOperation.ID,
 			resultOperation.To, idx)
 		if err = am.qrProcessor.WriteQR(qrPath, chunk); err != nil {
-			return nil, fmt.Errorf("failed to write QR")
+			return nil, fmt.Errorf("failed to write QR: %w", err)
 		}
 		qrPaths = append(qrPaths, qrPath)
 	}

airgapped/types.go

@@ -3,6 +3,8 @@ package airgapped
 import (
 	"fmt"
 	"github.com/depools/dc4bc/dkg"
+	"github.com/syndtr/goleveldb/leveldb/util"
+	"strings"
 )
 
 const (
@@ -39,3 +41,24 @@ func (am *AirgappedMachine) loadBLSKeyring(dkgID string) (*dkg.BLSKeyring, error
 	}
 	return blsKeyring, nil
 }
+
+func (am *AirgappedMachine) GetBLSKeyrings() (map[string]*dkg.BLSKeyring, error) {
+	var (
+		blsKeyring *dkg.BLSKeyring
+		err        error
+	)
+
+	keyrings := make(map[string]*dkg.BLSKeyring)
+	iter := am.db.NewIterator(util.BytesPrefix([]byte(blsKeyringPrefix)), nil)
+	defer iter.Release()
+
+	for iter.Next() {
+		key := iter.Key()
+		value := iter.Value()
+		if blsKeyring, err = dkg.LoadBLSKeyringFromBytes(value); err != nil {
+			return nil, fmt.Errorf("failed to decode bls keyring: %w", err)
+		}
+		keyrings[strings.TrimLeft(string(key), blsKeyringPrefix)] = blsKeyring
+	}
+	return keyrings, iter.Error()
+}

cmd/airgapped/main.go

@@ -49,6 +49,10 @@ func NewTerminal(machine *airgapped.AirgappedMachine) *terminal {
 		commandHandler: t.setAddressCommand,
 		description:    "set an airgapped address",
 	})
+	t.addCommand("show_finished_dkg", &terminalCommand{
+		commandHandler: t.showFinishedDKGCommand,
+		description:    "shows a list of finished dkg rounds",
+	})
 	return &t
 }
 
@@ -105,6 +109,19 @@ func (t *terminal) helpCommand() error {
 	return nil
 }
 
+func (t *terminal) showFinishedDKGCommand() error {
+	keyrings, err := t.airgapped.GetBLSKeyrings()
+	if err != nil {
+		return fmt.Errorf("failed to get a list of finished dkgs: %w", err)
+	}
+	for dkgID, keyring := range keyrings {
+		fmt.Printf("DKG identifier: %s\n", dkgID)
+		fmt.Printf("PubKey: %s\n", keyring.PubPoly.Commit().String())
+		fmt.Println("-----------------------------------------------------")
+	}
+	return nil
+}
+
 func (t *terminal) run() error {
 	reader := bufio.NewReader(os.Stdin)
 

cmd/dc4bc_cli/main.go

@@ -296,27 +296,28 @@ func startDKGCommand() *cobra.Command {
 				p := &requests.SignatureProposalParticipantsEntry{}
 				fmt.Printf("Enter a necessary data for participant %d:\n", i)
 				fmt.Printf("Enter address: ")
-				p.Addr, err = reader.ReadString('\n')
+				addr, _, err := reader.ReadLine()
 				if err != nil {
 					return fmt.Errorf("failed to read addr: %w", err)
 				}
+				p.Addr = string(addr)
 
 				fmt.Printf("Enter pubkey (base64): ")
-				pubKeyStr, err := reader.ReadString('\n')
+				pubKey, _, err := reader.ReadLine()
 				if err != nil {
 					return fmt.Errorf("failed to read pubKey: %w", err)
 				}
-				p.PubKey, err = base64.StdEncoding.DecodeString(pubKeyStr)
+				p.PubKey, err = base64.StdEncoding.DecodeString(string(pubKey))
 				if err != nil {
 					return fmt.Errorf("failed to decode pubKey: %w", err)
 				}
 
 				fmt.Printf("Enter DKGPubKey (base64): ")
-				DKGPubKeyStr, err := reader.ReadString('\n')
+				DKGPubKey, _, err := reader.ReadLine()
 				if err != nil {
 					return fmt.Errorf("failed to read DKGPubKey: %w", err)
 				}
-				p.DkgPubKey, err = base64.StdEncoding.DecodeString(DKGPubKeyStr)
+				p.DkgPubKey, err = base64.StdEncoding.DecodeString(string(DKGPubKey))
 				if err != nil {
 					return fmt.Errorf("failed to decode DKGPubKey: %w", err)
 				}

qr/chunk.go

@@ -7,7 +7,7 @@ import (
 	"math"
 )
 
-const chunkSize = 512
+const chunkSize = 256
 
 type chunk struct {
 	Data    []byte

qr/qr.go

@@ -34,7 +34,7 @@ func (p *CameraProcessor) ReadQR() ([]byte, error) {
 	if err != nil {
 		return nil, fmt.Errorf("failed to OpenVideoCapture: %w", err)
 	}
-	window := gocv.NewWindow("Hello")
+	window := gocv.NewWindow("Please, show a qr code")
 
 	defer func() {
 		if err := webcam.Close(); err != nil {
@@ -50,29 +50,24 @@ func (p *CameraProcessor) ReadQR() ([]byte, error) {
 	img := gocv.NewMat()
 	defer img.Close()
 
-	tk := time.NewTimer(timeToScan)
-
-	// This loop reads an image from the webcam every millisecond
-	// for 5 seconds. The last image taken will be used as the final
-	//one.
-loop:
 	for {
-		select {
-		case <-tk.C:
-			break loop
-		default:
-			webcam.Read(&img)
-			window.IMShow(img)
-			window.WaitKey(1)
+		webcam.Read(&img)
+		window.IMShow(img)
+		window.WaitKey(1)
+
+		imgObject, err := img.ToImage()
+		if err != nil {
+			return nil, fmt.Errorf("failed to get image object: %w", err)
 		}
+		data, err := ReadDataFromQR(imgObject)
+		if err != nil {
+			if _, ok := err.(gozxing.NotFoundException); ok {
+				continue
+			}
+			return nil, err
+		}
+		return data, nil
 	}
-
-	imgObject, err := img.ToImage()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get image object: %w", err)
-	}
-
-	return ReadDataFromQR(imgObject)
 }
 
 func (p *CameraProcessor) WriteQR(path string, data []byte) error {
@@ -93,6 +88,9 @@ func ReadDataFromQR(img image.Image) ([]byte, error) {
 	qrReader := qrcode.NewQRCodeReader()
 	result, err := qrReader.Decode(bmp, nil)
 	if err != nil {
+		if _, ok := err.(gozxing.NotFoundException); ok {
+			return nil, err
+		}
 		return nil, fmt.Errorf("failed to decode the QR-code contents: %w", err)
 	}
 	return []byte(result.String()), nil