Keyring revealer object to handle JSON hex or certifier

Author: jchavannes

wallet/interfaces.go

@@ -608,6 +608,41 @@ func AcquisitionProtocolFromString(s string) (AcquisitionProtocol, error) {
 
 const KeyringRevealerCertifier = "certifier"
 
+// KeyringRevealer is a special JSON type used for identifying the revealer of a keyring.
+// It can either point to the certifier or be a public key.
+type KeyringRevealer struct {
+	Certifier bool
+	PubKey    HexBytes33
+}
+
+func (r KeyringRevealer) MarshalJSON() ([]byte, error) {
+	if r.Certifier {
+		return json.Marshal(KeyringRevealerCertifier)
+	}
+	return json.Marshal(hex.EncodeToString(r.PubKey[:]))
+}
+
+func (r *KeyringRevealer) UnmarshalJSON(data []byte) error {
+	var str string
+	if err := json.Unmarshal(data, &str); err != nil {
+		return fmt.Errorf("error unmarshaling revealer: %w", err)
+	}
+
+	if str == KeyringRevealerCertifier {
+		r.Certifier = true
+		return nil
+	}
+	data, err := hex.DecodeString(str)
+	if err != nil {
+		return fmt.Errorf("error decoding revealer hex: %w", err)
+	}
+	if len(data) != 33 {
+		return fmt.Errorf("revealer hex must be 33 bytes, got %d", len(data))
+	}
+	copy(r.PubKey[:], data)
+	return nil
+}
+
 type AcquireCertificateArgs struct {
 	Type                Base64Bytes32       `json:"type"`
 	Certifier           HexBytes33          `json:"certifier"`
@@ -617,7 +652,7 @@ type AcquireCertificateArgs struct {
 	RevocationOutpoint  *Outpoint           `json:"revocationOutpoint,omitempty"`
 	Signature           JSONByteHex         `json:"signature,omitempty"`
 	CertifierUrl        string              `json:"certifierUrl,omitempty"`
-	KeyringRevealer     string              `json:"keyringRevealer,omitempty"` // "certifier" | PubKeyHex
+	KeyringRevealer     KeyringRevealer     `json:"keyringRevealer,omitempty"` // "certifier" | PubKeyHex
 	KeyringForSubject   map[string]string   `json:"keyringForSubject,omitempty"`
 	Privileged          *bool               `json:"privileged,omitempty"`
 	PrivilegedReason    string              `json:"privilegedReason,omitempty"`

wallet/serializer/acquire_certificate.go

@@ -1,7 +1,6 @@
 package serializer
 
 import (
-	"encoding/hex"
 	"fmt"
 
 	"github.com/bsv-blockchain/go-sdk/util"
@@ -63,10 +62,10 @@ func SerializeAcquireCertificateArgs(args *wallet.AcquireCertificateArgs) ([]byt
 		w.WriteIntBytes(args.Signature)
 
 		// Keyring revealer
-		if args.KeyringRevealer == wallet.KeyringRevealerCertifier {
+		if args.KeyringRevealer.Certifier {
 			w.WriteByte(keyRingRevealerCertifier)
-		} else if err := w.WriteSizeFromHex(args.KeyringRevealer, sizeRevealer); err != nil {
-			return nil, fmt.Errorf("invalid keyringRevealer hex: %w", err)
+		} else {
+			w.WriteBytes(args.KeyringRevealer.PubKey[:])
 		}
 
 		// Keyring for subject
@@ -152,10 +151,12 @@ func DeserializeAcquireCertificateArgs(data []byte) (*wallet.AcquireCertificateA
 		// Read keyring revealer
 		keyringRevealerIdentifier := r.ReadByte()
 		if keyringRevealerIdentifier == keyRingRevealerCertifier {
-			args.KeyringRevealer = wallet.KeyringRevealerCertifier
+			args.KeyringRevealer = wallet.KeyringRevealer{
+				Certifier: true,
+			}
 		} else {
 			keyringRevealerBytes := append([]byte{keyringRevealerIdentifier}, r.ReadBytes(sizeRevealer-1)...)
-			args.KeyringRevealer = hex.EncodeToString(keyringRevealerBytes)
+			copy(args.KeyringRevealer.PubKey[:], keyringRevealerBytes)
 		}
 
 		// Read keyring for subject

wallet/serializer/acquire_certificate_test.go

@@ -2,7 +2,6 @@ package serializer
 
 import (
 	"encoding/base64"
-	"encoding/hex"
 	"github.com/bsv-blockchain/go-sdk/util"
 	"github.com/bsv-blockchain/go-sdk/util/test_util"
 	"github.com/bsv-blockchain/go-sdk/wallet"
@@ -28,7 +27,7 @@ func TestAcquireCertificateArgs(t *testing.T) {
 			SerialNumber:       [32]byte{1},
 			RevocationOutpoint: revocationOutpoint,
 			Signature:          make([]byte, 64),
-			KeyringRevealer:    wallet.KeyringRevealerCertifier,
+			KeyringRevealer:    wallet.KeyringRevealer{Certifier: true},
 			KeyringForSubject: map[string]string{
 				"field1": base64.StdEncoding.EncodeToString([]byte("keyring1")),
 			},
@@ -54,8 +53,6 @@ func TestAcquireCertificateArgs(t *testing.T) {
 			AcquisitionProtocol: wallet.AcquisitionProtocolDirect,
 			SerialNumber:        [32]byte{3},
 			RevocationOutpoint:  revocationOutpoint,
-			Signature:           make([]byte, 64),
-			KeyringRevealer:     hex.EncodeToString(make([]byte, sizeRevealer)),
 		},
 	}}
 

wallet/substrates/testdata/acquireCertificate-simple-args.json

@@ -11,7 +11,7 @@
     "revocationOutpoint": "aec245f27b7640c8b1865045107731bfb848115c573f7da38166074b1c9e475d.0",
     "signature": "3045022100a6f09ee70382ab364f3f6b040aebb8fe7a51dbc3b4c99cfeb2f7756432162833022067349b91a6319345996faddf36d1b2f3a502e4ae002205f9d2db85474f9aed5a",
     "certifierUrl": "https://certifier.example.com",
-    "keyringRevealer": "revealer-key-hex",
+    "keyringRevealer": "319ee9fb4b2d9d84d2f5046986a12f29f163c5aa2db664a9b758e983837a321838",
     "keyringForSubject": {
       "field1": "key1",
       "field2": "key2"

wallet/substrates/vector_test.go

@@ -443,7 +443,7 @@ func TestVectors(t *testing.T) {
 			RevocationOutpoint:  outpoint,
 			Signature:           signature,
 			CertifierUrl:        "https://certifier.example.com",
-			KeyringRevealer:     "revealer-key-hex", // TODO: change to real hex, e.g. 319ee9fb4b2d9d84d2f5046986a12f29f163c5aa2db664a9b758e983837a321838
+			KeyringRevealer:     wallet.KeyringRevealer{PubKey: tu.GetByte33FromHexString(t, "319ee9fb4b2d9d84d2f5046986a12f29f163c5aa2db664a9b758e983837a321838")},
 			KeyringForSubject:   map[string]string{"field1": "key1", "field2": "key2"},
 			Privileged:          util.BoolPtr(false),
 		},