Merge branch 'dev'

Author: setavenger

.github/workflows/docker-image.yml

@@ -43,7 +43,7 @@ jobs:
           tags: setavenger/blindbit-oracle:dev-${{ steps.commit.outputs.short }} # Use the short SHA to distinguish dev images
 
       # Build and push the Docker image (tags)
-      - name: Build and push Docker image
+      - name: Build and push Docker image (tags)
         if: startsWith(github.ref, 'refs/tags/')
         uses: docker/build-push-action@v4
         with:
@@ -61,5 +61,3 @@ jobs:
           push: true
           build-args: --progress=plain
           tags: setavenger/blindbit-oracle:${{ github.ref_name }}
-
-

Dockerfile

@@ -6,7 +6,7 @@ WORKDIR /app
 
 
 RUN go mod download
-RUN env CGO_ENABLED=0 go build -o main ./src
+RUN env CGO_ENABLED=0 go build -o main ./cmd/blindbit-oracle
 
 FROM busybox
 COPY --from=buildstage /app/main .

Makefile

@@ -0,0 +1,32 @@
+# Benchmark targets
+.PHONY: benchmark
+benchmark: build-benchmark
+	@echo "Running benchmark..."
+	./bin/benchmark $(ARGS)
+
+.PHONY: benchmark-v1
+benchmark-v1: build-benchmark
+	@echo "Running v1 HTTP benchmark only..."
+	./bin/benchmark -v1 -v2=false $(ARGS)
+
+.PHONY: benchmark-v2
+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..."
+	@mkdir -p bin
+	go build -o bin/benchmark ./cmd/benchmark
+
+# Example usage:
+# 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"

NOTES.md

@@ -13,15 +13,15 @@ The installation process is still very manual. Will be improved based on feedbac
 
 - Endpoints were expanded and have a slightly different syntax now [see endpoints](#endpoints)
 
-### Requirements
+## Requirements
 
 - RPC access to a bitcoin full node
     - unpruned because we need the prevouts for every transaction in the block with a taproot output
     - Note: Indexing will take longer if the rpc calls take longer;
       You might also want to allow more rpc workers on your node to speed things up.
 - Processing a block takes ~100ms-300ms
 - Disk space (~10Gb)
-- go 1.20 installed
+- go 1.21 installed
 
 ### Build
 
@@ -45,10 +45,6 @@ You still have to set up a config file in any case as the rpc users can't and **
 
 You can now also decide which index you want to run. This setting can be set in the config file (blindbit.toml).
 
-## Known Errors
-
-No known issues.
-
 ## Todos
 
 - [ ] Add flags to control setup
@@ -88,6 +84,7 @@ No known issues.
 ```text
 GET("/info")  // returns basic information about the oracle instance
 GET("/block-height")  // returns the height of the indexing server
+GET("/block-hash/:blockheight")  // returns the block-hash for a certain block-height
 GET("/tweaks/:blockheight?dustLimit=<sat_amount>")  // returns tweak data (cut-through); optional parameter dustLimit can be omitted; filtering happens per request, so virtually any amount can be specified
 GET("/tweak-index/:blockheight?dustLimit=<sat_amount>")  // returns the full tweak index (no cut-through); optional parameter dustLimit can be omitted; filtering happens per request, so virtually any amount can be specified
 GET("/spent-index/:blockheight")  // returns the spent outpoints index (see https://github.com/setavenger/BIP0352-light-client-specification?tab=readme-ov-file#spent-utxos)

README.md

@@ -1,3 +1,6 @@
+# possible values: trace, debug, info, warn, error
+log_level = "debug"
+
 # 0.0.0.0:8000 to expose outside of localhost
 # default: "127.0.0.1:8000"
 host = "127.0.0.1:8000"

blindbit.example.toml

@@ -0,0 +1,71 @@
+# Oracle Benchmark Tool
+
+This tool benchmarks the performance difference between v1 (HTTP) and v2 (gRPC streaming) APIs for fetching block data.
+
+## Building
+
+```bash
+make build-benchmark
+```
+
+## Usage
+
+### Run both benchmarks
+```bash
+./bin/benchmark -startheight=100 -endheight=200
+```
+
+### Run only v1 HTTP benchmark
+```bash
+./bin/benchmark -v1 -v2=false -startheight=100 -endheight=200
+```
+
+### Run only v2 gRPC benchmark
+```bash
+./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
+make benchmark ARGS="-startheight=100 -endheight=200"
+
+# Run only v1
+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
+
+- `-startheight`: Start block height (default: 1)
+- `-endheight`: End block height (default: 10)
+- `-http`: HTTP API base URL (default: "http://127.0.0.1:8000")
+- `-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
+
+The benchmark fetches block data (tweaks, filters) for each block height in the range and measures:
+
+- Total time to fetch all blocks
+- Blocks processed per second
+- Individual block fetch times
+
+## Expected Results
+
+- **v1 (HTTP)**: Makes individual HTTP requests for each block, good for small ranges
+- **v2 (gRPC)**: Uses streaming to fetch all blocks in one connection, better for large ranges
+
+The gRPC streaming approach should show better performance for larger block ranges due to reduced connection overhead and better batching.

cmd/benchmark/README.md

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"flag"
+
+	"github.com/rs/zerolog"
+	"github.com/setavenger/blindbit-lib/logging"
+	"github.com/setavenger/blindbit-oracle/internal/benchmark"
+)
+
+func main() {
+	var (
+		startHeight = flag.Uint64("startheight", 1, "Start block height")
+		endHeight   = flag.Uint64("endheight", 10, "End block height")
+		httpURL     = flag.String("http", "http://127.0.0.1:8000", "HTTP API base URL")
+		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).
+		Msg("Starting benchmark")
+
+	if *runV1 {
+		logging.L.Info().Msg("=== Running V1 HTTP Benchmark ===")
+		benchmark.BenchmarkV1(*startHeight, *endHeight, *httpURL)
+	}
+
+	if *runV2 {
+		logging.L.Info().Msg("=== Running V2 gRPC Streaming Benchmark ===")
+		benchmark.BenchmarkV2(*startHeight, *endHeight, *grpcHost)
+	}
+
+	logging.L.Info().Msg("Benchmark completed")
+}