Merge pull request #10436 from ellemouton/musigRegisterAggNonce

docs/release-notes/release-notes-0.21.0.md

@@ -50,6 +50,14 @@
 
 ## RPC Additions
 
+* [Added support for coordinator-based MuSig2 signing
+  patterns](https://github.com/lightningnetwork/lnd/pull/10436) with two new
+  RPCs: `MuSig2RegisterCombinedNonce` allows registering a pre-aggregated
+  combined nonce for a session (useful when a coordinator aggregates all nonces
+  externally), and `MuSig2GetCombinedNonce` retrieves the combined nonce after
+  it becomes available. These methods provide an alternative to the standard
+  `MuSig2RegisterNonces` workflow and are only supported in MuSig2 v1.0.0rc2.
+
 ## lncli Additions
 
 # Improvements

go.mod

@@ -5,7 +5,7 @@ require (
 	github.com/Yawning/aez v0.0.0-20211027044916-e49e68abd344
 	github.com/andybalholm/brotli v1.0.4
 	github.com/btcsuite/btcd v0.24.3-0.20250318170759-4f4ea81776d6
-	github.com/btcsuite/btcd/btcec/v2 v2.3.4
+	github.com/btcsuite/btcd/btcec/v2 v2.3.6
 	github.com/btcsuite/btcd/btcutil v1.1.5
 	github.com/btcsuite/btcd/btcutil/psbt v1.1.8
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0

go.sum

@@ -46,8 +46,8 @@ github.com/btcsuite/btcd v0.24.3-0.20250318170759-4f4ea81776d6 h1:8n9k3I7e8DkpdQ
 github.com/btcsuite/btcd v0.24.3-0.20250318170759-4f4ea81776d6/go.mod h1:OmM4kFtB0klaG/ZqT86rQiyw/1iyXlJgc3UHClPhhbs=
 github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA=
 github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE=
-github.com/btcsuite/btcd/btcec/v2 v2.3.4 h1:3EJjcN70HCu/mwqlUsGK8GcNVyLVxFDlWurTXGPFfiQ=
+github.com/btcsuite/btcd/btcec/v2 v2.3.6 h1:IzlsEr9olcSRKB/n7c4351F3xHKxS2lma+1UFGCYd4E=
-github.com/btcsuite/btcd/btcec/v2 v2.3.4/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
+github.com/btcsuite/btcd/btcec/v2 v2.3.6/go.mod h1:m22FrOAiuxl/tht9wIqAoGHcbnCCaPWyauO8y2LGGtQ=
 github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A=
 github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE=
 github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8=

input/mocks.go

@@ -258,6 +258,29 @@ func (m *MockInputSigner) MuSig2RegisterNonces(versio MuSig2SessionID,
 	return args.Bool(0), args.Error(1)
 }
 
+// MuSig2RegisterCombinedNonce registers a pre-aggregated combined nonce for a
+// session identified by its ID.
+func (m *MockInputSigner) MuSig2RegisterCombinedNonce(sessionID MuSig2SessionID,
+	combinedNonce [musig2.PubNonceSize]byte) error {
+
+	args := m.Called(sessionID, combinedNonce)
+
+	return args.Error(0)
+}
+
+// MuSig2GetCombinedNonce retrieves the combined nonce for a session identified
+// by its ID.
+func (m *MockInputSigner) MuSig2GetCombinedNonce(sessionID MuSig2SessionID) (
+	[musig2.PubNonceSize]byte, error) {
+
+	args := m.Called(sessionID)
+	if args.Get(0) == nil {
+		return [musig2.PubNonceSize]byte{}, args.Error(1)
+	}
+
+	return args.Get(0).([musig2.PubNonceSize]byte), args.Error(1)
+}
+
 // MuSig2Sign creates a partial signature using the local signing key that was
 // specified when the session was created.
 func (m *MockInputSigner) MuSig2Sign(sessionID MuSig2SessionID,

input/musig2.go

@@ -64,6 +64,25 @@ type MuSig2Signer interface {
 	MuSig2RegisterNonces(MuSig2SessionID,
 		[][musig2.PubNonceSize]byte) (bool, error)
 
+	// MuSig2RegisterCombinedNonce registers a pre-aggregated combined nonce
+	// for a session identified by its ID. This is an alternative to
+	// MuSig2RegisterNonces and is used when a coordinator has already
+	// aggregated all individual nonces and wants to distribute the combined
+	// nonce to participants.
+	//
+	// NOTE: This method is mutually exclusive with MuSig2RegisterNonces for
+	// the same session. Once this method is called, MuSig2RegisterNonces
+	// will return an error if called later for the same session.
+	MuSig2RegisterCombinedNonce(MuSig2SessionID,
+		[musig2.PubNonceSize]byte) error
+
+	// MuSig2GetCombinedNonce retrieves the combined nonce for a session
+	// identified by its ID. This will be available after either all
+	// individual nonces have been registered via MuSig2RegisterNonces, or a
+	// combined nonce has been registered via MuSig2RegisterCombinedNonce.
+	MuSig2GetCombinedNonce(MuSig2SessionID) ([musig2.PubNonceSize]byte,
+		error)
+
 	// MuSig2Sign creates a partial signature using the local signing key
 	// that was specified when the session was created. This can only be
 	// called when all public nonces of all participants are known and have
@@ -130,6 +149,26 @@ type MuSig2Session interface {
 	// of signers. This method returns true once all the public nonces have
 	// been accounted for.
 	RegisterPubNonce(nonce [musig2.PubNonceSize]byte) (bool, error)
+
+	// CombinedNonce returns the combined/aggregated public nonce for the
+	// session. This will be available after either all individual nonces
+	// have been registered via RegisterPubNonce, or a combined nonce has
+	// been registered via RegisterCombinedNonce.
+	//
+	// If the combined nonce is not yet available, this method returns an
+	// error.
+	CombinedNonce() ([musig2.PubNonceSize]byte, error)
+
+	// RegisterCombinedNonce allows a caller to directly register a
+	// pre-aggregated nonce that was generated externally. This is useful
+	// in coordinator-based protocols where the coordinator aggregates all
+	// nonces and distributes the combined nonce to participants.
+	//
+	// NOTE: This method is mutually exclusive with RegisterPubNonce. Once
+	// this method is called, RegisterPubNonce will return an error if
+	// called later. Similarly, if RegisterPubNonce has already been called,
+	// this method will return an error.
+	RegisterCombinedNonce(combinedNonce [musig2.PubNonceSize]byte) error
 }
 
 // MuSig2SessionInfo is a struct for keeping track of a signing session

input/musig2_session_manager.go

@@ -302,3 +302,70 @@ func (m *MusigSessionManager) MuSig2RegisterNonces(sessionID MuSig2SessionID,
 
 	return session.HaveAllNonces, nil
 }
+
+// MuSig2RegisterCombinedNonce registers a pre-aggregated combined nonce for a
+// session identified by its ID. This is an alternative to MuSig2RegisterNonces
+// and is used when a coordinator has already aggregated all individual nonces
+// and wants to distribute the combined nonce to participants.
+//
+// NOTE: This method is mutually exclusive with MuSig2RegisterNonces for the
+// same session. Once this method is called, MuSig2RegisterNonces will return
+// an error if called later for the same session.
+func (m *MusigSessionManager) MuSig2RegisterCombinedNonce(
+	sessionID MuSig2SessionID,
+	combinedNonce [musig2.PubNonceSize]byte) error {
+
+	// Hold the lock during the whole operation.
+	m.sessionMtx.Lock(sessionID)
+	defer m.sessionMtx.Unlock(sessionID)
+
+	// Load the session.
+	session, ok := m.musig2Sessions.Load(sessionID)
+	if !ok {
+		return fmt.Errorf("session with ID %x not found", sessionID[:])
+	}
+
+	// Check if we already have all nonces.
+	if session.HaveAllNonces {
+		return fmt.Errorf("already have all nonces")
+	}
+
+	// Delegate to the version-specific implementation.
+	err := session.session.RegisterCombinedNonce(combinedNonce)
+	if err != nil {
+		return fmt.Errorf("error registering combined nonce: %w", err)
+	}
+
+	// Mark that we have all nonces now.
+	session.HaveAllNonces = true
+
+	return nil
+}
+
+// MuSig2GetCombinedNonce retrieves the combined nonce for a session identified
+// by its ID. This will be available after either all individual nonces have
+// been registered via MuSig2RegisterNonces, or a combined nonce has been
+// registered via MuSig2RegisterCombinedNonce.
+func (m *MusigSessionManager) MuSig2GetCombinedNonce(
+	sessionID MuSig2SessionID) ([musig2.PubNonceSize]byte, error) {
+
+	// Hold the lock during the operation.
+	m.sessionMtx.Lock(sessionID)
+	defer m.sessionMtx.Unlock(sessionID)
+
+	// Load the session.
+	session, ok := m.musig2Sessions.Load(sessionID)
+	if !ok {
+		return [musig2.PubNonceSize]byte{}, fmt.Errorf("session with "+
+			"ID %x not found", sessionID[:])
+	}
+
+	// Get the combined nonce from the session.
+	combinedNonce, err := session.session.CombinedNonce()
+	if err != nil {
+		return [musig2.PubNonceSize]byte{}, fmt.Errorf("error getting "+
+			"combined nonce: %w", err)
+	}
+
+	return combinedNonce, nil
+}

internal/musig2v040/README.md

@@ -8,3 +8,17 @@ This corresponds to the [MuSig2 BIP specification version of
 
 We only keep this code here to allow implementing a backward compatible,
 versioned MuSig2 RPC.
+
+## Unsupported Methods
+
+The following methods from the newer MuSig2 specifications are not supported in
+this legacy v0.4.0 implementation and will return `ErrUnsupportedMethod` if
+called:
+
+- `CombinedNonce()`: Returns error instead of the combined nonce.
+- `RegisterCombinedNonce()`: Returns error instead of registering a
+  pre-aggregated combined nonce.
+
+These methods are only available when using MuSig2 v1.0.0rc2 or later. To use
+these features, create sessions with `MuSig2Version100RC2` instead of
+`MuSig2Version040`.

internal/musig2v040/context.go

@@ -59,6 +59,11 @@ var (
 	// ErrNotEnoughSigners is returned if a caller attempts to obtain an
 	// early nonce when it wasn't specified
 	ErrNoEarlyNonce = fmt.Errorf("no early nonce available")
+
+	// ErrUnsupportedMethod is returned when calling methods that are not
+	// supported in the legacy v0.4.0 implementation.
+	ErrUnsupportedMethod = fmt.Errorf("method not supported in MuSig2 " +
+		"v0.4.0")
 )
 
 // Context is a managed signing context for musig2. It takes care of things
@@ -668,3 +673,15 @@ func (s *Session) CombineSig(sig *PartialSignature) (bool, error) {
 func (s *Session) FinalSig() *schnorr.Signature {
 	return s.finalSig
 }
+
+// CombinedNonce is not supported in the legacy v0.4.0 implementation and will
+// always return an error.
+func (s *Session) CombinedNonce() ([PubNonceSize]byte, error) {
+	return [PubNonceSize]byte{}, ErrUnsupportedMethod
+}
+
+// RegisterCombinedNonce is not supported in the legacy v0.4.0 implementation
+// and will always return an error.
+func (s *Session) RegisterCombinedNonce(_ [PubNonceSize]byte) error {
+	return ErrUnsupportedMethod
+}

itest/lnd_taproot_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/btcsuite/btcd/blockchain"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
+	"github.com/btcsuite/btcd/btcec/v2/schnorr/musig2"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/psbt"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
@@ -79,6 +80,7 @@ func testTaprootMuSig2(ht *lntest.HarnessTest) {
 		testTaprootMuSig2ScriptSpend(ht, alice, version)
 		testTaprootMuSig2CombinedLeafKeySpend(ht, alice, version)
 		testMuSig2CombineKey(ht, alice, version)
+		testTaprootMuSig2CombinedNonceCoordinator(ht, alice, version)
 	}
 }
 
@@ -2113,3 +2115,189 @@ func testMuSig2CombineKey(ht *lntest.HarnessTest, alice *node.HarnessNode,
 		)
 	}
 }
+
+// testTaprootMuSig2CombinedNonceCoordinator tests the coordinator pattern where
+// a single party aggregates all nonces and distributes the combined nonce to
+// participants using MuSig2RegisterCombinedNonce.
+func testTaprootMuSig2CombinedNonceCoordinator(ht *lntest.HarnessTest,
+	alice *node.HarnessNode, version signrpc.MuSig2Version) {
+
+	// We're using a simple BIP-86 key spend only setup.
+	taprootTweak := &signrpc.TaprootTweakDesc{
+		KeySpendOnly: true,
+	}
+
+	// Derive signing keys for our three participants.
+	keyDesc1, keyDesc2, keyDesc3, allPubKeys := deriveSigningKeys(
+		ht, alice, version,
+	)
+
+	// Create three sessions WITHOUT exchanging nonces initially. This
+	// simulates the coordinator pattern where the coordinator collects
+	// nonces first, then aggregates them externally.
+	sessResp1 := alice.RPC.MuSig2CreateSession(
+		&signrpc.MuSig2SessionRequest{
+			KeyLoc:           keyDesc1.KeyLoc,
+			AllSignerPubkeys: allPubKeys,
+			TaprootTweak:     taprootTweak,
+			Version:          version,
+		},
+	)
+	require.Equal(ht, version, sessResp1.Version)
+	require.False(ht, sessResp1.HaveAllNonces)
+
+	sessResp2 := alice.RPC.MuSig2CreateSession(
+		&signrpc.MuSig2SessionRequest{
+			KeyLoc:           keyDesc2.KeyLoc,
+			AllSignerPubkeys: allPubKeys,
+			TaprootTweak:     taprootTweak,
+			Version:          version,
+		},
+	)
+	require.False(ht, sessResp2.HaveAllNonces)
+
+	sessResp3 := alice.RPC.MuSig2CreateSession(
+		&signrpc.MuSig2SessionRequest{
+			KeyLoc:           keyDesc3.KeyLoc,
+			AllSignerPubkeys: allPubKeys,
+			TaprootTweak:     taprootTweak,
+			Version:          version,
+		},
+	)
+	require.False(ht, sessResp3.HaveAllNonces)
+
+	// The coordinator collects all individual nonces.
+	allNonces := [][]byte{
+		sessResp1.LocalPublicNonces,
+		sessResp2.LocalPublicNonces,
+		sessResp3.LocalPublicNonces,
+	}
+
+	// For v0.4.0, both RegisterCombinedNonce and GetCombinedNonce should
+	// return unsupported errors.
+	if version == signrpc.MuSig2Version_MUSIG2_VERSION_V040 {
+		// Try to register a combined nonce - should fail with
+		// unsupported error.
+		var dummyNonce [66]byte
+		err := alice.RPC.MuSig2RegisterCombinedNonceErr(
+			&signrpc.MuSig2RegisterCombinedNonceRequest{
+				SessionId:           sessResp1.SessionId,
+				CombinedPublicNonce: dummyNonce[:],
+			},
+		)
+		require.ErrorContains(ht, err, "not supported")
+
+		// Try to get combined nonce - should also fail.
+		err = alice.RPC.MuSig2GetCombinedNonceErr(
+			&signrpc.MuSig2GetCombinedNonceRequest{
+				SessionId: sessResp1.SessionId,
+			},
+		)
+		require.ErrorContains(ht, err, "not supported")
+
+		// For v0.4.0, we can't proceed with the coordinator pattern,
+		// so we're done with this version.
+		return
+	}
+
+	// Copy the nonces over to slice of fixed byte arrays and then use the
+	// musig2 library to aggregate them.
+	var nonces [][musig2.PubNonceSize]byte
+	for _, nonce := range allNonces {
+		var n [musig2.PubNonceSize]byte
+		copy(n[:], nonce)
+		nonces = append(nonces, n)
+	}
+
+	combinedNonce, err := musig2.AggregateNonces(nonces)
+	require.NoError(ht, err)
+
+	// The coordinator now distributes the combined nonce to all
+	// participants.
+	alice.RPC.MuSig2RegisterCombinedNonce(
+		&signrpc.MuSig2RegisterCombinedNonceRequest{
+			SessionId:           sessResp1.SessionId,
+			CombinedPublicNonce: combinedNonce[:],
+		},
+	)
+
+	alice.RPC.MuSig2RegisterCombinedNonce(
+		&signrpc.MuSig2RegisterCombinedNonceRequest{
+			SessionId:           sessResp2.SessionId,
+			CombinedPublicNonce: combinedNonce[:],
+		},
+	)
+
+	alice.RPC.MuSig2RegisterCombinedNonce(
+		&signrpc.MuSig2RegisterCombinedNonceRequest{
+			SessionId:           sessResp3.SessionId,
+			CombinedPublicNonce: combinedNonce[:],
+		},
+	)
+
+	// Verify we can retrieve the combined nonce.
+	getNonceResp := alice.RPC.MuSig2GetCombinedNonce(
+		&signrpc.MuSig2GetCombinedNonceRequest{
+			SessionId: sessResp1.SessionId,
+		},
+	)
+	require.Equal(ht, combinedNonce[:], getNonceResp.CombinedPublicNonce)
+
+	// Test mutual exclusivity: trying to register individual nonces after
+	// combined nonce should fail.
+	err = alice.RPC.MuSig2RegisterNoncesErr(
+		&signrpc.MuSig2RegisterNoncesRequest{
+			SessionId: sessResp1.SessionId,
+			OtherSignerPublicNonces: [][]byte{
+				sessResp2.LocalPublicNonces,
+			},
+		},
+	)
+	require.ErrorContains(ht, err, "already have all nonces")
+
+	// Now complete a full signing flow to verify everything works.
+	combinedKey, err := schnorr.ParsePubKey(sessResp1.CombinedKey)
+	require.NoError(ht, err)
+
+	// Create a simple message to sign.
+	var msg [32]byte
+	copy(msg[:], []byte("test message for combined nonce"))
+
+	// All three participants sign the message.
+	signReq := &signrpc.MuSig2SignRequest{
+		SessionId:     sessResp1.SessionId,
+		MessageDigest: msg[:],
+	}
+	alice.RPC.MuSig2Sign(signReq)
+
+	signReq = &signrpc.MuSig2SignRequest{
+		SessionId:     sessResp2.SessionId,
+		MessageDigest: msg[:],
+		Cleanup:       true,
+	}
+	signResp2 := alice.RPC.MuSig2Sign(signReq)
+
+	signReq = &signrpc.MuSig2SignRequest{
+		SessionId:     sessResp3.SessionId,
+		MessageDigest: msg[:],
+		Cleanup:       true,
+	}
+	signResp3 := alice.RPC.MuSig2Sign(signReq)
+
+	// Combine the signatures.
+	combineReq := &signrpc.MuSig2CombineSigRequest{
+		SessionId: sessResp1.SessionId,
+		OtherPartialSignatures: [][]byte{
+			signResp2.LocalPartialSignature,
+			signResp3.LocalPartialSignature,
+		},
+	}
+	combineResp := alice.RPC.MuSig2CombineSig(combineReq)
+	require.True(ht, combineResp.HaveAllSignatures)
+	require.NotEmpty(ht, combineResp.FinalSignature)
+
+	// Verify the final signature is valid.
+	sig, err := schnorr.ParseSignature(combineResp.FinalSignature)
+	require.NoError(ht, err)
+	require.True(ht, sig.Verify(msg[:], combinedKey))
+}

lnrpc/signrpc/signer.pb.go

@@ -1703,6 +1703,200 @@ func (x *MuSig2RegisterNoncesResponse) GetHaveAllNonces() bool {
 	return false
 }
 
+type MuSig2RegisterCombinedNonceRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The unique ID of the signing session the combined nonce should be registered
+	// with.
+	SessionId []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
+	// The 66-byte combined public nonce that was aggregated externally. This is a
+	// concatenation of two 33-byte compressed public keys (R1 || R2).
+	CombinedPublicNonce []byte `protobuf:"bytes,2,opt,name=combined_public_nonce,json=combinedPublicNonce,proto3" json:"combined_public_nonce,omitempty"`
+}
+
+func (x *MuSig2RegisterCombinedNonceRequest) Reset() {
+	*x = MuSig2RegisterCombinedNonceRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_signrpc_signer_proto_msgTypes[22]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MuSig2RegisterCombinedNonceRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MuSig2RegisterCombinedNonceRequest) ProtoMessage() {}
+
+func (x *MuSig2RegisterCombinedNonceRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_signrpc_signer_proto_msgTypes[22]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MuSig2RegisterCombinedNonceRequest.ProtoReflect.Descriptor instead.
+func (*MuSig2RegisterCombinedNonceRequest) Descriptor() ([]byte, []int) {
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{22}
+}
+
+func (x *MuSig2RegisterCombinedNonceRequest) GetSessionId() []byte {
+	if x != nil {
+		return x.SessionId
+	}
+	return nil
+}
+
+func (x *MuSig2RegisterCombinedNonceRequest) GetCombinedPublicNonce() []byte {
+	if x != nil {
+		return x.CombinedPublicNonce
+	}
+	return nil
+}
+
+type MuSig2RegisterCombinedNonceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *MuSig2RegisterCombinedNonceResponse) Reset() {
+	*x = MuSig2RegisterCombinedNonceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_signrpc_signer_proto_msgTypes[23]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MuSig2RegisterCombinedNonceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MuSig2RegisterCombinedNonceResponse) ProtoMessage() {}
+
+func (x *MuSig2RegisterCombinedNonceResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_signrpc_signer_proto_msgTypes[23]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MuSig2RegisterCombinedNonceResponse.ProtoReflect.Descriptor instead.
+func (*MuSig2RegisterCombinedNonceResponse) Descriptor() ([]byte, []int) {
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{23}
+}
+
+type MuSig2GetCombinedNonceRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The unique ID of the signing session to get the combined nonce for.
+	SessionId []byte `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
+}
+
+func (x *MuSig2GetCombinedNonceRequest) Reset() {
+	*x = MuSig2GetCombinedNonceRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_signrpc_signer_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MuSig2GetCombinedNonceRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MuSig2GetCombinedNonceRequest) ProtoMessage() {}
+
+func (x *MuSig2GetCombinedNonceRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_signrpc_signer_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MuSig2GetCombinedNonceRequest.ProtoReflect.Descriptor instead.
+func (*MuSig2GetCombinedNonceRequest) Descriptor() ([]byte, []int) {
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *MuSig2GetCombinedNonceRequest) GetSessionId() []byte {
+	if x != nil {
+		return x.SessionId
+	}
+	return nil
+}
+
+type MuSig2GetCombinedNonceResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// The 66-byte combined public nonce. This is a concatenation of two 33-byte
+	// compressed public keys (R1 || R2).
+	CombinedPublicNonce []byte `protobuf:"bytes,1,opt,name=combined_public_nonce,json=combinedPublicNonce,proto3" json:"combined_public_nonce,omitempty"`
+}
+
+func (x *MuSig2GetCombinedNonceResponse) Reset() {
+	*x = MuSig2GetCombinedNonceResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_signrpc_signer_proto_msgTypes[25]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *MuSig2GetCombinedNonceResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*MuSig2GetCombinedNonceResponse) ProtoMessage() {}
+
+func (x *MuSig2GetCombinedNonceResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_signrpc_signer_proto_msgTypes[25]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use MuSig2GetCombinedNonceResponse.ProtoReflect.Descriptor instead.
+func (*MuSig2GetCombinedNonceResponse) Descriptor() ([]byte, []int) {
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{25}
+}
+
+func (x *MuSig2GetCombinedNonceResponse) GetCombinedPublicNonce() []byte {
+	if x != nil {
+		return x.CombinedPublicNonce
+	}
+	return nil
+}
+
 type MuSig2SignRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -1721,7 +1915,7 @@ type MuSig2SignRequest struct {
 func (x *MuSig2SignRequest) Reset() {
 	*x = MuSig2SignRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_signrpc_signer_proto_msgTypes[22]
+		mi := &file_signrpc_signer_proto_msgTypes[26]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1734,7 +1928,7 @@ func (x *MuSig2SignRequest) String() string {
 func (*MuSig2SignRequest) ProtoMessage() {}
 
 func (x *MuSig2SignRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_signrpc_signer_proto_msgTypes[22]
+	mi := &file_signrpc_signer_proto_msgTypes[26]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1747,7 +1941,7 @@ func (x *MuSig2SignRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MuSig2SignRequest.ProtoReflect.Descriptor instead.
 func (*MuSig2SignRequest) Descriptor() ([]byte, []int) {
-	return file_signrpc_signer_proto_rawDescGZIP(), []int{22}
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{26}
 }
 
 func (x *MuSig2SignRequest) GetSessionId() []byte {
@@ -1783,7 +1977,7 @@ type MuSig2SignResponse struct {
 func (x *MuSig2SignResponse) Reset() {
 	*x = MuSig2SignResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_signrpc_signer_proto_msgTypes[23]
+		mi := &file_signrpc_signer_proto_msgTypes[27]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1796,7 +1990,7 @@ func (x *MuSig2SignResponse) String() string {
 func (*MuSig2SignResponse) ProtoMessage() {}
 
 func (x *MuSig2SignResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_signrpc_signer_proto_msgTypes[23]
+	mi := &file_signrpc_signer_proto_msgTypes[27]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1809,7 +2003,7 @@ func (x *MuSig2SignResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MuSig2SignResponse.ProtoReflect.Descriptor instead.
 func (*MuSig2SignResponse) Descriptor() ([]byte, []int) {
-	return file_signrpc_signer_proto_rawDescGZIP(), []int{23}
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{27}
 }
 
 func (x *MuSig2SignResponse) GetLocalPartialSignature() []byte {
@@ -1834,7 +2028,7 @@ type MuSig2CombineSigRequest struct {
 func (x *MuSig2CombineSigRequest) Reset() {
 	*x = MuSig2CombineSigRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_signrpc_signer_proto_msgTypes[24]
+		mi := &file_signrpc_signer_proto_msgTypes[28]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1847,7 +2041,7 @@ func (x *MuSig2CombineSigRequest) String() string {
 func (*MuSig2CombineSigRequest) ProtoMessage() {}
 
 func (x *MuSig2CombineSigRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_signrpc_signer_proto_msgTypes[24]
+	mi := &file_signrpc_signer_proto_msgTypes[28]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1860,7 +2054,7 @@ func (x *MuSig2CombineSigRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MuSig2CombineSigRequest.ProtoReflect.Descriptor instead.
 func (*MuSig2CombineSigRequest) Descriptor() ([]byte, []int) {
-	return file_signrpc_signer_proto_rawDescGZIP(), []int{24}
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{28}
 }
 
 func (x *MuSig2CombineSigRequest) GetSessionId() []byte {
@@ -1893,7 +2087,7 @@ type MuSig2CombineSigResponse struct {
 func (x *MuSig2CombineSigResponse) Reset() {
 	*x = MuSig2CombineSigResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_signrpc_signer_proto_msgTypes[25]
+		mi := &file_signrpc_signer_proto_msgTypes[29]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1906,7 +2100,7 @@ func (x *MuSig2CombineSigResponse) String() string {
 func (*MuSig2CombineSigResponse) ProtoMessage() {}
 
 func (x *MuSig2CombineSigResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_signrpc_signer_proto_msgTypes[25]
+	mi := &file_signrpc_signer_proto_msgTypes[29]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1919,7 +2113,7 @@ func (x *MuSig2CombineSigResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MuSig2CombineSigResponse.ProtoReflect.Descriptor instead.
 func (*MuSig2CombineSigResponse) Descriptor() ([]byte, []int) {
-	return file_signrpc_signer_proto_rawDescGZIP(), []int{25}
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{29}
 }
 
 func (x *MuSig2CombineSigResponse) GetHaveAllSignatures() bool {
@@ -1948,7 +2142,7 @@ type MuSig2CleanupRequest struct {
 func (x *MuSig2CleanupRequest) Reset() {
 	*x = MuSig2CleanupRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_signrpc_signer_proto_msgTypes[26]
+		mi := &file_signrpc_signer_proto_msgTypes[30]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1961,7 +2155,7 @@ func (x *MuSig2CleanupRequest) String() string {
 func (*MuSig2CleanupRequest) ProtoMessage() {}
 
 func (x *MuSig2CleanupRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_signrpc_signer_proto_msgTypes[26]
+	mi := &file_signrpc_signer_proto_msgTypes[30]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1974,7 +2168,7 @@ func (x *MuSig2CleanupRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MuSig2CleanupRequest.ProtoReflect.Descriptor instead.
 func (*MuSig2CleanupRequest) Descriptor() ([]byte, []int) {
-	return file_signrpc_signer_proto_rawDescGZIP(), []int{26}
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{30}
 }
 
 func (x *MuSig2CleanupRequest) GetSessionId() []byte {
@@ -1993,7 +2187,7 @@ type MuSig2CleanupResponse struct {
 func (x *MuSig2CleanupResponse) Reset() {
 	*x = MuSig2CleanupResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_signrpc_signer_proto_msgTypes[27]
+		mi := &file_signrpc_signer_proto_msgTypes[31]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -2006,7 +2200,7 @@ func (x *MuSig2CleanupResponse) String() string {
 func (*MuSig2CleanupResponse) ProtoMessage() {}
 
 func (x *MuSig2CleanupResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_signrpc_signer_proto_msgTypes[27]
+	mi := &file_signrpc_signer_proto_msgTypes[31]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -2019,7 +2213,7 @@ func (x *MuSig2CleanupResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use MuSig2CleanupResponse.ProtoReflect.Descriptor instead.
 func (*MuSig2CleanupResponse) Descriptor() ([]byte, []int) {
-	return file_signrpc_signer_proto_rawDescGZIP(), []int{27}
+	return file_signrpc_signer_proto_rawDescGZIP(), []int{31}
 }
 
 var File_signrpc_signer_proto protoreflect.FileDescriptor
@@ -2218,112 +2412,146 @@ var file_signrpc_signer_proto_rawDesc = []byte{
 	0x74, 0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
 	0x65, 0x12, 0x26, 0x0a, 0x0f, 0x68, 0x61, 0x76, 0x65, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x6e, 0x6f,
 	0x6e, 0x63, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x68, 0x61, 0x76, 0x65,
-	0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x73, 0x0a, 0x11, 0x4d, 0x75, 0x53,
+	0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x22, 0x77, 0x0a, 0x22, 0x4d, 0x75, 0x53,
-	0x69, 0x67, 0x32, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d,
+	0x69, 0x67, 0x32, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x62, 0x69,
-	0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01,
+	0x6e, 0x65, 0x64, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12,
-	0x28, 0x0c, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x25, 0x0a,
+	0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
-	0x0e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18,
+	0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x32,
-	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x44, 0x69,
+	0x0a, 0x15, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69,
-	0x67, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x18,
+	0x63, 0x5f, 0x6e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x13, 0x63,
-	0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x22, 0x4c,
+	0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4e, 0x6f, 0x6e,
-	0x0a, 0x12, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70,
+	0x63, 0x65, 0x22, 0x25, 0x0a, 0x23, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x52, 0x65, 0x67, 0x69,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x70, 0x61,
+	0x73, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f, 0x6e, 0x63,
-	0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18,
+	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x3e, 0x0a, 0x1d, 0x4d, 0x75, 0x53,
-	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x15, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x50, 0x61, 0x72, 0x74,
+	0x69, 0x67, 0x32, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f,
-	0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x72, 0x0a, 0x17,
+	0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65,
-	0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x53, 0x69, 0x67,
+	0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69,
+	0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x54, 0x0a, 0x1e, 0x4d, 0x75, 0x53,
-	0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x65, 0x73,
+	0x69, 0x67, 0x32, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f,
-	0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x38, 0x0a, 0x18, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x5f,
+	0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x63,
-	0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
+	0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x6e,
-	0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x16, 0x6f, 0x74, 0x68, 0x65, 0x72, 0x50,
+	0x6f, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x13, 0x63, 0x6f, 0x6d, 0x62,
-	0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73,
+	0x69, 0x6e, 0x65, 0x64, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x22,
-	0x22, 0x73, 0x0a, 0x18, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e,
+	0x73, 0x0a, 0x11, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x71,
-	0x65, 0x53, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2e, 0x0a, 0x13,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
-	0x68, 0x61, 0x76, 0x65, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75,
+	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f,
-	0x72, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x11, 0x68, 0x61, 0x76, 0x65, 0x41,
+	0x6e, 0x49, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x64,
-	0x6c, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f,
+	0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6d, 0x65, 0x73,
-	0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x18,
+	0x73, 0x61, 0x67, 0x65, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6c,
-	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e,
+	0x65, 0x61, 0x6e, 0x75, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x63, 0x6c, 0x65,
-	0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x35, 0x0a, 0x14, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43,
+	0x61, 0x6e, 0x75, 0x70, 0x22, 0x4c, 0x0a, 0x12, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x53, 0x69,
-	0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a,
+	0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x36, 0x0a, 0x17, 0x6c, 0x6f,
+	0x63, 0x61, 0x6c, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e,
+	0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x15, 0x6c, 0x6f, 0x63,
+	0x61, 0x6c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75,
+	0x72, 0x65, 0x22, 0x72, 0x0a, 0x17, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62,
+	0x69, 0x6e, 0x65, 0x53, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a,
 	0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x17, 0x0a, 0x15,
+	0x0c, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x38, 0x0a, 0x18,
-	0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x52, 0x65, 0x73,
+	0x6f, 0x74, 0x68, 0x65, 0x72, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x5f, 0x73, 0x69,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2a, 0x9c, 0x01, 0x0a, 0x0a, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65,
+	0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x16,
-	0x74, 0x68, 0x6f, 0x64, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x49, 0x47, 0x4e, 0x5f, 0x4d, 0x45, 0x54,
+	0x6f, 0x74, 0x68, 0x65, 0x72, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e,
-	0x48, 0x4f, 0x44, 0x5f, 0x57, 0x49, 0x54, 0x4e, 0x45, 0x53, 0x53, 0x5f, 0x56, 0x30, 0x10, 0x00,
+	0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x22, 0x73, 0x0a, 0x18, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32,
-	0x12, 0x29, 0x0a, 0x25, 0x53, 0x49, 0x47, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f,
+	0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x53, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x54, 0x41, 0x50, 0x52, 0x4f, 0x4f, 0x54, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x53, 0x50, 0x45, 0x4e,
+	0x73, 0x65, 0x12, 0x2e, 0x0a, 0x13, 0x68, 0x61, 0x76, 0x65, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x73,
-	0x44, 0x5f, 0x42, 0x49, 0x50, 0x30, 0x30, 0x38, 0x36, 0x10, 0x01, 0x12, 0x21, 0x0a, 0x1d, 0x53,
+	0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52,
-	0x49, 0x47, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x54, 0x41, 0x50, 0x52, 0x4f,
+	0x11, 0x68, 0x61, 0x76, 0x65, 0x41, 0x6c, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72,
-	0x4f, 0x54, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x53, 0x50, 0x45, 0x4e, 0x44, 0x10, 0x02, 0x12, 0x24,
+	0x65, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x73, 0x69, 0x67, 0x6e,
-	0x0a, 0x20, 0x53, 0x49, 0x47, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x54, 0x41,
+	0x61, 0x74, 0x75, 0x72, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x66, 0x69, 0x6e,
-	0x50, 0x52, 0x4f, 0x4f, 0x54, 0x5f, 0x53, 0x43, 0x52, 0x49, 0x50, 0x54, 0x5f, 0x53, 0x50, 0x45,
+	0x61, 0x6c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x22, 0x35, 0x0a, 0x14, 0x4d,
-	0x4e, 0x44, 0x10, 0x03, 0x2a, 0x62, 0x0a, 0x0d, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x56, 0x65,
+	0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75,
-	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x18, 0x4d, 0x55, 0x53, 0x49, 0x47, 0x32, 0x5f,
+	0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69,
-	0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45,
+	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e,
-	0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x4d, 0x55, 0x53, 0x49, 0x47, 0x32, 0x5f, 0x56, 0x45,
+	0x49, 0x64, 0x22, 0x17, 0x0a, 0x15, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6c, 0x65, 0x61,
-	0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x30, 0x34, 0x30, 0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16,
+	0x6e, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2a, 0x9c, 0x01, 0x0a, 0x0a,
-	0x4d, 0x55, 0x53, 0x49, 0x47, 0x32, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56,
+	0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x12, 0x1a, 0x0a, 0x16, 0x53, 0x49,
-	0x31, 0x30, 0x30, 0x52, 0x43, 0x32, 0x10, 0x02, 0x32, 0xdb, 0x06, 0x0a, 0x06, 0x53, 0x69, 0x67,
+	0x47, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x57, 0x49, 0x54, 0x4e, 0x45, 0x53,
-	0x6e, 0x65, 0x72, 0x12, 0x34, 0x0a, 0x0d, 0x53, 0x69, 0x67, 0x6e, 0x4f, 0x75, 0x74, 0x70, 0x75,
+	0x53, 0x5f, 0x56, 0x30, 0x10, 0x00, 0x12, 0x29, 0x0a, 0x25, 0x53, 0x49, 0x47, 0x4e, 0x5f, 0x4d,
-	0x74, 0x52, 0x61, 0x77, 0x12, 0x10, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53,
+	0x45, 0x54, 0x48, 0x4f, 0x44, 0x5f, 0x54, 0x41, 0x50, 0x52, 0x4f, 0x4f, 0x54, 0x5f, 0x4b, 0x45,
-	0x69, 0x67, 0x6e, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63,
+	0x59, 0x5f, 0x53, 0x50, 0x45, 0x4e, 0x44, 0x5f, 0x42, 0x49, 0x50, 0x30, 0x30, 0x38, 0x36, 0x10,
-	0x2e, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12, 0x40, 0x0a, 0x12, 0x43, 0x6f, 0x6d,
+	0x01, 0x12, 0x21, 0x0a, 0x1d, 0x53, 0x49, 0x47, 0x4e, 0x5f, 0x4d, 0x45, 0x54, 0x48, 0x4f, 0x44,
-	0x70, 0x75, 0x74, 0x65, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x12,
+	0x5f, 0x54, 0x41, 0x50, 0x52, 0x4f, 0x4f, 0x54, 0x5f, 0x4b, 0x45, 0x59, 0x5f, 0x53, 0x50, 0x45,
-	0x10, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65,
+	0x4e, 0x44, 0x10, 0x02, 0x12, 0x24, 0x0a, 0x20, 0x53, 0x49, 0x47, 0x4e, 0x5f, 0x4d, 0x45, 0x54,
-	0x71, 0x1a, 0x18, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x49, 0x6e, 0x70, 0x75,
+	0x48, 0x4f, 0x44, 0x5f, 0x54, 0x41, 0x50, 0x52, 0x4f, 0x4f, 0x54, 0x5f, 0x53, 0x43, 0x52, 0x49,
-	0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x65, 0x73, 0x70, 0x12, 0x40, 0x0a, 0x0b, 0x53,
+	0x50, 0x54, 0x5f, 0x53, 0x50, 0x45, 0x4e, 0x44, 0x10, 0x03, 0x2a, 0x62, 0x0a, 0x0d, 0x4d, 0x75,
-	0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x17, 0x2e, 0x73, 0x69, 0x67,
+	0x53, 0x69, 0x67, 0x32, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x18, 0x4d,
-	0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
+	0x55, 0x53, 0x49, 0x47, 0x32, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x55, 0x4e,
-	0x52, 0x65, 0x71, 0x1a, 0x18, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69,
+	0x44, 0x45, 0x46, 0x49, 0x4e, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x4d, 0x55, 0x53,
-	0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x46, 0x0a,
+	0x49, 0x47, 0x32, 0x5f, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x30, 0x34, 0x30,
-	0x0d, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x19,
+	0x10, 0x01, 0x12, 0x1a, 0x0a, 0x16, 0x4d, 0x55, 0x53, 0x49, 0x47, 0x32, 0x5f, 0x56, 0x45, 0x52,
-	0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d,
+	0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x56, 0x31, 0x30, 0x30, 0x52, 0x43, 0x32, 0x10, 0x02, 0x32, 0xc0,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x1a, 0x1a, 0x2e, 0x73, 0x69, 0x67, 0x6e,
+	0x08, 0x0a, 0x06, 0x53, 0x69, 0x67, 0x6e, 0x65, 0x72, 0x12, 0x34, 0x0a, 0x0d, 0x53, 0x69, 0x67,
-	0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
+	0x6e, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x52, 0x61, 0x77, 0x12, 0x10, 0x2e, 0x73, 0x69, 0x67,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x48, 0x0a, 0x0f, 0x44, 0x65, 0x72, 0x69, 0x76, 0x65, 0x53,
+	0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x71, 0x1a, 0x11, 0x2e, 0x73,
-	0x68, 0x61, 0x72, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x12, 0x19, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72,
+	0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x12,
-	0x70, 0x63, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x71, 0x75,
+	0x40, 0x0a, 0x12, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x53,
-	0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x68,
+	0x63, 0x72, 0x69, 0x70, 0x74, 0x12, 0x10, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e,
-	0x61, 0x72, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
+	0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x71, 0x1a, 0x18, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70,
-	0x5a, 0x0a, 0x11, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65,
+	0x63, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x53, 0x63, 0x72, 0x69, 0x70, 0x74, 0x52, 0x65, 0x73,
-	0x4b, 0x65, 0x79, 0x73, 0x12, 0x21, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d,
+	0x70, 0x12, 0x40, 0x0a, 0x0b, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x4b, 0x65, 0x79, 0x73,
+	0x12, 0x17, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x4d,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x1a, 0x18, 0x2e, 0x73, 0x69, 0x67, 0x6e,
-	0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x4b,
+	0x72, 0x70, 0x63, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52,
-	0x65, 0x79, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x54, 0x0a, 0x13, 0x4d,
+	0x65, 0x73, 0x70, 0x12, 0x46, 0x0a, 0x0d, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73,
-	0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x65, 0x73, 0x73, 0x69,
+	0x73, 0x61, 0x67, 0x65, 0x12, 0x19, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x56,
-	0x6f, 0x6e, 0x12, 0x1d, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53,
+	0x65, 0x72, 0x69, 0x66, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x71, 0x1a,
-	0x69, 0x67, 0x32, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x1a, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79,
-	0x74, 0x1a, 0x1e, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x12, 0x48, 0x0a, 0x0f, 0x44,
-	0x67, 0x32, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x72, 0x69, 0x76, 0x65, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x12, 0x19,
-	0x65, 0x12, 0x63, 0x0a, 0x14, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x52, 0x65, 0x67, 0x69, 0x73,
+	0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4b,
-	0x74, 0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x12, 0x24, 0x2e, 0x73, 0x69, 0x67, 0x6e,
+	0x65, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x73, 0x69, 0x67, 0x6e,
-	0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
+	0x72, 0x70, 0x63, 0x2e, 0x53, 0x68, 0x61, 0x72, 0x65, 0x64, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x73,
-	0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5a, 0x0a, 0x11, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43,
-	0x25, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32,
+	0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x21, 0x2e, 0x73, 0x69, 0x67,
+	0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69,
+	0x6e, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e,
+	0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f,
+	0x6d, 0x62, 0x69, 0x6e, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x54, 0x0a, 0x13, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x72, 0x65, 0x61, 0x74,
+	0x65, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72,
+	0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70,
+	0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x63, 0x0a, 0x14, 0x4d, 0x75, 0x53, 0x69, 0x67,
+	0x32, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x12,
+	0x24, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32,
 	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0a, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e,
-	0x53, 0x69, 0x67, 0x6e, 0x12, 0x1a, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d,
+	0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x6f,
-	0x75, 0x53, 0x69, 0x67, 0x32, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x6e, 0x63, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x78, 0x0a, 0x1b,
-	0x1a, 0x1b, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67,
+	0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x43, 0x6f,
-	0x32, 0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x57, 0x0a,
+	0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x12, 0x2b, 0x2e, 0x73, 0x69,
-	0x10, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x53, 0x69,
+	0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x52, 0x65, 0x67, 0x69,
-	0x67, 0x12, 0x20, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69,
+	0x73, 0x74, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f, 0x6e, 0x63,
-	0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x53, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72,
-	0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75,
+	0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65,
-	0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x53, 0x69, 0x67, 0x52, 0x65,
+	0x72, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4e, 0x0a, 0x0d, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x69, 0x0a, 0x16, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32,
-	0x43, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x12, 0x1d, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70,
+	0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f, 0x6e, 0x63, 0x65,
-	0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x52,
+	0x12, 0x26, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63,
+	0x32, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f, 0x6e, 0x63,
-	0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x52, 0x65,
+	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x2f, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x62,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x6e, 0x65,
+	0x69, 0x6e, 0x65, 0x64, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x74, 0x77, 0x6f, 0x72, 0x6b, 0x2f, 0x6c, 0x6e, 0x64, 0x2f, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2f,
+	0x65, 0x12, 0x45, 0x0a, 0x0a, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x53, 0x69, 0x67, 0x6e, 0x12,
-	0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x1a, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32,
+	0x53, 0x69, 0x67, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x73, 0x69,
+	0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x53, 0x69, 0x67, 0x6e,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x57, 0x0a, 0x10, 0x4d, 0x75, 0x53, 0x69,
+	0x67, 0x32, 0x43, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x53, 0x69, 0x67, 0x12, 0x20, 0x2e, 0x73,
+	0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6f, 0x6d,
+	0x62, 0x69, 0x6e, 0x65, 0x53, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21,
+	0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43,
+	0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x53, 0x69, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x4e, 0x0a, 0x0d, 0x4d, 0x75, 0x53, 0x69, 0x67, 0x32, 0x43, 0x6c, 0x65, 0x61, 0x6e,
+	0x75, 0x70, 0x12, 0x1d, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53,
+	0x69, 0x67, 0x32, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x1e, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x72, 0x70, 0x63, 0x2e, 0x4d, 0x75, 0x53, 0x69,
+	0x67, 0x32, 0x43, 0x6c, 0x65, 0x61, 0x6e, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x42, 0x2f, 0x5a, 0x2d, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
+	0x6c, 0x69, 0x67, 0x68, 0x74, 0x6e, 0x69, 0x6e, 0x67, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b,
+	0x2f, 0x6c, 0x6e, 0x64, 0x2f, 0x6c, 0x6e, 0x72, 0x70, 0x63, 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x72,
+	0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -2339,38 +2567,42 @@ func file_signrpc_signer_proto_rawDescGZIP() []byte {
 }
 
 var file_signrpc_signer_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-var file_signrpc_signer_proto_msgTypes = make([]protoimpl.MessageInfo, 28)
+var file_signrpc_signer_proto_msgTypes = make([]protoimpl.MessageInfo, 32)
 var file_signrpc_signer_proto_goTypes = []interface{}{
-	(SignMethod)(0),                      // 0: signrpc.SignMethod
+	(SignMethod)(0),                             // 0: signrpc.SignMethod
-	(MuSig2Version)(0),                   // 1: signrpc.MuSig2Version
+	(MuSig2Version)(0),                          // 1: signrpc.MuSig2Version
-	(*KeyLocator)(nil),                   // 2: signrpc.KeyLocator
+	(*KeyLocator)(nil),                          // 2: signrpc.KeyLocator
-	(*KeyDescriptor)(nil),                // 3: signrpc.KeyDescriptor
+	(*KeyDescriptor)(nil),                       // 3: signrpc.KeyDescriptor
-	(*TxOut)(nil),                        // 4: signrpc.TxOut
+	(*TxOut)(nil),                               // 4: signrpc.TxOut
-	(*SignDescriptor)(nil),               // 5: signrpc.SignDescriptor
+	(*SignDescriptor)(nil),                      // 5: signrpc.SignDescriptor
-	(*SignReq)(nil),                      // 6: signrpc.SignReq
+	(*SignReq)(nil),                             // 6: signrpc.SignReq
-	(*SignResp)(nil),                     // 7: signrpc.SignResp
+	(*SignResp)(nil),                            // 7: signrpc.SignResp
-	(*InputScript)(nil),                  // 8: signrpc.InputScript
+	(*InputScript)(nil),                         // 8: signrpc.InputScript
-	(*InputScriptResp)(nil),              // 9: signrpc.InputScriptResp
+	(*InputScriptResp)(nil),                     // 9: signrpc.InputScriptResp
-	(*SignMessageReq)(nil),               // 10: signrpc.SignMessageReq
+	(*SignMessageReq)(nil),                      // 10: signrpc.SignMessageReq
-	(*SignMessageResp)(nil),              // 11: signrpc.SignMessageResp
+	(*SignMessageResp)(nil),                     // 11: signrpc.SignMessageResp
-	(*VerifyMessageReq)(nil),             // 12: signrpc.VerifyMessageReq
+	(*VerifyMessageReq)(nil),                    // 12: signrpc.VerifyMessageReq
-	(*VerifyMessageResp)(nil),            // 13: signrpc.VerifyMessageResp
+	(*VerifyMessageResp)(nil),                   // 13: signrpc.VerifyMessageResp
-	(*SharedKeyRequest)(nil),             // 14: signrpc.SharedKeyRequest
+	(*SharedKeyRequest)(nil),                    // 14: signrpc.SharedKeyRequest
-	(*SharedKeyResponse)(nil),            // 15: signrpc.SharedKeyResponse
+	(*SharedKeyResponse)(nil),                   // 15: signrpc.SharedKeyResponse
-	(*TweakDesc)(nil),                    // 16: signrpc.TweakDesc
+	(*TweakDesc)(nil),                           // 16: signrpc.TweakDesc
-	(*TaprootTweakDesc)(nil),             // 17: signrpc.TaprootTweakDesc
+	(*TaprootTweakDesc)(nil),                    // 17: signrpc.TaprootTweakDesc
-	(*MuSig2CombineKeysRequest)(nil),     // 18: signrpc.MuSig2CombineKeysRequest
+	(*MuSig2CombineKeysRequest)(nil),            // 18: signrpc.MuSig2CombineKeysRequest
-	(*MuSig2CombineKeysResponse)(nil),    // 19: signrpc.MuSig2CombineKeysResponse
+	(*MuSig2CombineKeysResponse)(nil),           // 19: signrpc.MuSig2CombineKeysResponse
-	(*MuSig2SessionRequest)(nil),         // 20: signrpc.MuSig2SessionRequest
+	(*MuSig2SessionRequest)(nil),                // 20: signrpc.MuSig2SessionRequest
-	(*MuSig2SessionResponse)(nil),        // 21: signrpc.MuSig2SessionResponse
+	(*MuSig2SessionResponse)(nil),               // 21: signrpc.MuSig2SessionResponse
-	(*MuSig2RegisterNoncesRequest)(nil),  // 22: signrpc.MuSig2RegisterNoncesRequest
+	(*MuSig2RegisterNoncesRequest)(nil),         // 22: signrpc.MuSig2RegisterNoncesRequest
-	(*MuSig2RegisterNoncesResponse)(nil), // 23: signrpc.MuSig2RegisterNoncesResponse
+	(*MuSig2RegisterNoncesResponse)(nil),        // 23: signrpc.MuSig2RegisterNoncesResponse
-	(*MuSig2SignRequest)(nil),            // 24: signrpc.MuSig2SignRequest
+	(*MuSig2RegisterCombinedNonceRequest)(nil),  // 24: signrpc.MuSig2RegisterCombinedNonceRequest
-	(*MuSig2SignResponse)(nil),           // 25: signrpc.MuSig2SignResponse
+	(*MuSig2RegisterCombinedNonceResponse)(nil), // 25: signrpc.MuSig2RegisterCombinedNonceResponse
-	(*MuSig2CombineSigRequest)(nil),      // 26: signrpc.MuSig2CombineSigRequest
+	(*MuSig2GetCombinedNonceRequest)(nil),       // 26: signrpc.MuSig2GetCombinedNonceRequest
-	(*MuSig2CombineSigResponse)(nil),     // 27: signrpc.MuSig2CombineSigResponse
+	(*MuSig2GetCombinedNonceResponse)(nil),      // 27: signrpc.MuSig2GetCombinedNonceResponse
-	(*MuSig2CleanupRequest)(nil),         // 28: signrpc.MuSig2CleanupRequest
+	(*MuSig2SignRequest)(nil),                   // 28: signrpc.MuSig2SignRequest
-	(*MuSig2CleanupResponse)(nil),        // 29: signrpc.MuSig2CleanupResponse
+	(*MuSig2SignResponse)(nil),                  // 29: signrpc.MuSig2SignResponse
+	(*MuSig2CombineSigRequest)(nil),             // 30: signrpc.MuSig2CombineSigRequest
+	(*MuSig2CombineSigResponse)(nil),            // 31: signrpc.MuSig2CombineSigResponse
+	(*MuSig2CleanupRequest)(nil),                // 32: signrpc.MuSig2CleanupRequest
+	(*MuSig2CleanupResponse)(nil),               // 33: signrpc.MuSig2CleanupResponse
 }
 var file_signrpc_signer_proto_depIdxs = []int32{
 	2,  // 0: signrpc.KeyDescriptor.key_loc:type_name -> signrpc.KeyLocator
@@ -2400,22 +2632,26 @@ var file_signrpc_signer_proto_depIdxs = []int32{
 	18, // 24: signrpc.Signer.MuSig2CombineKeys:input_type -> signrpc.MuSig2CombineKeysRequest
 	20, // 25: signrpc.Signer.MuSig2CreateSession:input_type -> signrpc.MuSig2SessionRequest
 	22, // 26: signrpc.Signer.MuSig2RegisterNonces:input_type -> signrpc.MuSig2RegisterNoncesRequest
-	24, // 27: signrpc.Signer.MuSig2Sign:input_type -> signrpc.MuSig2SignRequest
+	24, // 27: signrpc.Signer.MuSig2RegisterCombinedNonce:input_type -> signrpc.MuSig2RegisterCombinedNonceRequest
-	26, // 28: signrpc.Signer.MuSig2CombineSig:input_type -> signrpc.MuSig2CombineSigRequest
+	26, // 28: signrpc.Signer.MuSig2GetCombinedNonce:input_type -> signrpc.MuSig2GetCombinedNonceRequest
-	28, // 29: signrpc.Signer.MuSig2Cleanup:input_type -> signrpc.MuSig2CleanupRequest
+	28, // 29: signrpc.Signer.MuSig2Sign:input_type -> signrpc.MuSig2SignRequest
-	7,  // 30: signrpc.Signer.SignOutputRaw:output_type -> signrpc.SignResp
+	30, // 30: signrpc.Signer.MuSig2CombineSig:input_type -> signrpc.MuSig2CombineSigRequest
-	9,  // 31: signrpc.Signer.ComputeInputScript:output_type -> signrpc.InputScriptResp
+	32, // 31: signrpc.Signer.MuSig2Cleanup:input_type -> signrpc.MuSig2CleanupRequest
-	11, // 32: signrpc.Signer.SignMessage:output_type -> signrpc.SignMessageResp
+	7,  // 32: signrpc.Signer.SignOutputRaw:output_type -> signrpc.SignResp
-	13, // 33: signrpc.Signer.VerifyMessage:output_type -> signrpc.VerifyMessageResp
+	9,  // 33: signrpc.Signer.ComputeInputScript:output_type -> signrpc.InputScriptResp
-	15, // 34: signrpc.Signer.DeriveSharedKey:output_type -> signrpc.SharedKeyResponse
+	11, // 34: signrpc.Signer.SignMessage:output_type -> signrpc.SignMessageResp
-	19, // 35: signrpc.Signer.MuSig2CombineKeys:output_type -> signrpc.MuSig2CombineKeysResponse
+	13, // 35: signrpc.Signer.VerifyMessage:output_type -> signrpc.VerifyMessageResp
-	21, // 36: signrpc.Signer.MuSig2CreateSession:output_type -> signrpc.MuSig2SessionResponse
+	15, // 36: signrpc.Signer.DeriveSharedKey:output_type -> signrpc.SharedKeyResponse
-	23, // 37: signrpc.Signer.MuSig2RegisterNonces:output_type -> signrpc.MuSig2RegisterNoncesResponse
+	19, // 37: signrpc.Signer.MuSig2CombineKeys:output_type -> signrpc.MuSig2CombineKeysResponse
-	25, // 38: signrpc.Signer.MuSig2Sign:output_type -> signrpc.MuSig2SignResponse
+	21, // 38: signrpc.Signer.MuSig2CreateSession:output_type -> signrpc.MuSig2SessionResponse
-	27, // 39: signrpc.Signer.MuSig2CombineSig:output_type -> signrpc.MuSig2CombineSigResponse
+	23, // 39: signrpc.Signer.MuSig2RegisterNonces:output_type -> signrpc.MuSig2RegisterNoncesResponse
-	29, // 40: signrpc.Signer.MuSig2Cleanup:output_type -> signrpc.MuSig2CleanupResponse
+	25, // 40: signrpc.Signer.MuSig2RegisterCombinedNonce:output_type -> signrpc.MuSig2RegisterCombinedNonceResponse
-	30, // [30:41] is the sub-list for method output_type
+	27, // 41: signrpc.Signer.MuSig2GetCombinedNonce:output_type -> signrpc.MuSig2GetCombinedNonceResponse
-	19, // [19:30] is the sub-list for method input_type
+	29, // 42: signrpc.Signer.MuSig2Sign:output_type -> signrpc.MuSig2SignResponse
+	31, // 43: signrpc.Signer.MuSig2CombineSig:output_type -> signrpc.MuSig2CombineSigResponse
+	33, // 44: signrpc.Signer.MuSig2Cleanup:output_type -> signrpc.MuSig2CleanupResponse
+	32, // [32:45] is the sub-list for method output_type
+	19, // [19:32] is the sub-list for method input_type
 	19, // [19:19] is the sub-list for extension type_name
 	19, // [19:19] is the sub-list for extension extendee
 	0,  // [0:19] is the sub-list for field type_name
@@ -2692,7 +2928,7 @@ func file_signrpc_signer_proto_init() {
 			}
 		}
 		file_signrpc_signer_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MuSig2SignRequest); i {
+			switch v := v.(*MuSig2RegisterCombinedNonceRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2704,7 +2940,7 @@ func file_signrpc_signer_proto_init() {
 			}
 		}
 		file_signrpc_signer_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MuSig2SignResponse); i {
+			switch v := v.(*MuSig2RegisterCombinedNonceResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2716,7 +2952,7 @@ func file_signrpc_signer_proto_init() {
 			}
 		}
 		file_signrpc_signer_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MuSig2CombineSigRequest); i {
+			switch v := v.(*MuSig2GetCombinedNonceRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2728,7 +2964,7 @@ func file_signrpc_signer_proto_init() {
 			}
 		}
 		file_signrpc_signer_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MuSig2CombineSigResponse); i {
+			switch v := v.(*MuSig2GetCombinedNonceResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2740,7 +2976,7 @@ func file_signrpc_signer_proto_init() {
 			}
 		}
 		file_signrpc_signer_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*MuSig2CleanupRequest); i {
+			switch v := v.(*MuSig2SignRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2752,6 +2988,54 @@ func file_signrpc_signer_proto_init() {
 			}
 		}
 		file_signrpc_signer_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MuSig2SignResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_signrpc_signer_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MuSig2CombineSigRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_signrpc_signer_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MuSig2CombineSigResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_signrpc_signer_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*MuSig2CleanupRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_signrpc_signer_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*MuSig2CleanupResponse); i {
 			case 0:
 				return &v.state
@@ -2770,7 +3054,7 @@ func file_signrpc_signer_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_signrpc_signer_proto_rawDesc,
 			NumEnums:      2,
-			NumMessages:   28,
+			NumMessages:   32,
 			NumExtensions: 0,
 			NumServices:   1,
 		},

lnrpc/signrpc/signer.pb.gw.go

@@ -303,6 +303,74 @@ func local_request_Signer_MuSig2RegisterNonces_0(ctx context.Context, marshaler
 
 }
 
+func request_Signer_MuSig2RegisterCombinedNonce_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MuSig2RegisterCombinedNonceRequest
+	var metadata runtime.ServerMetadata
+
+	newReader, berr := utilities.IOReaderFactory(req.Body)
+	if berr != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
+	}
+	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.MuSig2RegisterCombinedNonce(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Signer_MuSig2RegisterCombinedNonce_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MuSig2RegisterCombinedNonceRequest
+	var metadata runtime.ServerMetadata
+
+	newReader, berr := utilities.IOReaderFactory(req.Body)
+	if berr != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
+	}
+	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.MuSig2RegisterCombinedNonce(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
+func request_Signer_MuSig2GetCombinedNonce_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MuSig2GetCombinedNonceRequest
+	var metadata runtime.ServerMetadata
+
+	newReader, berr := utilities.IOReaderFactory(req.Body)
+	if berr != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
+	}
+	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.MuSig2GetCombinedNonce(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Signer_MuSig2GetCombinedNonce_0(ctx context.Context, marshaler runtime.Marshaler, server SignerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MuSig2GetCombinedNonceRequest
+	var metadata runtime.ServerMetadata
+
+	newReader, berr := utilities.IOReaderFactory(req.Body)
+	if berr != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
+	}
+	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.MuSig2GetCombinedNonce(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 func request_Signer_MuSig2Sign_0(ctx context.Context, marshaler runtime.Marshaler, client SignerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq MuSig2SignRequest
 	var metadata runtime.ServerMetadata
@@ -611,6 +679,56 @@ func RegisterSignerHandlerServer(ctx context.Context, mux *runtime.ServeMux, ser
 
 	})
 
+	mux.Handle("POST", pattern_Signer_MuSig2RegisterCombinedNonce_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/MuSig2RegisterCombinedNonce", runtime.WithHTTPPathPattern("/v2/signer/musig2/registercombinednonce"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Signer_MuSig2RegisterCombinedNonce_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Signer_MuSig2RegisterCombinedNonce_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("POST", pattern_Signer_MuSig2GetCombinedNonce_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/signrpc.Signer/MuSig2GetCombinedNonce", runtime.WithHTTPPathPattern("/v2/signer/musig2/getcombinednonce"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Signer_MuSig2GetCombinedNonce_0(annotatedContext, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Signer_MuSig2GetCombinedNonce_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("POST", pattern_Signer_MuSig2Sign_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -903,6 +1021,50 @@ func RegisterSignerHandlerClient(ctx context.Context, mux *runtime.ServeMux, cli
 
 	})
 
+	mux.Handle("POST", pattern_Signer_MuSig2RegisterCombinedNonce_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/MuSig2RegisterCombinedNonce", runtime.WithHTTPPathPattern("/v2/signer/musig2/registercombinednonce"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Signer_MuSig2RegisterCombinedNonce_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Signer_MuSig2RegisterCombinedNonce_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
+	mux.Handle("POST", pattern_Signer_MuSig2GetCombinedNonce_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/signrpc.Signer/MuSig2GetCombinedNonce", runtime.WithHTTPPathPattern("/v2/signer/musig2/getcombinednonce"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Signer_MuSig2GetCombinedNonce_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Signer_MuSig2GetCombinedNonce_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("POST", pattern_Signer_MuSig2Sign_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -989,6 +1151,10 @@ var (
 
 	pattern_Signer_MuSig2RegisterNonces_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "registernonces"}, ""))
 
+	pattern_Signer_MuSig2RegisterCombinedNonce_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "registercombinednonce"}, ""))
+
+	pattern_Signer_MuSig2GetCombinedNonce_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "getcombinednonce"}, ""))
+
 	pattern_Signer_MuSig2Sign_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "sign"}, ""))
 
 	pattern_Signer_MuSig2CombineSig_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v2", "signer", "musig2", "combinesig"}, ""))
@@ -1013,6 +1179,10 @@ var (
 
 	forward_Signer_MuSig2RegisterNonces_0 = runtime.ForwardResponseMessage
 
+	forward_Signer_MuSig2RegisterCombinedNonce_0 = runtime.ForwardResponseMessage
+
+	forward_Signer_MuSig2GetCombinedNonce_0 = runtime.ForwardResponseMessage
+
 	forward_Signer_MuSig2Sign_0 = runtime.ForwardResponseMessage
 
 	forward_Signer_MuSig2CombineSig_0 = runtime.ForwardResponseMessage

lnrpc/signrpc/signer.pb.json.go

@@ -221,6 +221,56 @@ func RegisterSignerJSONCallbacks(registry map[string]func(ctx context.Context,
 		callback(string(respBytes), nil)
 	}
 
+	registry["signrpc.Signer.MuSig2RegisterCombinedNonce"] = func(ctx context.Context,
+		conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
+
+		req := &MuSig2RegisterCombinedNonceRequest{}
+		err := marshaler.Unmarshal([]byte(reqJSON), req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		client := NewSignerClient(conn)
+		resp, err := client.MuSig2RegisterCombinedNonce(ctx, req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		respBytes, err := marshaler.Marshal(resp)
+		if err != nil {
+			callback("", err)
+			return
+		}
+		callback(string(respBytes), nil)
+	}
+
+	registry["signrpc.Signer.MuSig2GetCombinedNonce"] = func(ctx context.Context,
+		conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
+
+		req := &MuSig2GetCombinedNonceRequest{}
+		err := marshaler.Unmarshal([]byte(reqJSON), req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		client := NewSignerClient(conn)
+		resp, err := client.MuSig2GetCombinedNonce(ctx, req)
+		if err != nil {
+			callback("", err)
+			return
+		}
+
+		respBytes, err := marshaler.Marshal(resp)
+		if err != nil {
+			callback("", err)
+			return
+		}
+		callback(string(respBytes), nil)
+	}
+
 	registry["signrpc.Signer.MuSig2Sign"] = func(ctx context.Context,
 		conn *grpc.ClientConn, reqJSON string, callback func(string, error)) {
 

lnrpc/signrpc/signer.proto

@@ -106,6 +106,34 @@ service Signer {
     rpc MuSig2RegisterNonces (MuSig2RegisterNoncesRequest)
         returns (MuSig2RegisterNoncesResponse);
 
+    /*
+    MuSig2RegisterCombinedNonce (experimental!) registers a pre-aggregated
+    combined nonce for a signing session. This is an alternative to
+    MuSig2RegisterNonces and is used when a coordinator has already aggregated
+    all individual nonces and wants to distribute the combined nonce to
+    participants.
+
+    NOTE: This method is mutually exclusive with MuSig2RegisterNonces for the
+    same session. The MuSig2 BIP is not final yet and therefore this API must
+    be considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
+    releases. Backward compatibility is not guaranteed!
+    */
+    rpc MuSig2RegisterCombinedNonce (MuSig2RegisterCombinedNonceRequest)
+        returns (MuSig2RegisterCombinedNonceResponse);
+
+    /*
+    MuSig2GetCombinedNonce (experimental!) retrieves the combined nonce for a
+    signing session. This will be available after either all individual nonces
+    have been registered via MuSig2RegisterNonces, or a combined nonce has been
+    registered via MuSig2RegisterCombinedNonce.
+
+    NOTE: The MuSig2 BIP is not final yet and therefore this API must be
+    considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
+    releases. Backward compatibility is not guaranteed!
+    */
+    rpc MuSig2GetCombinedNonce (MuSig2GetCombinedNonceRequest)
+        returns (MuSig2GetCombinedNonceResponse);
+
     /*
     MuSig2Sign (experimental!) creates a partial signature using the local
     signing key that was specified when the session was created. This can only
@@ -645,6 +673,38 @@ message MuSig2RegisterNoncesResponse {
     bool have_all_nonces = 1;
 }
 
+message MuSig2RegisterCombinedNonceRequest {
+    /*
+    The unique ID of the signing session the combined nonce should be registered
+    with.
+    */
+    bytes session_id = 1;
+
+    /*
+    The 66-byte combined public nonce that was aggregated externally. This is a
+    concatenation of two 33-byte compressed public keys (R1 || R2).
+    */
+    bytes combined_public_nonce = 2;
+}
+
+message MuSig2RegisterCombinedNonceResponse {
+}
+
+message MuSig2GetCombinedNonceRequest {
+    /*
+    The unique ID of the signing session to get the combined nonce for.
+    */
+    bytes session_id = 1;
+}
+
+message MuSig2GetCombinedNonceResponse {
+    /*
+    The 66-byte combined public nonce. This is a concatenation of two 33-byte
+    compressed public keys (R1 || R2).
+    */
+    bytes combined_public_nonce = 1;
+}
+
 message MuSig2SignRequest {
     /*
     The unique ID of the signing session to use for signing.

lnrpc/signrpc/signer.swagger.json

@@ -186,6 +186,74 @@
         ]
       }
     },
+    "/v2/signer/musig2/getcombinednonce": {
+      "post": {
+        "summary": "MuSig2GetCombinedNonce (experimental!) retrieves the combined nonce for a\nsigning session. This will be available after either all individual nonces\nhave been registered via MuSig2RegisterNonces, or a combined nonce has been\nregistered via MuSig2RegisterCombinedNonce.",
+        "description": "NOTE: The MuSig2 BIP is not final yet and therefore this API must be\nconsidered to be HIGHLY EXPERIMENTAL and subject to change in upcoming\nreleases. Backward compatibility is not guaranteed!",
+        "operationId": "Signer_MuSig2GetCombinedNonce",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/signrpcMuSig2GetCombinedNonceResponse"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/signrpcMuSig2GetCombinedNonceRequest"
+            }
+          }
+        ],
+        "tags": [
+          "Signer"
+        ]
+      }
+    },
+    "/v2/signer/musig2/registercombinednonce": {
+      "post": {
+        "summary": "MuSig2RegisterCombinedNonce (experimental!) registers a pre-aggregated\ncombined nonce for a signing session. This is an alternative to\nMuSig2RegisterNonces and is used when a coordinator has already aggregated\nall individual nonces and wants to distribute the combined nonce to\nparticipants.",
+        "description": "NOTE: This method is mutually exclusive with MuSig2RegisterNonces for the\nsame session. The MuSig2 BIP is not final yet and therefore this API must\nbe considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming\nreleases. Backward compatibility is not guaranteed!",
+        "operationId": "Signer_MuSig2RegisterCombinedNonce",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/signrpcMuSig2RegisterCombinedNonceResponse"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/signrpcMuSig2RegisterCombinedNonceRequest"
+            }
+          }
+        ],
+        "tags": [
+          "Signer"
+        ]
+      }
+    },
     "/v2/signer/musig2/registernonces": {
       "post": {
         "summary": "MuSig2RegisterNonces (experimental!) registers one or more public nonces of\nother signing participants for a session identified by its ID. This RPC can\nbe called multiple times until all nonces are registered.",
@@ -572,6 +640,44 @@
         }
       }
     },
+    "signrpcMuSig2GetCombinedNonceRequest": {
+      "type": "object",
+      "properties": {
+        "session_id": {
+          "type": "string",
+          "format": "byte",
+          "description": "The unique ID of the signing session to get the combined nonce for."
+        }
+      }
+    },
+    "signrpcMuSig2GetCombinedNonceResponse": {
+      "type": "object",
+      "properties": {
+        "combined_public_nonce": {
+          "type": "string",
+          "format": "byte",
+          "description": "The 66-byte combined public nonce. This is a concatenation of two 33-byte\ncompressed public keys (R1 || R2)."
+        }
+      }
+    },
+    "signrpcMuSig2RegisterCombinedNonceRequest": {
+      "type": "object",
+      "properties": {
+        "session_id": {
+          "type": "string",
+          "format": "byte",
+          "description": "The unique ID of the signing session the combined nonce should be registered\nwith."
+        },
+        "combined_public_nonce": {
+          "type": "string",
+          "format": "byte",
+          "description": "The 66-byte combined public nonce that was aggregated externally. This is a\nconcatenation of two 33-byte compressed public keys (R1 || R2)."
+        }
+      }
+    },
+    "signrpcMuSig2RegisterCombinedNonceResponse": {
+      "type": "object"
+    },
     "signrpcMuSig2RegisterNoncesRequest": {
       "type": "object",
       "properties": {

lnrpc/signrpc/signer.yaml

@@ -27,6 +27,12 @@ http:
     - selector: signrpc.Signer.MuSig2RegisterNonces
       post: "/v2/signer/musig2/registernonces"
       body: "*"
+    - selector: signrpc.Signer.MuSig2RegisterCombinedNonce
+      post: "/v2/signer/musig2/registercombinednonce"
+      body: "*"
+    - selector: signrpc.Signer.MuSig2GetCombinedNonce
+      post: "/v2/signer/musig2/getcombinednonce"
+      body: "*"
     - selector: signrpc.Signer.MuSig2Sign
       post: "/v2/signer/musig2/sign"
       body: "*"

lnrpc/signrpc/signer_grpc.pb.go

@@ -90,6 +90,26 @@ type SignerClient interface {
 	// considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
 	// releases. Backward compatibility is not guaranteed!
 	MuSig2RegisterNonces(ctx context.Context, in *MuSig2RegisterNoncesRequest, opts ...grpc.CallOption) (*MuSig2RegisterNoncesResponse, error)
+	// MuSig2RegisterCombinedNonce (experimental!) registers a pre-aggregated
+	// combined nonce for a signing session. This is an alternative to
+	// MuSig2RegisterNonces and is used when a coordinator has already aggregated
+	// all individual nonces and wants to distribute the combined nonce to
+	// participants.
+	//
+	// NOTE: This method is mutually exclusive with MuSig2RegisterNonces for the
+	// same session. The MuSig2 BIP is not final yet and therefore this API must
+	// be considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
+	// releases. Backward compatibility is not guaranteed!
+	MuSig2RegisterCombinedNonce(ctx context.Context, in *MuSig2RegisterCombinedNonceRequest, opts ...grpc.CallOption) (*MuSig2RegisterCombinedNonceResponse, error)
+	// MuSig2GetCombinedNonce (experimental!) retrieves the combined nonce for a
+	// signing session. This will be available after either all individual nonces
+	// have been registered via MuSig2RegisterNonces, or a combined nonce has been
+	// registered via MuSig2RegisterCombinedNonce.
+	//
+	// NOTE: The MuSig2 BIP is not final yet and therefore this API must be
+	// considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
+	// releases. Backward compatibility is not guaranteed!
+	MuSig2GetCombinedNonce(ctx context.Context, in *MuSig2GetCombinedNonceRequest, opts ...grpc.CallOption) (*MuSig2GetCombinedNonceResponse, error)
 	// MuSig2Sign (experimental!) creates a partial signature using the local
 	// signing key that was specified when the session was created. This can only
 	// be called when all public nonces of all participants are known and have been
@@ -200,6 +220,24 @@ func (c *signerClient) MuSig2RegisterNonces(ctx context.Context, in *MuSig2Regis
 	return out, nil
 }
 
+func (c *signerClient) MuSig2RegisterCombinedNonce(ctx context.Context, in *MuSig2RegisterCombinedNonceRequest, opts ...grpc.CallOption) (*MuSig2RegisterCombinedNonceResponse, error) {
+	out := new(MuSig2RegisterCombinedNonceResponse)
+	err := c.cc.Invoke(ctx, "/signrpc.Signer/MuSig2RegisterCombinedNonce", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *signerClient) MuSig2GetCombinedNonce(ctx context.Context, in *MuSig2GetCombinedNonceRequest, opts ...grpc.CallOption) (*MuSig2GetCombinedNonceResponse, error) {
+	out := new(MuSig2GetCombinedNonceResponse)
+	err := c.cc.Invoke(ctx, "/signrpc.Signer/MuSig2GetCombinedNonce", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *signerClient) MuSig2Sign(ctx context.Context, in *MuSig2SignRequest, opts ...grpc.CallOption) (*MuSig2SignResponse, error) {
 	out := new(MuSig2SignResponse)
 	err := c.cc.Invoke(ctx, "/signrpc.Signer/MuSig2Sign", in, out, opts...)
@@ -303,6 +341,26 @@ type SignerServer interface {
 	// considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
 	// releases. Backward compatibility is not guaranteed!
 	MuSig2RegisterNonces(context.Context, *MuSig2RegisterNoncesRequest) (*MuSig2RegisterNoncesResponse, error)
+	// MuSig2RegisterCombinedNonce (experimental!) registers a pre-aggregated
+	// combined nonce for a signing session. This is an alternative to
+	// MuSig2RegisterNonces and is used when a coordinator has already aggregated
+	// all individual nonces and wants to distribute the combined nonce to
+	// participants.
+	//
+	// NOTE: This method is mutually exclusive with MuSig2RegisterNonces for the
+	// same session. The MuSig2 BIP is not final yet and therefore this API must
+	// be considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
+	// releases. Backward compatibility is not guaranteed!
+	MuSig2RegisterCombinedNonce(context.Context, *MuSig2RegisterCombinedNonceRequest) (*MuSig2RegisterCombinedNonceResponse, error)
+	// MuSig2GetCombinedNonce (experimental!) retrieves the combined nonce for a
+	// signing session. This will be available after either all individual nonces
+	// have been registered via MuSig2RegisterNonces, or a combined nonce has been
+	// registered via MuSig2RegisterCombinedNonce.
+	//
+	// NOTE: The MuSig2 BIP is not final yet and therefore this API must be
+	// considered to be HIGHLY EXPERIMENTAL and subject to change in upcoming
+	// releases. Backward compatibility is not guaranteed!
+	MuSig2GetCombinedNonce(context.Context, *MuSig2GetCombinedNonceRequest) (*MuSig2GetCombinedNonceResponse, error)
 	// MuSig2Sign (experimental!) creates a partial signature using the local
 	// signing key that was specified when the session was created. This can only
 	// be called when all public nonces of all participants are known and have been
@@ -362,6 +420,12 @@ func (UnimplementedSignerServer) MuSig2CreateSession(context.Context, *MuSig2Ses
 func (UnimplementedSignerServer) MuSig2RegisterNonces(context.Context, *MuSig2RegisterNoncesRequest) (*MuSig2RegisterNoncesResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method MuSig2RegisterNonces not implemented")
 }
+func (UnimplementedSignerServer) MuSig2RegisterCombinedNonce(context.Context, *MuSig2RegisterCombinedNonceRequest) (*MuSig2RegisterCombinedNonceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MuSig2RegisterCombinedNonce not implemented")
+}
+func (UnimplementedSignerServer) MuSig2GetCombinedNonce(context.Context, *MuSig2GetCombinedNonceRequest) (*MuSig2GetCombinedNonceResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method MuSig2GetCombinedNonce not implemented")
+}
 func (UnimplementedSignerServer) MuSig2Sign(context.Context, *MuSig2SignRequest) (*MuSig2SignResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method MuSig2Sign not implemented")
 }
@@ -528,6 +592,42 @@ func _Signer_MuSig2RegisterNonces_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Signer_MuSig2RegisterCombinedNonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MuSig2RegisterCombinedNonceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SignerServer).MuSig2RegisterCombinedNonce(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/signrpc.Signer/MuSig2RegisterCombinedNonce",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SignerServer).MuSig2RegisterCombinedNonce(ctx, req.(*MuSig2RegisterCombinedNonceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Signer_MuSig2GetCombinedNonce_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MuSig2GetCombinedNonceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(SignerServer).MuSig2GetCombinedNonce(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/signrpc.Signer/MuSig2GetCombinedNonce",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(SignerServer).MuSig2GetCombinedNonce(ctx, req.(*MuSig2GetCombinedNonceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Signer_MuSig2Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MuSig2SignRequest)
 	if err := dec(in); err != nil {
@@ -621,6 +721,14 @@ var Signer_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "MuSig2RegisterNonces",
 			Handler:    _Signer_MuSig2RegisterNonces_Handler,
 		},
+		{
+			MethodName: "MuSig2RegisterCombinedNonce",
+			Handler:    _Signer_MuSig2RegisterCombinedNonce_Handler,
+		},
+		{
+			MethodName: "MuSig2GetCombinedNonce",
+			Handler:    _Signer_MuSig2GetCombinedNonce_Handler,
+		},
 		{
 			MethodName: "MuSig2Sign",
 			Handler:    _Signer_MuSig2Sign_Handler,

lnrpc/signrpc/signer_server.go

@@ -86,6 +86,14 @@ var (
 			Entity: "signer",
 			Action: "generate",
 		}},
+		"/signrpc.Signer/MuSig2RegisterCombinedNonce": {{
+			Entity: "signer",
+			Action: "generate",
+		}},
+		"/signrpc.Signer/MuSig2GetCombinedNonce": {{
+			Entity: "signer",
+			Action: "read",
+		}},
 		"/signrpc.Signer/MuSig2Sign": {{
 			Entity: "signer",
 			Action: "generate",
@@ -1080,6 +1088,62 @@ func (s *Server) MuSig2RegisterNonces(_ context.Context,
 	return &MuSig2RegisterNoncesResponse{HaveAllNonces: haveAllNonces}, nil
 }
 
+// MuSig2RegisterCombinedNonce registers a pre-aggregated combined nonce for a
+// session identified by its ID. This is an alternative to MuSig2RegisterNonces
+// and is used when a coordinator has already aggregated all individual nonces.
+func (s *Server) MuSig2RegisterCombinedNonce(_ context.Context,
+	in *MuSig2RegisterCombinedNonceRequest) (
+	*MuSig2RegisterCombinedNonceResponse, error) {
+
+	// Check session ID length.
+	sessionID, err := parseMuSig2SessionID(in.SessionId)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing session ID: %w", err)
+	}
+
+	// Validate the combined nonce length.
+	if len(in.CombinedPublicNonce) != musig2.PubNonceSize {
+		return nil, fmt.Errorf("invalid combined nonce length, got "+
+			"%d wanted %d", len(in.CombinedPublicNonce),
+			musig2.PubNonceSize)
+	}
+
+	// Convert to the expected fixed-size array.
+	var combinedNonce [musig2.PubNonceSize]byte
+	copy(combinedNonce[:], in.CombinedPublicNonce)
+
+	// Register the combined nonce.
+	err = s.cfg.Signer.MuSig2RegisterCombinedNonce(sessionID, combinedNonce)
+	if err != nil {
+		return nil, fmt.Errorf("error registering combined nonce: %w",
+			err)
+	}
+
+	return &MuSig2RegisterCombinedNonceResponse{}, nil
+}
+
+// MuSig2GetCombinedNonce retrieves the combined nonce for a signing session.
+func (s *Server) MuSig2GetCombinedNonce(_ context.Context,
+	in *MuSig2GetCombinedNonceRequest) (
+	*MuSig2GetCombinedNonceResponse, error) {
+
+	// Check session ID length.
+	sessionID, err := parseMuSig2SessionID(in.SessionId)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing session ID: %w", err)
+	}
+
+	// Get the combined nonce from the signer.
+	combinedNonce, err := s.cfg.Signer.MuSig2GetCombinedNonce(sessionID)
+	if err != nil {
+		return nil, fmt.Errorf("error getting combined nonce: %w", err)
+	}
+
+	return &MuSig2GetCombinedNonceResponse{
+		CombinedPublicNonce: combinedNonce[:],
+	}, nil
+}
+
 // MuSig2Sign creates a partial signature using the local signing key that was
 // specified when the session was created. This can only be called when all
 // public nonces of all participants are known and have been registered with

lntest/mock/signer.go

@@ -72,6 +72,22 @@ func (d *DummySigner) MuSig2RegisterNonces(input.MuSig2SessionID,
 	return false, nil
 }
 
+// MuSig2RegisterCombinedNonce registers a pre-aggregated combined nonce for a
+// session identified by its ID.
+func (d *DummySigner) MuSig2RegisterCombinedNonce(input.MuSig2SessionID,
+	[musig2.PubNonceSize]byte) error {
+
+	return nil
+}
+
+// MuSig2GetCombinedNonce retrieves the combined nonce for a session identified
+// by its ID.
+func (d *DummySigner) MuSig2GetCombinedNonce(input.MuSig2SessionID) (
+	[musig2.PubNonceSize]byte, error) {
+
+	return [musig2.PubNonceSize]byte{}, nil
+}
+
 // MuSig2Sign creates a partial signature using the local signing key
 // that was specified when the session was created. This can only be
 // called when all public nonces of all participants are known and have

lntest/rpc/signer.go

@@ -130,6 +130,80 @@ func (h *HarnessRPC) MuSig2RegisterNonces(
 	return resp
 }
 
+// MuSig2RegisterNoncesErr makes a RPC call to the node's SignerClient and
+// asserts an error is returned.
+func (h *HarnessRPC) MuSig2RegisterNoncesErr(
+	req *signrpc.MuSig2RegisterNoncesRequest) error {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Signer.MuSig2RegisterNonces(ctxt, req)
+	require.Error(h, err, "expected error from MuSig2RegisterNonces")
+
+	return err
+}
+
+// MuSig2RegisterCombinedNonce makes a RPC call to the node's SignerClient and
+// asserts.
+//
+//nolint:ll
+func (h *HarnessRPC) MuSig2RegisterCombinedNonce(
+	req *signrpc.MuSig2RegisterCombinedNonceRequest) *signrpc.MuSig2RegisterCombinedNonceResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2RegisterCombinedNonce(ctxt, req)
+	h.NoError(err, "MuSig2RegisterCombinedNonce")
+
+	return resp
+}
+
+// MuSig2RegisterCombinedNonceErr makes a RPC call to the node's SignerClient
+// and asserts an error is returned.
+func (h *HarnessRPC) MuSig2RegisterCombinedNonceErr(
+	req *signrpc.MuSig2RegisterCombinedNonceRequest) error {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Signer.MuSig2RegisterCombinedNonce(ctxt, req)
+	require.Error(h, err, "expected error from MuSig2RegisterCombinedNonce")
+
+	return err
+}
+
+// MuSig2GetCombinedNonce makes a RPC call to the node's SignerClient and
+// asserts.
+//
+//nolint:ll
+func (h *HarnessRPC) MuSig2GetCombinedNonce(
+	req *signrpc.MuSig2GetCombinedNonceRequest) *signrpc.MuSig2GetCombinedNonceResponse {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	resp, err := h.Signer.MuSig2GetCombinedNonce(ctxt, req)
+	h.NoError(err, "MuSig2GetCombinedNonce")
+
+	return resp
+}
+
+// MuSig2GetCombinedNonceErr makes a RPC call to the node's SignerClient and
+// asserts an error is returned.
+func (h *HarnessRPC) MuSig2GetCombinedNonceErr(
+	req *signrpc.MuSig2GetCombinedNonceRequest) error {
+
+	ctxt, cancel := context.WithTimeout(h.runCtx, DefaultTimeout)
+	defer cancel()
+
+	_, err := h.Signer.MuSig2GetCombinedNonce(ctxt, req)
+	require.Error(h, err, "expected error from MuSig2GetCombinedNonce")
+
+	return err
+}
+
 // MuSig2Sign makes a RPC call to the node's SignerClient and asserts.
 func (h *HarnessRPC) MuSig2Sign(
 	req *signrpc.MuSig2SignRequest) *signrpc.MuSig2SignResponse {

lnwallet/rpcwallet/rpcwallet.go

@@ -780,6 +780,59 @@ func (r *RPCKeyRing) MuSig2RegisterNonces(sessionID input.MuSig2SessionID,
 	return resp.HaveAllNonces, nil
 }
 
+// MuSig2RegisterCombinedNonce registers a pre-aggregated combined nonce for a
+// session identified by its ID. This is an alternative to MuSig2RegisterNonces
+// and is used when a coordinator has already aggregated all individual nonces.
+func (r *RPCKeyRing) MuSig2RegisterCombinedNonce(
+	sessionID input.MuSig2SessionID,
+	combinedNonce [musig2.PubNonceSize]byte) error {
+
+	req := &signrpc.MuSig2RegisterCombinedNonceRequest{
+		SessionId:           sessionID[:],
+		CombinedPublicNonce: combinedNonce[:],
+	}
+
+	ctxt, cancel := context.WithTimeout(context.Background(), r.rpcTimeout)
+	defer cancel()
+
+	_, err := r.signerClient.MuSig2RegisterCombinedNonce(ctxt, req)
+	if err != nil {
+		considerShutdown(err)
+
+		return fmt.Errorf("error registering MuSig2 combined nonce "+
+			"in remote signer instance: %v", err)
+	}
+
+	return nil
+}
+
+// MuSig2GetCombinedNonce retrieves the combined nonce for a session identified
+// by its ID.
+func (r *RPCKeyRing) MuSig2GetCombinedNonce(sessionID input.MuSig2SessionID) (
+	[musig2.PubNonceSize]byte, error) {
+
+	req := &signrpc.MuSig2GetCombinedNonceRequest{
+		SessionId: sessionID[:],
+	}
+
+	ctxt, cancel := context.WithTimeout(context.Background(), r.rpcTimeout)
+	defer cancel()
+
+	resp, err := r.signerClient.MuSig2GetCombinedNonce(ctxt, req)
+	if err != nil {
+		considerShutdown(err)
+
+		return [musig2.PubNonceSize]byte{}, fmt.Errorf("error getting "+
+			"MuSig2 combined nonce from remote signer instance: %v",
+			err)
+	}
+
+	var combinedNonce [musig2.PubNonceSize]byte
+	copy(combinedNonce[:], resp.CombinedPublicNonce)
+
+	return combinedNonce, nil
+}
+
 // MuSig2Sign creates a partial signature using the local signing key
 // that was specified when the session was created. This can only be
 // called when all public nonces of all participants are known and have

watchtower/wtmock/signer.go

@@ -150,6 +150,22 @@ func (s *MockSigner) MuSig2RegisterNonces(input.MuSig2SessionID,
 	return false, nil
 }
 
+// MuSig2RegisterCombinedNonce registers a pre-aggregated combined nonce for a
+// session identified by its ID.
+func (s *MockSigner) MuSig2RegisterCombinedNonce(input.MuSig2SessionID,
+	[musig2.PubNonceSize]byte) error {
+
+	return nil
+}
+
+// MuSig2GetCombinedNonce retrieves the combined nonce for a session identified
+// by its ID.
+func (s *MockSigner) MuSig2GetCombinedNonce(input.MuSig2SessionID) (
+	[musig2.PubNonceSize]byte, error) {
+
+	return [musig2.PubNonceSize]byte{}, nil
+}
+
 // MuSig2Sign creates a partial signature using the local signing key
 // that was specified when the session was created. This can only be
 // called when all public nonces of all participants are known and have