graph,discovery: version IsZombieChannel

diff --git a/discovery/gossiper.go b/discovery/gossiper.go
index fd0f371..49481a1 100644
--- a/discovery/gossiper.go
+++ b/discovery/gossiper.go
@@ -380,10 +380,9 @@ type Config struct {
 	FindChannel func(node *btcec.PublicKey, chanID lnwire.ChannelID) (
 		*channeldb.OpenChannel, error)
 
-	// IsStillZombieChannel takes the timestamps of the latest channel
-	// updates for a channel and returns true if the channel should be
-	// considered a zombie based on these timestamps.
-	IsStillZombieChannel func(time.Time, time.Time) bool
+	// IsStillZombieChannel returns true if the channel described by info
+	// should still be considered a zombie.
+	IsStillZombieChannel func(graphdb.ChannelUpdateInfo) bool
 
 	// AssumeChannelValid toggles whether the gossiper will check for
 	// spent-ness of channel outpoints. For neutrino, this saves long
diff --git a/discovery/sync_manager.go b/discovery/sync_manager.go
index 56e81e6..4ea3eac 100644
--- a/discovery/sync_manager.go
+++ b/discovery/sync_manager.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	graphdb "github.com/lightningnetwork/lnd/graph/db"
 	"github.com/lightningnetwork/lnd/lnpeer"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing/route"
@@ -129,10 +130,9 @@ type SyncManagerCfg struct {
 	// PassiveSync.
 	PinnedSyncers PinnedSyncers
 
-	// IsStillZombieChannel takes the timestamps of the latest channel
-	// updates for a channel and returns true if the channel should be
-	// considered a zombie based on these timestamps.
-	IsStillZombieChannel func(time.Time, time.Time) bool
+	// IsStillZombieChannel returns true if the channel described by info
+	// should still be considered a zombie.
+	IsStillZombieChannel func(graphdb.ChannelUpdateInfo) bool
 
 	// AllotedMsgBytesPerSecond is the allotted bandwidth rate, expressed in
 	// bytes/second that the gossip manager can consume. Once we exceed this
diff --git a/discovery/syncer.go b/discovery/syncer.go
index f6426c0..7c59cc2 100644
--- a/discovery/syncer.go
+++ b/discovery/syncer.go
@@ -284,10 +284,9 @@ type gossipSyncerCfg struct {
 	// for a single QueryChannelRange request.
 	maxQueryChanRangeReplies uint32
 
-	// isStillZombieChannel takes the timestamps of the latest channel
-	// updates for a channel and returns true if the channel should be
-	// considered a zombie based on these timestamps.
-	isStillZombieChannel func(time.Time, time.Time) bool
+	// isStillZombieChannel returns true if the channel described by info
+	// should still be considered a zombie.
+	isStillZombieChannel func(graphdb.ChannelUpdateInfo) bool
 
 	// timestampQueueSize is the size of the timestamp range queue. If not
 	// set, defaults to the global timestampQueueSize constant.
@@ -974,7 +973,9 @@ func (g *GossipSyncer) processChanRangeReply(_ context.Context,
 	g.prevReplyChannelRange = msg
 
 	for i, scid := range msg.ShortChanIDs {
-		info := graphdb.NewV1ChannelUpdateInfo(scid, time.Time{}, time.Time{})
+		info := graphdb.NewV1ChannelUpdateInfo(
+			scid, time.Time{}, time.Time{},
+		)
 
 		if len(msg.Timestamps) != 0 {
 			info.Node1Freshness = lnwire.UnixTimestamp(
@@ -1060,17 +1061,9 @@ func (g *GossipSyncer) processChanRangeReply(_ context.Context,
 
 	// Otherwise, this is the final response, so we'll now check to see
 	// which channels they know of that we don't.
-	// TODO(elle): isStillZombieChannel only inspects v1 time-based
-	// timestamps; once the gossip sync protocol supports v2, this
-	// should be updated to handle block-height freshness for v2
-	// channels.
-	isZombieChan := func(info graphdb.ChannelUpdateInfo) bool {
-		return g.cfg.isStillZombieChannel(
-			info.Node1FreshnessTime(), info.Node2FreshnessTime(),
-		)
-	}
 	newChans, err := g.cfg.channelSeries.FilterKnownChanIDs(
-		g.cfg.chainHash, g.bufferedChanRangeReplies, isZombieChan,
+		g.cfg.chainHash, g.bufferedChanRangeReplies,
+		g.cfg.isStillZombieChannel,
 	)
 	if err != nil {
 		return fmt.Errorf("unable to filter chan ids: %w", err)
diff --git a/graph/builder.go b/graph/builder.go
index 3040709..2e17ef5 100644
--- a/graph/builder.go
+++ b/graph/builder.go
@@ -465,30 +465,57 @@ func (b *Builder) syncGraphWithChain() error {
 	return nil
 }
 
-// isPolicyZombie returns true if the given edge policy is considered stale
-// based on version-specific freshness criteria. For v1 policies, staleness is
-// determined by wall-clock time since the last update. For v2 policies,
-// staleness is determined by how many blocks have elapsed since the last
-// update block height.
-func (b *Builder) isPolicyZombie(e *models.ChannelEdgePolicy) bool {
+// isTimestampStale returns true if the given freshness timestamp is considered
+// stale based on the gossip version. For v1, staleness is determined by
+// wall-clock time since the unix timestamp. For v2, staleness is determined by
+// how many blocks have elapsed since the block height timestamp.
+func (b *Builder) isTimestampStale(v lnwire.GossipVersion,
+	freshness lnwire.Timestamp) bool {
+
 	chanExpiry := b.cfg.ChannelPruneExpiry
 
-	switch e.Version {
+	switch v {
 	case lnwire.GossipVersion1:
-		return time.Since(e.LastUpdate) >= chanExpiry
+		ts, ok := freshness.(lnwire.UnixTimestamp)
+		if !ok || ts.IsZero() {
+			return true
+		}
+
+		t := time.Unix(int64(ts), 0)
+
+		return time.Since(t) >= chanExpiry
 
 	default:
+		h, ok := freshness.(lnwire.BlockHeightTimestamp)
+		if !ok || uint32(h) == 0 {
+			return true
+		}
+
 		expiryBlocks := uint32(chanExpiry / avgBitcoinBlockTime)
 		currentHeight := b.bestHeight.Load()
+		height := uint32(h)
 
-		if e.LastBlockHeight > currentHeight {
+		if height > currentHeight {
 			return false
 		}
 
-		return currentHeight-e.LastBlockHeight >= expiryBlocks
+		return currentHeight-height >= expiryBlocks
 	}
 }
 
+// isPolicyZombie returns true if the given edge policy is considered stale
+// based on version-specific freshness criteria.
+func (b *Builder) isPolicyZombie(e *models.ChannelEdgePolicy) bool {
+	var freshness lnwire.Timestamp
+	if e.Version == lnwire.GossipVersion1 {
+		freshness = lnwire.UnixTimestamp(e.LastUpdate.Unix())
+	} else {
+		freshness = lnwire.BlockHeightTimestamp(e.LastBlockHeight)
+	}
+
+	return b.isTimestampStale(e.Version, freshness)
+}
+
 // isZombieChannel takes two edge policy updates and determines if the
 // corresponding channel should be considered a zombie. The first boolean is
 // true if the policy update from node 1 is considered a zombie, the second
@@ -510,28 +537,17 @@ func (b *Builder) isZombieChannel(e1,
 	return e1Zombie, e2Zombie, e1Zombie && e2Zombie
 }
 
-// IsZombieChannel takes the timestamps of the latest channel updates for a
-// channel and returns true if the channel should be considered a zombie based
-// on these timestamps.
-func (b *Builder) IsZombieChannel(updateTime1,
-	updateTime2 time.Time) bool {
-
-	chanExpiry := b.cfg.ChannelPruneExpiry
-
-	e1Zombie := updateTime1.IsZero() ||
-		time.Since(updateTime1) >= chanExpiry
-
-	e2Zombie := updateTime2.IsZero() ||
-		time.Since(updateTime2) >= chanExpiry
+// IsZombieChannel returns true if the channel described by info should be
+// considered a zombie. For v1 channels, freshness is a unix timestamp; for v2+
+// channels it is a block height.
+func (b *Builder) IsZombieChannel(info graphdb.ChannelUpdateInfo) bool {
+	e1Zombie := b.isTimestampStale(info.Version, info.Node1Freshness)
+	e2Zombie := b.isTimestampStale(info.Version, info.Node2Freshness)
 
-	// If we're using strict zombie pruning, then a channel is only
-	// considered live if both edges have a recent update we know of.
 	if b.cfg.StrictZombiePruning {
 		return e1Zombie || e2Zombie
 	}
 
-	// Otherwise, if we're using the less strict variant, then a channel is
-	// considered live if either of the edges have a recent update.
 	return e1Zombie && e2Zombie
 }
 
diff --git a/graph/builder_test.go b/graph/builder_test.go
index 8e7e5f2..5b62439 100644
--- a/graph/builder_test.go
+++ b/graph/builder_test.go
@@ -1037,6 +1037,97 @@ func TestIsPolicyZombie(t *testing.T) {
 	}
 }
 
+// TestIsZombieChannel verifies that IsZombieChannel uses version-aware
+// freshness checks and applies strict zombie pruning correctly.
+func TestIsZombieChannel(t *testing.T) {
+	t.Parallel()
+
+	const (
+		pruneExpiry   = time.Hour
+		currentHeight = uint32(1000)
+	)
+
+	tests := []struct {
+		name                string
+		strictZombiePruning bool
+		info                graphdb.ChannelUpdateInfo
+		zombie              bool
+	}{
+		{
+			name: "v1 both stale",
+			info: graphdb.NewV1ChannelUpdateInfo(
+				lnwire.ShortChannelID{},
+				time.Now().Add(-2*pruneExpiry),
+				time.Now().Add(-2*pruneExpiry),
+			),
+			zombie: true,
+		},
+		{
+			name: "v1 one stale not strict",
+			info: graphdb.NewV1ChannelUpdateInfo(
+				lnwire.ShortChannelID{},
+				time.Now().Add(-2*pruneExpiry),
+				time.Now(),
+			),
+			zombie: false,
+		},
+		{
+			name:                "v1 one stale strict",
+			strictZombiePruning: true,
+			info: graphdb.NewV1ChannelUpdateInfo(
+				lnwire.ShortChannelID{},
+				time.Now().Add(-2*pruneExpiry),
+				time.Now(),
+			),
+			zombie: true,
+		},
+		{
+			name: "v2 both stale",
+			info: graphdb.NewV2ChannelUpdateInfo(
+				lnwire.ShortChannelID{}, 987, 988,
+			),
+			zombie: true,
+		},
+		{
+			name: "v2 one stale not strict",
+			info: graphdb.NewV2ChannelUpdateInfo(
+				lnwire.ShortChannelID{}, 987, 995,
+			),
+			zombie: false,
+		},
+		{
+			name:                "v2 one stale strict",
+			strictZombiePruning: true,
+			info: graphdb.NewV2ChannelUpdateInfo(
+				lnwire.ShortChannelID{}, 987, 995,
+			),
+			zombie: true,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			strictPruning := test.strictZombiePruning
+			b := &Builder{
+				cfg: &Config{
+					ChannelPruneExpiry:  pruneExpiry,
+					StrictZombiePruning: strictPruning,
+				},
+			}
+			b.bestHeight.Store(currentHeight)
+
+			require.Equal(
+				t, test.zombie,
+				b.IsZombieChannel(test.info),
+			)
+		})
+	}
+}
+
 // TestIsStaleNode tests that the IsStaleNode method properly detects stale
 // node announcements.
 func TestIsStaleNode(t *testing.T) {