12312390362

Committed 13 Dec 2024 08:44AM UTC coverage: 57.458% (+8.5%) from 48.92%

Build # 12312390362

Build Type

Pull #9343

github

Committed by

ellemouton

Commit Message

fn: rework the ContextGuard and add tests

In this commit, the ContextGuard struct is re-worked such that the
context that its new main WithCtx method provides is cancelled in sync
with a parent context being cancelled or with it's quit channel being
cancelled. Tests are added to assert the behaviour. In order for the
close of the quit channel to be consistent with the cancelling of the
derived context, the quit channel _must_ be contained internal to the
ContextGuard so that callers are only able to close the channel via the
exposed Quit method which will then take care to first cancel any
derived context that depend on the quit channel before returning.

Pull Request Pull Request #9343: fn: expand the ContextGuard and add tests

Run Details

101853 of 177264 relevant lines covered (57.46%)

24972.93 hits per line

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

86.85

/routing/blinding.go

package routing

import (
        "bytes"
        "errors"
        "fmt"

        "github.com/btcsuite/btcd/btcec/v2"
        "github.com/decred/dcrd/dcrec/secp256k1/v4"
        sphinx "github.com/lightningnetwork/lightning-onion"
        "github.com/lightningnetwork/lnd/graph/db/models"
        "github.com/lightningnetwork/lnd/input"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/routing/route"
)

// BlindedPathNUMSHex is the hex encoded version of the blinded path target
// NUMs key (in compressed format) which has no known private key.
// This was generated using the following script:
// https://github.com/lightninglabs/lightning-node-connect/tree/master/
// mailbox/numsgen, with the seed phrase "Lightning Blinded Path".
const BlindedPathNUMSHex = "02667a98ef82ecb522f803b17a74f14508a48b25258f9831" +
        "dd6e95f5e299dfd54e"

var (
        // ErrNoBlindedPath is returned when the blinded path in a blinded
        // payment is missing.
        ErrNoBlindedPath = errors.New("blinded path required")

        // ErrInsufficientBlindedHops is returned when a blinded path does
        // not have enough blinded hops.
        ErrInsufficientBlindedHops = errors.New("blinded path requires " +
                "at least one hop")

        // ErrHTLCRestrictions is returned when a blinded path has invalid
        // HTLC maximum and minimum values.
        ErrHTLCRestrictions = errors.New("invalid htlc minimum and maximum")

        // BlindedPathNUMSKey is a NUMS key (nothing up my sleeves number) that
        // has no known private key.
        BlindedPathNUMSKey = input.MustParsePubKey(BlindedPathNUMSHex)

        // CompressedBlindedPathNUMSKey is the compressed version of the
        // BlindedPathNUMSKey.
        CompressedBlindedPathNUMSKey = BlindedPathNUMSKey.SerializeCompressed()
)

// BlindedPaymentPathSet groups the data we need to handle sending to a set of
// blinded paths provided by the recipient of a payment.
//
// NOTE: for now this only holds a single BlindedPayment. By the end of the PR
// series, it will handle multiple paths.
type BlindedPaymentPathSet struct {
        // paths is the set of blinded payment paths for a single payment.
        // NOTE: For now this will always only have a single entry. By the end
        // of this PR, it can hold multiple.
        paths []*BlindedPayment

        // targetPubKey is the ephemeral node pub key that we will inject into
        // each path as the last hop. This is only for the sake of path finding.
        // Once the path has been found, the original destination pub key is
        // used again. In the edge case where there is only a single hop in the
        // path (the introduction node is the destination node), then this will
        // just be the introduction node's real public key.
        targetPubKey *btcec.PublicKey

        // features is the set of relay features available for the payment.
        // This is extracted from the set of blinded payment paths. At the
        // moment we require that all paths for the same payment have the
        // same feature set.
        features *lnwire.FeatureVector

        // finalCLTV is the final hop's expiry delta of _any_ path in the set.
        // For any multi-hop path, the final CLTV delta should be seen as zero
        // since the final hop's final CLTV delta is accounted for in the
        // accumulated path policy values. The only edge case is for when the
        // final hop in the path is also the introduction node in which case
        // that path's FinalCLTV must be the non-zero min CLTV of the final hop
        // so that it is accounted for in path finding. For this reason, if
        // we have any single path in the set with only one hop, then we throw
        // away all the other paths. This should be fine to do since if there is
        // a path where the intro node is also the destination node, then there
        // isn't any need to try any other longer blinded path. In other words,
        // if this value is non-zero, then there is only one path in this
        // blinded path set and that path only has a single hop: the
        // introduction node.
        finalCLTV uint16
}

// NewBlindedPaymentPathSet constructs a new BlindedPaymentPathSet from a set of
// BlindedPayments. For blinded paths which have more than one single hop a
// dummy hop via a NUMS key is appeneded to allow for MPP path finding via
// multiple blinded paths.
func NewBlindedPaymentPathSet(paths []*BlindedPayment) (*BlindedPaymentPathSet,
        error) {

        if len(paths) == 0 {
                return nil, ErrNoBlindedPath
        }

        // For now, we assert that all the paths have the same set of features.
        features := paths[0].Features
        noFeatures := features == nil || features.IsEmpty()
        for i := 1; i < len(paths); i++ {
                noFeats := paths[i].Features == nil ||
                        paths[i].Features.IsEmpty()

                if noFeatures && !noFeats {
                        return nil, fmt.Errorf("all blinded paths must have " +
                                "the same set of features")
                }

                if noFeatures {
                        continue
                }

                if !features.RawFeatureVector.Equals(
                        paths[i].Features.RawFeatureVector,
                ) {

                        return nil, fmt.Errorf("all blinded paths must have " +
                                "the same set of features")
                }
        }

        // Deep copy the paths to avoid mutating the original paths.
        pathSet := make([]*BlindedPayment, len(paths))
        for i, path := range paths {
                pathSet[i] = path.deepCopy()
        }

        // For blinded paths we use the NUMS key as a target if the blinded
        // path has more hops than just the introduction node.
        targetPub := &BlindedPathNUMSKey

        var finalCLTVDelta uint16

        // In case the paths do NOT include a single hop route we append a
        // dummy hop via a NUMS key to allow for MPP path finding via multiple
        // blinded paths. A unified target is needed to use all blinded paths
        // during the payment lifecycle. A dummy hop is solely added for the
        // path finding process and is removed after the path is found. This
        // ensures that we still populate the mission control with the correct
        // data and also respect these mc entries when looking for a path.
        for _, path := range pathSet {
                pathLength := len(path.BlindedPath.BlindedHops)

                // If any provided blinded path only has a single hop (ie, the
                // destination node is also the introduction node), then we
                // discard all other paths since we know the real pub key of the
                // destination node. We also then set the final CLTV delta to
                // the path's delta since there are no other edge hints that
                // will account for it.
                if pathLength == 1 {
                        pathSet = []*BlindedPayment{path}
                        finalCLTVDelta = path.CltvExpiryDelta
                        targetPub = path.BlindedPath.IntroductionPoint

                        break
                }

                lastHop := path.BlindedPath.BlindedHops[pathLength-1]
                path.BlindedPath.BlindedHops = append(
                        path.BlindedPath.BlindedHops,
                        &sphinx.BlindedHopInfo{
                                BlindedNodePub: &BlindedPathNUMSKey,
                                // We add the last hop's cipher text so that
                                // the payload size of the final hop is equal
                                // to the real last hop.
                                CipherText: lastHop.CipherText,
                        },
                )
        }

        return &BlindedPaymentPathSet{
                paths:        pathSet,
                targetPubKey: targetPub,
                features:     features,
                finalCLTV:    finalCLTVDelta,
        }, nil
}

// TargetPubKey returns the public key to be used as the destination node's
// public key during pathfinding.
func (s *BlindedPaymentPathSet) TargetPubKey() *btcec.PublicKey {
        return s.targetPubKey
}

// Features returns the set of relay features available for the payment.
func (s *BlindedPaymentPathSet) Features() *lnwire.FeatureVector {
        return s.features
}

// IntroNodeOnlyPath can be called if it is expected that the path set only
// contains a single payment path which itself only has one hop. It errors if
// this is not the case.
func (s *BlindedPaymentPathSet) IntroNodeOnlyPath() (*BlindedPayment, error) {
        if len(s.paths) != 1 {
                return nil, fmt.Errorf("expected only a single path in the "+
                        "blinded payment set, got %d", len(s.paths))
        }

        if len(s.paths[0].BlindedPath.BlindedHops) > 1 {
                return nil, fmt.Errorf("an intro node only path cannot have " +
                        "more than one hop")
        }

        return s.paths[0], nil
}

// IsIntroNode returns true if the given vertex is an introduction node for one
// of the paths in the blinded payment path set.
func (s *BlindedPaymentPathSet) IsIntroNode(source route.Vertex) bool {
        for _, path := range s.paths {
                introVertex := route.NewVertex(
                        path.BlindedPath.IntroductionPoint,
                )
                if source == introVertex {
                        return true
                }
        }

        return false
}

// FinalCLTVDelta is the minimum CLTV delta to use for the final hop on the
// route. In most cases this will return zero since the value is accounted for
// in the path's accumulated CLTVExpiryDelta. Only in the edge case of the path
// set only including a single path which only includes an introduction node
// will this return a non-zero value.
func (s *BlindedPaymentPathSet) FinalCLTVDelta() uint16 {
        return s.finalCLTV
}

// LargestLastHopPayloadPath returns the BlindedPayment in the set that has the
// largest last-hop payload. This is to be used for onion size estimation in
// path finding.
func (s *BlindedPaymentPathSet) LargestLastHopPayloadPath() (*BlindedPayment,
        error) {

        var (
                largestPath *BlindedPayment
                currentMax  int
        )

        if len(s.paths) == 0 {
                return nil, fmt.Errorf("no blinded paths in the set")
        }

        // We set the largest path to make sure we always return a path even
        // if the cipher text is empty.
        largestPath = s.paths[0]

        for _, path := range s.paths {
                numHops := len(path.BlindedPath.BlindedHops)
                lastHop := path.BlindedPath.BlindedHops[numHops-1]

                if len(lastHop.CipherText) > currentMax {
                        largestPath = path
                        currentMax = len(lastHop.CipherText)
                }
        }

        return largestPath, nil
}

// ToRouteHints converts the blinded path payment set into a RouteHints map so
// that the blinded payment paths can be treated like route hints throughout the
// code base.
func (s *BlindedPaymentPathSet) ToRouteHints() (RouteHints, error) {
        hints := make(RouteHints)

        for _, path := range s.paths {
                pathHints, err := path.toRouteHints()
                if err != nil {
                        return nil, err
                }

                for from, edges := range pathHints {
                        hints[from] = append(hints[from], edges...)
                }
        }

        if len(hints) == 0 {
                return nil, nil
        }

        return hints, nil
}

// IsBlindedRouteNUMSTargetKey returns true if the given public key is the
// NUMS key used as a target for blinded path final hops.
func IsBlindedRouteNUMSTargetKey(pk []byte) bool {
        return bytes.Equal(pk, CompressedBlindedPathNUMSKey)
}

// BlindedPayment provides the path and payment parameters required to send a
// payment along a blinded path.
type BlindedPayment struct {
        // BlindedPath contains the unblinded introduction point and blinded
        // hops for the blinded section of the payment.
        BlindedPath *sphinx.BlindedPath

        // BaseFee is the total base fee to be paid for payments made over the
        // blinded path.
        BaseFee uint32

        // ProportionalFeeRate is the aggregated proportional fee rate for
        // payments made over the blinded path.
        ProportionalFeeRate uint32

        // CltvExpiryDelta is the total expiry delta for the blinded path. This
        // field includes the CLTV for the blinded hops *and* the final cltv
        // delta for the receiver.
        CltvExpiryDelta uint16

        // HtlcMinimum is the highest HLTC minimum supported along the blinded
        // path (while some hops may have lower values, we're effectively
        // bounded by the highest minimum).
        HtlcMinimum uint64

        // HtlcMaximum is the lowest HTLC maximum supported along the blinded
        // path (while some hops may have higher values, we're effectively
        // bounded by the lowest maximum).
        HtlcMaximum uint64

        // Features is the set of relay features available for the payment.
        Features *lnwire.FeatureVector
}

// Validate performs validation on a blinded payment.
func (b *BlindedPayment) Validate() error {
        if b.BlindedPath == nil {
                return ErrNoBlindedPath
        }

        // The sphinx library inserts the introduction node as the first hop,
        // so we expect at least one hop.
        if len(b.BlindedPath.BlindedHops) < 1 {
                return fmt.Errorf("%w got: %v", ErrInsufficientBlindedHops,
                        len(b.BlindedPath.BlindedHops))
        }

        if b.HtlcMaximum < b.HtlcMinimum {
                return fmt.Errorf("%w: %v < %v", ErrHTLCRestrictions,
                        b.HtlcMaximum, b.HtlcMinimum)
        }

        for _, hop := range b.BlindedPath.BlindedHops {
                // The first hop of the blinded path does not necessarily have
                // blinded node pub key because it is the introduction point.
                if hop.BlindedNodePub == nil {
                        continue
                }

                if IsBlindedRouteNUMSTargetKey(
                        hop.BlindedNodePub.SerializeCompressed(),
                ) {

                        return fmt.Errorf("blinded path cannot include NUMS "+
                                "key: %s", BlindedPathNUMSHex)
                }
        }

        return nil
}

// toRouteHints produces a set of chained route hints that represent a blinded
// path. In the case of a single hop blinded route (which is paying directly
// to the introduction point), no hints will be returned. In this case callers
// *must* account for the blinded route's CLTV delta elsewhere (as this is
// effectively the final_cltv_delta for the receiving introduction node). In
// the case of multiple blinded hops, CLTV delta is fully accounted for in the
// hints (both for intermediate hops and the final_cltv_delta for the receiving
// node).
func (b *BlindedPayment) toRouteHints() (RouteHints, error) {
        // If we just have a single hop in our blinded route, it just contains
        // an introduction node (this is a valid path according to the spec).
        // Since we have the un-blinded node ID for the introduction node, we
        // don't need to add any route hints.
        if len(b.BlindedPath.BlindedHops) == 1 {
                return nil, nil
        }

        hintCount := len(b.BlindedPath.BlindedHops) - 1
        hints := make(
                RouteHints, hintCount,
        )

        // Start at the unblinded introduction node, because our pathfinding
        // will be able to locate this point in the graph.
        fromNode := route.NewVertex(b.BlindedPath.IntroductionPoint)

        features := lnwire.EmptyFeatureVector()
        if b.Features != nil {
                features = b.Features.Clone()
        }

        // Use the total aggregate relay parameters for the entire blinded
        // route as the policy for the hint from our introduction node. This
        // will ensure that pathfinding provides sufficient fees/delay for the
        // blinded portion to the introduction node.
        firstBlindedHop := b.BlindedPath.BlindedHops[1].BlindedNodePub
        edgePolicy := &models.CachedEdgePolicy{
                TimeLockDelta: b.CltvExpiryDelta,
                MinHTLC:       lnwire.MilliSatoshi(b.HtlcMinimum),
                MaxHTLC:       lnwire.MilliSatoshi(b.HtlcMaximum),
                FeeBaseMSat:   lnwire.MilliSatoshi(b.BaseFee),
                FeeProportionalMillionths: lnwire.MilliSatoshi(
                        b.ProportionalFeeRate,
                ),
                ToNodePubKey: func() route.Vertex {
                        return route.NewVertex(
                                // The first node in this slice is
                                // the introduction node, so we start
                                // at index 1 to get the first blinded
                                // relaying node.
                                firstBlindedHop,
                        )
                },
                ToNodeFeatures: features,
        }

        lastEdge, err := NewBlindedEdge(edgePolicy, b, 0)
        if err != nil {
                return nil, err
        }

        hints[fromNode] = []AdditionalEdge{lastEdge}

        // Start at an offset of 1 because the first node in our blinded hops
        // is the introduction node and terminate at the second-last node
        // because we're dealing with hops as pairs.
        for i := 1; i < hintCount; i++ {
                // Set our origin node to the current
                fromNode = route.NewVertex(
                        b.BlindedPath.BlindedHops[i].BlindedNodePub,
                )

                // Create a hint which has no fee or cltv delta. We
                // specifically want zero values here because our relay
                // parameters are expressed in encrypted blobs rather than the
                // route itself for blinded routes.
                nextHopIdx := i + 1
                nextNode := route.NewVertex(
                        b.BlindedPath.BlindedHops[nextHopIdx].BlindedNodePub,
                )

                edgePolicy := &models.CachedEdgePolicy{
                        ToNodePubKey: func() route.Vertex {
                                return nextNode
                        },
                        ToNodeFeatures: features,
                }

                lastEdge, err = NewBlindedEdge(edgePolicy, b, i)
                if err != nil {
                        return nil, err
                }

                hints[fromNode] = []AdditionalEdge{lastEdge}
        }

        return hints, nil
}

// deepCopy returns a deep copy of the BlindedPayment.
func (b *BlindedPayment) deepCopy() *BlindedPayment {
        if b == nil {
                return nil
        }

        cpyPayment := &BlindedPayment{
                BaseFee:             b.BaseFee,
                ProportionalFeeRate: b.ProportionalFeeRate,
                CltvExpiryDelta:     b.CltvExpiryDelta,
                HtlcMinimum:         b.HtlcMinimum,
                HtlcMaximum:         b.HtlcMaximum,
        }

        // Deep copy the BlindedPath if it exists
        if b.BlindedPath != nil {
                cpyPayment.BlindedPath = &sphinx.BlindedPath{
                        BlindedHops: make([]*sphinx.BlindedHopInfo,
                                len(b.BlindedPath.BlindedHops)),
                }

                if b.BlindedPath.IntroductionPoint != nil {
                        cpyPayment.BlindedPath.IntroductionPoint =
                                copyPublicKey(b.BlindedPath.IntroductionPoint)
                }

                if b.BlindedPath.BlindingPoint != nil {
                        cpyPayment.BlindedPath.BlindingPoint =
                                copyPublicKey(b.BlindedPath.BlindingPoint)
                }

                // Copy each blinded hop info.
                for i, hop := range b.BlindedPath.BlindedHops {
                        if hop == nil {
                                continue
                        }

                        cpyHop := &sphinx.BlindedHopInfo{
                                CipherText: hop.CipherText,
                        }

                        if hop.BlindedNodePub != nil {
                                cpyHop.BlindedNodePub =
                                        copyPublicKey(hop.BlindedNodePub)
                        }

                        cpyHop.CipherText = make([]byte, len(hop.CipherText))
                        copy(cpyHop.CipherText, hop.CipherText)

                        cpyPayment.BlindedPath.BlindedHops[i] = cpyHop
                }
        }

        // Deep copy the Features if they exist
        if b.Features != nil {
                cpyPayment.Features = b.Features.Clone()
        }

        return cpyPayment
}

// copyPublicKey makes a deep copy of a public key.
//
// TODO(ziggie): Remove this function if this is available in the btcec library.
func copyPublicKey(pk *btcec.PublicKey) *btcec.PublicKey {
        var result secp256k1.JacobianPoint
        pk.AsJacobian(&result)
        result.ToAffine()

        return btcec.NewPublicKey(&result.X, &result.Y)
}

1	package routing
2
3	import (
4	"bytes"
5	"errors"
6	"fmt"
7
8	"github.com/btcsuite/btcd/btcec/v2"
9	"github.com/decred/dcrd/dcrec/secp256k1/v4"
10	sphinx "github.com/lightningnetwork/lightning-onion"
11	"github.com/lightningnetwork/lnd/graph/db/models"
12	"github.com/lightningnetwork/lnd/input"
13	"github.com/lightningnetwork/lnd/lnwire"
14	"github.com/lightningnetwork/lnd/routing/route"
15	)
16
17	// BlindedPathNUMSHex is the hex encoded version of the blinded path target
18	// NUMs key (in compressed format) which has no known private key.
19	// This was generated using the following script:
20	// https://github.com/lightninglabs/lightning-node-connect/tree/master/
21	// mailbox/numsgen, with the seed phrase "Lightning Blinded Path".
22	const BlindedPathNUMSHex = "02667a98ef82ecb522f803b17a74f14508a48b25258f9831" +
23	"dd6e95f5e299dfd54e"
24
25	var (
26	// ErrNoBlindedPath is returned when the blinded path in a blinded
27	// payment is missing.
28	ErrNoBlindedPath = errors.New("blinded path required")
29
30	// ErrInsufficientBlindedHops is returned when a blinded path does
31	// not have enough blinded hops.
32	ErrInsufficientBlindedHops = errors.New("blinded path requires " +
33	"at least one hop")
34
35	// ErrHTLCRestrictions is returned when a blinded path has invalid
36	// HTLC maximum and minimum values.
37	ErrHTLCRestrictions = errors.New("invalid htlc minimum and maximum")
38
39	// BlindedPathNUMSKey is a NUMS key (nothing up my sleeves number) that
40	// has no known private key.
41	BlindedPathNUMSKey = input.MustParsePubKey(BlindedPathNUMSHex)
42
43	// CompressedBlindedPathNUMSKey is the compressed version of the
44	// BlindedPathNUMSKey.
45	CompressedBlindedPathNUMSKey = BlindedPathNUMSKey.SerializeCompressed()
46	)
47
48	// BlindedPaymentPathSet groups the data we need to handle sending to a set of
49	// blinded paths provided by the recipient of a payment.
50	//
51	// NOTE: for now this only holds a single BlindedPayment. By the end of the PR
52	// series, it will handle multiple paths.
53	type BlindedPaymentPathSet struct {
54	// paths is the set of blinded payment paths for a single payment.
55	// NOTE: For now this will always only have a single entry. By the end
56	// of this PR, it can hold multiple.
57	paths []*BlindedPayment
58
59	// targetPubKey is the ephemeral node pub key that we will inject into
60	// each path as the last hop. This is only for the sake of path finding.
61	// Once the path has been found, the original destination pub key is
62	// used again. In the edge case where there is only a single hop in the
63	// path (the introduction node is the destination node), then this will
64	// just be the introduction node's real public key.
65	targetPubKey *btcec.PublicKey
66
67	// features is the set of relay features available for the payment.
68	// This is extracted from the set of blinded payment paths. At the
69	// moment we require that all paths for the same payment have the
70	// same feature set.
71	features *lnwire.FeatureVector
72
73	// finalCLTV is the final hop's expiry delta of _any_ path in the set.
74	// For any multi-hop path, the final CLTV delta should be seen as zero
75	// since the final hop's final CLTV delta is accounted for in the
76	// accumulated path policy values. The only edge case is for when the
77	// final hop in the path is also the introduction node in which case
78	// that path's FinalCLTV must be the non-zero min CLTV of the final hop
79	// so that it is accounted for in path finding. For this reason, if
80	// we have any single path in the set with only one hop, then we throw
81	// away all the other paths. This should be fine to do since if there is
82	// a path where the intro node is also the destination node, then there
83	// isn't any need to try any other longer blinded path. In other words,
84	// if this value is non-zero, then there is only one path in this
85	// blinded path set and that path only has a single hop: the
86	// introduction node.
87	finalCLTV uint16
88	}
89
90	// NewBlindedPaymentPathSet constructs a new BlindedPaymentPathSet from a set of
91	// BlindedPayments. For blinded paths which have more than one single hop a
92	// dummy hop via a NUMS key is appeneded to allow for MPP path finding via
93	// multiple blinded paths.
94	func NewBlindedPaymentPathSet(paths []BlindedPayment) (BlindedPaymentPathSet,
95	error) {	9✔
96		9✔
97	if len(paths) == 0 {	9✔
98	return nil, ErrNoBlindedPath	×
99	}	×
100
101	// For now, we assert that all the paths have the same set of features.
102	features := paths[0].Features	9✔
103	noFeatures := features == nil \|\| features.IsEmpty()	9✔
104	for i := 1; i < len(paths); i++ {	10✔
105	noFeats := paths[i].Features == nil \|\|	1✔
106	paths[i].Features.IsEmpty()	1✔
107		1✔
108	if noFeatures && !noFeats {	1✔
109	return nil, fmt.Errorf("all blinded paths must have " +	×
110	"the same set of features")	×
111	}	×
112
113	if noFeatures {	2✔
114	continue	1✔
115	}
116
117	if !features.RawFeatureVector.Equals(	×
118	paths[i].Features.RawFeatureVector,	×
119	) {	×
120		×
121	return nil, fmt.Errorf("all blinded paths must have " +	×
122	"the same set of features")	×
123	}	×
124	}
125
126	// Deep copy the paths to avoid mutating the original paths.
127	pathSet := make([]*BlindedPayment, len(paths))	9✔
128	for i, path := range paths {	19✔
129	pathSet[i] = path.deepCopy()	10✔
130	}	10✔
131
132	// For blinded paths we use the NUMS key as a target if the blinded
133	// path has more hops than just the introduction node.
134	targetPub := &BlindedPathNUMSKey	9✔
135		9✔
136	var finalCLTVDelta uint16	9✔
137		9✔
138	// In case the paths do NOT include a single hop route we append a	9✔
139	// dummy hop via a NUMS key to allow for MPP path finding via multiple	9✔
140	// blinded paths. A unified target is needed to use all blinded paths	9✔
141	// during the payment lifecycle. A dummy hop is solely added for the	9✔
142	// path finding process and is removed after the path is found. This	9✔
143	// ensures that we still populate the mission control with the correct	9✔
144	// data and also respect these mc entries when looking for a path.	9✔
145	for _, path := range pathSet {	19✔
146	pathLength := len(path.BlindedPath.BlindedHops)	10✔
147		10✔
148	// If any provided blinded path only has a single hop (ie, the	10✔
149	// destination node is also the introduction node), then we	10✔
150	// discard all other paths since we know the real pub key of the	10✔
151	// destination node. We also then set the final CLTV delta to	10✔
152	// the path's delta since there are no other edge hints that	10✔
153	// will account for it.	10✔
154	if pathLength == 1 {	14✔
155	pathSet = []*BlindedPayment{path}	4✔
156	finalCLTVDelta = path.CltvExpiryDelta	4✔
157	targetPub = path.BlindedPath.IntroductionPoint	4✔
158		4✔
159	break	4✔
160	}
161
162	lastHop := path.BlindedPath.BlindedHops[pathLength-1]	6✔
163	path.BlindedPath.BlindedHops = append(	6✔
164	path.BlindedPath.BlindedHops,	6✔
165	&sphinx.BlindedHopInfo{	6✔
166	BlindedNodePub: &BlindedPathNUMSKey,	6✔
167	// We add the last hop's cipher text so that	6✔
168	// the payload size of the final hop is equal	6✔
169	// to the real last hop.	6✔
170	CipherText: lastHop.CipherText,	6✔
171	},	6✔
172	)	6✔
173	}
174
175	return &BlindedPaymentPathSet{	9✔
176	paths: pathSet,	9✔
177	targetPubKey: targetPub,	9✔
178	features: features,	9✔
179	finalCLTV: finalCLTVDelta,	9✔
180	}, nil	9✔
181	}
182
183	// TargetPubKey returns the public key to be used as the destination node's
184	// public key during pathfinding.
185	func (s BlindedPaymentPathSet) TargetPubKey() btcec.PublicKey {	8✔
186	return s.targetPubKey	8✔
187	}	8✔
188
189	// Features returns the set of relay features available for the payment.
190	func (s BlindedPaymentPathSet) Features() lnwire.FeatureVector {	×
191	return s.features	×
192	}	×
193
194	// IntroNodeOnlyPath can be called if it is expected that the path set only
195	// contains a single payment path which itself only has one hop. It errors if
196	// this is not the case.
197	func (s BlindedPaymentPathSet) IntroNodeOnlyPath() (BlindedPayment, error) {	×
198	if len(s.paths) != 1 {	×
199	return nil, fmt.Errorf("expected only a single path in the "+	×
200	"blinded payment set, got %d", len(s.paths))	×
201	}	×
202
203	if len(s.paths[0].BlindedPath.BlindedHops) > 1 {	×
204	return nil, fmt.Errorf("an intro node only path cannot have " +	×
205	"more than one hop")	×
206	}	×
207
208	return s.paths[0], nil	×
209	}
210
211	// IsIntroNode returns true if the given vertex is an introduction node for one
212	// of the paths in the blinded payment path set.
213	func (s *BlindedPaymentPathSet) IsIntroNode(source route.Vertex) bool {	6✔
214	for _, path := range s.paths {	12✔
215	introVertex := route.NewVertex(	6✔
216	path.BlindedPath.IntroductionPoint,	6✔
217	)	6✔
218	if source == introVertex {	7✔
219	return true	1✔
220	}	1✔
221	}
222
223	return false	5✔
224	}
225
226	// FinalCLTVDelta is the minimum CLTV delta to use for the final hop on the
227	// route. In most cases this will return zero since the value is accounted for
228	// in the path's accumulated CLTVExpiryDelta. Only in the edge case of the path
229	// set only including a single path which only includes an introduction node
230	// will this return a non-zero value.
231	func (s *BlindedPaymentPathSet) FinalCLTVDelta() uint16 {	4✔
232	return s.finalCLTV	4✔
233	}	4✔
234
235	// LargestLastHopPayloadPath returns the BlindedPayment in the set that has the
236	// largest last-hop payload. This is to be used for onion size estimation in
237	// path finding.
238	func (s BlindedPaymentPathSet) LargestLastHopPayloadPath() (BlindedPayment,
239	error) {	4✔
240		4✔
241	var (	4✔
242	largestPath *BlindedPayment	4✔
243	currentMax int	4✔
244	)	4✔
245		4✔
246	if len(s.paths) == 0 {	4✔
247	return nil, fmt.Errorf("no blinded paths in the set")	×
248	}	×
249
250	// We set the largest path to make sure we always return a path even
251	// if the cipher text is empty.
252	largestPath = s.paths[0]	4✔
253		4✔
254	for _, path := range s.paths {	10✔
255	numHops := len(path.BlindedPath.BlindedHops)	6✔
256	lastHop := path.BlindedPath.BlindedHops[numHops-1]	6✔
257		6✔
258	if len(lastHop.CipherText) > currentMax {	10✔
259	largestPath = path	4✔
260	currentMax = len(lastHop.CipherText)	4✔
261	}	4✔
262	}
263
264	return largestPath, nil	4✔
265	}
266
267	// ToRouteHints converts the blinded path payment set into a RouteHints map so
268	// that the blinded payment paths can be treated like route hints throughout the
269	// code base.
270	func (s *BlindedPaymentPathSet) ToRouteHints() (RouteHints, error) {	3✔
271	hints := make(RouteHints)	3✔
272		3✔
273	for _, path := range s.paths {	6✔
274	pathHints, err := path.toRouteHints()	3✔
275	if err != nil {	3✔
276	return nil, err	×
277	}	×
278
279	for from, edges := range pathHints {	5✔
280	hints[from] = append(hints[from], edges...)	2✔
281	}	2✔
282	}
283
284	if len(hints) == 0 {	5✔
285	return nil, nil	2✔
286	}	2✔
287
288	return hints, nil	1✔
289	}
290
291	// IsBlindedRouteNUMSTargetKey returns true if the given public key is the
292	// NUMS key used as a target for blinded path final hops.
293	func IsBlindedRouteNUMSTargetKey(pk []byte) bool {	3✔
294	return bytes.Equal(pk, CompressedBlindedPathNUMSKey)	3✔
295	}	3✔
296
297	// BlindedPayment provides the path and payment parameters required to send a
298	// payment along a blinded path.
299	type BlindedPayment struct {
300	// BlindedPath contains the unblinded introduction point and blinded
301	// hops for the blinded section of the payment.
302	BlindedPath *sphinx.BlindedPath
303
304	// BaseFee is the total base fee to be paid for payments made over the
305	// blinded path.
306	BaseFee uint32
307
308	// ProportionalFeeRate is the aggregated proportional fee rate for
309	// payments made over the blinded path.
310	ProportionalFeeRate uint32
311
312	// CltvExpiryDelta is the total expiry delta for the blinded path. This
313	// field includes the CLTV for the blinded hops and the final cltv
314	// delta for the receiver.
315	CltvExpiryDelta uint16
316
317	// HtlcMinimum is the highest HLTC minimum supported along the blinded
318	// path (while some hops may have lower values, we're effectively
319	// bounded by the highest minimum).
320	HtlcMinimum uint64
321
322	// HtlcMaximum is the lowest HTLC maximum supported along the blinded
323	// path (while some hops may have higher values, we're effectively
324	// bounded by the lowest maximum).
325	HtlcMaximum uint64
326
327	// Features is the set of relay features available for the payment.
328	Features *lnwire.FeatureVector
329	}
330
331	// Validate performs validation on a blinded payment.
332	func (b *BlindedPayment) Validate() error {	5✔
333	if b.BlindedPath == nil {	6✔
334	return ErrNoBlindedPath	1✔
335	}	1✔
336
337	// The sphinx library inserts the introduction node as the first hop,
338	// so we expect at least one hop.
339	if len(b.BlindedPath.BlindedHops) < 1 {	5✔
340	return fmt.Errorf("%w got: %v", ErrInsufficientBlindedHops,	1✔
341	len(b.BlindedPath.BlindedHops))	1✔
342	}	1✔
343
344	if b.HtlcMaximum < b.HtlcMinimum {	4✔
345	return fmt.Errorf("%w: %v < %v", ErrHTLCRestrictions,	1✔
346	b.HtlcMaximum, b.HtlcMinimum)	1✔
347	}	1✔
348
349	for _, hop := range b.BlindedPath.BlindedHops {	6✔
350	// The first hop of the blinded path does not necessarily have	4✔
351	// blinded node pub key because it is the introduction point.	4✔
352	if hop.BlindedNodePub == nil {	6✔
353	continue	2✔
354	}
355
356	if IsBlindedRouteNUMSTargetKey(	2✔
357	hop.BlindedNodePub.SerializeCompressed(),	2✔
358	) {	2✔
359		×
360	return fmt.Errorf("blinded path cannot include NUMS "+	×
361	"key: %s", BlindedPathNUMSHex)	×
362	}	×
363	}
364
365	return nil	2✔
366	}
367
368	// toRouteHints produces a set of chained route hints that represent a blinded
369	// path. In the case of a single hop blinded route (which is paying directly
370	// to the introduction point), no hints will be returned. In this case callers
371	// must account for the blinded route's CLTV delta elsewhere (as this is
372	// effectively the final_cltv_delta for the receiving introduction node). In
373	// the case of multiple blinded hops, CLTV delta is fully accounted for in the
374	// hints (both for intermediate hops and the final_cltv_delta for the receiving
375	// node).
376	func (b *BlindedPayment) toRouteHints() (RouteHints, error) {	8✔
377	// If we just have a single hop in our blinded route, it just contains	8✔
378	// an introduction node (this is a valid path according to the spec).	8✔
379	// Since we have the un-blinded node ID for the introduction node, we	8✔
380	// don't need to add any route hints.	8✔
381	if len(b.BlindedPath.BlindedHops) == 1 {	11✔
382	return nil, nil	3✔
383	}	3✔
384
385	hintCount := len(b.BlindedPath.BlindedHops) - 1	5✔
386	hints := make(	5✔
387	RouteHints, hintCount,	5✔
388	)	5✔
389		5✔
390	// Start at the unblinded introduction node, because our pathfinding	5✔
391	// will be able to locate this point in the graph.	5✔
392	fromNode := route.NewVertex(b.BlindedPath.IntroductionPoint)	5✔
393		5✔
394	features := lnwire.EmptyFeatureVector()	5✔
395	if b.Features != nil {	7✔
396	features = b.Features.Clone()	2✔
397	}	2✔
398
399	// Use the total aggregate relay parameters for the entire blinded
400	// route as the policy for the hint from our introduction node. This
401	// will ensure that pathfinding provides sufficient fees/delay for the
402	// blinded portion to the introduction node.
403	firstBlindedHop := b.BlindedPath.BlindedHops[1].BlindedNodePub	5✔
404	edgePolicy := &models.CachedEdgePolicy{	5✔
405	TimeLockDelta: b.CltvExpiryDelta,	5✔
406	MinHTLC: lnwire.MilliSatoshi(b.HtlcMinimum),	5✔
407	MaxHTLC: lnwire.MilliSatoshi(b.HtlcMaximum),	5✔
408	FeeBaseMSat: lnwire.MilliSatoshi(b.BaseFee),	5✔
409	FeeProportionalMillionths: lnwire.MilliSatoshi(	5✔
410	b.ProportionalFeeRate,	5✔
411	),	5✔
412	ToNodePubKey: func() route.Vertex {	13✔
413	return route.NewVertex(	8✔
414	// The first node in this slice is	8✔
415	// the introduction node, so we start	8✔
416	// at index 1 to get the first blinded	8✔
417	// relaying node.	8✔
418	firstBlindedHop,	8✔
419	)	8✔
420	},	8✔
421	ToNodeFeatures: features,
422	}
423
424	lastEdge, err := NewBlindedEdge(edgePolicy, b, 0)	5✔
425	if err != nil {	5✔
426	return nil, err	×
427	}	×
428
429	hints[fromNode] = []AdditionalEdge{lastEdge}	5✔
430		5✔
431	// Start at an offset of 1 because the first node in our blinded hops	5✔
432	// is the introduction node and terminate at the second-last node	5✔
433	// because we're dealing with hops as pairs.	5✔
434	for i := 1; i < hintCount; i++ {	16✔
435	// Set our origin node to the current	11✔
436	fromNode = route.NewVertex(	11✔
437	b.BlindedPath.BlindedHops[i].BlindedNodePub,	11✔
438	)	11✔
439		11✔
440	// Create a hint which has no fee or cltv delta. We	11✔
441	// specifically want zero values here because our relay	11✔
442	// parameters are expressed in encrypted blobs rather than the	11✔
443	// route itself for blinded routes.	11✔
444	nextHopIdx := i + 1	11✔
445	nextNode := route.NewVertex(	11✔
446	b.BlindedPath.BlindedHops[nextHopIdx].BlindedNodePub,	11✔
447	)	11✔
448		11✔
449	edgePolicy := &models.CachedEdgePolicy{	11✔
450	ToNodePubKey: func() route.Vertex {	24✔
451	return nextNode	13✔
452	},	13✔
453	ToNodeFeatures: features,
454	}
455
456	lastEdge, err = NewBlindedEdge(edgePolicy, b, i)	11✔
457	if err != nil {	11✔
458	return nil, err	×
459	}	×
460
461	hints[fromNode] = []AdditionalEdge{lastEdge}	11✔
462	}
463
464	return hints, nil	5✔
465	}
466
467	// deepCopy returns a deep copy of the BlindedPayment.
468	func (b BlindedPayment) deepCopy() BlindedPayment {	12✔
469	if b == nil {	13✔
470	return nil	1✔
471	}	1✔
472
473	cpyPayment := &BlindedPayment{	11✔
474	BaseFee: b.BaseFee,	11✔
475	ProportionalFeeRate: b.ProportionalFeeRate,	11✔
476	CltvExpiryDelta: b.CltvExpiryDelta,	11✔
477	HtlcMinimum: b.HtlcMinimum,	11✔
478	HtlcMaximum: b.HtlcMaximum,	11✔
479	}	11✔
480		11✔
481	// Deep copy the BlindedPath if it exists	11✔
482	if b.BlindedPath != nil {	22✔
483	cpyPayment.BlindedPath = &sphinx.BlindedPath{	11✔
484	BlindedHops: make([]*sphinx.BlindedHopInfo,	11✔
485	len(b.BlindedPath.BlindedHops)),	11✔
486	}	11✔
487		11✔
488	if b.BlindedPath.IntroductionPoint != nil {	19✔
489	cpyPayment.BlindedPath.IntroductionPoint =	8✔
490	copyPublicKey(b.BlindedPath.IntroductionPoint)	8✔
491	}	8✔
492
493	if b.BlindedPath.BlindingPoint != nil {	16✔
494	cpyPayment.BlindedPath.BlindingPoint =	5✔
495	copyPublicKey(b.BlindedPath.BlindingPoint)	5✔
496	}	5✔
497
498	// Copy each blinded hop info.
499	for i, hop := range b.BlindedPath.BlindedHops {	29✔
500	if hop == nil {	18✔
501	continue	×
502	}
503
504	cpyHop := &sphinx.BlindedHopInfo{	18✔
505	CipherText: hop.CipherText,	18✔
506	}	18✔
507		18✔
508	if hop.BlindedNodePub != nil {	24✔
509	cpyHop.BlindedNodePub =	6✔
510	copyPublicKey(hop.BlindedNodePub)	6✔
511	}	6✔
512
513	cpyHop.CipherText = make([]byte, len(hop.CipherText))	18✔
514	copy(cpyHop.CipherText, hop.CipherText)	18✔
515		18✔
516	cpyPayment.BlindedPath.BlindedHops[i] = cpyHop	18✔
517	}
518	}
519
520	// Deep copy the Features if they exist
521	if b.Features != nil {	13✔
522	cpyPayment.Features = b.Features.Clone()	2✔
523	}	2✔
524
525	return cpyPayment	11✔
526	}
527
528	// copyPublicKey makes a deep copy of a public key.
529	//
530	// TODO(ziggie): Remove this function if this is available in the btcec library.
531	func copyPublicKey(pk btcec.PublicKey) btcec.PublicKey {	19✔
532	var result secp256k1.JacobianPoint	19✔
533	pk.AsJacobian(&result)	19✔
534	result.ToAffine()	19✔
535		19✔
536	return btcec.NewPublicKey(&result.X, &result.Y)	19✔
537	}	19✔

lightningnetwork / lnd / 12312390362

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