From eb068bf6667b816d925f3b2758a5425d5b7dad33 Mon Sep 17 00:00:00 2001 From: carla Date: Wed, 19 May 2021 09:03:46 +0200 Subject: [PATCH] multi: unexport session key and add constructor for htlc attempt info --- channeldb/duplicate_payments.go | 2 +- channeldb/mp_payment.go | 23 +++++++++++++++++++++-- channeldb/payment_control_test.go | 2 +- channeldb/payments.go | 4 ++-- channeldb/payments_test.go | 4 +--- routing/control_tower_test.go | 8 +++----- routing/payment_lifecycle.go | 16 ++++++---------- 7 files changed, 35 insertions(+), 24 deletions(-) diff --git a/channeldb/duplicate_payments.go b/channeldb/duplicate_payments.go index c26f185a..1a1fdae7 100644 --- a/channeldb/duplicate_payments.go +++ b/channeldb/duplicate_payments.go @@ -181,7 +181,7 @@ func fetchDuplicatePayment(bucket kvdb.RBucket) (*MPPayment, error) { HTLCAttemptInfo: HTLCAttemptInfo{ AttemptID: attempt.attemptID, Route: attempt.route, - SessionKey: attempt.sessionKey, + sessionKey: attempt.sessionKey, }, } diff --git a/channeldb/mp_payment.go b/channeldb/mp_payment.go index 4d14d504..8603c291 100644 --- a/channeldb/mp_payment.go +++ b/channeldb/mp_payment.go @@ -21,8 +21,8 @@ type HTLCAttemptInfo struct { // AttemptID is the unique ID used for this attempt. AttemptID uint64 - // SessionKey is the ephemeral key used for this attempt. - SessionKey *btcec.PrivateKey + // sessionKey is the ephemeral key used for this attempt. + sessionKey *btcec.PrivateKey // Route is the route attempted to send the HTLC. Route route.Route @@ -38,6 +38,25 @@ type HTLCAttemptInfo struct { Hash *lntypes.Hash } +// NewHtlcAttemptInfo creates a htlc attempt. +func NewHtlcAttemptInfo(attemptID uint64, sessionKey *btcec.PrivateKey, + route route.Route, attemptTime time.Time, + hash *lntypes.Hash) *HTLCAttemptInfo { + + return &HTLCAttemptInfo{ + AttemptID: attemptID, + sessionKey: sessionKey, + Route: route, + AttemptTime: attemptTime, + Hash: hash, + } +} + +// SessionKey returns the ephemeral key used for a htlc attempt. +func (h *HTLCAttemptInfo) SessionKey() *btcec.PrivateKey { + return h.sessionKey +} + // HTLCAttempt contains information about a specific HTLC attempt for a given // payment. It contains the HTLCAttemptInfo used to send the HTLC, as well // as a timestamp and any known outcome of the attempt. diff --git a/channeldb/payment_control_test.go b/channeldb/payment_control_test.go index a524fb0e..a4e9c846 100644 --- a/channeldb/payment_control_test.go +++ b/channeldb/payment_control_test.go @@ -45,7 +45,7 @@ func genInfo() (*PaymentCreationInfo, *HTLCAttemptInfo, }, &HTLCAttemptInfo{ AttemptID: 0, - SessionKey: priv, + sessionKey: priv, Route: *testRoute.Copy(), }, preimage, nil } diff --git a/channeldb/payments.go b/channeldb/payments.go index 72b15ffb..1abe54a5 100644 --- a/channeldb/payments.go +++ b/channeldb/payments.go @@ -919,7 +919,7 @@ func deserializePaymentCreationInfo(r io.Reader) (*PaymentCreationInfo, error) { } func serializeHTLCAttemptInfo(w io.Writer, a *HTLCAttemptInfo) error { - if err := WriteElements(w, a.SessionKey); err != nil { + if err := WriteElements(w, a.sessionKey); err != nil { return err } @@ -945,7 +945,7 @@ func serializeHTLCAttemptInfo(w io.Writer, a *HTLCAttemptInfo) error { func deserializeHTLCAttemptInfo(r io.Reader) (*HTLCAttemptInfo, error) { a := &HTLCAttemptInfo{} - err := ReadElements(r, &a.SessionKey) + err := ReadElements(r, &a.sessionKey) if err != nil { return nil, err } diff --git a/channeldb/payments_test.go b/channeldb/payments_test.go index 9fab9a1f..1ef0e7dd 100644 --- a/channeldb/payments_test.go +++ b/channeldb/payments_test.go @@ -70,7 +70,7 @@ func makeFakeInfo() (*PaymentCreationInfo, *HTLCAttemptInfo) { a := &HTLCAttemptInfo{ AttemptID: 44, - SessionKey: priv, + sessionKey: priv, Route: testRoute, AttemptTime: time.Unix(100, 0), Hash: &hash, @@ -124,8 +124,6 @@ func TestSentPaymentSerialization(t *testing.T) { s.Route = route.Route{} if !reflect.DeepEqual(s, newWireInfo) { - s.SessionKey.Curve = nil - newWireInfo.SessionKey.Curve = nil t.Fatalf("Payments do not match after "+ "serialization/deserialization %v vs %v", spew.Sdump(s), spew.Sdump(newWireInfo), diff --git a/routing/control_tower_test.go b/routing/control_tower_test.go index 15706eaf..8b7082db 100644 --- a/routing/control_tower_test.go +++ b/routing/control_tower_test.go @@ -331,11 +331,9 @@ func genInfo() (*channeldb.PaymentCreationInfo, *channeldb.HTLCAttemptInfo, CreationTime: time.Unix(time.Now().Unix(), 0), PaymentRequest: []byte("hola"), }, - &channeldb.HTLCAttemptInfo{ - AttemptID: 1, - SessionKey: priv, - Route: testRoute, - }, preimage, nil + channeldb.NewHtlcAttemptInfo( + 1, priv, testRoute, time.Time{}, nil, + ), preimage, nil } func genPreimage() ([32]byte, error) { diff --git a/routing/payment_lifecycle.go b/routing/payment_lifecycle.go index 90dd684b..4703a627 100644 --- a/routing/payment_lifecycle.go +++ b/routing/payment_lifecycle.go @@ -499,7 +499,7 @@ func (p *shardHandler) collectResult(attempt *channeldb.HTLCAttemptInfo) ( // Regenerate the circuit for this attempt. _, circuit, err := generateSphinxPacket( - &attempt.Route, hash[:], attempt.SessionKey, + &attempt.Route, hash[:], attempt.SessionKey(), ) if err != nil { return nil, err @@ -677,15 +677,11 @@ func (p *shardHandler) createNewPaymentAttempt(rt *route.Route, lastShard bool) rt.Hops[0].ChannelID, ) - // We now have all the information needed to populate - // the current attempt information. - attempt := &channeldb.HTLCAttemptInfo{ - AttemptID: attemptID, - AttemptTime: p.router.cfg.Clock.Now(), - SessionKey: sessionKey, - Route: *rt, - Hash: &hash, - } + // We now have all the information needed to populate the current + // attempt information. + attempt := channeldb.NewHtlcAttemptInfo( + attemptID, sessionKey, *rt, p.router.cfg.Clock.Now(), &hash, + ) return firstHop, htlcAdd, attempt, nil }