13566028875

Committed 27 Feb 2025 12:09PM UTC coverage: 49.396% (-9.4%) from 58.748%

Build # 13566028875

Build Type

Pull #9555

github

Committed by

ellemouton

Commit Message

graph/db: populate the graph cache in Start instead of during construction

In this commit, we move the graph cache population logic out of the
ChannelGraph constructor and into its Start method instead.

Pull Request Pull Request #9555: graph: extract cache from CRUD [6]

Run Details

34 of 54 new or added lines in 4 files covered. (62.96%)

27464 existing lines in 436 files now uncovered.

101095 of 204664 relevant lines covered (49.4%)

1.54 hits per line

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

73.58

/lnwire/closing_signed.go

package lnwire

import (
        "bytes"
        "io"

        "github.com/btcsuite/btcd/btcutil"
        "github.com/lightningnetwork/lnd/tlv"
)

// ClosingSigned is sent by both parties to a channel once the channel is clear
// of HTLCs, and is primarily concerned with negotiating fees for the close
// transaction. Each party provides a signature for a transaction with a fee
// that they believe is fair. The process terminates when both sides agree on
// the same fee, or when one side force closes the channel.
//
// NOTE: The responder is able to send a signature without any additional
// messages as all transactions are assembled observing BIP 69 which defines a
// canonical ordering for input/outputs. Therefore, both sides are able to
// arrive at an identical closure transaction as they know the order of the
// inputs/outputs.
type ClosingSigned struct {
        // ChannelID serves to identify which channel is to be closed.
        ChannelID ChannelID

        // FeeSatoshis is the total fee in satoshis that the party to the
        // channel would like to propose for the close transaction.
        FeeSatoshis btcutil.Amount

        // Signature is for the proposed channel close transaction.
        Signature Sig

        // PartialSig is used to transmit a musig2 extended partial signature
        // that signs the latest fee offer. The nonce isn't sent along side, as
        // that has already been sent in the initial shutdown message.
        //
        // NOTE: This field is only populated if a musig2 taproot channel is
        // being signed for. In this case, the above Sig type MUST be blank.
        PartialSig OptPartialSigTLV

        // ExtraData is the set of data that was appended to this message to
        // fill out the full maximum transport message size. These fields can
        // be used to specify optional data such as custom TLV fields.
        ExtraData ExtraOpaqueData
}

// NewClosingSigned creates a new empty ClosingSigned message.
func NewClosingSigned(cid ChannelID, fs btcutil.Amount,
        sig Sig) *ClosingSigned {

        return &ClosingSigned{
                ChannelID:   cid,
                FeeSatoshis: fs,
                Signature:   sig,
        }
}

// A compile time check to ensure ClosingSigned implements the lnwire.Message
// interface.
var _ Message = (*ClosingSigned)(nil)

// Decode deserializes a serialized ClosingSigned message stored in the passed
// io.Reader observing the specified protocol version.
//
// This is part of the lnwire.Message interface.
func (c *ClosingSigned) Decode(r io.Reader, pver uint32) error {
        err := ReadElements(
                r, &c.ChannelID, &c.FeeSatoshis, &c.Signature,
        )
        if err != nil {
                return err
        }

        var tlvRecords ExtraOpaqueData
        if err := ReadElements(r, &tlvRecords); err != nil {
                return err
        }

        partialSig := c.PartialSig.Zero()
        typeMap, err := tlvRecords.ExtractRecords(&partialSig)
        if err != nil {
                return err
        }

        // Set the corresponding TLV types if they were included in the stream.
        if val, ok := typeMap[c.PartialSig.TlvType()]; ok && val == nil {
                c.PartialSig = tlv.SomeRecordT(partialSig)
        }

        if len(tlvRecords) != 0 {
                c.ExtraData = tlvRecords
        }

        return nil
}

// Encode serializes the target ClosingSigned into the passed io.Writer
// observing the protocol version specified.
//
// This is part of the lnwire.Message interface.
func (c *ClosingSigned) Encode(w *bytes.Buffer, pver uint32) error {
        recordProducers := make([]tlv.RecordProducer, 0, 1)
        c.PartialSig.WhenSome(func(sig PartialSigTLV) {
                recordProducers = append(recordProducers, &sig)
        })
        err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)
        if err != nil {
                return err
        }

        if err := WriteChannelID(w, c.ChannelID); err != nil {
                return err
        }

        if err := WriteSatoshi(w, c.FeeSatoshis); err != nil {
                return err
        }

        if err := WriteSig(w, c.Signature); err != nil {
                return err
        }

        return WriteBytes(w, c.ExtraData)
}

// MsgType returns the integer uniquely identifying this message type on the
// wire.
//
// This is part of the lnwire.Message interface.
func (c *ClosingSigned) MsgType() MessageType {
        return MsgClosingSigned
}

1	package lnwire
2
3	import (
4	"bytes"
5	"io"
6
7	"github.com/btcsuite/btcd/btcutil"
8	"github.com/lightningnetwork/lnd/tlv"
9	)
10
11	// ClosingSigned is sent by both parties to a channel once the channel is clear
12	// of HTLCs, and is primarily concerned with negotiating fees for the close
13	// transaction. Each party provides a signature for a transaction with a fee
14	// that they believe is fair. The process terminates when both sides agree on
15	// the same fee, or when one side force closes the channel.
16	//
17	// NOTE: The responder is able to send a signature without any additional
18	// messages as all transactions are assembled observing BIP 69 which defines a
19	// canonical ordering for input/outputs. Therefore, both sides are able to
20	// arrive at an identical closure transaction as they know the order of the
21	// inputs/outputs.
22	type ClosingSigned struct {
23	// ChannelID serves to identify which channel is to be closed.
24	ChannelID ChannelID
25
26	// FeeSatoshis is the total fee in satoshis that the party to the
27	// channel would like to propose for the close transaction.
28	FeeSatoshis btcutil.Amount
29
30	// Signature is for the proposed channel close transaction.
31	Signature Sig
32
33	// PartialSig is used to transmit a musig2 extended partial signature
34	// that signs the latest fee offer. The nonce isn't sent along side, as
35	// that has already been sent in the initial shutdown message.
36	//
37	// NOTE: This field is only populated if a musig2 taproot channel is
38	// being signed for. In this case, the above Sig type MUST be blank.
39	PartialSig OptPartialSigTLV
40
41	// ExtraData is the set of data that was appended to this message to
42	// fill out the full maximum transport message size. These fields can
43	// be used to specify optional data such as custom TLV fields.
44	ExtraData ExtraOpaqueData
45	}
46
47	// NewClosingSigned creates a new empty ClosingSigned message.
48	func NewClosingSigned(cid ChannelID, fs btcutil.Amount,
49	sig Sig) *ClosingSigned {	3✔
50		3✔
51	return &ClosingSigned{	3✔
52	ChannelID: cid,	3✔
53	FeeSatoshis: fs,	3✔
54	Signature: sig,	3✔
55	}	3✔
56	}	3✔
57
58	// A compile time check to ensure ClosingSigned implements the lnwire.Message
59	// interface.
60	var _ Message = (*ClosingSigned)(nil)
61
62	// Decode deserializes a serialized ClosingSigned message stored in the passed
63	// io.Reader observing the specified protocol version.
64	//
65	// This is part of the lnwire.Message interface.
66	func (c *ClosingSigned) Decode(r io.Reader, pver uint32) error {	3✔
67	err := ReadElements(	3✔
68	r, &c.ChannelID, &c.FeeSatoshis, &c.Signature,	3✔
69	)	3✔
70	if err != nil {	3✔
UNCOV 71	return err	×
UNCOV 72	}	×
73
74	var tlvRecords ExtraOpaqueData	3✔
75	if err := ReadElements(r, &tlvRecords); err != nil {	3✔
76	return err	×
77	}	×
78
79	partialSig := c.PartialSig.Zero()	3✔
80	typeMap, err := tlvRecords.ExtractRecords(&partialSig)	3✔
81	if err != nil {	3✔
UNCOV 82	return err	×
UNCOV 83	}	×
84
85	// Set the corresponding TLV types if they were included in the stream.
86	if val, ok := typeMap[c.PartialSig.TlvType()]; ok && val == nil {	6✔
87	c.PartialSig = tlv.SomeRecordT(partialSig)	3✔
88	}	3✔
89
90	if len(tlvRecords) != 0 {	6✔
91	c.ExtraData = tlvRecords	3✔
92	}	3✔
93
94	return nil	3✔
95	}
96
97	// Encode serializes the target ClosingSigned into the passed io.Writer
98	// observing the protocol version specified.
99	//
100	// This is part of the lnwire.Message interface.
101	func (c ClosingSigned) Encode(w bytes.Buffer, pver uint32) error {	3✔
102	recordProducers := make([]tlv.RecordProducer, 0, 1)	3✔
103	c.PartialSig.WhenSome(func(sig PartialSigTLV) {	6✔
104	recordProducers = append(recordProducers, &sig)	3✔
105	})	3✔
106	err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)	3✔
107	if err != nil {	3✔
108	return err	×
109	}	×
110
111	if err := WriteChannelID(w, c.ChannelID); err != nil {	3✔
112	return err	×
113	}	×
114
115	if err := WriteSatoshi(w, c.FeeSatoshis); err != nil {	3✔
116	return err	×
117	}	×
118
119	if err := WriteSig(w, c.Signature); err != nil {	3✔
120	return err	×
121	}	×
122
123	return WriteBytes(w, c.ExtraData)	3✔
124	}
125
126	// MsgType returns the integer uniquely identifying this message type on the
127	// wire.
128	//
129	// This is part of the lnwire.Message interface.
130	func (c *ClosingSigned) MsgType() MessageType {	3✔
131	return MsgClosingSigned	3✔
132	}	3✔

lightningnetwork / lnd / 13566028875

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