diff --git a/autopilot/graph.go b/autopilot/graph.go
index a16a7f71d..7b97b7c6f 100644
--- a/autopilot/graph.go
+++ b/autopilot/graph.go
@@ -58,7 +58,7 @@ type dbNode struct {
 
 	tx kvdb.RTx
 
-	node *graphdb.LightningNode
+	node *models.LightningNode
 }
 
 // A compile time assertion to ensure dbNode meets the autopilot.Node
@@ -134,7 +134,7 @@ func (d *dbNode) ForEachChannel(cb func(ChannelEdge) error) error {
 //
 // NOTE: Part of the autopilot.ChannelGraph interface.
 func (d *databaseChannelGraph) ForEachNode(cb func(Node) error) error {
-	return d.db.ForEachNode(func(tx kvdb.RTx, n *graphdb.LightningNode) error {
+	return d.db.ForEachNode(func(tx kvdb.RTx, n *models.LightningNode) error {
 		// We'll skip over any node that doesn't have any advertised
 		// addresses. As we won't be able to reach them to actually
 		// open any channels.
@@ -157,7 +157,7 @@ func (d *databaseChannelGraph) ForEachNode(cb func(Node) error) error {
 func (d *databaseChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
 	capacity btcutil.Amount) (*ChannelEdge, *ChannelEdge, error) {
 
-	fetchNode := func(pub *btcec.PublicKey) (*graphdb.LightningNode, error) {
+	fetchNode := func(pub *btcec.PublicKey) (*models.LightningNode, error) {
 		if pub != nil {
 			vertex, err := route.NewVertexFromBytes(
 				pub.SerializeCompressed(),
@@ -171,7 +171,7 @@ func (d *databaseChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
 			case err == graphdb.ErrGraphNodeNotFound:
 				fallthrough
 			case err == graphdb.ErrGraphNotFound:
-				graphNode := &graphdb.LightningNode{
+				graphNode := &models.LightningNode{
 					HaveNodeAnnouncement: true,
 					Addresses: []net.Addr{
 						&net.TCPAddr{
@@ -198,7 +198,7 @@ func (d *databaseChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
 		if err != nil {
 			return nil, err
 		}
-		dbNode := &graphdb.LightningNode{
+		dbNode := &models.LightningNode{
 			HaveNodeAnnouncement: true,
 			Addresses: []net.Addr{
 				&net.TCPAddr{
@@ -302,7 +302,7 @@ func (d *databaseChannelGraph) addRandNode() (*btcec.PublicKey, error) {
 	if err != nil {
 		return nil, err
 	}
-	dbNode := &graphdb.LightningNode{
+	dbNode := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		Addresses: []net.Addr{
 			&net.TCPAddr{
diff --git a/channeldb/db_test.go b/channeldb/db_test.go
index 1fd1f9d41..7d48af942 100644
--- a/channeldb/db_test.go
+++ b/channeldb/db_test.go
@@ -15,6 +15,7 @@ import (
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/wire"
 	graphdb "github.com/lightningnetwork/lnd/graph/db"
+	"github.com/lightningnetwork/lnd/graph/db/models"
 	"github.com/lightningnetwork/lnd/keychain"
 	"github.com/lightningnetwork/lnd/kvdb"
 	"github.com/lightningnetwork/lnd/lntypes"
@@ -724,11 +725,11 @@ func TestFetchHistoricalChannel(t *testing.T) {
 	}
 }
 
-func createLightningNode(priv *btcec.PrivateKey) *graphdb.LightningNode {
+func createLightningNode(priv *btcec.PrivateKey) *models.LightningNode {
 	updateTime := rand.Int63()
 
 	pub := priv.PubKey().SerializeCompressed()
-	n := &graphdb.LightningNode{
+	n := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		AuthSigBytes:         testSig.Serialize(),
 		LastUpdate:           time.Unix(updateTime, 0),
@@ -742,7 +743,7 @@ func createLightningNode(priv *btcec.PrivateKey) *graphdb.LightningNode {
 	return n
 }
 
-func createTestVertex(t *testing.T) *graphdb.LightningNode {
+func createTestVertex(t *testing.T) *models.LightningNode {
 	priv, err := btcec.NewPrivateKey()
 	require.NoError(t, err)
 
diff --git a/discovery/gossiper.go b/discovery/gossiper.go
index f83666b84..ec00e63c7 100644
--- a/discovery/gossiper.go
+++ b/discovery/gossiper.go
@@ -1964,7 +1964,7 @@ func (d *AuthenticatedGossiper) addNode(msg *lnwire.NodeAnnouncement,
 
 	timestamp := time.Unix(int64(msg.Timestamp), 0)
 	features := lnwire.NewFeatureVector(msg.Features, lnwire.Features)
-	node := &graphdb.LightningNode{
+	node := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           timestamp,
 		Addresses:            msg.Addresses,
diff --git a/discovery/gossiper_test.go b/discovery/gossiper_test.go
index 2894bf155..9fd916d0c 100644
--- a/discovery/gossiper_test.go
+++ b/discovery/gossiper_test.go
@@ -93,7 +93,7 @@ type mockGraphSource struct {
 	bestHeight uint32
 
 	mu             sync.Mutex
-	nodes          []graphdb.LightningNode
+	nodes          []models.LightningNode
 	infos          map[uint64]models.ChannelEdgeInfo
 	edges          map[uint64][]models.ChannelEdgePolicy
 	zombies        map[uint64][][33]byte
@@ -113,7 +113,7 @@ func newMockRouter(height uint32) *mockGraphSource {
 
 var _ graph.ChannelGraphSource = (*mockGraphSource)(nil)
 
-func (r *mockGraphSource) AddNode(node *graphdb.LightningNode,
+func (r *mockGraphSource) AddNode(node *models.LightningNode,
 	_ ...batch.SchedulerOption) error {
 
 	r.mu.Lock()
@@ -203,7 +203,7 @@ func (r *mockGraphSource) AddProof(chanID lnwire.ShortChannelID,
 	return nil
 }
 
-func (r *mockGraphSource) ForEachNode(func(node *graphdb.LightningNode) error) error {
+func (r *mockGraphSource) ForEachNode(func(node *models.LightningNode) error) error {
 	return nil
 }
 
@@ -280,7 +280,7 @@ func (r *mockGraphSource) GetChannelByID(chanID lnwire.ShortChannelID) (
 }
 
 func (r *mockGraphSource) FetchLightningNode(
-	nodePub route.Vertex) (*graphdb.LightningNode, error) {
+	nodePub route.Vertex) (*models.LightningNode, error) {
 
 	for _, node := range r.nodes {
 		if bytes.Equal(nodePub[:], node.PubKeyBytes[:]) {
diff --git a/graph/builder.go b/graph/builder.go
index 553b27988..ea2361dd3 100644
--- a/graph/builder.go
+++ b/graph/builder.go
@@ -1165,7 +1165,7 @@ func (b *Builder) processUpdate(msg interface{},
 	op ...batch.SchedulerOption) error {
 
 	switch msg := msg.(type) {
-	case *graphdb.LightningNode:
+	case *models.LightningNode:
 		// Before we add the node to the database, we'll check to see
 		// if the announcement is "fresh" or not. If it isn't, then
 		// we'll return an error.
@@ -1517,7 +1517,7 @@ func (b *Builder) ApplyChannelUpdate(msg *lnwire.ChannelUpdate1) bool {
 // be ignored.
 //
 // NOTE: This method is part of the ChannelGraphSource interface.
-func (b *Builder) AddNode(node *graphdb.LightningNode,
+func (b *Builder) AddNode(node *models.LightningNode,
 	op ...batch.SchedulerOption) error {
 
 	rMsg := &routingMsg{
@@ -1624,7 +1624,7 @@ func (b *Builder) GetChannelByID(chanID lnwire.ShortChannelID) (
 //
 // NOTE: This method is part of the ChannelGraphSource interface.
 func (b *Builder) FetchLightningNode(
-	node route.Vertex) (*graphdb.LightningNode, error) {
+	node route.Vertex) (*models.LightningNode, error) {
 
 	return b.cfg.Graph.FetchLightningNode(node)
 }
@@ -1633,10 +1633,10 @@ func (b *Builder) FetchLightningNode(
 //
 // NOTE: This method is part of the ChannelGraphSource interface.
 func (b *Builder) ForEachNode(
-	cb func(*graphdb.LightningNode) error) error {
+	cb func(*models.LightningNode) error) error {
 
 	return b.cfg.Graph.ForEachNode(
-		func(_ kvdb.RTx, n *graphdb.LightningNode) error {
+		func(_ kvdb.RTx, n *models.LightningNode) error {
 			return cb(n)
 		})
 }
diff --git a/graph/builder_test.go b/graph/builder_test.go
index ee963280e..24aff2624 100644
--- a/graph/builder_test.go
+++ b/graph/builder_test.go
@@ -93,7 +93,7 @@ func TestIgnoreNodeAnnouncement(t *testing.T) {
 	ctx := createTestCtxFromFile(t, startingBlockHeight, basicGraphFilePath)
 
 	pub := priv1.PubKey()
-	node := &graphdb.LightningNode{
+	node := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           time.Unix(123, 0),
 		Addresses:            testAddrs,
@@ -1038,7 +1038,7 @@ func TestIsStaleNode(t *testing.T) {
 
 	// With the node stub in the database, we'll add the fully node
 	// announcement to the database.
-	n1 := &graphdb.LightningNode{
+	n1 := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           updateTimeStamp,
 		Addresses:            testAddrs,
@@ -1453,7 +1453,7 @@ func parseTestGraph(t *testing.T, useCache bool, path string) (
 	privKeyMap := make(map[string]*btcec.PrivateKey)
 	channelIDs := make(map[route.Vertex]map[route.Vertex]uint64)
 	links := make(map[lnwire.ShortChannelID]htlcswitch.ChannelLink)
-	var source *graphdb.LightningNode
+	var source *models.LightningNode
 
 	// First we insert all the nodes within the graph as vertexes.
 	for _, node := range g.Nodes {
@@ -1462,7 +1462,7 @@ func parseTestGraph(t *testing.T, useCache bool, path string) (
 			return nil, err
 		}
 
-		dbNode := &graphdb.LightningNode{
+		dbNode := &models.LightningNode{
 			HaveNodeAnnouncement: true,
 			AuthSigBytes:         testSig.Serialize(),
 			LastUpdate:           testTime,
@@ -1832,7 +1832,7 @@ func createTestGraphFromChannels(t *testing.T, useCache bool,
 
 	nodeIndex := byte(0)
 	addNodeWithAlias := func(alias string, features *lnwire.FeatureVector) (
-		*graphdb.LightningNode, error) {
+		*models.LightningNode, error) {
 
 		keyBytes := []byte{
 			0, 0, 0, 0, 0, 0, 0, 0,
@@ -1847,7 +1847,7 @@ func createTestGraphFromChannels(t *testing.T, useCache bool,
 			features = lnwire.EmptyFeatureVector()
 		}
 
-		dbNode := &graphdb.LightningNode{
+		dbNode := &models.LightningNode{
 			HaveNodeAnnouncement: true,
 			AuthSigBytes:         testSig.Serialize(),
 			LastUpdate:           testTime,
diff --git a/graph/db/graph.go b/graph/db/graph.go
index ca0f58fe5..a9f2f8b5a 100644
--- a/graph/db/graph.go
+++ b/graph/db/graph.go
@@ -6,7 +6,6 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"image/color"
 	"io"
 	"math"
 	"net"
@@ -16,7 +15,6 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2"
-	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
@@ -602,7 +600,7 @@ func (c *ChannelGraph) ForEachNodeCached(cb func(node route.Vertex,
 	// We'll iterate over each node, then the set of channels for each
 	// node, and construct a similar callback functiopn signature as the
 	// main funcotin expects.
-	return c.ForEachNode(func(tx kvdb.RTx, node *LightningNode) error {
+	return c.ForEachNode(func(tx kvdb.RTx, node *models.LightningNode) error {
 		channels := make(map[uint64]*DirectedChannel)
 
 		err := c.ForEachNodeChannelTx(tx, node.PubKeyBytes,
@@ -710,7 +708,7 @@ func (c *ChannelGraph) DisabledChannelIDs() ([]uint64, error) {
 // TODO(roasbeef): add iterator interface to allow for memory efficient graph
 // traversal when graph gets mega
 func (c *ChannelGraph) ForEachNode(
-	cb func(kvdb.RTx, *LightningNode) error) error {
+	cb func(kvdb.RTx, *models.LightningNode) error) error {
 
 	traversal := func(tx kvdb.RTx) error {
 		// First grab the nodes bucket which stores the mapping from
@@ -787,8 +785,8 @@ func (c *ChannelGraph) ForEachNodeCacheable(cb func(kvdb.RTx,
 // as the center node within a star-graph. This method may be used to kick off
 // a path finding algorithm in order to explore the reachability of another
 // node based off the source node.
-func (c *ChannelGraph) SourceNode() (*LightningNode, error) {
-	var source *LightningNode
+func (c *ChannelGraph) SourceNode() (*models.LightningNode, error) {
+	var source *models.LightningNode
 	err := kvdb.View(c.db, func(tx kvdb.RTx) error {
 		// First grab the nodes bucket which stores the mapping from
 		// pubKey to node information.
@@ -818,7 +816,7 @@ func (c *ChannelGraph) SourceNode() (*LightningNode, error) {
 // of the graph. The source node is treated as the center node within a
 // star-graph. This method may be used to kick off a path finding algorithm in
 // order to explore the reachability of another node based off the source node.
-func (c *ChannelGraph) sourceNode(nodes kvdb.RBucket) (*LightningNode, error) {
+func (c *ChannelGraph) sourceNode(nodes kvdb.RBucket) (*models.LightningNode, error) {
 	selfPub := nodes.Get(sourceKey)
 	if selfPub == nil {
 		return nil, ErrSourceNodeNotSet
@@ -837,7 +835,7 @@ func (c *ChannelGraph) sourceNode(nodes kvdb.RBucket) (*LightningNode, error) {
 // SetSourceNode sets the source node within the graph database. The source
 // node is to be used as the center of a star-graph within path finding
 // algorithms.
-func (c *ChannelGraph) SetSourceNode(node *LightningNode) error {
+func (c *ChannelGraph) SetSourceNode(node *models.LightningNode) error {
 	nodePubBytes := node.PubKeyBytes[:]
 
 	return kvdb.Update(c.db, func(tx kvdb.RwTx) error {
@@ -868,7 +866,7 @@ func (c *ChannelGraph) SetSourceNode(node *LightningNode) error {
 // channel update.
 //
 // TODO(roasbeef): also need sig of announcement
-func (c *ChannelGraph) AddLightningNode(node *LightningNode,
+func (c *ChannelGraph) AddLightningNode(node *models.LightningNode,
 	op ...batch.SchedulerOption) error {
 
 	r := &batch.Request{
@@ -894,7 +892,7 @@ func (c *ChannelGraph) AddLightningNode(node *LightningNode,
 	return c.nodeScheduler.Execute(r)
 }
 
-func addLightningNode(tx kvdb.RwTx, node *LightningNode) error {
+func addLightningNode(tx kvdb.RwTx, node *models.LightningNode) error {
 	nodes, err := tx.CreateTopLevelBucket(nodeBucket)
 	if err != nil {
 		return err
@@ -1107,7 +1105,7 @@ func (c *ChannelGraph) addChannelEdge(tx kvdb.RwTx,
 	_, node1Err := fetchLightningNode(nodes, edge.NodeKey1Bytes[:])
 	switch {
 	case node1Err == ErrGraphNodeNotFound:
-		node1Shell := LightningNode{
+		node1Shell := models.LightningNode{
 			PubKeyBytes:          edge.NodeKey1Bytes,
 			HaveNodeAnnouncement: false,
 		}
@@ -1123,7 +1121,7 @@ func (c *ChannelGraph) addChannelEdge(tx kvdb.RwTx,
 	_, node2Err := fetchLightningNode(nodes, edge.NodeKey2Bytes[:])
 	switch {
 	case node2Err == ErrGraphNodeNotFound:
-		node2Shell := LightningNode{
+		node2Shell := models.LightningNode{
 			PubKeyBytes:          edge.NodeKey2Bytes,
 			HaveNodeAnnouncement: false,
 		}
@@ -1922,11 +1920,11 @@ type ChannelEdge struct {
 
 	// Node1 is "node 1" in the channel. This is the node that would have
 	// produced Policy1 if it exists.
-	Node1 *LightningNode
+	Node1 *models.LightningNode
 
 	// Node2 is "node 2" in the channel. This is the node that would have
 	// produced Policy2 if it exists.
-	Node2 *LightningNode
+	Node2 *models.LightningNode
 }
 
 // ChanUpdatesInHorizon returns all the known channel edges which have at least
@@ -2082,9 +2080,9 @@ func (c *ChannelGraph) ChanUpdatesInHorizon(startTime,
 // nodes to quickly determine if they have the same set of up to date node
 // announcements.
 func (c *ChannelGraph) NodeUpdatesInHorizon(startTime,
-	endTime time.Time) ([]LightningNode, error) {
+	endTime time.Time) ([]models.LightningNode, error) {
 
-	var nodesInHorizon []LightningNode
+	var nodesInHorizon []models.LightningNode
 
 	err := kvdb.View(c.db, func(tx kvdb.RTx) error {
 		nodes := tx.ReadBucket(nodeBucket)
@@ -2880,127 +2878,6 @@ func updateEdgePolicy(tx kvdb.RwTx, edge *models.ChannelEdgePolicy,
 	return isUpdate1, nil
 }
 
-// LightningNode represents an individual vertex/node within the channel graph.
-// A node is connected to other nodes by one or more channel edges emanating
-// from it. As the graph is directed, a node will also have an incoming edge
-// attached to it for each outgoing edge.
-type LightningNode struct {
-	// PubKeyBytes is the raw bytes of the public key of the target node.
-	PubKeyBytes [33]byte
-	pubKey      *btcec.PublicKey
-
-	// HaveNodeAnnouncement indicates whether we received a node
-	// announcement for this particular node. If true, the remaining fields
-	// will be set, if false only the PubKey is known for this node.
-	HaveNodeAnnouncement bool
-
-	// LastUpdate is the last time the vertex information for this node has
-	// been updated.
-	LastUpdate time.Time
-
-	// Address is the TCP address this node is reachable over.
-	Addresses []net.Addr
-
-	// Color is the selected color for the node.
-	Color color.RGBA
-
-	// Alias is a nick-name for the node. The alias can be used to confirm
-	// a node's identity or to serve as a short ID for an address book.
-	Alias string
-
-	// AuthSigBytes is the raw signature under the advertised public key
-	// which serves to authenticate the attributes announced by this node.
-	AuthSigBytes []byte
-
-	// Features is the list of protocol features supported by this node.
-	Features *lnwire.FeatureVector
-
-	// ExtraOpaqueData is the set of data that was appended to this
-	// message, some of which we may not actually know how to iterate or
-	// parse. By holding onto this data, we ensure that we're able to
-	// properly validate the set of signatures that cover these new fields,
-	// and ensure we're able to make upgrades to the network in a forwards
-	// compatible manner.
-	ExtraOpaqueData []byte
-
-	// TODO(roasbeef): discovery will need storage to keep it's last IP
-	// address and re-announce if interface changes?
-
-	// TODO(roasbeef): add update method and fetch?
-}
-
-// PubKey is the node's long-term identity public key. This key will be used to
-// authenticated any advertisements/updates sent by the node.
-//
-// NOTE: By having this method to access an attribute, we ensure we only need
-// to fully deserialize the pubkey if absolutely necessary.
-func (l *LightningNode) PubKey() (*btcec.PublicKey, error) {
-	if l.pubKey != nil {
-		return l.pubKey, nil
-	}
-
-	key, err := btcec.ParsePubKey(l.PubKeyBytes[:])
-	if err != nil {
-		return nil, err
-	}
-	l.pubKey = key
-
-	return key, nil
-}
-
-// AuthSig is a signature under the advertised public key which serves to
-// authenticate the attributes announced by this node.
-//
-// NOTE: By having this method to access an attribute, we ensure we only need
-// to fully deserialize the signature if absolutely necessary.
-func (l *LightningNode) AuthSig() (*ecdsa.Signature, error) {
-	return ecdsa.ParseSignature(l.AuthSigBytes)
-}
-
-// AddPubKey is a setter-link method that can be used to swap out the public
-// key for a node.
-func (l *LightningNode) AddPubKey(key *btcec.PublicKey) {
-	l.pubKey = key
-	copy(l.PubKeyBytes[:], key.SerializeCompressed())
-}
-
-// NodeAnnouncement retrieves the latest node announcement of the node.
-func (l *LightningNode) NodeAnnouncement(signed bool) (*lnwire.NodeAnnouncement,
-	error) {
-
-	if !l.HaveNodeAnnouncement {
-		return nil, fmt.Errorf("node does not have node announcement")
-	}
-
-	alias, err := lnwire.NewNodeAlias(l.Alias)
-	if err != nil {
-		return nil, err
-	}
-
-	nodeAnn := &lnwire.NodeAnnouncement{
-		Features:        l.Features.RawFeatureVector,
-		NodeID:          l.PubKeyBytes,
-		RGBColor:        l.Color,
-		Alias:           alias,
-		Addresses:       l.Addresses,
-		Timestamp:       uint32(l.LastUpdate.Unix()),
-		ExtraOpaqueData: l.ExtraOpaqueData,
-	}
-
-	if !signed {
-		return nodeAnn, nil
-	}
-
-	sig, err := lnwire.NewSigFromECDSARawSignature(l.AuthSigBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	nodeAnn.Signature = sig
-
-	return nodeAnn, nil
-}
-
 // isPublic determines whether the node is seen as public within the graph from
 // the source node's point of view. An existing database transaction can also be
 // specified.
@@ -3050,7 +2927,7 @@ func (c *ChannelGraph) isPublic(tx kvdb.RTx, nodePub route.Vertex,
 // ErrGraphNodeNotFound is returned. An optional transaction may be provided.
 // If none is provided, then a new one will be created.
 func (c *ChannelGraph) FetchLightningNodeTx(tx kvdb.RTx, nodePub route.Vertex) (
-	*LightningNode, error) {
+	*models.LightningNode, error) {
 
 	return c.fetchLightningNode(tx, nodePub)
 }
@@ -3058,7 +2935,7 @@ func (c *ChannelGraph) FetchLightningNodeTx(tx kvdb.RTx, nodePub route.Vertex) (
 // FetchLightningNode attempts to look up a target node by its identity public
 // key. If the node isn't found in the database, then ErrGraphNodeNotFound is
 // returned.
-func (c *ChannelGraph) FetchLightningNode(nodePub route.Vertex) (*LightningNode,
+func (c *ChannelGraph) FetchLightningNode(nodePub route.Vertex) (*models.LightningNode,
 	error) {
 
 	return c.fetchLightningNode(nil, nodePub)
@@ -3069,9 +2946,9 @@ func (c *ChannelGraph) FetchLightningNode(nodePub route.Vertex) (*LightningNode,
 // returned. An optional transaction may be provided. If none is provided, then
 // a new one will be created.
 func (c *ChannelGraph) fetchLightningNode(tx kvdb.RTx,
-	nodePub route.Vertex) (*LightningNode, error) {
+	nodePub route.Vertex) (*models.LightningNode, error) {
 
-	var node *LightningNode
+	var node *models.LightningNode
 	fetch := func(tx kvdb.RTx) error {
 		// First grab the nodes bucket which stores the mapping from
 		// pubKey to node information.
@@ -3339,7 +3216,7 @@ func (c *ChannelGraph) ForEachNodeChannelTx(tx kvdb.RTx,
 // one of the nodes, and wishes to obtain the full LightningNode for the other
 // end of the channel.
 func (c *ChannelGraph) FetchOtherNode(tx kvdb.RTx,
-	channel *models.ChannelEdgeInfo, thisNodeKey []byte) (*LightningNode,
+	channel *models.ChannelEdgeInfo, thisNodeKey []byte) (*models.LightningNode,
 	error) {
 
 	// Ensure that the node passed in is actually a member of the channel.
@@ -3353,7 +3230,7 @@ func (c *ChannelGraph) FetchOtherNode(tx kvdb.RTx,
 		return nil, fmt.Errorf("node not participating in this channel")
 	}
 
-	var targetNode *LightningNode
+	var targetNode *models.LightningNode
 	fetchNodeFunc := func(tx kvdb.RTx) error {
 		// First grab the nodes bucket which stores the mapping from
 		// pubKey to node information.
@@ -3976,7 +3853,7 @@ func (c *ChannelGraph) IsClosedScid(scid lnwire.ShortChannelID) (bool, error) {
 }
 
 func putLightningNode(nodeBucket kvdb.RwBucket, aliasBucket kvdb.RwBucket, // nolint:dupl
-	updateIndex kvdb.RwBucket, node *LightningNode) error {
+	updateIndex kvdb.RwBucket, node *models.LightningNode) error {
 
 	var (
 		scratch [16]byte
@@ -4105,11 +3982,11 @@ func putLightningNode(nodeBucket kvdb.RwBucket, aliasBucket kvdb.RwBucket, // no
 }
 
 func fetchLightningNode(nodeBucket kvdb.RBucket,
-	nodePub []byte) (LightningNode, error) {
+	nodePub []byte) (models.LightningNode, error) {
 
 	nodeBytes := nodeBucket.Get(nodePub)
 	if nodeBytes == nil {
-		return LightningNode{}, ErrGraphNodeNotFound
+		return models.LightningNode{}, ErrGraphNodeNotFound
 	}
 
 	nodeReader := bytes.NewReader(nodeBytes)
@@ -4172,9 +4049,9 @@ func deserializeLightningNodeCacheable(r io.Reader) (*graphCacheNode, error) {
 	return node, nil
 }
 
-func deserializeLightningNode(r io.Reader) (LightningNode, error) {
+func deserializeLightningNode(r io.Reader) (models.LightningNode, error) {
 	var (
-		node    LightningNode
+		node    models.LightningNode
 		scratch [8]byte
 		err     error
 	)
@@ -4184,18 +4061,18 @@ func deserializeLightningNode(r io.Reader) (LightningNode, error) {
 	node.Features = lnwire.EmptyFeatureVector()
 
 	if _, err := r.Read(scratch[:]); err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 
 	unix := int64(byteOrder.Uint64(scratch[:]))
 	node.LastUpdate = time.Unix(unix, 0)
 
 	if _, err := io.ReadFull(r, node.PubKeyBytes[:]); err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 
 	if _, err := r.Read(scratch[:2]); err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 
 	hasNodeAnn := byteOrder.Uint16(scratch[:2])
@@ -4214,27 +4091,27 @@ func deserializeLightningNode(r io.Reader) (LightningNode, error) {
 	// We did get a node announcement for this node, so we'll have the rest
 	// of the data available.
 	if err := binary.Read(r, byteOrder, &node.Color.R); err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 	if err := binary.Read(r, byteOrder, &node.Color.G); err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 	if err := binary.Read(r, byteOrder, &node.Color.B); err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 
 	node.Alias, err = wire.ReadVarString(r, 0)
 	if err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 
 	err = node.Features.Decode(r)
 	if err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 
 	if _, err := r.Read(scratch[:2]); err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 	numAddresses := int(byteOrder.Uint16(scratch[:2]))
 
@@ -4242,7 +4119,7 @@ func deserializeLightningNode(r io.Reader) (LightningNode, error) {
 	for i := 0; i < numAddresses; i++ {
 		address, err := DeserializeAddr(r)
 		if err != nil {
-			return LightningNode{}, err
+			return models.LightningNode{}, err
 		}
 		addresses = append(addresses, address)
 	}
@@ -4250,7 +4127,7 @@ func deserializeLightningNode(r io.Reader) (LightningNode, error) {
 
 	node.AuthSigBytes, err = wire.ReadVarBytes(r, 0, 80, "sig")
 	if err != nil {
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 
 	// We'll try and see if there are any opaque bytes left, if not, then
@@ -4262,7 +4139,7 @@ func deserializeLightningNode(r io.Reader) (LightningNode, error) {
 	case err == io.ErrUnexpectedEOF:
 	case err == io.EOF:
 	case err != nil:
-		return LightningNode{}, err
+		return models.LightningNode{}, err
 	}
 
 	return node, nil
diff --git a/graph/db/graph_test.go b/graph/db/graph_test.go
index 60b3621a3..2f88dc22a 100644
--- a/graph/db/graph_test.go
+++ b/graph/db/graph_test.go
@@ -65,11 +65,11 @@ var (
 	}
 )
 
-func createLightningNode(db kvdb.Backend, priv *btcec.PrivateKey) (*LightningNode, error) {
+func createLightningNode(db kvdb.Backend, priv *btcec.PrivateKey) (*models.LightningNode, error) {
 	updateTime := prand.Int63()
 
 	pub := priv.PubKey().SerializeCompressed()
-	n := &LightningNode{
+	n := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		AuthSigBytes:         testSig.Serialize(),
 		LastUpdate:           time.Unix(updateTime, 0),
@@ -83,7 +83,7 @@ func createLightningNode(db kvdb.Backend, priv *btcec.PrivateKey) (*LightningNod
 	return n, nil
 }
 
-func createTestVertex(db kvdb.Backend) (*LightningNode, error) {
+func createTestVertex(db kvdb.Backend) (*models.LightningNode, error) {
 	priv, err := btcec.NewPrivateKey()
 	if err != nil {
 		return nil, err
@@ -100,7 +100,7 @@ func TestNodeInsertionAndDeletion(t *testing.T) {
 
 	// We'd like to test basic insertion/deletion for vertexes from the
 	// graph, so we'll create a test vertex to start with.
-	node := &LightningNode{
+	node := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		AuthSigBytes:         testSig.Serialize(),
 		LastUpdate:           time.Unix(1232342, 0),
@@ -160,7 +160,7 @@ func TestPartialNode(t *testing.T) {
 
 	// We want to be able to insert nodes into the graph that only has the
 	// PubKey set.
-	node := &LightningNode{
+	node := &models.LightningNode{
 		HaveNodeAnnouncement: false,
 		PubKeyBytes:          testPub,
 	}
@@ -183,7 +183,7 @@ func TestPartialNode(t *testing.T) {
 
 	// The two nodes should match exactly! (with default values for
 	// LastUpdate and db set to satisfy compareNodes())
-	node = &LightningNode{
+	node = &models.LightningNode{
 		HaveNodeAnnouncement: false,
 		LastUpdate:           time.Unix(0, 0),
 		PubKeyBytes:          testPub,
@@ -366,7 +366,7 @@ func TestEdgeInsertionDeletion(t *testing.T) {
 }
 
 func createEdge(height, txIndex uint32, txPosition uint16, outPointIndex uint32,
-	node1, node2 *LightningNode) (models.ChannelEdgeInfo,
+	node1, node2 *models.LightningNode) (models.ChannelEdgeInfo,
 	lnwire.ShortChannelID) {
 
 	shortChanID := lnwire.ShortChannelID{
@@ -598,7 +598,7 @@ func assertEdgeInfoEqual(t *testing.T, e1 *models.ChannelEdgeInfo,
 	}
 }
 
-func createChannelEdge(db kvdb.Backend, node1, node2 *LightningNode) (
+func createChannelEdge(db kvdb.Backend, node1, node2 *models.LightningNode) (
 	*models.ChannelEdgeInfo, *models.ChannelEdgePolicy,
 	*models.ChannelEdgePolicy) {
 
@@ -770,7 +770,7 @@ func TestEdgeInfoUpdates(t *testing.T) {
 	assertEdgeInfoEqual(t, dbEdgeInfo, edgeInfo)
 }
 
-func assertNodeInCache(t *testing.T, g *ChannelGraph, n *LightningNode,
+func assertNodeInCache(t *testing.T, g *ChannelGraph, n *models.LightningNode,
 	expectedFeatures *lnwire.FeatureVector) {
 
 	// Let's check the internal view first.
@@ -1089,7 +1089,7 @@ func TestGraphTraversalCacheable(t *testing.T) {
 	// Create a map of all nodes with the iteration we know works (because
 	// it is tested in another test).
 	nodeMap := make(map[route.Vertex]struct{})
-	err = graph.ForEachNode(func(tx kvdb.RTx, n *LightningNode) error {
+	err = graph.ForEachNode(func(tx kvdb.RTx, n *models.LightningNode) error {
 		nodeMap[n.PubKeyBytes] = struct{}{}
 
 		return nil
@@ -1192,9 +1192,9 @@ func TestGraphCacheTraversal(t *testing.T) {
 }
 
 func fillTestGraph(t require.TestingT, graph *ChannelGraph, numNodes,
-	numChannels int) (map[uint64]struct{}, []*LightningNode) {
+	numChannels int) (map[uint64]struct{}, []*models.LightningNode) {
 
-	nodes := make([]*LightningNode, numNodes)
+	nodes := make([]*models.LightningNode, numNodes)
 	nodeIndex := map[string]struct{}{}
 	for i := 0; i < numNodes; i++ {
 		node, err := createTestVertex(graph.db)
@@ -1212,7 +1212,7 @@ func fillTestGraph(t require.TestingT, graph *ChannelGraph, numNodes,
 
 	// Iterate over each node as returned by the graph, if all nodes are
 	// reached, then the map created above should be empty.
-	err := graph.ForEachNode(func(_ kvdb.RTx, node *LightningNode) error {
+	err := graph.ForEachNode(func(_ kvdb.RTx, node *models.LightningNode) error {
 		delete(nodeIndex, node.Alias)
 		return nil
 	})
@@ -1320,7 +1320,7 @@ func assertNumChans(t *testing.T, graph *ChannelGraph, n int) {
 
 func assertNumNodes(t *testing.T, graph *ChannelGraph, n int) {
 	numNodes := 0
-	err := graph.ForEachNode(func(_ kvdb.RTx, _ *LightningNode) error {
+	err := graph.ForEachNode(func(_ kvdb.RTx, _ *models.LightningNode) error {
 		numNodes++
 		return nil
 	})
@@ -1391,7 +1391,7 @@ func TestGraphPruning(t *testing.T) {
 	// and enough edges to create a fully connected graph. The graph will
 	// be rather simple, representing a straight line.
 	const numNodes = 5
-	graphNodes := make([]*LightningNode, numNodes)
+	graphNodes := make([]*models.LightningNode, numNodes)
 	for i := 0; i < numNodes; i++ {
 		node, err := createTestVertex(graph.db)
 		if err != nil {
@@ -1809,7 +1809,7 @@ func TestNodeUpdatesInHorizon(t *testing.T) {
 	// We'll create 10 node announcements, each with an update timestamp 10
 	// seconds after the other.
 	const numNodes = 10
-	nodeAnns := make([]LightningNode, 0, numNodes)
+	nodeAnns := make([]models.LightningNode, 0, numNodes)
 	for i := 0; i < numNodes; i++ {
 		nodeAnn, err := createTestVertex(graph.db)
 		if err != nil {
@@ -1835,7 +1835,7 @@ func TestNodeUpdatesInHorizon(t *testing.T) {
 		start time.Time
 		end   time.Time
 
-		resp []LightningNode
+		resp []models.LightningNode
 	}{
 		// If we query for a time range that's strictly below our set
 		// of updates, then we'll get an empty result back.
@@ -2408,7 +2408,7 @@ func TestFilterChannelRange(t *testing.T) {
 	)
 
 	updateTimeSeed := time.Now().Unix()
-	maybeAddPolicy := func(chanID uint64, node *LightningNode,
+	maybeAddPolicy := func(chanID uint64, node *models.LightningNode,
 		node2 bool) time.Time {
 
 		var chanFlags lnwire.ChanUpdateChanFlags
@@ -2725,7 +2725,7 @@ func TestIncompleteChannelPolicies(t *testing.T) {
 	}
 
 	// Ensure that channel is reported with unknown policies.
-	checkPolicies := func(node *LightningNode, expectedIn, expectedOut bool) {
+	checkPolicies := func(node *models.LightningNode, expectedIn, expectedOut bool) {
 		calls := 0
 		err := graph.ForEachNodeChannel(node.PubKeyBytes,
 			func(_ kvdb.RTx, _ *models.ChannelEdgeInfo, outEdge,
@@ -3145,7 +3145,7 @@ func TestNodeIsPublic(t *testing.T) {
 
 	// After creating all of our nodes and edges, we'll add them to each
 	// participant's graph.
-	nodes := []*LightningNode{aliceNode, bobNode, carolNode}
+	nodes := []*models.LightningNode{aliceNode, bobNode, carolNode}
 	edges := []*models.ChannelEdgeInfo{&aliceBobEdge, &bobCarolEdge}
 	graphs := []*ChannelGraph{aliceGraph, bobGraph, carolGraph}
 	for _, graph := range graphs {
@@ -3163,7 +3163,7 @@ func TestNodeIsPublic(t *testing.T) {
 
 	// checkNodes is a helper closure that will be used to assert that the
 	// given nodes are seen as public/private within the given graphs.
-	checkNodes := func(nodes []*LightningNode, graphs []*ChannelGraph,
+	checkNodes := func(nodes []*models.LightningNode, graphs []*ChannelGraph,
 		public bool) {
 
 		t.Helper()
@@ -3204,7 +3204,7 @@ func TestNodeIsPublic(t *testing.T) {
 		}
 	}
 	checkNodes(
-		[]*LightningNode{aliceNode},
+		[]*models.LightningNode{aliceNode},
 		[]*ChannelGraph{bobGraph, carolGraph},
 		false,
 	)
@@ -3235,7 +3235,7 @@ func TestNodeIsPublic(t *testing.T) {
 	// With the modifications above, Bob should now be seen as a private
 	// node from both Alice's and Carol's perspective.
 	checkNodes(
-		[]*LightningNode{bobNode},
+		[]*models.LightningNode{bobNode},
 		[]*ChannelGraph{aliceGraph, carolGraph},
 		false,
 	)
@@ -3554,7 +3554,7 @@ func TestGraphZombieIndex(t *testing.T) {
 // compareNodes is used to compare two LightningNodes while excluding the
 // Features struct, which cannot be compared as the semantics for reserializing
 // the featuresMap have not been defined.
-func compareNodes(a, b *LightningNode) error {
+func compareNodes(a, b *models.LightningNode) error {
 	if a.LastUpdate != b.LastUpdate {
 		return fmt.Errorf("node LastUpdate doesn't match: expected %v, \n"+
 			"got %v", a.LastUpdate, b.LastUpdate)
diff --git a/graph/db/models/node.go b/graph/db/models/node.go
new file mode 100644
index 000000000..962415433
--- /dev/null
+++ b/graph/db/models/node.go
@@ -0,0 +1,133 @@
+package models
+
+import (
+	"fmt"
+	"image/color"
+	"net"
+	"time"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
+	"github.com/lightningnetwork/lnd/lnwire"
+)
+
+// LightningNode represents an individual vertex/node within the channel graph.
+// A node is connected to other nodes by one or more channel edges emanating
+// from it. As the graph is directed, a node will also have an incoming edge
+// attached to it for each outgoing edge.
+type LightningNode struct {
+	// PubKeyBytes is the raw bytes of the public key of the target node.
+	PubKeyBytes [33]byte
+	pubKey      *btcec.PublicKey
+
+	// HaveNodeAnnouncement indicates whether we received a node
+	// announcement for this particular node. If true, the remaining fields
+	// will be set, if false only the PubKey is known for this node.
+	HaveNodeAnnouncement bool
+
+	// LastUpdate is the last time the vertex information for this node has
+	// been updated.
+	LastUpdate time.Time
+
+	// Address is the TCP address this node is reachable over.
+	Addresses []net.Addr
+
+	// Color is the selected color for the node.
+	Color color.RGBA
+
+	// Alias is a nick-name for the node. The alias can be used to confirm
+	// a node's identity or to serve as a short ID for an address book.
+	Alias string
+
+	// AuthSigBytes is the raw signature under the advertised public key
+	// which serves to authenticate the attributes announced by this node.
+	AuthSigBytes []byte
+
+	// Features is the list of protocol features supported by this node.
+	Features *lnwire.FeatureVector
+
+	// ExtraOpaqueData is the set of data that was appended to this
+	// message, some of which we may not actually know how to iterate or
+	// parse. By holding onto this data, we ensure that we're able to
+	// properly validate the set of signatures that cover these new fields,
+	// and ensure we're able to make upgrades to the network in a forwards
+	// compatible manner.
+	ExtraOpaqueData []byte
+
+	// TODO(roasbeef): discovery will need storage to keep it's last IP
+	// address and re-announce if interface changes?
+
+	// TODO(roasbeef): add update method and fetch?
+}
+
+// PubKey is the node's long-term identity public key. This key will be used to
+// authenticated any advertisements/updates sent by the node.
+//
+// NOTE: By having this method to access an attribute, we ensure we only need
+// to fully deserialize the pubkey if absolutely necessary.
+func (l *LightningNode) PubKey() (*btcec.PublicKey, error) {
+	if l.pubKey != nil {
+		return l.pubKey, nil
+	}
+
+	key, err := btcec.ParsePubKey(l.PubKeyBytes[:])
+	if err != nil {
+		return nil, err
+	}
+	l.pubKey = key
+
+	return key, nil
+}
+
+// AuthSig is a signature under the advertised public key which serves to
+// authenticate the attributes announced by this node.
+//
+// NOTE: By having this method to access an attribute, we ensure we only need
+// to fully deserialize the signature if absolutely necessary.
+func (l *LightningNode) AuthSig() (*ecdsa.Signature, error) {
+	return ecdsa.ParseSignature(l.AuthSigBytes)
+}
+
+// AddPubKey is a setter-link method that can be used to swap out the public
+// key for a node.
+func (l *LightningNode) AddPubKey(key *btcec.PublicKey) {
+	l.pubKey = key
+	copy(l.PubKeyBytes[:], key.SerializeCompressed())
+}
+
+// NodeAnnouncement retrieves the latest node announcement of the node.
+func (l *LightningNode) NodeAnnouncement(signed bool) (*lnwire.NodeAnnouncement,
+	error) {
+
+	if !l.HaveNodeAnnouncement {
+		return nil, fmt.Errorf("node does not have node announcement")
+	}
+
+	alias, err := lnwire.NewNodeAlias(l.Alias)
+	if err != nil {
+		return nil, err
+	}
+
+	nodeAnn := &lnwire.NodeAnnouncement{
+		Features:        l.Features.RawFeatureVector,
+		NodeID:          l.PubKeyBytes,
+		RGBColor:        l.Color,
+		Alias:           alias,
+		Addresses:       l.Addresses,
+		Timestamp:       uint32(l.LastUpdate.Unix()),
+		ExtraOpaqueData: l.ExtraOpaqueData,
+	}
+
+	if !signed {
+		return nodeAnn, nil
+	}
+
+	sig, err := lnwire.NewSigFromECDSARawSignature(l.AuthSigBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	nodeAnn.Signature = sig
+
+	return nodeAnn, nil
+}
diff --git a/graph/interfaces.go b/graph/interfaces.go
index cfcd1099d..0dd24e52b 100644
--- a/graph/interfaces.go
+++ b/graph/interfaces.go
@@ -23,7 +23,7 @@ type ChannelGraphSource interface {
 	// AddNode is used to add information about a node to the router
 	// database. If the node with this pubkey is not present in an existing
 	// channel, it will be ignored.
-	AddNode(node *graphdb.LightningNode,
+	AddNode(node *models.LightningNode,
 		op ...batch.SchedulerOption) error
 
 	// AddEdge is used to add edge/channel to the topology of the router,
@@ -85,10 +85,10 @@ type ChannelGraphSource interface {
 	// FetchLightningNode attempts to look up a target node by its identity
 	// public key. channeldb.ErrGraphNodeNotFound is returned if the node
 	// doesn't exist within the graph.
-	FetchLightningNode(route.Vertex) (*graphdb.LightningNode, error)
+	FetchLightningNode(route.Vertex) (*models.LightningNode, error)
 
 	// ForEachNode is used to iterate over every node in the known graph.
-	ForEachNode(func(node *graphdb.LightningNode) error) error
+	ForEachNode(func(node *models.LightningNode) error) error
 }
 
 // DB is an interface describing a persisted Lightning Network graph.
@@ -129,7 +129,7 @@ type DB interface {
 	// treated as the center node within a star-graph. This method may be
 	// used to kick off a path finding algorithm in order to explore the
 	// reachability of another node based off the source node.
-	SourceNode() (*graphdb.LightningNode, error)
+	SourceNode() (*models.LightningNode, error)
 
 	// DisabledChannelIDs returns the channel ids of disabled channels.
 	// A channel is disabled when two of the associated ChanelEdgePolicies
@@ -200,7 +200,7 @@ type DB interface {
 	// update that node's information. Note that this method is expected to
 	// only be called to update an already present node from a node
 	// announcement, or to insert a node found in a channel update.
-	AddLightningNode(node *graphdb.LightningNode,
+	AddLightningNode(node *models.LightningNode,
 		op ...batch.SchedulerOption) error
 
 	// AddChannelEdge adds a new (undirected, blank) edge to the graph
@@ -239,14 +239,14 @@ type DB interface {
 	// FetchLightningNode attempts to look up a target node by its identity
 	// public key. If the node isn't found in the database, then
 	// ErrGraphNodeNotFound is returned.
-	FetchLightningNode(nodePub route.Vertex) (*graphdb.LightningNode,
+	FetchLightningNode(nodePub route.Vertex) (*models.LightningNode,
 		error)
 
 	// ForEachNode iterates through all the stored vertices/nodes in the
 	// graph, executing the passed callback with each node encountered. If
 	// the callback returns an error, then the transaction is aborted and
 	// the iteration stops early.
-	ForEachNode(cb func(kvdb.RTx, *graphdb.LightningNode) error) error
+	ForEachNode(cb func(kvdb.RTx, *models.LightningNode) error) error
 
 	// ForEachNodeChannel iterates through all channels of the given node,
 	// executing the passed callback with an edge info structure and the
diff --git a/graph/notifications.go b/graph/notifications.go
index d31bfe222..76eabdb02 100644
--- a/graph/notifications.go
+++ b/graph/notifications.go
@@ -10,7 +10,6 @@ import (
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/wire"
 	"github.com/go-errors/errors"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
 	"github.com/lightningnetwork/lnd/graph/db/models"
 	"github.com/lightningnetwork/lnd/lnwire"
 )
@@ -318,7 +317,7 @@ func addToTopologyChange(graph DB, update *TopologyChange,
 
 	// Any node announcement maps directly to a NetworkNodeUpdate struct.
 	// No further data munging or db queries are required.
-	case *graphdb.LightningNode:
+	case *models.LightningNode:
 		pubKey, err := m.PubKey()
 		if err != nil {
 			return err
diff --git a/graph/notifications_test.go b/graph/notifications_test.go
index d614c3dc8..cbcc7e8c9 100644
--- a/graph/notifications_test.go
+++ b/graph/notifications_test.go
@@ -77,14 +77,14 @@ var (
 	}
 )
 
-func createTestNode(t *testing.T) *graphdb.LightningNode {
+func createTestNode(t *testing.T) *models.LightningNode {
 	updateTime := prand.Int63()
 
 	priv, err := btcec.NewPrivateKey()
 	require.NoError(t, err)
 
 	pub := priv.PubKey().SerializeCompressed()
-	n := &graphdb.LightningNode{
+	n := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           time.Unix(updateTime, 0),
 		Addresses:            testAddrs,
@@ -99,7 +99,7 @@ func createTestNode(t *testing.T) *graphdb.LightningNode {
 }
 
 func randEdgePolicy(chanID *lnwire.ShortChannelID,
-	node *graphdb.LightningNode) (*models.ChannelEdgePolicy, error) {
+	node *models.LightningNode) (*models.ChannelEdgePolicy, error) {
 
 	InboundFee := models.InboundFee{
 		Base: prand.Int31() * -1,
@@ -686,7 +686,7 @@ func TestNodeUpdateNotification(t *testing.T) {
 		t.Fatalf("unable to add node: %v", err)
 	}
 
-	assertNodeNtfnCorrect := func(t *testing.T, ann *graphdb.LightningNode,
+	assertNodeNtfnCorrect := func(t *testing.T, ann *models.LightningNode,
 		nodeUpdate *NetworkNodeUpdate) {
 
 		nodeKey, _ := ann.PubKey()
diff --git a/graph/validation_barrier.go b/graph/validation_barrier.go
index 82523b8f3..a97709605 100644
--- a/graph/validation_barrier.go
+++ b/graph/validation_barrier.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"sync"
 
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
 	"github.com/lightningnetwork/lnd/graph/db/models"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
@@ -151,7 +150,7 @@ func (v *ValidationBarrier) InitJobDependencies(job interface{}) {
 	case *lnwire.NodeAnnouncement:
 		// TODO(roasbeef): node ann needs to wait on existing channel updates
 		return
-	case *graphdb.LightningNode:
+	case *models.LightningNode:
 		return
 	case *lnwire.AnnounceSignatures1:
 		// TODO(roasbeef): need to wait on chan ann?
@@ -195,7 +194,7 @@ func (v *ValidationBarrier) WaitForDependants(job interface{}) error {
 		jobDesc = fmt.Sprintf("job=lnwire.ChannelEdgePolicy, scid=%v",
 			msg.ChannelID)
 
-	case *graphdb.LightningNode:
+	case *models.LightningNode:
 		vertex := route.Vertex(msg.PubKeyBytes)
 		signals, ok = v.nodeAnnDependencies[vertex]
 
@@ -291,7 +290,7 @@ func (v *ValidationBarrier) SignalDependants(job interface{}, allow bool) {
 	// For all other job types, we'll delete the tracking entries from the
 	// map, as if we reach this point, then all dependants have already
 	// finished executing and we can proceed.
-	case *graphdb.LightningNode:
+	case *models.LightningNode:
 		delete(v.nodeAnnDependencies, route.Vertex(msg.PubKeyBytes))
 	case *lnwire.NodeAnnouncement:
 		delete(v.nodeAnnDependencies, route.Vertex(msg.NodeID))
diff --git a/lnrpc/devrpc/dev_server.go b/lnrpc/devrpc/dev_server.go
index a58384927..ebd4591ab 100644
--- a/lnrpc/devrpc/dev_server.go
+++ b/lnrpc/devrpc/dev_server.go
@@ -17,7 +17,6 @@ import (
 	"github.com/btcsuite/btcd/wire"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 	"github.com/lightningnetwork/lnd/fn"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
 	"github.com/lightningnetwork/lnd/graph/db/models"
 	"github.com/lightningnetwork/lnd/lncfg"
 	"github.com/lightningnetwork/lnd/lnrpc"
@@ -227,7 +226,7 @@ func (s *Server) ImportGraph(ctx context.Context,
 
 	var err error
 	for _, rpcNode := range graph.Nodes {
-		node := &graphdb.LightningNode{
+		node := &models.LightningNode{
 			HaveNodeAnnouncement: true,
 			LastUpdate: time.Unix(
 				int64(rpcNode.LastUpdate), 0,
diff --git a/routing/pathfind_test.go b/routing/pathfind_test.go
index 176875046..6cd7d13c0 100644
--- a/routing/pathfind_test.go
+++ b/routing/pathfind_test.go
@@ -214,7 +214,7 @@ func parseTestGraph(t *testing.T, useCache bool, path string) (
 	privKeyMap := make(map[string]*btcec.PrivateKey)
 	channelIDs := make(map[route.Vertex]map[route.Vertex]uint64)
 	links := make(map[lnwire.ShortChannelID]htlcswitch.ChannelLink)
-	var source *graphdb.LightningNode
+	var source *models.LightningNode
 
 	// First we insert all the nodes within the graph as vertexes.
 	for _, node := range g.Nodes {
@@ -223,7 +223,7 @@ func parseTestGraph(t *testing.T, useCache bool, path string) (
 			return nil, err
 		}
 
-		dbNode := &graphdb.LightningNode{
+		dbNode := &models.LightningNode{
 			HaveNodeAnnouncement: true,
 			AuthSigBytes:         testSig.Serialize(),
 			LastUpdate:           testTime,
@@ -536,7 +536,7 @@ func createTestGraphFromChannels(t *testing.T, useCache bool,
 
 	nodeIndex := byte(0)
 	addNodeWithAlias := func(alias string, features *lnwire.FeatureVector) (
-		*graphdb.LightningNode, error) {
+		*models.LightningNode, error) {
 
 		keyBytes := []byte{
 			0, 0, 0, 0, 0, 0, 0, 0,
@@ -551,7 +551,7 @@ func createTestGraphFromChannels(t *testing.T, useCache bool,
 			features = lnwire.EmptyFeatureVector()
 		}
 
-		dbNode := &graphdb.LightningNode{
+		dbNode := &models.LightningNode{
 			HaveNodeAnnouncement: true,
 			AuthSigBytes:         testSig.Serialize(),
 			LastUpdate:           testTime,
@@ -1207,7 +1207,7 @@ func runPathFindingWithAdditionalEdges(t *testing.T, useCache bool) {
 	dogePubKey, err := btcec.ParsePubKey(dogePubKeyBytes)
 	require.NoError(t, err, "unable to parse public key from bytes")
 
-	doge := &graphdb.LightningNode{}
+	doge := &models.LightningNode{}
 	doge.AddPubKey(dogePubKey)
 	doge.Alias = "doge"
 	copy(doge.PubKeyBytes[:], dogePubKeyBytes)
diff --git a/routing/payment_session_source.go b/routing/payment_session_source.go
index d1d363e26..d5f1a6af4 100644
--- a/routing/payment_session_source.go
+++ b/routing/payment_session_source.go
@@ -3,7 +3,6 @@ package routing
 import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightningnetwork/lnd/fn"
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
 	"github.com/lightningnetwork/lnd/graph/db/models"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
@@ -24,7 +23,7 @@ type SessionSource struct {
 	GraphSessionFactory GraphSessionFactory
 
 	// SourceNode is the graph's source node.
-	SourceNode *graphdb.LightningNode
+	SourceNode *models.LightningNode
 
 	// GetLink is a method that allows querying the lower link layer
 	// to determine the up to date available bandwidth at a prospective link
@@ -101,7 +100,7 @@ func RouteHintsToEdges(routeHints [][]zpay32.HopHint, target route.Vertex) (
 			// we'll need to look at the next hint's start node. If
 			// we've reached the end of the hints list, we can
 			// assume we've reached the destination.
-			endNode := &graphdb.LightningNode{}
+			endNode := &models.LightningNode{}
 			if i != len(routeHint)-1 {
 				endNode.AddPubKey(routeHint[i+1].NodeID)
 			} else {
diff --git a/routing/payment_session_test.go b/routing/payment_session_test.go
index 9998c9aac..278e09044 100644
--- a/routing/payment_session_test.go
+++ b/routing/payment_session_test.go
@@ -4,7 +4,6 @@ import (
 	"testing"
 	"time"
 
-	graphdb "github.com/lightningnetwork/lnd/graph/db"
 	"github.com/lightningnetwork/lnd/graph/db/models"
 	"github.com/lightningnetwork/lnd/lntypes"
 	"github.com/lightningnetwork/lnd/lnwire"
@@ -89,7 +88,7 @@ func TestUpdateAdditionalEdge(t *testing.T) {
 
 	// Create a minimal test node using the private key priv1.
 	pub := priv1.PubKey().SerializeCompressed()
-	testNode := &graphdb.LightningNode{}
+	testNode := &models.LightningNode{}
 	copy(testNode.PubKeyBytes[:], pub)
 
 	nodeID, err := testNode.PubKey()
diff --git a/routing/router_test.go b/routing/router_test.go
index 6248f80ad..db72bf266 100644
--- a/routing/router_test.go
+++ b/routing/router_test.go
@@ -192,7 +192,7 @@ func createTestCtxFromGraphInstanceAssumeValid(t *testing.T,
 	return ctx
 }
 
-func createTestNode() (*graphdb.LightningNode, error) {
+func createTestNode() (*models.LightningNode, error) {
 	updateTime := rand.Int63()
 
 	priv, err := btcec.NewPrivateKey()
@@ -201,7 +201,7 @@ func createTestNode() (*graphdb.LightningNode, error) {
 	}
 
 	pub := priv.PubKey().SerializeCompressed()
-	n := &graphdb.LightningNode{
+	n := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           time.Unix(updateTime, 0),
 		Addresses:            testAddrs,
@@ -2899,7 +2899,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
 
 	// Now check that we can update the node info for the partial node
 	// without messing up the channel graph.
-	n1 := &graphdb.LightningNode{
+	n1 := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           time.Unix(123, 0),
 		Addresses:            testAddrs,
@@ -2912,7 +2912,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
 
 	require.NoError(t, ctx.graph.AddLightningNode(n1))
 
-	n2 := &graphdb.LightningNode{
+	n2 := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           time.Unix(123, 0),
 		Addresses:            testAddrs,
diff --git a/rpcserver.go b/rpcserver.go
index 147ca54b9..62facc6d9 100644
--- a/rpcserver.go
+++ b/rpcserver.go
@@ -6533,7 +6533,7 @@ func (r *rpcServer) DescribeGraph(ctx context.Context,
 	// First iterate through all the known nodes (connected or unconnected
 	// within the graph), collating their current state into the RPC
 	// response.
-	err := graph.ForEachNode(func(_ kvdb.RTx, node *graphdb.LightningNode) error {
+	err := graph.ForEachNode(func(_ kvdb.RTx, node *models.LightningNode) error {
 		lnNode := marshalNode(node)
 
 		resp.Nodes = append(resp.Nodes, lnNode)
@@ -6861,7 +6861,7 @@ func (r *rpcServer) GetNodeInfo(ctx context.Context,
 	}, nil
 }
 
-func marshalNode(node *graphdb.LightningNode) *lnrpc.LightningNode {
+func marshalNode(node *models.LightningNode) *lnrpc.LightningNode {
 	nodeAddrs := make([]*lnrpc.NodeAddress, len(node.Addresses))
 	for i, addr := range node.Addresses {
 		nodeAddr := &lnrpc.NodeAddress{
diff --git a/server.go b/server.go
index acde63803..7efe99a8b 100644
--- a/server.go
+++ b/server.go
@@ -877,7 +877,7 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
 	if err != nil {
 		return nil, err
 	}
-	selfNode := &graphdb.LightningNode{
+	selfNode := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           time.Now(),
 		Addresses:            selfAddrs,
@@ -3184,7 +3184,7 @@ func (s *server) createNewHiddenService() error {
 
 	// Finally, we'll update the on-disk version of our announcement so it
 	// will eventually propagate to nodes in the network.
-	selfNode := &graphdb.LightningNode{
+	selfNode := &models.LightningNode{
 		HaveNodeAnnouncement: true,
 		LastUpdate:           time.Unix(int64(newNodeAnn.Timestamp), 0),
 		Addresses:            newNodeAnn.Addresses,