fix: in-memory intersect points (#1438)

Signed-off-by: Chris Gianelloni <wolf31o2@blinklabs.io>

Author: wolf31o2

chain/chain.go

@@ -479,6 +479,48 @@ func (c *Chain) ClearHeaders() {
 	c.headers = c.headers[:0]
 }
 
+// RecentPoints returns up to count recent chain points in descending
+// order (most recent first) using the in-memory chain state. This
+// includes the current tip and, for non-persistent chains, any blocks
+// stored in the in-memory buffer. For persistent chains, it walks
+// backwards through the database using block indices.
+//
+// This method is useful for building intersection point lists that
+// remain accurate even when the blob store has not yet been fully
+// flushed, since the chain's in-memory tip is always up-to-date.
+func (c *Chain) RecentPoints(count int) []ocommon.Point {
+	if c == nil || count <= 0 {
+		return nil
+	}
+	c.mutex.RLock()
+	defer c.mutex.RUnlock()
+	// If the chain has no blocks yet, return nothing
+	if c.tipBlockIndex < initialBlockIndex {
+		return nil
+	}
+	var points []ocommon.Point
+	// Always include the current tip
+	tip := c.currentTip.Point
+	if tip.Slot > 0 || len(tip.Hash) > 0 {
+		points = append(points, tip)
+	}
+	if len(points) >= count {
+		return points[:count]
+	}
+	// Walk backwards through block indices to gather more points
+	for idx := c.tipBlockIndex - 1; idx >= initialBlockIndex && len(points) < count; idx-- {
+		blk, err := c.blockByIndex(idx)
+		if err != nil {
+			break
+		}
+		points = append(
+			points,
+			ocommon.NewPoint(blk.Slot, blk.Hash),
+		)
+	}
+	return points
+}
+
 func (c *Chain) HeaderCount() int {
 	c.mutex.RLock()
 	defer c.mutex.RUnlock()

chain/chain_test.go

@@ -663,6 +663,148 @@ func TestChainFromIntersect(t *testing.T) {
 	}
 }
 
+func TestRecentPointsNoDatabase(t *testing.T) {
+	// Create a chain manager with no database. Blocks are stored
+	// in memory only. RecentPoints must return the in-memory
+	// chain points even though there is no blob store.
+	cm, err := chain.NewManager(nil, nil)
+	if err != nil {
+		t.Fatalf(
+			"unexpected error creating chain manager: %s",
+			err,
+		)
+	}
+	c := cm.PrimaryChain()
+
+	// Empty chain should return no points
+	points := c.RecentPoints(10)
+	if len(points) != 0 {
+		t.Fatalf(
+			"expected 0 points on empty chain, got %d",
+			len(points),
+		)
+	}
+
+	// Add all test blocks
+	for _, testBlock := range testBlocks {
+		if err := c.AddBlock(testBlock, nil); err != nil {
+			t.Fatalf(
+				"unexpected error adding block to chain: %s",
+				err,
+			)
+		}
+	}
+
+	// Request more points than exist; should get all blocks
+	points = c.RecentPoints(100)
+	if len(points) != len(testBlocks) {
+		t.Fatalf(
+			"expected %d points, got %d",
+			len(testBlocks),
+			len(points),
+		)
+	}
+
+	// Points should be in descending order (most recent first)
+	for i, p := range points {
+		expectedBlock := testBlocks[len(testBlocks)-1-i]
+		expectedHash := decodeHex(expectedBlock.MockHash)
+		if p.Slot != expectedBlock.MockSlot {
+			t.Fatalf(
+				"point %d: expected slot %d, got %d",
+				i,
+				expectedBlock.MockSlot,
+				p.Slot,
+			)
+		}
+		if string(p.Hash) != string(expectedHash) {
+			t.Fatalf(
+				"point %d: expected hash %x, got %x",
+				i,
+				expectedHash,
+				p.Hash,
+			)
+		}
+	}
+
+	// Request fewer points than exist; should get exactly the
+	// requested count, starting from the tip
+	points = c.RecentPoints(2)
+	if len(points) != 2 {
+		t.Fatalf("expected 2 points, got %d", len(points))
+	}
+	lastBlock := testBlocks[len(testBlocks)-1]
+	if points[0].Slot != lastBlock.MockSlot {
+		t.Fatalf(
+			"first point should be tip: expected slot %d, got %d",
+			lastBlock.MockSlot,
+			points[0].Slot,
+		)
+	}
+	secondLastBlock := testBlocks[len(testBlocks)-2]
+	if points[1].Slot != secondLastBlock.MockSlot {
+		t.Fatalf(
+			"second point should be tip-1: expected slot %d, got %d",
+			secondLastBlock.MockSlot,
+			points[1].Slot,
+		)
+	}
+}
+
+func TestRecentPointsWithDatabase(t *testing.T) {
+	// Create a chain manager with a real database. RecentPoints
+	// should still return the correct in-memory tip even though
+	// block storage goes through the blob store.
+	db := newTestDB(t)
+	cm, err := chain.NewManager(db, nil)
+	if err != nil {
+		t.Fatalf(
+			"unexpected error creating chain manager: %s",
+			err,
+		)
+	}
+	c := cm.PrimaryChain()
+
+	// Add all test blocks
+	for _, testBlock := range testBlocks {
+		if err := c.AddBlock(testBlock, nil); err != nil {
+			t.Fatalf(
+				"unexpected error adding block to chain: %s",
+				err,
+			)
+		}
+	}
+
+	// RecentPoints should return points in descending order
+	points := c.RecentPoints(3)
+	if len(points) != 3 {
+		t.Fatalf("expected 3 points, got %d", len(points))
+	}
+
+	// Verify descending order by slot
+	for i := range len(points) - 1 {
+		if points[i].Slot <= points[i+1].Slot {
+			t.Fatalf(
+				"points not in descending order: "+
+					"point %d (slot %d) <= point %d (slot %d)",
+				i, points[i].Slot,
+				i+1, points[i+1].Slot,
+			)
+		}
+	}
+
+	// Tip should be the first point
+	tip := c.Tip()
+	if points[0].Slot != tip.Point.Slot ||
+		string(points[0].Hash) != string(tip.Point.Hash) {
+		t.Fatalf(
+			"first point should match tip: got %d.%x, wanted %d.%x",
+			points[0].Slot, points[0].Hash,
+			tip.Point.Slot, tip.Point.Hash,
+		)
+	}
+}
+
 // mockLedger implements the interface{ SecurityParam() int }
 // interface used by ChainManager.SetLedger.
 type mockLedger struct {

ledger/state.go

@@ -2552,22 +2552,63 @@ func (ls *LedgerState) GetBlock(point ocommon.Point) (models.Block, error) {
 	return ret, nil
 }
 
-// RecentChainPoints returns the requested count of recent chain points in descending order. This is used mostly
-// for building a set of intersect points when acting as a chainsync client
-func (ls *LedgerState) RecentChainPoints(count int) ([]ocommon.Point, error) {
-	tmpBlocks, err := database.BlocksRecent(ls.db, count)
-	if err != nil {
-		return nil, err
-	}
-	ret := make([]ocommon.Point, 0, len(tmpBlocks))
-	var tmpBlock models.Block
-	for _, tmpBlock = range tmpBlocks {
-		ret = append(
-			ret,
-			ocommon.NewPoint(tmpBlock.Slot, tmpBlock.Hash),
+// RecentChainPoints returns the requested count of recent chain
+// points in descending order. This is used mostly for building a set
+// of intersect points when acting as a chainsync client.
+//
+// Points are first collected from the in-memory chain state, which is
+// always up-to-date even when the blob store has not yet flushed
+// recent writes. Database points are then appended to fill the
+// requested count, with duplicates removed.
+func (ls *LedgerState) RecentChainPoints(
+	count int,
+) ([]ocommon.Point, error) {
+	var points []ocommon.Point
+	// Collect points from the in-memory chain first. The chain's
+	// tip and recent blocks are always current, even when the
+	// underlying blob store has pending writes that are not yet
+	// visible to new read transactions.
+	if ls.chain != nil {
+		points = ls.chain.RecentPoints(count)
+	}
+	// Supplement with database points for deeper history
+	if len(points) < count {
+		remaining := count - len(points)
+		tmpBlocks, err := database.BlocksRecent(
+			ls.db, remaining,
 		)
+		if err != nil {
+			// If we already have in-memory points, a database
+			// error is non-fatal: return what we have.
+			if len(points) > 0 {
+				return points, nil
+			}
+			return nil, err
+		}
+		// Build a set of existing points for deduplication
+		seen := make(map[string]struct{}, len(points))
+		for _, p := range points {
+			seen[pointKey(p)] = struct{}{}
+		}
+		for _, blk := range tmpBlocks {
+			p := ocommon.NewPoint(blk.Slot, blk.Hash)
+			key := pointKey(p)
+			if _, exists := seen[key]; exists {
+				continue
+			}
+			seen[key] = struct{}{}
+			points = append(points, p)
+			if len(points) >= count {
+				break
+			}
+		}
 	}
-	return ret, nil
+	return points, nil
+}
+
+// pointKey returns a string key for deduplication of chain points.
+func pointKey(p ocommon.Point) string {
+	return fmt.Sprintf("%d:%x", p.Slot, p.Hash)
 }
 
 // GetIntersectPoint returns the intersect between the specified points and the current chain