db: populate AddressInfo.HasDerivationPath

Set HasDerivationPath on the shared and kvdb address-info paths so
HD-derived addresses (derived accounts and imported-xpub watch-only
children) are distinguished from raw single imports, and accept
imported-xpub HD rows in convertAddressPath instead of rejecting them.

Author: yyforyongyu

wallet/internal/db/addresses_common.go

@@ -459,23 +459,41 @@ func convertAddressMetadata[TypeID, OriginIDType any](
 }
 
 // convertAddressPath converts BIP44 branch/index values into uint32 fields.
-// Imported addresses must have both branch/index unset and return zero values.
-// Derived addresses must have both fields set and convertible to uint32.
+//
+// The both-or-neither invariant holds for every origin: a row must carry both
+// branch and index or neither, and exactly one set is a corrupt path. Beyond
+// that, the meaning of an unset path depends on the origin:
+//
+//   - A derived account is always HD, so both fields must be set.
+//   - An imported account spans two shapes. A raw/bucket import (a single
+//     pubkey or script with no chain position) carries neither field and maps
+//     to zero values. An imported-xpub (watch-only xpub) account is HD: the
+//     scan-batch horizon extension derives child addresses from its account
+//     xpub and persists them with a real branch/index, which the schema
+//     permits (only the both-or-neither and range constraints apply). Those
+//     rows must read back with their derivation path, not be rejected, so they
+//     surface through IterAddresses/ListAddresses like any HD address.
 func convertAddressPath(origin AccountOrigin, branch,
 	index sql.NullInt64) (uint32, uint32, error) {
 
-	if origin == ImportedAccount {
-		if branch.Valid || index.Valid {
-			return 0, 0, errInvalidDerivationPath
-		}
-
-		return 0, 0, nil
+	// Reject a half-populated path for every origin; the remaining branches
+	// only have to distinguish "both unset" from "both set".
+	if branch.Valid != index.Valid {
+		return 0, 0, errInvalidDerivationPath
 	}
 
-	if !branch.Valid || !index.Valid {
+	// A raw/bucket imported address carries no chain position and reads back
+	// as zero values; a derived account must always have a path set.
+	if !branch.Valid {
+		if origin == ImportedAccount {
+			return 0, 0, nil
+		}
+
 		return 0, 0, errInvalidDerivationPath
 	}
 
+	// Both fields are set: a derived address or an imported-xpub HD address,
+	// converted the same way.
 	addrBranch, err := Int64ToUint32(branch.Int64)
 	if err != nil {
 		return 0, 0, fmt.Errorf("address branch: %w", err)
@@ -520,6 +538,11 @@ func AddressRowToInfo[TypeID, OriginIDType any](
 		return nil, err
 	}
 
+	// A row carries an HD path iff both nullable path columns are present.
+	// convertAddressPath has already rejected a half-populated path, so the
+	// two Valid flags agree here; checking both keeps the intent explicit.
+	hasDerivationPath := row.AddressBranch.Valid && row.AddressIndex.Valid
+
 	return &AddressInfo{
 		ID:                   id,
 		AccountID:            accountID,
@@ -532,6 +555,7 @@ func AddressRowToInfo[TypeID, OriginIDType any](
 		Origin:               origin,
 		Branch:               addrBranch,
 		Index:                addrIndex,
+		HasDerivationPath:    hasDerivationPath,
 		ScriptPubKey:         row.ScriptPubKey,
 		PubKey:               row.PubKey,
 		HasScript:            row.HasScript,
@@ -761,16 +785,17 @@ func createDerivedAddress[T any](ctx context.Context,
 	}
 
 	return &AddressInfo{
-		ID:           id,
-		AccountID:    convertedAcctID,
-		AddrType:     addrType,
-		CreatedAt:    rowCreatedAt(row),
-		Origin:       DerivedAccount,
-		Branch:       branch,
-		Index:        index,
-		ScriptPubKey: scriptPubKey,
-		PubKey:       pubKey,
-		IsWatchOnly:  walletIsWatchOnly,
+		ID:                id,
+		AccountID:         convertedAcctID,
+		AddrType:          addrType,
+		CreatedAt:         rowCreatedAt(row),
+		Origin:            DerivedAccount,
+		Branch:            branch,
+		Index:             index,
+		HasDerivationPath: true,
+		ScriptPubKey:      scriptPubKey,
+		PubKey:            pubKey,
+		IsWatchOnly:       walletIsWatchOnly,
 	}, nil
 }
 

wallet/internal/db/kvdb/addressstore.go

@@ -851,23 +851,29 @@ func managedAddressInfo(ns walletdb.ReadBucket,
 	}
 
 	var (
-		branch      uint32
-		index       uint32
-		fingerprint uint32
-		pubKey      []byte
+		branch            uint32
+		index             uint32
+		fingerprint       uint32
+		pubKey            []byte
+		hasDerivationPath bool
 	)
 
 	pubKeyAddr, ok := managedAddr.(waddrmgr.ManagedPubKeyAddress)
 	if ok {
 		pubKey = managedAddressPubKey(pubKeyAddr)
 
+		// DerivationInfo reports ok only for HD-derived addresses (both
+		// normal derived accounts and imported-xpub watch-only children);
+		// raw single imports return false because their key has no known
+		// chain position. That is exactly the HasDerivationPath signal.
 		scope, path, ok := pubKeyAddr.DerivationInfo()
 		if ok {
 			accountNumber = path.InternalAccount
 			branch = path.Branch
 			index = path.Index
 			fingerprint = path.MasterKeyFingerprint
 			keyScope = db.KeyScope(scope)
+			hasDerivationPath = true
 		}
 	}
 
@@ -888,6 +894,7 @@ func managedAddressInfo(ns walletdb.ReadBucket,
 		Origin:               origin,
 		Branch:               branch,
 		Index:                index,
+		HasDerivationPath:    hasDerivationPath,
 		ScriptPubKey:         scriptPubKey,
 		PubKey:               pubKey,
 		HasScript:            addrType.HasScript,