wallet: route manager master fingerprint read through Store

resolveMasterFingerprint read the master HD public key with a direct
walletdb.View against the address manager during wallet load. The master
public key is public wallet metadata, so route it through Store.GetWallet
instead, removing the last direct walletdb transaction for public-metadata
reads from wallet/manager.go.

To serve the read, add MasterHDPubKey to the waddrmgr.AddrStore interface
(already implemented on *waddrmgr.Manager) and have kvdb's GetWallet fill
WalletInfo.MasterPubKey from it, tolerating ErrNoExist for shell, watch-only,
and pre-master-key wallets. The MasterHDPubKey read is extracted into a small
readMasterPubKey helper to keep GetWallet within the complexity limit.

The DBCreateWallet/DBLoadWallet create/load path is left as-is: kvdb's
Store.CreateWallet is unimplemented and the Store does not return the legacy
waddrmgr.Manager/wtxmgr.Store the runtime needs, so that remains justified
runtime-construction scope. Passphrase, private-key, and signer flows are
unchanged (deferred to ADR 0010).

TestManagerLoadSuccess now asserts the loaded wallet's cached master
fingerprint is non-zero and matches the create-time value, locking in the
Store-routed read.

Author: yyforyongyu

bwtest/mock/addr_store.go

@@ -189,6 +189,17 @@ func (m *AddrStore) BirthdayBlock(
 	return args.Get(0).(waddrmgr.BlockStamp), args.Bool(1), args.Error(2)
 }
 
+// MasterHDPubKey returns the plaintext master HD public key bytes persisted
+// for the wallet.
+func (m *AddrStore) MasterHDPubKey(ns walletdb.ReadBucket) ([]byte, error) {
+	args := m.Called(ns)
+	if raw, ok := args.Get(0).([]byte); ok {
+		return raw, args.Error(1)
+	}
+
+	return nil, args.Error(1)
+}
+
 // IsWatchOnlyAccount determines if the account with the given key scope
 // is set up as watch-only.
 func (m *AddrStore) IsWatchOnlyAccount(ns walletdb.ReadBucket,

waddrmgr/interface.go

@@ -151,6 +151,11 @@ type AddrStore interface {
 	// BirthdayBlock returns the birthday block of the address store.
 	BirthdayBlock(ns walletdb.ReadBucket) (BlockStamp, bool, error)
 
+	// MasterHDPubKey returns the plaintext master HD public key bytes
+	// persisted for the wallet, or ErrNoExist when none is persisted (shell,
+	// watch-only, or pre-master-key wallets).
+	MasterHDPubKey(ns walletdb.ReadBucket) ([]byte, error)
+
 	// IsWatchOnlyAccount determines if the account with the given key scope
 	// is set up as watch-only.
 	IsWatchOnlyAccount(ns walletdb.ReadBucket, keyScope KeyScope,

wallet/db_ops_test.go

@@ -11,6 +11,7 @@ import (
 	bwmock "github.com/btcsuite/btcwallet/bwtest/mock"
 	"github.com/btcsuite/btcwallet/waddrmgr"
 	walletmock "github.com/btcsuite/btcwallet/wallet/internal/bwtest/mock"
+	"github.com/btcsuite/btcwallet/wallet/internal/db"
 	"github.com/btcsuite/btcwallet/walletdb"
 	_ "github.com/btcsuite/btcwallet/walletdb/bdb"
 	"github.com/btcsuite/btcwallet/wtxmgr"
@@ -531,66 +532,40 @@ func TestDBGetScanData(t *testing.T) {
 	require.Empty(t, initialUnspent)
 }
 
-// TestLoadWalletScanDataKeepsImportedXpubHorizons verifies that full-scan setup
-// builds its horizon targets from the legacy address manager's active accounts.
-// Imported xpub accounts have real waddrmgr account numbers that must remain in
-// the lookahead set even though SQL account metadata may not expose a BIP44
-// account number for them.
+// TestLoadWalletScanDataKeepsImportedXpubHorizons verifies full-scan setup
+// preserves imported xpub recovery horizons under their non-masked waddrmgr
+// account number while still skipping the keyless imported-address bucket.
 func TestLoadWalletScanDataKeepsImportedXpubHorizons(t *testing.T) {
 	t.Parallel()
 
-	w, mocks := createTestWalletWithMocks(t)
-	s := newSyncer(w.cfg, w.addrStore, w.txStore, nil, &walletmock.Store{}, 0)
-
-	const importedAccount = uint32(9)
-
+	s, mgr := newStoreScanSyncer(t)
 	scope := waddrmgr.KeyScopeBIP0084
-	props := &waddrmgr.AccountProperties{
-		AccountNumber:    importedAccount,
-		AccountName:      "imported-xpub",
-		ExternalKeyCount: 5,
-		InternalKeyCount: 2,
-		KeyScope:         scope,
-		IsWatchOnly:      true,
-	}
-
-	scopedMgr := &bwmock.AccountStore{}
-	mocks.addrStore.On("ActiveScopedKeyManagers").Return(
-		[]waddrmgr.AccountStore{scopedMgr},
-	).Once()
-
-	scopedMgr.On("ActiveAccounts").Return([]uint32{importedAccount}).Once()
-	scopedMgr.On("Scope").Return(scope).Once()
-
-	mocks.addrStore.On("FetchScopedKeyManager", scope).Return(
-		scopedMgr, nil,
-	).Once()
-
-	scopedMgr.On("AccountProperties", mock.Anything, importedAccount).Return(
-		props, nil,
-	).Once()
-
-	mocks.addrStore.On("ForEachRelevantActiveAddress", mock.Anything,
-		mock.Anything,
-	).Return(nil).Once()
-
-	mocks.txStore.On("OutputsToWatch", mock.Anything).Return(
-		[]wtxmgr.Credit(nil), nil,
-	).Once()
+	importedNumber := createImportedXpubAccount(
+		t, s, mgr, scope, "imported-xpub",
+	)
 
 	horizonData, initialAddrs, initialUnspent, err := s.loadWalletScanData(
 		t.Context(),
 	)
 
 	require.NoError(t, err)
-	require.Len(t, horizonData, 1)
-	require.Equal(t, props, horizonData[0])
-	require.Equal(t, importedAccount, horizonData[0].AccountNumber)
+
+	var importedProps *waddrmgr.AccountProperties
+	for _, props := range horizonData {
+		require.NotEqual(t, db.DefaultImportedAccountName,
+			props.AccountName)
+
+		if props.AccountName == "imported-xpub" {
+			importedProps = props
+		}
+	}
+
+	require.NotNil(t, importedProps)
+	require.Equal(t, importedNumber, importedProps.AccountNumber)
+	require.Equal(t, scope, importedProps.KeyScope)
+	require.True(t, importedProps.IsWatchOnly)
 	require.Empty(t, initialAddrs)
 	require.Empty(t, initialUnspent)
-
-	mocks.addrStore.AssertExpectations(t)
-	scopedMgr.AssertExpectations(t)
 }
 
 // TestDBGetSyncedBlocks verifies that the wallet can successfully retrieve a

wallet/internal/db/kvdb/walletstore.go

@@ -39,6 +39,25 @@ func (s *Store) CreateWallet(ctx context.Context,
 	return nil, notImplemented(ctx, "CreateWallet")
 }
 
+// readMasterPubKey returns the plaintext master HD public key persisted for
+// the wallet, or nil for shell, watch-only, and pre-master-key wallets, which
+// persist none and surface ErrNoExist.
+func readMasterPubKey(addrStore waddrmgr.AddrStore,
+	ns walletdb.ReadBucket) ([]byte, error) {
+
+	pubKey, err := addrStore.MasterHDPubKey(ns)
+	switch {
+	case err == nil:
+		return pubKey, nil
+
+	case waddrmgr.IsError(err, waddrmgr.ErrNoExist):
+		return nil, nil
+
+	default:
+		return nil, fmt.Errorf("get master HD pubkey: %w", err)
+	}
+}
+
 // GetWallet reads wallet runtime metadata from the legacy address manager.
 //
 // NOTE: kvdb is a single-wallet legacy backend. The supplied name is not
@@ -55,14 +74,24 @@ func (s *Store) GetWallet(_ context.Context,
 
 	addrStore := s.addrStore
 
-	var birthdayBlock *db.Block
+	var (
+		birthdayBlock *db.Block
+		masterPubKey  []byte
+	)
 
 	err := walletdb.View(s.db, func(tx walletdb.ReadTx) error {
 		ns := tx.ReadBucket(waddrmgr.NamespaceKey)
 		if ns == nil {
 			return errMissingAddrmgrNamespace
 		}
 
+		var err error
+
+		masterPubKey, err = readMasterPubKey(addrStore, ns)
+		if err != nil {
+			return err
+		}
+
 		block, verified, err := addrStore.BirthdayBlock(ns)
 		if err != nil {
 			if waddrmgr.IsError(err, waddrmgr.ErrBirthdayBlockNotSet) {
@@ -96,6 +125,7 @@ func (s *Store) GetWallet(_ context.Context,
 		BirthdayBlock: birthdayBlock,
 		SyncedTo:      syncedTo,
 		IsWatchOnly:   addrStore.WatchOnly(),
+		MasterPubKey:  masterPubKey,
 	}, nil
 }
 

wallet/manager.go

@@ -10,9 +10,9 @@ import (
 
 	"github.com/btcsuite/btcd/btcutil/v2/hdkeychain"
 	"github.com/btcsuite/btcwallet/waddrmgr"
+	"github.com/btcsuite/btcwallet/wallet/internal/db"
 	kvdb "github.com/btcsuite/btcwallet/wallet/internal/db/kvdb"
 	"github.com/btcsuite/btcwallet/wallet/internal/keyvault"
-	"github.com/btcsuite/btcwallet/walletdb"
 )
 
 var (
@@ -323,18 +323,22 @@ func (m *Manager) Load(cfg Config) (*Wallet, error) {
 		<-lockTimer.C
 	}
 
+	store := kvdb.NewStore(cfg.DB, txMgr, addrMgr)
+
 	// Cache the wallet's master HD fingerprint up-front, before any
 	// context/cancel is set up so an error here doesn't leak a
-	// cancellable context.
-	masterFingerprint, err := resolveMasterFingerprint(cfg.DB, addrMgr)
+	// cancellable context. The master public key is public wallet metadata,
+	// so it is read through the Store rather than a direct database
+	// transaction.
+	masterFingerprint, err := resolveMasterFingerprint(
+		context.Background(), store, cfg.Name,
+	)
 	if err != nil {
 		return nil, fmt.Errorf("cache master fingerprint: %w", err)
 	}
 
 	lifetimeCtx, cancel := context.WithCancel(context.Background())
 
-	store := kvdb.NewStore(cfg.DB, txMgr, addrMgr)
-
 	w := &Wallet{
 		cfg:               cfg,
 		id:                walletID,
@@ -364,72 +368,35 @@ func (m *Manager) Load(cfg Config) (*Wallet, error) {
 	return w, nil
 }
 
-// errMissingWaddrmgrNamespace is returned when the waddrmgr namespace
-// bucket is missing from the wallet database. DBLoadWallet would have
-// already failed if this were a real wallet, so encountering it here
-// indicates a wiring bug.
-var errMissingWaddrmgrNamespace = errors.New(
-	"missing waddrmgr namespace",
-)
-
-// resolveMasterFingerprint reads the persisted master HD pubkey via
-// addrMgr, parses it, and returns its BIP32 fingerprint. Shell,
-// watch-only, and pre-master-key wallets have no pubkey persisted —
+// resolveMasterFingerprint reads the wallet's persisted master HD public key
+// through the Store, parses it, and returns its BIP32 fingerprint. Shell,
+// watch-only, and pre-master-key wallets have no pubkey persisted, so the
 // fingerprint is zero.
-func resolveMasterFingerprint(db walletdb.DB,
-	addrMgr *waddrmgr.Manager) (uint32, error) {
-
-	var fingerprint uint32
-
-	err := walletdb.View(db, func(tx walletdb.ReadTx) error {
-		ns := tx.ReadBucket(waddrmgr.NamespaceKey)
-		if ns == nil {
-			return errMissingWaddrmgrNamespace
-		}
-
-		masterHDPubKey, err := addrMgr.MasterHDPubKey(ns)
-		switch {
-		case err == nil:
-			// Continue to parse below.
-
-		case waddrmgr.IsError(err, waddrmgr.ErrNoExist):
-			// Shell / watch-only / pre-master-key wallets:
-			// no pubkey persisted. Leave fingerprint at zero
-			// and continue.
-			return nil
-
-		default:
-			return fmt.Errorf("read master HD pubkey: %w", err)
-		}
+func resolveMasterFingerprint(ctx context.Context, store db.Store,
+	name string) (uint32, error) {
 
-		if len(masterHDPubKey) == 0 {
-			// Defensive: persisted-but-empty is treated the
-			// same as the ErrNoExist case above.
-			return nil
-		}
-
-		extKey, err := hdkeychain.NewKeyFromString(
-			string(masterHDPubKey),
-		)
-		if err != nil {
-			return fmt.Errorf("parse master HD pubkey: %w",
-				err)
-		}
+	info, err := store.GetWallet(ctx, name)
+	if err != nil {
+		return 0, fmt.Errorf("get wallet: %w", err)
+	}
 
-		mfp, err := masterKeyFingerprint(extKey)
-		if err != nil {
-			return fmt.Errorf("master fingerprint: %w", err)
-		}
+	// Shell / watch-only / pre-master-key wallets persist no master HD
+	// public key, so the fingerprint stays zero.
+	if len(info.MasterPubKey) == 0 {
+		return 0, nil
+	}
 
-		fingerprint = mfp
+	extKey, err := hdkeychain.NewKeyFromString(string(info.MasterPubKey))
+	if err != nil {
+		return 0, fmt.Errorf("parse master HD pubkey: %w", err)
+	}
 
-		return nil
-	})
+	mfp, err := masterKeyFingerprint(extKey)
 	if err != nil {
-		return 0, fmt.Errorf("read master fingerprint: %w", err)
+		return 0, fmt.Errorf("master fingerprint: %w", err)
 	}
 
-	return fingerprint, nil
+	return mfp, nil
 }
 
 // prepareWalletCreation validates the configuration and parameters, and derives

wallet/manager_test.go

@@ -398,6 +398,12 @@ func TestManagerLoadSuccess(t *testing.T) {
 	require.True(t, ok)
 	require.Same(t, w, loadedW)
 	require.Zero(t, w.ID())
+
+	// The master HD fingerprint is read through the Store during load. A
+	// ModeGenSeed wallet persists a master HD public key, so the cached
+	// fingerprint is non-zero and matches the value resolved at create time.
+	require.NotZero(t, w.masterFingerprint)
+	require.Equal(t, wCreated.masterFingerprint, w.masterFingerprint)
 }
 
 // TestManagerLoad_ExistingWallet verifies that if Load is called for a wallet