utils: accept raw keys in MuSig2Sign

Author: starius

staticaddr/script/script_test.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/lightninglabs/loop/test"
@@ -28,9 +27,12 @@ func TestStaticAddressScript(t *testing.T) {
 	clientPrivKey, clientPubKey := test.CreateKey(1)
 	serverPrivKey, serverPubKey := test.CreateKey(2)
 
+	var clientKey, serverKey [32]byte
+	copy(clientKey[:], clientPrivKey.Serialize())
+	copy(serverKey[:], serverPrivKey.Serialize())
+
 	// Keys used for the Musig2 session.
-	privKeys := []*btcec.PrivateKey{clientPrivKey, serverPrivKey}
-	pubKeys := []*btcec.PublicKey{clientPubKey, serverPubKey}
+	privKeys := [][32]byte{clientKey, serverKey}
 
 	// Create a new static address.
 	staticAddress, err := NewStaticAddress(
@@ -91,7 +93,7 @@ func TestStaticAddressScript(t *testing.T) {
 				}
 
 				sig, err := utils.MuSig2Sign(
-					version, privKeys, pubKeys, tweak, msg,
+					version, privKeys, tweak, msg,
 				)
 				require.NoError(t, err)
 

utils/musig.go

@@ -4,22 +4,37 @@ import (
 	"fmt"
 
 	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr/musig2"
 	"github.com/lightningnetwork/lnd/input"
 )
 
 // MuSig2Sign will create a MuSig2 signature for the passed message using the
-// passed private keys. It expects at least two signing keys, and the number of
-// private keys and public keys must match.
-func MuSig2Sign(version input.MuSig2Version, privKeys []*btcec.PrivateKey,
-	pubKeys []*btcec.PublicKey, tweaks *input.MuSig2Tweaks,
-	msg [32]byte) ([]byte, error) {
-
-	if len(privKeys) != len(pubKeys) {
-		return nil, fmt.Errorf("number of private keys (%d) must "+
-			"match number of public keys (%d)",
-			len(privKeys), len(pubKeys))
+// passed raw private keys. It expects at least two signing keys.
+func MuSig2Sign(version input.MuSig2Version, keys [][32]byte,
+	tweaks *input.MuSig2Tweaks, msg [32]byte) ([]byte, error) {
+
+	privKeys := make([]*btcec.PrivateKey, len(keys))
+	pubKeys := make([]*btcec.PublicKey, len(keys))
+
+	// First parse the raw private keys and also create the corresponding
+	// public keys.
+	for i, key := range keys {
+		privKeys[i], pubKeys[i] = btcec.PrivKeyFromBytes(key[:])
+
+		// MuSig2 v0.4 expects x-only public keys.
+		if version == input.MuSig2Version040 {
+			pubKey := pubKeys[i].SerializeCompressed()
+			xOnlyPubKey, err := schnorr.ParsePubKey(pubKey[1:])
+			if err != nil {
+				return nil, fmt.Errorf("error parsing x-only "+
+					"pubkey: %v", err)
+			}
+
+			pubKeys[i] = xOnlyPubKey
+		}
 	}
+
 	if len(privKeys) < 2 {
 		return nil, fmt.Errorf("need at least two signing keys")
 	}

utils/musig_test.go

@@ -3,39 +3,66 @@ package utils
 import (
 	"testing"
 
-	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightninglabs/loop/test"
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/stretchr/testify/require"
 )
 
+// rawKeys returns serialized private keys for the given test seeds.
+func rawKeys(seeds ...int32) [][32]byte {
+	keys := make([][32]byte, len(seeds))
+	for i, seed := range seeds {
+		privKey, _ := test.CreateKey(seed)
+		copy(keys[i][:], privKey.Serialize())
+	}
+
+	return keys
+}
+
 // TestMuSig2SignRejectsSingleSigner ensures the helper fails fast with a clear
 // error instead of entering an invalid one-party MuSig2 flow.
 func TestMuSig2SignRejectsSingleSigner(t *testing.T) {
-	privKey, pubKey := test.CreateKey(1)
-
 	_, err := MuSig2Sign(
 		input.MuSig2Version100RC2,
-		[]*btcec.PrivateKey{privKey},
-		[]*btcec.PublicKey{pubKey},
+		rawKeys(1),
 		&input.MuSig2Tweaks{},
 		[32]byte{},
 	)
 	require.ErrorContains(t, err, "need at least two signing keys")
 }
 
-// TestMuSig2SignRejectsMismatchedKeyCounts ensures we fail before creating any
-// MuSig2 sessions when the signer sets are inconsistent.
-func TestMuSig2SignRejectsMismatchedKeyCounts(t *testing.T) {
-	privKey, pubKey1 := test.CreateKey(1)
-	_, pubKey2 := test.CreateKey(2)
+// TestMuSig2SignSupportsVersions verifies the helper works with the supported
+// MuSig2 versions used in Loop.
+func TestMuSig2SignSupportsVersions(t *testing.T) {
+	t.Parallel()
 
-	_, err := MuSig2Sign(
+	for _, version := range []input.MuSig2Version{
+		input.MuSig2Version040,
 		input.MuSig2Version100RC2,
-		[]*btcec.PrivateKey{privKey},
-		[]*btcec.PublicKey{pubKey1, pubKey2},
-		&input.MuSig2Tweaks{},
-		[32]byte{},
-	)
-	require.ErrorContains(t, err, "must match number of public keys")
+	} {
+		t.Run(testVersionName(version), func(t *testing.T) {
+			t.Parallel()
+
+			sig, err := MuSig2Sign(
+				version, rawKeys(1, 2), &input.MuSig2Tweaks{},
+				[32]byte{},
+			)
+			require.NoError(t, err)
+			require.Len(t, sig, 64)
+		})
+	}
+}
+
+// testVersionName returns a stable subtest name for a MuSig2 version.
+func testVersionName(version input.MuSig2Version) string {
+	switch version {
+	case input.MuSig2Version040:
+		return "MuSig2 0.4"
+
+	case input.MuSig2Version100RC2:
+		return "MuSig2 1.0RC2"
+
+	default:
+		return "unknown"
+	}
 }