graph: check zombie chan by age

In this commit, we add a method to determine if a channel is a
zombie using the timestamp of the block of the funding trx that
opened the channel.

Author: Abdulkbk

graph/builder.go

@@ -499,6 +499,26 @@ func (b *Builder) IsZombieChannel(updateTime1,
 	return e1Zombie && e2Zombie
 }
 
+// IsZombieByAge checks if a channel is a zombie by its age. It uses the
+// timestamp of the block of the transaction that opened the channel. We use
+// this only for channels that have no edge policies, as we can't use the last
+// update timestamp to determine if the channel is a zombie.
+func (b *Builder) IsZombieByAge(scid uint64) (bool, error) {
+	blockHeight := lnwire.NewShortChanIDFromInt(scid).BlockHeight
+
+	blockhash, err := b.cfg.Chain.GetBlockHash(int64(blockHeight))
+	if err != nil {
+		return false, err
+	}
+
+	header, err := b.cfg.Chain.GetBlockHeader(blockhash)
+	if err != nil {
+		return false, err
+	}
+
+	return time.Since(header.Timestamp) >= b.cfg.ChannelPruneExpiry, nil
+}
+
 // pruneZombieChans is a method that will be called periodically to prune out
 // any "zombie" channels. We consider channels zombies if *both* edges haven't
 // been updated since our zombie horizon. If AssumeChannelValid is present,
@@ -536,6 +556,25 @@ func (b *Builder) pruneZombieChans() error {
 			return nil
 		}
 
+		// If both edges are nil, then we'll check if the channel is a
+		// zombie that has been opened for long and never received a
+		// policy update.
+		if e1 == nil && e2 == nil {
+			isZombie, err := b.IsZombieByAge(info.ChannelID)
+			if err != nil {
+				return fmt.Errorf("unable to check if "+
+					"channel is a zombie: %w", err)
+			}
+
+			if isZombie {
+				chansToPrune[info.ChannelID] = struct{}{}
+			}
+
+			// We've handled channels with no policies, so we can
+			// exit early to process the next channel.
+			return nil
+		}
+
 		e1Zombie, e2Zombie, isZombieChan := b.isZombieChannel(e1, e2)
 
 		if e1Zombie {

graph/builder_test.go

@@ -884,6 +884,82 @@ func TestPruneChannelGraphStaleEdges(t *testing.T) {
 	}
 }
 
+// TestIsZombieByAge tests that we can properly determine if a channel with no
+// edge policies is a zombie or not using the block timestamp that the
+// transaction that opened the channel was included in.
+//
+//nolint:ll
+func TestIsZombieByAge(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name               string
+		blockTimestamp     time.Time
+		channelPruneExpiry time.Duration
+		expectedPrune      bool
+	}{
+		{
+			name:               "old chan",
+			blockTimestamp:     time.Now().Add(-30 * 24 * time.Hour),
+			channelPruneExpiry: 14 * 24 * time.Hour,
+			expectedPrune:      true,
+		},
+		{
+			name:               "recent channel",
+			blockTimestamp:     time.Now().Add(-7 * 24 * time.Hour),
+			channelPruneExpiry: 14 * 24 * time.Hour,
+			expectedPrune:      false,
+		},
+		{
+			name:               "chan at threshold",
+			blockTimestamp:     time.Now().Add(-14 * 24 * time.Hour),
+			channelPruneExpiry: 14 * 24 * time.Hour,
+			expectedPrune:      true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create mock chain with a starting height.
+			const startingHeight = 100
+			mockChain := newMockChain(startingHeight)
+
+			// Create a block with the desired timestamp.
+			block := &wire.MsgBlock{
+				Header: wire.BlockHeader{
+					Timestamp: tc.blockTimestamp,
+				},
+			}
+
+			// Add the block at a specific height.
+			const channelBlockHeight = 101
+			mockChain.addBlock(block, channelBlockHeight, 0)
+
+			scid := lnwire.ShortChannelID{
+				BlockHeight: channelBlockHeight,
+				TxIndex:     0,
+				TxPosition:  0,
+			}
+
+			// Create a minimal builder config that consist the mock
+			// chain and the channel prune expiry we set.
+			cfg := &Config{
+				Chain:              mockChain,
+				ChannelPruneExpiry: tc.channelPruneExpiry,
+			}
+			builder := &Builder{
+				cfg: cfg,
+			}
+
+			// Test the method to see we are able to determine if
+			// the channel is a zombie or not.
+			isZombie, err := builder.IsZombieByAge(scid.ToUint64())
+			require.NoError(t, err)
+			require.Equal(t, tc.expectedPrune, isZombie)
+		})
+	}
+}
+
 // TestPruneChannelGraphDoubleDisabled test that we can properly prune channels
 // with both edges disabled from our channel graph.
 func TestPruneChannelGraphDoubleDisabled(t *testing.T) {