13236757158

Committed 10 Feb 2025 08:39AM UTC coverage: 57.649% (-1.2%) from 58.815%

Build # 13236757158

Build Type

Pull #9493

github

Committed by

ziggie1984

Commit Message

lncli: for some cmds we don't replace the data of the response.

For some cmds it is not very practical to replace the json output
because we might pipe it into other commands. For example when
creating the route we want to pipe it into sendtoRoute.

Pull Request Pull Request #9493: For some lncli cmds we should not replace the content with other data

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

19535 existing lines in 252 files now uncovered.

103517 of 179563 relevant lines covered (57.65%)

24878.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

6.58

/peer/musig_chan_closer.go

package peer

import (
        "fmt"

        "github.com/btcsuite/btcd/btcec/v2/schnorr/musig2"
        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/input"
        "github.com/lightningnetwork/lnd/lnwallet"
        "github.com/lightningnetwork/lnd/lnwallet/chancloser"
        "github.com/lightningnetwork/lnd/lnwire"
)

// MusigChanCloser is an adapter over the normal channel state machine that
// allows the chan closer to handle the musig2 details of closing taproot
// channels.
type MusigChanCloser struct {
        channel *lnwallet.LightningChannel

        musigSession *lnwallet.MusigSession

        localNonce  *musig2.Nonces
        remoteNonce *musig2.Nonces
}

// NewMusigChanCloser creates a new musig chan closer from a normal channel.
func NewMusigChanCloser(channel *lnwallet.LightningChannel) *MusigChanCloser {
        return &MusigChanCloser{
                channel: channel,
        }
}

// ProposalClosingOpts returns the options that should be used when
// generating a new co-op close signature.
func (m *MusigChanCloser) ProposalClosingOpts() (
        []lnwallet.ChanCloseOpt, error) {

        switch {
        case m.localNonce == nil:
                return nil, fmt.Errorf("local nonce not generated")

        case m.remoteNonce == nil:
                return nil, fmt.Errorf("remote nonce not generated")
        }

        localKey, remoteKey := m.channel.MultiSigKeys()

        tapscriptTweak := fn.MapOption(lnwallet.TapscriptRootToTweak)(
                m.channel.State().TapscriptRoot,
        )

        m.musigSession = lnwallet.NewPartialMusigSession(
                *m.remoteNonce, localKey, remoteKey,
                m.channel.Signer, m.channel.FundingTxOut(),
                lnwallet.RemoteMusigCommit, tapscriptTweak,
        )

        err := m.musigSession.FinalizeSession(*m.localNonce)
        if err != nil {
                return nil, err
        }

        return []lnwallet.ChanCloseOpt{
                lnwallet.WithCoopCloseMusigSession(m.musigSession),
        }, nil
}

// CombineClosingOpts returns the options that should be used when combining
// the final musig partial signature. The method also maps the lnwire partial
// signatures into an input.Signature that can be used more generally.
func (m *MusigChanCloser) CombineClosingOpts(localSig,
        remoteSig lnwire.PartialSig) (input.Signature, input.Signature,
        []lnwallet.ChanCloseOpt, error) {

        if m.musigSession == nil {
                return nil, nil, nil, fmt.Errorf("musig session not created")
        }

        // We'll convert the wire partial signatures into an input.Signature
        // compliant struct so we can pass it into the final combination
        // function.
        localPartialSig := &lnwire.PartialSigWithNonce{
                PartialSig: localSig,
                Nonce:      m.localNonce.PubNonce,
        }
        remotePartialSig := &lnwire.PartialSigWithNonce{
                PartialSig: remoteSig,
                Nonce:      m.remoteNonce.PubNonce,
        }

        localMuSig := new(lnwallet.MusigPartialSig).FromWireSig(
                localPartialSig,
        )
        remoteMuSig := new(lnwallet.MusigPartialSig).FromWireSig(
                remotePartialSig,
        )

        opts := []lnwallet.ChanCloseOpt{
                lnwallet.WithCoopCloseMusigSession(m.musigSession),
        }

        // For taproot channels, we'll need to pass along the session so the
        // final combined signature can be created.
        return localMuSig, remoteMuSig, opts, nil
}

// ClosingNonce returns the nonce that should be used when generating the our
// partial signature for the remote party.
func (m *MusigChanCloser) ClosingNonce() (*musig2.Nonces, error) {
        if m.localNonce != nil {
                return m.localNonce, nil
        }

        localKey, _ := m.channel.MultiSigKeys()
        nonce, err := musig2.GenNonces(
                musig2.WithPublicKey(localKey.PubKey),
        )
        if err != nil {
                return nil, err
        }

        m.localNonce = nonce

        return nonce, nil
}

// InitRemoteNonce saves the remote nonce the party sent during their shutdown
// message so it can be used later to generate and verify signatures.
func (m *MusigChanCloser) InitRemoteNonce(nonce *musig2.Nonces) {
        m.remoteNonce = nonce
}

// A compile-time assertion to ensure MusigChanCloser implements the
// chancloser.MusigSession interface.
var _ chancloser.MusigSession = (*MusigChanCloser)(nil)

1	package peer
2
3	import (
4	"fmt"
5
6	"github.com/btcsuite/btcd/btcec/v2/schnorr/musig2"
7	"github.com/lightningnetwork/lnd/fn/v2"
8	"github.com/lightningnetwork/lnd/input"
9	"github.com/lightningnetwork/lnd/lnwallet"
10	"github.com/lightningnetwork/lnd/lnwallet/chancloser"
11	"github.com/lightningnetwork/lnd/lnwire"
12	)
13
14	// MusigChanCloser is an adapter over the normal channel state machine that
15	// allows the chan closer to handle the musig2 details of closing taproot
16	// channels.
17	type MusigChanCloser struct {
18	channel *lnwallet.LightningChannel
19
20	musigSession *lnwallet.MusigSession
21
22	localNonce *musig2.Nonces
23	remoteNonce *musig2.Nonces
24	}
25
26	// NewMusigChanCloser creates a new musig chan closer from a normal channel.
27	func NewMusigChanCloser(channel lnwallet.LightningChannel) MusigChanCloser {	9✔
28	return &MusigChanCloser{	9✔
29	channel: channel,	9✔
30	}	9✔
31	}	9✔
32
33	// ProposalClosingOpts returns the options that should be used when
34	// generating a new co-op close signature.
35	func (m *MusigChanCloser) ProposalClosingOpts() (
UNCOV 36	[]lnwallet.ChanCloseOpt, error) {	×
UNCOV 37		×
UNCOV 38	switch {	×
39	case m.localNonce == nil:	×
40	return nil, fmt.Errorf("local nonce not generated")	×
41
42	case m.remoteNonce == nil:	×
43	return nil, fmt.Errorf("remote nonce not generated")	×
44	}
45
UNCOV 46	localKey, remoteKey := m.channel.MultiSigKeys()	×
UNCOV 47		×
UNCOV 48	tapscriptTweak := fn.MapOption(lnwallet.TapscriptRootToTweak)(	×
UNCOV 49	m.channel.State().TapscriptRoot,	×
UNCOV 50	)	×
UNCOV 51		×
UNCOV 52	m.musigSession = lnwallet.NewPartialMusigSession(	×
UNCOV 53	*m.remoteNonce, localKey, remoteKey,	×
UNCOV 54	m.channel.Signer, m.channel.FundingTxOut(),	×
UNCOV 55	lnwallet.RemoteMusigCommit, tapscriptTweak,	×
UNCOV 56	)	×
UNCOV 57		×
UNCOV 58	err := m.musigSession.FinalizeSession(*m.localNonce)	×
UNCOV 59	if err != nil {	×
60	return nil, err	×
61	}	×
62
UNCOV 63	return []lnwallet.ChanCloseOpt{	×
UNCOV 64	lnwallet.WithCoopCloseMusigSession(m.musigSession),	×
UNCOV 65	}, nil	×
66	}
67
68	// CombineClosingOpts returns the options that should be used when combining
69	// the final musig partial signature. The method also maps the lnwire partial
70	// signatures into an input.Signature that can be used more generally.
71	func (m *MusigChanCloser) CombineClosingOpts(localSig,
72	remoteSig lnwire.PartialSig) (input.Signature, input.Signature,
UNCOV 73	[]lnwallet.ChanCloseOpt, error) {	×
UNCOV 74		×
UNCOV 75	if m.musigSession == nil {	×
76	return nil, nil, nil, fmt.Errorf("musig session not created")	×
77	}	×
78
79	// We'll convert the wire partial signatures into an input.Signature
80	// compliant struct so we can pass it into the final combination
81	// function.
UNCOV 82	localPartialSig := &lnwire.PartialSigWithNonce{	×
UNCOV 83	PartialSig: localSig,	×
UNCOV 84	Nonce: m.localNonce.PubNonce,	×
UNCOV 85	}	×
UNCOV 86	remotePartialSig := &lnwire.PartialSigWithNonce{	×
UNCOV 87	PartialSig: remoteSig,	×
UNCOV 88	Nonce: m.remoteNonce.PubNonce,	×
UNCOV 89	}	×
UNCOV 90		×
UNCOV 91	localMuSig := new(lnwallet.MusigPartialSig).FromWireSig(	×
UNCOV 92	localPartialSig,	×
UNCOV 93	)	×
UNCOV 94	remoteMuSig := new(lnwallet.MusigPartialSig).FromWireSig(	×
UNCOV 95	remotePartialSig,	×
UNCOV 96	)	×
UNCOV 97		×
UNCOV 98	opts := []lnwallet.ChanCloseOpt{	×
UNCOV 99	lnwallet.WithCoopCloseMusigSession(m.musigSession),	×
UNCOV 100	}	×
UNCOV 101		×
UNCOV 102	// For taproot channels, we'll need to pass along the session so the	×
UNCOV 103	// final combined signature can be created.	×
UNCOV 104	return localMuSig, remoteMuSig, opts, nil	×
105	}
106
107	// ClosingNonce returns the nonce that should be used when generating the our
108	// partial signature for the remote party.
UNCOV 109	func (m MusigChanCloser) ClosingNonce() (musig2.Nonces, error) {	×
UNCOV 110	if m.localNonce != nil {	×
111	return m.localNonce, nil	×
112	}	×
113
UNCOV 114	localKey, _ := m.channel.MultiSigKeys()	×
UNCOV 115	nonce, err := musig2.GenNonces(	×
UNCOV 116	musig2.WithPublicKey(localKey.PubKey),	×
UNCOV 117	)	×
UNCOV 118	if err != nil {	×
119	return nil, err	×
120	}	×
121
UNCOV 122	m.localNonce = nonce	×
UNCOV 123		×
UNCOV 124	return nonce, nil	×
125	}
126
127	// InitRemoteNonce saves the remote nonce the party sent during their shutdown
128	// message so it can be used later to generate and verify signatures.
UNCOV 129	func (m MusigChanCloser) InitRemoteNonce(nonce musig2.Nonces) {	×
UNCOV 130	m.remoteNonce = nonce	×
UNCOV 131	}	×
132
133	// A compile-time assertion to ensure MusigChanCloser implements the
134	// chancloser.MusigSession interface.
135	var _ chancloser.MusigSession = (*MusigChanCloser)(nil)

lightningnetwork / lnd / 13236757158

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous