Added a v1 <> v2 compare test

Author: setavenger

Makefile

@@ -14,6 +14,11 @@ benchmark-v2: build-benchmark
 	@echo "Running v2 gRPC benchmark only..."
 	./bin/benchmark -v1=false -v2 $(ARGS)
 
+.PHONY: compare
+compare: build-benchmark
+	@echo "Comparing v1 and v2 data..."
+	./bin/benchmark -compare $(ARGS)
+
 .PHONY: build-benchmark
 build-benchmark:
 	@echo "Building benchmark tool..."
@@ -24,3 +29,4 @@ build-benchmark:
 # make benchmark ARGS="-startheight=100 -endheight=200"
 # make benchmark-v1 ARGS="-startheight=100 -endheight=200"
 # make benchmark-v2 ARGS="-startheight=100 -endheight=200"
+# make compare ARGS="-startheight=100 -endheight=200"

cmd/benchmark/README.md

@@ -25,6 +25,11 @@ make build-benchmark
 ./bin/benchmark -v1=false -v2 -startheight=100 -endheight=200
 ```
 
+### Compare v1 and v2 data (validation)
+```bash
+./bin/benchmark -compare -startheight=100 -endheight=200
+```
+
 ### Using Makefile
 ```bash
 # Run both
@@ -35,6 +40,9 @@ make benchmark-v1 ARGS="-startheight=100 -endheight=200"
 
 # Run only v2
 make benchmark-v2 ARGS="-startheight=100 -endheight=200"
+
+# Compare data
+make benchmark ARGS="-compare -startheight=264100 -endheight=264200"
 ```
 
 ## Command Line Flags
@@ -45,6 +53,7 @@ make benchmark-v2 ARGS="-startheight=100 -endheight=200"
 - `-grpc`: gRPC server host:port (default: "127.0.0.1:50051")
 - `-v1`: Run v1 HTTP benchmark (default: true)
 - `-v2`: Run v2 gRPC benchmark (default: true)
+- `-compare`: Compare v1 and v2 data instead of benchmarking (default: false)
 
 ## What it measures
 

cmd/benchmark/main.go

@@ -16,12 +16,23 @@ func main() {
 		grpcHost    = flag.String("grpc", "127.0.0.1:50051", "gRPC server host:port")
 		runV1       = flag.Bool("v1", true, "Run v1 HTTP benchmark")
 		runV2       = flag.Bool("v2", true, "Run v2 gRPC benchmark")
+		compare     = flag.Bool("compare", false, "Compare v1 and v2 data instead of benchmarking")
 	)
 	flag.Parse()
 
 	// Setup logging
 	logging.SetLogLevel(zerolog.InfoLevel)
 
+	if *compare {
+		logging.L.Info().
+			Uint64("start_height", *startHeight).
+			Uint64("end_height", *endHeight).
+			Msg("Starting data comparison")
+
+		benchmark.CompareV1V2Results(*startHeight, *endHeight, *httpURL, *grpcHost)
+		return
+	}
+
 	logging.L.Info().
 		Uint64("start_height", *startHeight).
 		Uint64("end_height", *endHeight).

internal/benchmark/compare.go

@@ -0,0 +1,145 @@
+package benchmark
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/setavenger/blindbit-lib/logging"
+	"github.com/setavenger/blindbit-lib/networking"
+	"github.com/setavenger/blindbit-lib/proto/pb"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+// CompareV1V2Results compares v1 and v2 results for validation
+func CompareV1V2Results(startHeight, endHeight uint64, httpURL, grpcHost string) {
+	logging.L.Info().Msgf("Comparing v1 and v2 results from height %d to %d", startHeight, endHeight)
+
+	for height := startHeight; height <= endHeight; height++ {
+		logging.L.Info().Uint64("height", height).Msg("comparing block")
+
+		// Fetch v1 data
+		v1Data, err := fetchBlockDataV1(height, &networking.ClientBlindBit{BaseURL: httpURL})
+		if err != nil {
+			logging.L.Err(err).Uint64("height", height).Msg("failed to fetch v1 data")
+			continue
+		}
+
+		// Fetch v2 data
+		v2Data, err := fetchBlockDataV2(height, grpcHost)
+		if err != nil {
+			logging.L.Err(err).Uint64("height", height).Msg("failed to fetch v2 data")
+			continue
+		}
+
+		// Quick validation
+		if len(v1Data.Tweaks) != len(v2Data.Tweaks) {
+			logging.L.Warn().Uint64("height", height).
+				Int("v1_tweaks", len(v1Data.Tweaks)).
+				Int("v2_tweaks", len(v2Data.Tweaks)).
+				Msg("tweak count mismatch")
+		}
+
+		if v1Data.FilterNew != nil && v2Data.FilterNew != nil {
+			if len(v1Data.FilterNew.Data) != len(v2Data.FilterNew.Data) {
+				logging.L.Warn().Uint64("height", height).
+					Int("v1_filter_new", len(v1Data.FilterNew.Data)).
+					Int("v2_filter_new", len(v2Data.FilterNew.Data)).
+					Msg("new UTXOs filter data length mismatch")
+			}
+		}
+
+		if v1Data.FilterSpent != nil && v2Data.FilterSpent != nil {
+			if len(v1Data.FilterSpent.Data) != len(v2Data.FilterSpent.Data) {
+				logging.L.Warn().Uint64("height", height).
+					Int("v1_filter_spent", len(v1Data.FilterSpent.Data)).
+					Int("v2_filter_spent", len(v2Data.FilterSpent.Data)).
+					Msg("spent outpoints filter data length mismatch")
+			}
+		}
+
+		logging.L.Info().Uint64("height", height).Msg("block comparison completed")
+	}
+
+	logging.L.Info().Msg("All block comparisons completed")
+}
+
+// fetchBlockDataV2 fetches block data using v2 gRPC API
+func fetchBlockDataV2(height uint64, grpcHost string) (*BlockDataV2, error) {
+	// Connect to gRPC server
+	conn, err := grpc.Dial(grpcHost, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to gRPC server: %v", err)
+	}
+	defer conn.Close()
+
+	client := pb.NewOracleServiceClient(conn)
+
+	// Use streaming API to fetch single block
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	req := &pb.RangedBlockHeightRequest{
+		Start: height,
+		End:   height,
+	}
+
+	stream, err := client.StreamBlockBatchSlim(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to start streaming: %v", err)
+	}
+
+	// Receive the single batch
+	batch, err := stream.Recv()
+	if err != nil {
+		return nil, fmt.Errorf("failed to receive batch: %v", err)
+	}
+
+	// Convert protobuf data to our format
+	return &BlockDataV2{
+		Height:      height,
+		FilterNew:   convertFilterData(batch.NewUtxosFilter, batch.BlockIdentifier),
+		FilterSpent: convertFilterData(batch.SpentUtxosFilter, batch.BlockIdentifier),
+		Tweaks:      convertTweaksToArray(batch.Tweaks),
+	}, nil
+}
+
+// convertTweaksToArray converts [][]byte to [][33]byte
+func convertTweaksToArray(tweaks [][]byte) [][33]byte {
+	result := make([][33]byte, len(tweaks))
+	for i, tweak := range tweaks {
+		if len(tweak) == 33 {
+			copy(result[i][:], tweak)
+		}
+	}
+	return result
+}
+
+// convertFilterData converts protobuf FilterData to networking.Filter
+func convertFilterData(pbFilter *pb.FilterData, blockIdentifier *pb.BlockIdentifier) *networking.Filter {
+	if pbFilter == nil {
+		return nil
+	}
+
+	// Convert block hash from bytes to [32]byte
+	var blockHash [32]byte
+	if len(blockIdentifier.BlockHash) == 32 {
+		copy(blockHash[:], blockIdentifier.BlockHash)
+	}
+
+	return &networking.Filter{
+		FilterType:  uint8(pbFilter.FilterType),
+		BlockHeight: blockIdentifier.BlockHeight,
+		BlockHash:   blockHash,
+		Data:        pbFilter.Data,
+	}
+}
+
+// BlockDataV2 represents the block data structure for v2
+type BlockDataV2 struct {
+	Height      uint64
+	FilterNew   *networking.Filter
+	FilterSpent *networking.Filter
+	Tweaks      [][33]byte
+}

internal/benchmark/compare_test.go

@@ -0,0 +1,124 @@
+package benchmark
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+	"github.com/setavenger/blindbit-lib/logging"
+	"github.com/setavenger/blindbit-lib/networking"
+)
+
+// TestCompareV1V2Results compares results from v1 HTTP and v2 gRPC endpoints
+func TestCompareV1V2Results(t *testing.T) {
+	// Configuration
+	httpURL := "http://127.0.0.1:8000"
+	grpcHost := "127.0.0.1:50051"
+	testHeight := uint64(100) // Adjust to a height you know has data
+
+	// Setup logging
+	logging.SetLogLevel(zerolog.InfoLevel)
+
+	t.Logf("Comparing v1 and v2 results for block height %d", testHeight)
+
+	// Fetch data from v1 (HTTP)
+	v1Data, err := fetchBlockDataV1(testHeight, &networking.ClientBlindBit{BaseURL: httpURL})
+	if err != nil {
+		t.Fatalf("Failed to fetch v1 data: %v", err)
+	}
+
+	// Fetch data from v2 (gRPC)
+	v2Data, err := fetchBlockDataV2(testHeight, grpcHost)
+	if err != nil {
+		t.Fatalf("Failed to fetch v2 data: %v", err)
+	}
+
+	// Compare results
+	t.Run("CompareTweaks", func(t *testing.T) {
+		compareTweaks(t, v1Data.Tweaks, v2Data.Tweaks)
+	})
+
+	t.Run("CompareNewUTXOsFilter", func(t *testing.T) {
+		compareFilter(t, "NewUTXOs", v1Data.FilterNew, v2Data.FilterNew)
+	})
+
+	t.Run("CompareSpentOutpointsFilter", func(t *testing.T) {
+		compareFilter(t, "SpentOutpoints", v1Data.FilterSpent, v2Data.FilterSpent)
+	})
+
+	t.Log("All comparisons passed - v1 and v2 endpoints return identical data")
+}
+
+// compareTweaks compares tweak arrays from v1 and v2
+func compareTweaks(t *testing.T, v1Tweaks, v2Tweaks [][33]byte) {
+	if len(v1Tweaks) != len(v2Tweaks) {
+		t.Errorf("Tweak count mismatch: v1=%d, v2=%d", len(v1Tweaks), len(v2Tweaks))
+		return
+	}
+
+	t.Logf("Comparing %d tweaks", len(v1Tweaks))
+
+	for i, v1Tweak := range v1Tweaks {
+		if i >= len(v2Tweaks) {
+			t.Errorf("v2 tweaks array too short at index %d", i)
+			continue
+		}
+
+		v2Tweak := v2Tweaks[i]
+		if v1Tweak != v2Tweak {
+			t.Errorf("Tweak mismatch at index %d: v1=%x, v2=%x",
+				i, v1Tweak, v2Tweak)
+		}
+	}
+}
+
+// compareFilter compares filter data from v1 and v2
+func compareFilter(t *testing.T, filterName string, v1Filter, v2Filter *networking.Filter) {
+	if v1Filter == nil && v2Filter == nil {
+		t.Logf("%s filter: both nil (no data)", filterName)
+		return
+	}
+
+	if v1Filter == nil {
+		t.Errorf("%s filter: v1 is nil but v2 is not", filterName)
+		return
+	}
+
+	if v2Filter == nil {
+		t.Errorf("%s filter: v2 is nil but v1 is not", filterName)
+		return
+	}
+
+	t.Logf("%s filter: comparing data", filterName)
+
+	// Compare filter data
+	if len(v1Filter.Data) != len(v2Filter.Data) {
+		t.Errorf("%s filter data length mismatch: v1=%d, v2=%d",
+			filterName, len(v1Filter.Data), len(v2Filter.Data))
+		return
+	}
+
+	for i, v1Byte := range v1Filter.Data {
+		if i >= len(v2Filter.Data) {
+			t.Errorf("%s filter: v2 data too short at index %d", filterName, i)
+			continue
+		}
+
+		v2Byte := v2Filter.Data[i]
+		if v1Byte != v2Byte {
+			t.Errorf("%s filter data mismatch at index %d: v1=%x, v2=%x",
+				filterName, i, v1Byte, v2Byte)
+		}
+	}
+
+	// Compare block hash
+	if v1Filter.BlockHash != v2Filter.BlockHash {
+		t.Errorf("%s filter block hash mismatch: v1=%x, v2=%x",
+			filterName, v1Filter.BlockHash, v2Filter.BlockHash)
+	}
+
+	// Compare block height
+	if v1Filter.BlockHeight != v2Filter.BlockHeight {
+		t.Errorf("%s filter block height mismatch: v1=%d, v2=%d",
+			filterName, v1Filter.BlockHeight, v2Filter.BlockHeight)
+	}
+}

internal/server/v2/service.go

@@ -328,6 +328,12 @@ func (s *OracleService) StreamBlockBatchFull(
 	req *pb.RangedBlockHeightRequest, stream pb.OracleService_StreamBlockBatchFullServer,
 ) error {
 	for height := req.Start; height <= req.End; height++ {
+		select {
+		case <-stream.Context().Done():
+			logging.L.Debug().Msg("stream context cancelled")
+			return nil
+		default:
+		}
 		headerInv, err := dblevel.FetchByBlockHeightBlockHeaderInv(uint32(height))
 		if err != nil {
 			logging.L.Err(err).Msg("error fetching block header inv")