12343072627

Committed 15 Dec 2024 11:09PM UTC coverage: 57.504% (-1.1%) from 58.636%

Build # 12343072627

Build Type

Pull #9315

github

Committed by

yyforyongyu

Commit Message

contractcourt: offer outgoing htlc one block earlier before its expiry

We need to offer the outgoing htlc one block earlier to make sure when
the expiry height hits, the sweeper will not miss sweeping it in the
same block. This also means the outgoing contest resolver now only does
one thing - watch for preimage spend till height expiry-1, which can
easily be moved into the timeout resolver instead in the future.

Pull Request Pull Request #9315: Implement `blockbeat`

Run Details

1445 of 2007 new or added lines in 26 files covered. (72.0%)

19246 existing lines in 249 files now uncovered.

102342 of 177975 relevant lines covered (57.5%)

24772.24 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 {	135✔
12	return &PubKeyECDH{	135✔
13	keyDesc: keyDesc,	135✔
14	ecdh: ecdh,	135✔
15	}	135✔
16	}	135✔
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 / 12343072627

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