feat: Add addPeers setting to neutrino server

Author: m0wer

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `addPeers` setting, similar to `connectPeers`, that allows specifying peers to connect to without disabling peer discovery.
+
 ## [0.7.0] - 2026-03-11
 
 ### Added

neutrino_server/cmd/neutrinod/main.go

@@ -33,6 +33,7 @@ func main() {
 	dataDir := flag.String("datadir", getEnv("DATA_DIR", "/data/neutrino"), "Data directory for headers and filters")
 	logLevel := flag.String("loglevel", getEnv("LOG_LEVEL", "info"), "Log level (trace, debug, info, warn, error)")
 	connectPeers := flag.String("connect", getEnv("CONNECT_PEERS", ""), "Comma-separated list of peers to connect to")
+	addPeers := flag.String("addpeer", getEnv("ADD_PEERS", ""), "Comma-separated list of peers to add while still allowing discovery")
 	torProxy := flag.String("torproxy", getEnv("TOR_PROXY", ""), "Tor SOCKS5 proxy address (e.g., 127.0.0.1:9050)")
 	showVersion := flag.Bool("version", false, "Show version and exit")
 	flag.Parse()
@@ -68,6 +69,7 @@ func main() {
 		DataDir:      *dataDir,
 		TorProxy:     *torProxy,
 		ConnectPeers: *connectPeers,
+		AddPeers:     *addPeers,
 		MaxPeers:     8,
 		Logger:       backend,
 		LogLevel:     *logLevel,

neutrino_server/internal/api/handler.go

@@ -30,6 +30,7 @@ type NodeInterface interface {
 	WatchAddress(address string) error
 	Rescan(startHeight int32, addresses []string) error
 	IsRescanInProgress() bool
+	RescanStatus() neutrino.RescanStatus
 }
 
 // Handler provides REST API endpoints for the neutrino node.
@@ -329,9 +330,14 @@ func (h *Handler) handleRescan(w http.ResponseWriter, r *http.Request) {
 
 // Rescan status endpoint
 func (h *Handler) handleGetRescanStatus(w http.ResponseWriter, r *http.Request) {
-	inProgress := h.node.IsRescanInProgress()
-	h.jsonResponse(w, map[string]bool{
-		"in_progress": inProgress,
+	status := h.node.RescanStatus()
+	h.jsonResponse(w, map[string]any{
+		"in_progress":       status.InProgress,
+		"last_started":      status.LastStarted,
+		"last_finished":     status.LastFinished,
+		"last_start_height": status.LastStartHeight,
+		"last_scanned_tip":  status.LastScannedTip,
+		"last_error":        status.LastError,
 	})
 }
 

neutrino_server/internal/api/handler_test.go

@@ -74,6 +74,10 @@ func (m *mockNode) IsRescanInProgress() bool {
 	return false
 }
 
+func (m *mockNode) RescanStatus() neutrino.RescanStatus {
+	return neutrino.RescanStatus{}
+}
+
 func TestHandleGetStatus(t *testing.T) {
 	backend := btclog.NewBackend(os.Stdout)
 	logger := backend.Logger("TEST")
@@ -554,12 +558,30 @@ func TestHandleGetRescanStatus_NotInProgress(t *testing.T) {
 		t.Errorf("handler returned wrong status code: got %v want %v", status, http.StatusOK)
 	}
 
-	var response map[string]bool
+	var response map[string]any
 	if err := json.Unmarshal(rr.Body.Bytes(), &response); err != nil {
 		t.Fatalf("could not decode response: %v", err)
 	}
 
-	if response["in_progress"] {
+	inProgress, ok := response["in_progress"].(bool)
+	if !ok {
+		t.Fatalf("expected boolean in_progress, got %T", response["in_progress"])
+	}
+
+	if inProgress {
 		t.Error("expected in_progress=false")
 	}
+
+	if _, ok := response["last_started"]; !ok {
+		t.Error("expected last_started in response")
+	}
+	if _, ok := response["last_finished"]; !ok {
+		t.Error("expected last_finished in response")
+	}
+	if _, ok := response["last_start_height"]; !ok {
+		t.Error("expected last_start_height in response")
+	}
+	if _, ok := response["last_scanned_tip"]; !ok {
+		t.Error("expected last_scanned_tip in response")
+	}
 }

neutrino_server/internal/neutrino/node.go

@@ -35,6 +35,7 @@ type Config struct {
 	DataDir         string
 	TorProxy        string
 	ConnectPeers    string
+	AddPeers        string
 	MaxPeers        int
 	BanDuration     time.Duration
 	FilterCacheSize int
@@ -152,6 +153,19 @@ func (n *Node) Start() error {
 		FilterCacheSize: uint64(n.config.FilterCacheSize),
 	}
 
+	// Add peers if specified
+	if n.config.AddPeers != "" {
+		peers := strings.Split(n.config.AddPeers, ",")
+		for _, peer := range peers {
+			peer = strings.TrimSpace(peer)
+			if peer != "" {
+				n.logger.Infof("Adding preferred peer: %s", peer)
+				neutrinoConfig.AddPeers = append(neutrinoConfig.AddPeers, peer)
+			}
+		}
+		n.logger.Infof("Total add peers configured: %d", len(neutrinoConfig.AddPeers))
+	}
+
 	// Add peers if specified
 	if n.config.ConnectPeers != "" {
 		peers := strings.Split(n.config.ConnectPeers, ",")
@@ -168,7 +182,11 @@ func (n *Node) Start() error {
 	// Add DNS seeds if no connect peers specified
 	if len(neutrinoConfig.ConnectPeers) == 0 {
 		seeds := getDNSSeeds(n.config.Network)
-		neutrinoConfig.AddPeers = seeds
+		if len(neutrinoConfig.AddPeers) > 0 {
+			neutrinoConfig.AddPeers = append(neutrinoConfig.AddPeers, seeds...)
+		} else {
+			neutrinoConfig.AddPeers = seeds
+		}
 		n.logger.Infof("No connect peers specified, using %d DNS seeds", len(seeds))
 	}
 
@@ -376,6 +394,14 @@ func (n *Node) IsRescanInProgress() bool {
 	return n.rescanMgr.IsRescanInProgress()
 }
 
+// RescanStatus returns detailed rescan lifecycle status.
+func (n *Node) RescanStatus() RescanStatus {
+	if n.rescanMgr == nil {
+		return RescanStatus{}
+	}
+	return n.rescanMgr.GetRescanStatus()
+}
+
 // UTXOSpendReport represents information about a UTXO.
 type UTXOSpendReport struct {
 	// If the output is unspent, these fields are populated

neutrino_server/internal/neutrino/rescan.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"sync"
 	"sync/atomic"
+	"time"
 
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/btcutil/gcs/builder"
@@ -32,6 +33,19 @@ type RescanManager struct {
 	// rescanInProgress tracks the number of active rescans (atomic).
 	// Non-zero means a rescan goroutine is running.
 	rescanInProgress atomic.Int32
+
+	statusMu sync.RWMutex
+	status   RescanStatus
+}
+
+// RescanStatus exposes rescan lifecycle details for API consumers.
+type RescanStatus struct {
+	InProgress      bool   `json:"in_progress"`
+	LastStarted     int64  `json:"last_started"`
+	LastFinished    int64  `json:"last_finished"`
+	LastStartHeight int32  `json:"last_start_height"`
+	LastScannedTip  int32  `json:"last_scanned_tip"`
+	LastError       string `json:"last_error,omitempty"`
 }
 
 // NewRescanManager creates a new rescan manager.
@@ -104,6 +118,16 @@ func (r *RescanManager) IsRescanInProgress() bool {
 	return r.rescanInProgress.Load() > 0
 }
 
+// GetRescanStatus returns the current detailed rescan status.
+func (r *RescanManager) GetRescanStatus() RescanStatus {
+	r.statusMu.RLock()
+	defer r.statusMu.RUnlock()
+
+	status := r.status
+	status.InProgress = r.IsRescanInProgress()
+	return status
+}
+
 // Rescan triggers a rescan from the given height for specified addresses.
 // This uses neutrino's block filter-based scanning.
 func (r *RescanManager) Rescan(startHeight int32, addresses []string) error {
@@ -129,6 +153,11 @@ func (r *RescanManager) Rescan(startHeight int32, addresses []string) error {
 	}
 
 	r.logger.Infof("Starting rescan from height %d for %d addresses", startHeight, len(addrs))
+	r.statusMu.Lock()
+	r.status.LastStarted = time.Now().Unix()
+	r.status.LastStartHeight = startHeight
+	r.status.LastError = ""
+	r.statusMu.Unlock()
 
 	// Mark rescan as in-progress so callers can poll /v1/rescan/status.
 	r.rescanInProgress.Add(1)
@@ -141,7 +170,15 @@ func (r *RescanManager) Rescan(startHeight int32, addresses []string) error {
 	}
 
 	// Scan blocks from startHeight to bestBlock.Height
-	return r.scanBlocks(startHeight, bestBlock.Height, addrs)
+	err = r.scanBlocks(startHeight, bestBlock.Height, addrs)
+	r.statusMu.Lock()
+	r.status.LastFinished = time.Now().Unix()
+	r.status.LastScannedTip = bestBlock.Height
+	if err != nil {
+		r.status.LastError = err.Error()
+	}
+	r.statusMu.Unlock()
+	return err
 }
 
 // scanBlocks scans blocks in the given range for transactions matching the addresses.

neutrino_server/internal/neutrino/rescan_test.go

@@ -266,3 +266,26 @@ func TestRescanNilChainService(t *testing.T) {
 		t.Errorf("expected 'chain service not initialized', got '%s'", err.Error())
 	}
 }
+
+func TestGetRescanStatusDefaults(t *testing.T) {
+	backend := btclog.NewBackend(nil)
+	logger := backend.Logger("TEST")
+
+	mgr := &RescanManager{
+		chainParams:  &chaincfg.MainNetParams,
+		logger:       logger,
+		watchedAddrs: make(map[string]btcutil.Address),
+		utxoSet:      make(map[string]UTXO),
+	}
+
+	status := mgr.GetRescanStatus()
+	if status.InProgress {
+		t.Error("expected InProgress=false")
+	}
+	if status.LastStarted != 0 {
+		t.Errorf("expected LastStarted=0, got %d", status.LastStarted)
+	}
+	if status.LastFinished != 0 {
+		t.Errorf("expected LastFinished=0, got %d", status.LastFinished)
+	}
+}