12986279612

Committed 27 Jan 2025 09:51AM UTC coverage: 57.652% (-1.1%) from 58.788%

Build # 12986279612

Build Type

Pull #9447

github

Committed by

yyforyongyu

Commit Message

sweep: rename methods for clarity

We now rename "third party" to "unknown" as the inputs can be spent via
an older sweeping tx, a third party (anchor), or a remote party (pin).
In fee bumper we don't have the info to distinguish the above cases, and
leave them to be further handled by the sweeper as it has more context.

Pull Request Pull Request #9447: sweep: start tracking input spending status in the fee bumper

Run Details

83 of 87 new or added lines in 2 files covered. (95.4%)

19578 existing lines in 256 files now uncovered.

103448 of 179434 relevant lines covered (57.65%)

24884.58 hits per line

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

88.89

/keychain/ecdh.go

package keychain

import (
        "crypto/sha256"

        "github.com/btcsuite/btcd/btcec/v2"
)

// NewPubKeyECDH wraps the given key of the key ring so it adheres to the
// SingleKeyECDH interface.
func NewPubKeyECDH(keyDesc KeyDescriptor, ecdh ECDHRing) *PubKeyECDH {
        return &PubKeyECDH{
                keyDesc: keyDesc,
                ecdh:    ecdh,
        }
}

// PubKeyECDH is an implementation of the SingleKeyECDH interface. It wraps an
// ECDH key ring so it can perform ECDH shared key generation against a single
// abstracted away private key.
type PubKeyECDH struct {
        keyDesc KeyDescriptor
        ecdh    ECDHRing
}

// PubKey returns the public key of the private key that is abstracted away by
// the interface.
//
// NOTE: This is part of the SingleKeyECDH interface.
func (p *PubKeyECDH) PubKey() *btcec.PublicKey {
        return p.keyDesc.PubKey
}

// ECDH performs a scalar multiplication (ECDH-like operation) between the
// abstracted private key and a remote public key. The output returned will be
// the sha256 of the resulting shared point serialized in compressed format. If
// k is our private key, and P is the public key, we perform the following
// operation:
//
//        sx := k*P
//        s := sha256(sx.SerializeCompressed())
//
// NOTE: This is part of the SingleKeyECDH interface.
func (p *PubKeyECDH) ECDH(pubKey *btcec.PublicKey) ([32]byte, error) {
        return p.ecdh.ECDH(p.keyDesc, pubKey)
}

// PrivKeyECDH is an implementation of the SingleKeyECDH in which we do have the
// full private key. This can be used to wrap a temporary key to conform to the
// SingleKeyECDH interface.
type PrivKeyECDH struct {
        // PrivKey is the private key that is used for the ECDH operation.
        PrivKey *btcec.PrivateKey
}

// PubKey returns the public key of the private key that is abstracted away by
// the interface.
//
// NOTE: This is part of the SingleKeyECDH interface.
func (p *PrivKeyECDH) PubKey() *btcec.PublicKey {
        return p.PrivKey.PubKey()
}

// ECDH performs a scalar multiplication (ECDH-like operation) between the
// abstracted private key and a remote public key. The output returned will be
// the sha256 of the resulting shared point serialized in compressed format. If
// k is our private key, and P is the public key, we perform the following
// operation:
//
//        sx := k*P
//        s := sha256(sx.SerializeCompressed())
//
// NOTE: This is part of the SingleKeyECDH interface.
func (p *PrivKeyECDH) ECDH(pub *btcec.PublicKey) ([32]byte, error) {
        var (
                pubJacobian btcec.JacobianPoint
                s           btcec.JacobianPoint
        )
        pub.AsJacobian(&pubJacobian)

        btcec.ScalarMultNonConst(&p.PrivKey.Key, &pubJacobian, &s)
        s.ToAffine()
        sPubKey := btcec.NewPublicKey(&s.X, &s.Y)
        return sha256.Sum256(sPubKey.SerializeCompressed()), nil
}

var _ SingleKeyECDH = (*PubKeyECDH)(nil)
var _ SingleKeyECDH = (*PrivKeyECDH)(nil)

1	package keychain
2
3	import (
4	"crypto/sha256"
5
6	"github.com/btcsuite/btcd/btcec/v2"
7	)
8
9	// NewPubKeyECDH wraps the given key of the key ring so it adheres to the
10	// SingleKeyECDH interface.
11	func NewPubKeyECDH(keyDesc KeyDescriptor, ecdh ECDHRing) *PubKeyECDH {	137✔
12	return &PubKeyECDH{	137✔
13	keyDesc: keyDesc,	137✔
14	ecdh: ecdh,	137✔
15	}	137✔
16	}	137✔
17
18	// PubKeyECDH is an implementation of the SingleKeyECDH interface. It wraps an
19	// ECDH key ring so it can perform ECDH shared key generation against a single
20	// abstracted away private key.
21	type PubKeyECDH struct {
22	keyDesc KeyDescriptor
23	ecdh ECDHRing
24	}
25
26	// PubKey returns the public key of the private key that is abstracted away by
27	// the interface.
28	//
29	// NOTE: This is part of the SingleKeyECDH interface.
30	func (p PubKeyECDH) PubKey() btcec.PublicKey {	520✔
31	return p.keyDesc.PubKey	520✔
32	}	520✔
33
34	// ECDH performs a scalar multiplication (ECDH-like operation) between the
35	// abstracted private key and a remote public key. The output returned will be
36	// the sha256 of the resulting shared point serialized in compressed format. If
37	// k is our private key, and P is the public key, we perform the following
38	// operation:
39	//
40	// sx := k*P
41	// s := sha256(sx.SerializeCompressed())
42	//
43	// NOTE: This is part of the SingleKeyECDH interface.
UNCOV 44	func (p PubKeyECDH) ECDH(pubKey btcec.PublicKey) ([32]byte, error) {	×
UNCOV 45	return p.ecdh.ECDH(p.keyDesc, pubKey)	×
UNCOV 46	}	×
47
48	// PrivKeyECDH is an implementation of the SingleKeyECDH in which we do have the
49	// full private key. This can be used to wrap a temporary key to conform to the
50	// SingleKeyECDH interface.
51	type PrivKeyECDH struct {
52	// PrivKey is the private key that is used for the ECDH operation.
53	PrivKey *btcec.PrivateKey
54	}
55
56	// PubKey returns the public key of the private key that is abstracted away by
57	// the interface.
58	//
59	// NOTE: This is part of the SingleKeyECDH interface.
60	func (p PrivKeyECDH) PubKey() btcec.PublicKey {	768✔
61	return p.PrivKey.PubKey()	768✔
62	}	768✔
63
64	// ECDH performs a scalar multiplication (ECDH-like operation) between the
65	// abstracted private key and a remote public key. The output returned will be
66	// the sha256 of the resulting shared point serialized in compressed format. If
67	// k is our private key, and P is the public key, we perform the following
68	// operation:
69	//
70	// sx := k*P
71	// s := sha256(sx.SerializeCompressed())
72	//
73	// NOTE: This is part of the SingleKeyECDH interface.
74	func (p PrivKeyECDH) ECDH(pub btcec.PublicKey) ([32]byte, error) {	2,027✔
75	var (	2,027✔
76	pubJacobian btcec.JacobianPoint	2,027✔
77	s btcec.JacobianPoint	2,027✔
78	)	2,027✔
79	pub.AsJacobian(&pubJacobian)	2,027✔
80		2,027✔
81	btcec.ScalarMultNonConst(&p.PrivKey.Key, &pubJacobian, &s)	2,027✔
82	s.ToAffine()	2,027✔
83	sPubKey := btcec.NewPublicKey(&s.X, &s.Y)	2,027✔
84	return sha256.Sum256(sPubKey.SerializeCompressed()), nil	2,027✔
85	}	2,027✔
86
87	var _ SingleKeyECDH = (*PubKeyECDH)(nil)
88	var _ SingleKeyECDH = (*PrivKeyECDH)(nil)

lightningnetwork / lnd / 12986279612

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