feat: implemented sharesData format for keyshare file (#20)

Author: CluEleSsUK

cli/internal/cmd/sign.go

@@ -110,7 +110,7 @@ func Sign(cmd *cobra.Command, _ []string) {
 	if err != nil {
 		shared.Exit(fmt.Sprintf("couldn't turn the keyshare into json: %v", err))
 	}
-	log.MaybeLog("keyfile JSON for use with the SSV UI:")
+	log.MaybeLog("📄 here is a keyfile JSON for use with the SSV UI >")
 	log.Log(string(j))
 }
 

cli/internal/state/share.go

@@ -3,6 +3,7 @@ package state
 import (
 	"encoding/base64"
 	"encoding/hex"
+	"fmt"
 	"time"
 
 	"github.com/randa-mu/ssv-dkg/shared/api"
@@ -46,33 +47,38 @@ func CreateKeyshareFile(ownerConfig api.OwnerConfig, signingOutput api.SigningOu
 
 	operators := make([]operator, len(signingOutput.OperatorShares))
 	operatorIDs := make([]uint32, len(signingOutput.OperatorShares))
+	var publicKeys []byte
+	var encryptedShares []byte
 
 	for i, share := range signingOutput.OperatorShares {
-		operatorKey := make([]byte, base64.StdEncoding.EncodedLen(len(share.Identity.Public)))
-		base64.StdEncoding.Encode(operatorKey, share.Identity.Public)
+		operatorKey := make([]byte, base64.RawStdEncoding.EncodedLen(len(share.Identity.Public)))
+		base64.RawStdEncoding.Encode(operatorKey, share.Identity.Public)
 		operators[i] = operator{
 			Id:          uint32(i),
 			OperatorKey: operatorKey,
 		}
 		operatorIDs[i] = uint32(i)
+		publicKeys = append(publicKeys, share.Identity.Public...)
+		encryptedShares = append(encryptedShares, share.EncryptedShare...)
 	}
 
+	sharesData := append(append(signingOutput.ValidatorNonceSignature, publicKeys...), encryptedShares...)
+
 	return KeyshareFile{
 		Version:   KeyshareFileVersion,
 		CreatedAt: time.Now().UTC().String(),
 		Shares: []keyShare{
 			{
 				Data: data{
 					OwnerNonce:   ownerConfig.ValidatorNonce,
-					OwnerAddress: hex.EncodeToString(ownerConfig.Address),
+					OwnerAddress: fmt.Sprintf("0x%s", hex.EncodeToString(ownerConfig.Address)),
 					PublicKey:    publicKey,
 					Operators:    operators,
 				},
 				Payload: payload{
 					PublicKey:   publicKey,
 					OperatorIDs: operatorIDs,
-					// TODO: work out how this is actually encoded from the encrypted sahres
-					SharesData: "0xdeadbeefdeadbeef",
+					SharesData:  fmt.Sprintf("0x%s", hex.EncodeToString(sharesData)),
 				},
 			},
 		},

shared/api/cli.go

@@ -2,11 +2,12 @@ package api
 
 import (
 	"github.com/randa-mu/ssv-dkg/shared/crypto"
+	"github.com/randa-mu/ssv-dkg/shared/json"
 )
 
 type OwnerConfig struct {
-	Address        []byte
-	ValidatorNonce uint32
+	Address        json.HexBytes `json:"address"`
+	ValidatorNonce uint32        `json:"validator_nonce"`
 }
 
 type UnsignedDepositData struct {
@@ -26,16 +27,16 @@ type SignedDepositData struct {
 }
 
 type SigningOutput struct {
-	SessionID               []byte          `json:"session_id"`
-	GroupPublicKey          []byte          `json:"group_public_commitments"`
-	OperatorShares          []OperatorShare `json:"operator_shares"`
-	DepositDataSignature    []byte          `json:"deposit_data_signature"`
-	ValidatorNonceSignature []byte          `json:"validator_nonce_signature"`
+	SessionID               json.UnpaddedBytes `json:"session_id"`
+	GroupPublicKey          json.UnpaddedBytes `json:"group_public_commitments"`
+	OperatorShares          []OperatorShare    `json:"operator_shares"`
+	DepositDataSignature    json.UnpaddedBytes `json:"deposit_data_signature"`
+	ValidatorNonceSignature json.UnpaddedBytes `json:"validator_nonce_signature"`
 }
 
 type OperatorShare struct {
-	Identity       crypto.Identity `json:"identity"`
-	EncryptedShare []byte          `json:"encrypted_share"`
+	Identity       crypto.Identity    `json:"identity"`
+	EncryptedShare json.UnpaddedBytes `json:"encrypted_share"`
 }
 
 type OperatorResponse struct {

shared/api/sidecar.go

@@ -116,13 +116,15 @@ func createSignAPI(node Sidecar) http.HandlerFunc {
 		bytes, err := io.ReadAll(request.Body)
 		if err != nil {
 			writer.WriteHeader(http.StatusBadRequest)
+			slog.Debug("error reading signing body", "body", bytes, "err", err)
 			return
 		}
 
 		var requestBody SignRequest
 		err = json.Unmarshal(bytes, &requestBody)
 		if err != nil {
 			writer.WriteHeader(http.StatusBadRequest)
+			slog.Debug("error marshalling signing body", "body", bytes, "err", err)
 			return
 		}
 

shared/crypto/keys.go

@@ -6,6 +6,7 @@ import (
 	"encoding/binary"
 
 	"github.com/drand/kyber"
+	"github.com/randa-mu/ssv-dkg/shared/json"
 )
 
 // SigningScheme represents a cryptographic scheme used for signing and verification operations
@@ -56,9 +57,9 @@ func (k Keypair) SelfSign(suite SigningScheme, address string) (Identity, error)
 }
 
 type Identity struct {
-	Address   string `json:"address"`
-	Public    []byte `json:"public"`
-	Signature []byte `json:"signature"`
+	Address   string             `json:"address"`
+	Public    json.UnpaddedBytes `json:"public"`
+	Signature json.UnpaddedBytes `json:"signature"`
 }
 
 // Verify checks the signature for a given identity is valid, if e.g. pulled from a remote file

shared/json/bytes.go

@@ -0,0 +1,52 @@
+package json
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+)
+
+// UnpaddedBytes is a wrapper type that ensures bytes are marshalled to base64
+// in json with padding characters
+type UnpaddedBytes []byte
+
+func (b *UnpaddedBytes) MarshalJSON() ([]byte, error) {
+	encoded := base64.RawStdEncoding.EncodeToString(*b)
+	return json.Marshal(encoded)
+}
+
+func (b *UnpaddedBytes) UnmarshalJSON(data []byte) error {
+	var encoded string
+	if err := json.Unmarshal(data, &encoded); err != nil {
+		return err
+	}
+
+	decoded, err := base64.RawStdEncoding.DecodeString(encoded)
+	if err != nil {
+		return err
+	}
+	*b = decoded
+	return nil
+}
+
+// HexBytes is a wrapper type that ensures bytes are marshalled to
+// hex in json
+type HexBytes []byte
+
+func (b HexBytes) MarshalJSON() ([]byte, error) {
+	return json.Marshal(hex.EncodeToString(b))
+}
+
+func (b *HexBytes) UnmarshalJSON(data []byte) error {
+	var encoded string
+	if err := json.Unmarshal(data, &encoded); err != nil {
+		return err
+	}
+
+	decoded, err := hex.DecodeString(encoded)
+	if err != nil {
+		return err
+	}
+	*b = decoded
+	return nil
+}