graph/db/models: add channel wire conversion helpers

Add ChannelAuthProofFromWireAnnouncement and
ChannelAuthProofFromAnnounceSignatures for constructing auth proofs
from wire messages. Add ChannelEdgeInfoFromWireAnnouncement for
building a ChannelEdgeInfo from a ChannelAnnouncement interface.

Also add ChannelEdgePolicyFromWireUpdate for constructing a
ChannelEdgePolicy from a ChannelUpdate interface, and update the
KV and SQL stores to use the new ChannelEdgeInfo.ChanProofBytes()
accessor.

Author: ellemouton

graph/db/kv_store.go

@@ -3471,7 +3471,7 @@ func updateEdgePolicy(tx kvdb.RwTx, edge *models.ChannelEdgePolicy) (
 	// or second edge policy is being updated.
 	var fromNode, toNode []byte
 	var isUpdate1 bool
-	if edge.ChannelFlags&lnwire.ChanUpdateDirection == 0 {
+	if edge.IsNode1() {
 		fromNode = nodeInfo[:33]
 		toNode = nodeInfo[33:66]
 		isUpdate1 = true
@@ -5341,7 +5341,7 @@ func putChanEdgePolicy(edges kvdb.RwBucket, edge *models.ChannelEdgePolicy,
 
 	err = updateEdgePolicyDisabledIndex(
 		edges, edge.ChannelID,
-		edge.ChannelFlags&lnwire.ChanUpdateDirection > 0,
+		!edge.IsNode1(),
 		edge.IsDisabled(),
 	)
 	if err != nil {

graph/db/models/channel_auth_proof.go

@@ -1,10 +1,22 @@
 package models
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/lightningnetwork/lnd/fn/v2"
 	"github.com/lightningnetwork/lnd/lnwire"
 )
 
+var (
+	// ErrV2AnnSigProofAssemblyPending is returned when trying to derive a
+	// channel auth proof from v2 announce signatures. This will be
+	// supported once v2 proof assembly from announce_signatures_2 halves is
+	// implemented.
+	ErrV2AnnSigProofAssemblyPending = errors.New("v2 announce signatures " +
+		"proof assembly not yet implemented")
+)
+
 // ChannelAuthProof is the authentication proof (the signature portion) for a
 // channel.
 //
@@ -115,3 +127,74 @@ func (c *ChannelAuthProof) BitcoinSig2() []byte {
 func (c *ChannelAuthProof) Sig() []byte {
 	return c.Signature.UnwrapOr(nil)
 }
+
+// ChannelAuthProofFromWireAnnouncement constructs a channel auth proof from a
+// wire channel announcement message.
+func ChannelAuthProofFromWireAnnouncement(
+	ann lnwire.ChannelAnnouncement) (*ChannelAuthProof, error) {
+
+	switch ann := ann.(type) {
+	case *lnwire.ChannelAnnouncement1:
+		return NewV1ChannelAuthProof(
+			ann.NodeSig1.ToSignatureBytes(),
+			ann.NodeSig2.ToSignatureBytes(),
+			ann.BitcoinSig1.ToSignatureBytes(),
+			ann.BitcoinSig2.ToSignatureBytes(),
+		), nil
+
+	case *lnwire.ChannelAnnouncement2:
+		return NewV2ChannelAuthProof(
+			ann.Signature.Val.ToSignatureBytes(),
+		), nil
+
+	default:
+		return nil, fmt.Errorf("unsupported channel announcement: %T",
+			ann)
+	}
+}
+
+// ChannelAuthProofFromAnnounceSignatures derives a channel auth proof from two
+// opposing announce signatures messages.
+func ChannelAuthProofFromAnnounceSignatures(ann, oppositeAnn lnwire.AnnounceSignatures,
+	isFirstNode bool) (*ChannelAuthProof, error) {
+
+	if ann == nil || oppositeAnn == nil {
+		return nil, fmt.Errorf("announce signatures cannot be nil")
+	}
+
+	if ann.GossipVersion() != oppositeAnn.GossipVersion() {
+		return nil, fmt.Errorf("announce signatures version mismatch: %v "+
+			"!= %v", ann.GossipVersion(), oppositeAnn.GossipVersion())
+	}
+
+	switch annSig := ann.(type) {
+	case *lnwire.AnnounceSignatures1:
+		oppSig, ok := oppositeAnn.(*lnwire.AnnounceSignatures1)
+		if !ok {
+			return nil, fmt.Errorf("unexpected opposite announce "+
+				"signatures type: %T", oppositeAnn)
+		}
+
+		if isFirstNode {
+			return NewV1ChannelAuthProof(
+				annSig.NodeSignature.ToSignatureBytes(),
+				oppSig.NodeSignature.ToSignatureBytes(),
+				annSig.BitcoinSignature.ToSignatureBytes(),
+				oppSig.BitcoinSignature.ToSignatureBytes(),
+			), nil
+		}
+
+		return NewV1ChannelAuthProof(
+			oppSig.NodeSignature.ToSignatureBytes(),
+			annSig.NodeSignature.ToSignatureBytes(),
+			oppSig.BitcoinSignature.ToSignatureBytes(),
+			annSig.BitcoinSignature.ToSignatureBytes(),
+		), nil
+
+	case *lnwire.AnnounceSignatures2:
+		return nil, ErrV2AnnSigProofAssemblyPending
+
+	default:
+		return nil, fmt.Errorf("unsupported announce signatures: %T", ann)
+	}
+}

graph/db/models/channel_auth_proof_test.go

@@ -0,0 +1,64 @@
+package models
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/stretchr/testify/require"
+)
+
+func TestChannelAuthProofFromAnnounceSignaturesV1(t *testing.T) {
+	t.Parallel()
+
+	sig := func(b byte) lnwire.Sig {
+		raw := bytes.Repeat([]byte{b}, 64)
+		s, err := lnwire.NewSigFromWireECDSA(raw)
+		require.NoError(t, err)
+		return s
+	}
+
+	ann1 := &lnwire.AnnounceSignatures1{
+		NodeSignature:    sig(1),
+		BitcoinSignature: sig(2),
+	}
+	ann2 := &lnwire.AnnounceSignatures1{
+		NodeSignature:    sig(3),
+		BitcoinSignature: sig(4),
+	}
+
+	proof, err := ChannelAuthProofFromAnnounceSignatures(ann1, ann2, true)
+	require.NoError(t, err)
+	require.Equal(t, ann1.NodeSignature.ToSignatureBytes(), proof.NodeSig1())
+	require.Equal(t, ann2.NodeSignature.ToSignatureBytes(), proof.NodeSig2())
+	require.Equal(t, ann1.BitcoinSignature.ToSignatureBytes(),
+		proof.BitcoinSig1())
+	require.Equal(t, ann2.BitcoinSignature.ToSignatureBytes(),
+		proof.BitcoinSig2())
+}
+
+func TestChannelAuthProofFromAnnounceSignaturesV2Pending(t *testing.T) {
+	t.Parallel()
+
+	ann := lnwire.NewAnnSigs2(
+		lnwire.ChannelID{}, lnwire.ShortChannelID{}, lnwire.PartialSig{},
+	)
+
+	proof, err := ChannelAuthProofFromAnnounceSignatures(ann, ann, true)
+	require.ErrorIs(t, err, ErrV2AnnSigProofAssemblyPending)
+	require.Nil(t, proof)
+}
+
+func TestChannelAuthProofFromAnnounceSignaturesVersionMismatch(t *testing.T) {
+	t.Parallel()
+
+	ann1 := &lnwire.AnnounceSignatures1{}
+	ann2 := lnwire.NewAnnSigs2(
+		lnwire.ChannelID{}, lnwire.ShortChannelID{}, lnwire.PartialSig{},
+	)
+
+	proof, err := ChannelAuthProofFromAnnounceSignatures(ann1, ann2, true)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "version mismatch")
+	require.Nil(t, proof)
+}

graph/db/models/channel_edge_info.go

@@ -13,6 +13,7 @@ import (
 	"github.com/lightningnetwork/lnd/input"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
+	"github.com/lightningnetwork/lnd/tlv"
 )
 
 // ChannelEdgeInfo represents a fully authenticated channel along with all its
@@ -256,6 +257,59 @@ func NewV2Channel(chanID uint64, chainHash chainhash.Hash, node1,
 	return edge, nil
 }
 
+// ChannelEdgeInfoFromWireAnnouncement constructs a ChannelEdgeInfo from a wire
+// channel announcement message.
+func ChannelEdgeInfoFromWireAnnouncement(msg lnwire.ChannelAnnouncement,
+	proof *ChannelAuthProof) (*ChannelEdgeInfo, error) {
+
+	switch msg := msg.(type) {
+	case *lnwire.ChannelAnnouncement1:
+		return NewV1Channel(
+			msg.ShortChannelID.ToUint64(), msg.ChainHash,
+			msg.NodeID1, msg.NodeID2, &ChannelV1Fields{
+				BitcoinKey1Bytes: msg.BitcoinKey1,
+				BitcoinKey2Bytes: msg.BitcoinKey2,
+				ExtraOpaqueData:  msg.ExtraOpaqueData,
+			},
+			WithChanProof(proof), WithFeatures(msg.Features),
+		)
+
+	case *lnwire.ChannelAnnouncement2:
+		bitcoinKey1 := fn.MapOption(
+			func(key [33]byte) route.Vertex {
+				return key
+			},
+		)(msg.BitcoinKey1.ValOpt())
+		bitcoinKey2 := fn.MapOption(
+			func(key [33]byte) route.Vertex {
+				return key
+			},
+		)(msg.BitcoinKey2.ValOpt())
+		merkleRootHash := fn.MapOption(
+			func(hash [32]byte) chainhash.Hash {
+				return hash
+			},
+		)(msg.MerkleRootHash.ValOpt())
+
+		return NewV2Channel(
+			msg.ShortChannelID.Val.ToUint64(), msg.ChainHash.Val,
+			msg.NodeID1.Val, msg.NodeID2.Val, &ChannelV2Fields{
+				BitcoinKey1Bytes:  bitcoinKey1,
+				BitcoinKey2Bytes:  bitcoinKey2,
+				MerkleRootHash:    merkleRootHash,
+				ExtraSignedFields: msg.ExtraSignedFields,
+			},
+			WithChanProof(proof), WithFeatures(&msg.Features.Val),
+			WithCapacity(btcutil.Amount(msg.Capacity.Val)),
+			WithChannelPoint(wire.OutPoint(msg.Outpoint.Val)),
+		)
+
+	default:
+		return nil, fmt.Errorf("unsupported channel announcement: %T",
+			msg)
+	}
+}
+
 // NodeKey1 is the identity public key of the "first" node that was involved in
 // the creation of this channel. A node is considered "first" if the
 // lexicographical ordering the its serialized public key is "smaller" than
@@ -377,10 +431,10 @@ func (c *ChannelEdgeInfo) FundingPKScript() ([]byte, error) {
 	}
 }
 
-// ToChannelAnnouncement converts the ChannelEdgeInfo to a
+// toChannelAnnouncement1 converts the ChannelEdgeInfo to a
 // lnwire.ChannelAnnouncement1 message. Returns an error if AuthProof is nil
 // or if the version is not v1.
-func (c *ChannelEdgeInfo) ToChannelAnnouncement() (
+func (c *ChannelEdgeInfo) toChannelAnnouncement1() (
 	*lnwire.ChannelAnnouncement1, error) {
 
 	// We currently only support v1 channel announcements.
@@ -452,3 +506,84 @@ func (c *ChannelEdgeInfo) ToChannelAnnouncement() (
 
 	return chanAnn, nil
 }
+
+// ToWireAnnouncement converts the ChannelEdgeInfo to a version-aware wire
+// channel announcement.
+func (c *ChannelEdgeInfo) ToWireAnnouncement() (
+	lnwire.ChannelAnnouncement, error) {
+
+	switch c.Version {
+	case lnwire.GossipVersion1:
+		return c.toChannelAnnouncement1()
+
+	case lnwire.GossipVersion2:
+		return c.toChannelAnnouncement2()
+
+	default:
+		return nil, fmt.Errorf("unsupported channel version: %d",
+			c.Version)
+	}
+}
+
+// toChannelAnnouncement2 converts the ChannelEdgeInfo to a
+// lnwire.ChannelAnnouncement2 message.
+func (c *ChannelEdgeInfo) toChannelAnnouncement2() (
+	*lnwire.ChannelAnnouncement2, error) {
+
+	// If there's no auth proof, we can't create a full channel
+	// announcement.
+	if c.AuthProof == nil {
+		return nil, fmt.Errorf("cannot create channel announcement " +
+			"without auth proof")
+	}
+
+	if c.AuthProof.Version != lnwire.GossipVersion2 {
+		return nil, fmt.Errorf("invalid channel auth proof version: %d",
+			c.AuthProof.Version)
+	}
+
+	sigBytes := c.AuthProof.Sig()
+	if len(sigBytes) == 0 {
+		return nil, fmt.Errorf("missing signature for v2 channel " +
+			"announcement")
+	}
+
+	sig, err := lnwire.NewSigFromSchnorrRawSignature(sigBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	features := lnwire.RawFeatureVector{}
+	if c.Features != nil && c.Features.RawFeatureVector != nil {
+		features = *c.Features.RawFeatureVector
+	}
+
+	var chanAnn lnwire.ChannelAnnouncement2
+	chanAnn.ChainHash.Val = c.ChainHash
+	chanAnn.Features.Val = features
+	chanAnn.ShortChannelID.Val = lnwire.NewShortChanIDFromInt(c.ChannelID)
+	chanAnn.Capacity.Val = uint64(c.Capacity)
+	chanAnn.NodeID1.Val = [33]byte(c.NodeKey1Bytes)
+	chanAnn.NodeID2.Val = [33]byte(c.NodeKey2Bytes)
+	chanAnn.Outpoint.Val = lnwire.OutPoint(c.ChannelPoint)
+	chanAnn.Signature.Val = sig
+	chanAnn.ExtraSignedFields = c.ExtraSignedFields
+
+	c.BitcoinKey1Bytes.WhenSome(func(key route.Vertex) {
+		btcKey1 := tlv.ZeroRecordT[tlv.TlvType12, [33]byte]()
+		btcKey1.Val = [33]byte(key)
+		chanAnn.BitcoinKey1 = tlv.SomeRecordT(btcKey1)
+	})
+	c.BitcoinKey2Bytes.WhenSome(func(key route.Vertex) {
+		btcKey2 := tlv.ZeroRecordT[tlv.TlvType14, [33]byte]()
+		btcKey2.Val = [33]byte(key)
+		chanAnn.BitcoinKey2 = tlv.SomeRecordT(btcKey2)
+	})
+	c.MerkleRootHash.WhenSome(func(hash chainhash.Hash) {
+		merkleRoot := tlv.ZeroRecordT[tlv.TlvType16, [32]byte]()
+		merkleRoot.Val = [32]byte(hash)
+		chanAnn.MerkleRootHash = tlv.SomeRecordT(merkleRoot)
+	})
+
+	return &chanAnn, nil
+}

graph/db/models/channel_edge_policy.go

@@ -151,11 +151,11 @@ func ChanEdgePolicyFromWire(scid uint64,
 
 // IsNode1 returns true if this policy was announced by the channel's node_1.
 func (c *ChannelEdgePolicy) IsNode1() bool {
-	if c.Version == lnwire.GossipVersion1 {
-		return c.ChannelFlags&lnwire.ChanUpdateDirection == 0
+	if c.Version == lnwire.GossipVersion2 {
+		return !c.SecondPeer
 	}
 
-	return !c.SecondPeer
+	return c.ChannelFlags&lnwire.ChanUpdateDirection == 0
 }
 
 // IsDisabled determines whether the edge has the disabled bit set.

graph/db/notifications.go

@@ -424,7 +424,7 @@ func (c *ChannelGraph) addToTopologyChange(ctx context.Context,
 		// the second node.
 		sourceNode := edgeInfo.NodeKey1
 		connectingNode := edgeInfo.NodeKey2
-		if m.ChannelFlags&lnwire.ChanUpdateDirection == 1 {
+		if !m.IsNode1() {
 			sourceNode = edgeInfo.NodeKey2
 			connectingNode = edgeInfo.NodeKey1
 		}
@@ -449,7 +449,7 @@ func (c *ChannelGraph) addToTopologyChange(ctx context.Context,
 			FeeRate:         m.FeeProportionalMillionths,
 			AdvertisingNode: aNode,
 			ConnectingNode:  cNode,
-			Disabled:        m.ChannelFlags&lnwire.ChanUpdateDisabled != 0,
+			Disabled:        m.IsDisabled(),
 			InboundFee:      m.InboundFee,
 			ExtraOpaqueData: m.ExtraOpaqueData,
 		}