diff --git a/loopd/swapclient_server.go b/loopd/swapclient_server.go
index 497fe3a8..7b7e2467 100644
--- a/loopd/swapclient_server.go
+++ b/loopd/swapclient_server.go
@@ -1883,7 +1883,7 @@ func (s *swapClientServer) ListUnspentDeposits(ctx context.Context,
 
 	// List all unspent utxos the wallet sees, regardless of the number of
 	// confirmations.
-	staticAddress, utxos, err := s.staticAddressManager.ListUnspentRaw(
+	utxos, err := s.staticAddressManager.ListUnspentRaw(
 		ctx, req.MinConfs, req.MaxConfs,
 	)
 	if err != nil {
@@ -1934,6 +1934,20 @@ func (s *swapClientServer) ListUnspentDeposits(ctx context.Context,
 			continue
 		}
 
+		params := s.staticAddressManager.GetParameters(u.PkScript)
+		if params == nil {
+			return nil, fmt.Errorf("missing static address "+
+				"parameters for %v", u.OutPoint)
+		}
+
+		staticAddress, err := s.staticAddressManager.GetTaprootAddress(
+			params.ClientPubkey, params.ServerPubkey,
+			int64(params.Expiry),
+		)
+		if err != nil {
+			return nil, err
+		}
+
 		utxo := &looprpc.Utxo{
 			StaticAddress: staticAddress.String(),
 			AmountSat:     int64(u.Value),
diff --git a/loopd/swapclient_server_staticaddr_test.go b/loopd/swapclient_server_staticaddr_test.go
index bb4cc01c..9478109b 100644
--- a/loopd/swapclient_server_staticaddr_test.go
+++ b/loopd/swapclient_server_staticaddr_test.go
@@ -62,12 +62,44 @@ func (s *staticAddrDepositStore) AllDeposits(context.Context) (
 	return s.allDeposits, nil
 }
 
-type staticAddrTestAddressManager struct{}
+type staticAddrTestAddressManager struct {
+	params *address.Parameters
+}
+
+func newStaticAddrTestAddressManager() *staticAddrTestAddressManager {
+	_, client := mock_lnd.CreateKey(1)
+	_, server := mock_lnd.CreateKey(2)
+
+	return &staticAddrTestAddressManager{
+		params: &address.Parameters{
+			ID:           1,
+			ClientPubkey: client,
+			ServerPubkey: server,
+			Expiry:       10,
+			PkScript:     []byte("pkscript"),
+		},
+	}
+}
 
 func (s *staticAddrTestAddressManager) GetStaticAddressParameters(
 	context.Context) (*script.Parameters, error) {
 
-	return nil, nil
+	return s.params, nil
+}
+
+func (s *staticAddrTestAddressManager) GetStaticAddressID(
+	context.Context, []byte) (int32, error) {
+
+	return s.params.ID, nil
+}
+
+func (s *staticAddrTestAddressManager) GetParameters(
+	pkScript []byte) *address.Parameters {
+
+	params := *s.params
+	params.PkScript = pkScript
+
+	return &params
 }
 
 func (s *staticAddrTestAddressManager) GetStaticAddress(
@@ -99,7 +131,7 @@ func newTestDepositManager(
 	}
 
 	return deposit.NewManager(&deposit.ManagerConfig{
-		AddressManager: &staticAddrTestAddressManager{},
+		AddressManager: newStaticAddrTestAddressManager(),
 		Store: &staticAddrDepositStore{
 			allDeposits: deposits,
 			byOutpoint:  byOutpoint,
diff --git a/loopd/swapclient_server_test.go b/loopd/swapclient_server_test.go
index 1171389c..725340cf 100644
--- a/loopd/swapclient_server_test.go
+++ b/loopd/swapclient_server_test.go
@@ -1,7 +1,9 @@
 package loopd
 
 import (
+	"bytes"
 	"context"
+	"database/sql"
 	"fmt"
 	"os"
 	"testing"
@@ -1883,10 +1885,25 @@ type mockAddressStore struct {
 func (s *mockAddressStore) CreateStaticAddress(_ context.Context,
 	p *script.Parameters) error {
 
+	if p.ID == 0 {
+		p.ID = int32(len(s.params) + 1)
+	}
 	s.params = append(s.params, p)
 	return nil
 }
 
+func (s *mockAddressStore) GetStaticAddressID(_ context.Context,
+	pkScript []byte) (int32, error) {
+
+	for _, p := range s.params {
+		if bytes.Equal(p.PkScript, pkScript) {
+			return p.ID, nil
+		}
+	}
+
+	return 0, sql.ErrNoRows
+}
+
 func (s *mockAddressStore) GetStaticAddress(_ context.Context, _ []byte) (
 	*script.Parameters, error) {
 
@@ -1903,6 +1920,16 @@ func (s *mockAddressStore) GetAllStaticAddresses(_ context.Context) (
 	return s.params, nil
 }
 
+func (s *mockAddressStore) GetLegacyParameters(_ context.Context) (
+	*address.Parameters, error) {
+
+	if len(s.params) == 0 {
+		return nil, sql.ErrNoRows
+	}
+
+	return s.params[0], nil
+}
+
 // mockDepositStore implements deposit.Store minimally for DepositsForOutpoints.
 type mockDepositStore struct {
 	byOutpoint map[string]*deposit.Deposit
@@ -2038,7 +2065,12 @@ func TestListUnspentDeposits(t *testing.T) {
 	// Prepare a single static address parameter set.
 	_, client := mock_lnd.CreateKey(1)
 	_, server := mock_lnd.CreateKey(2)
-	pkScript := []byte("pkscript")
+	staticAddress, err := script.NewStaticAddress(
+		input.MuSig2Version100RC2, 10, client, server,
+	)
+	require.NoError(t, err)
+	pkScript, err := staticAddress.StaticAddressScript()
+	require.NoError(t, err)
 	addrParams := &script.Parameters{
 		ClientPubkey: client,
 		ServerPubkey: server,
@@ -2056,6 +2088,8 @@ func TestListUnspentDeposits(t *testing.T) {
 		// ChainNotifier and AddressClient are not needed for this test.
 	}, 1)
 	require.NoError(t, err)
+	_, err = addrMgr.EnsureStaticAddressSeed(ctx)
+	require.NoError(t, err)
 
 	// Construct several UTXOs with different confirmation counts.
 	makeUtxo := func(idx uint32, confs int64) *lnwallet.Utxo {
diff --git a/staticaddr/address/interface.go b/staticaddr/address/interface.go
index 63b6cf7c..8a9805a6 100644
--- a/staticaddr/address/interface.go
+++ b/staticaddr/address/interface.go
@@ -6,15 +6,26 @@ import (
 	"github.com/lightninglabs/loop/staticaddr/script"
 )
 
+// Parameters aliases the script-level static address parameters for callers
+// that interact with the address manager API.
+type Parameters = script.Parameters
+
 // Store is the database interface that is used to store and retrieve
 // static addresses.
 type Store interface {
 	// CreateStaticAddress inserts a new static address with its parameters
 	// into the store.
-	CreateStaticAddress(ctx context.Context,
-		addrParams *script.Parameters) error
+	CreateStaticAddress(ctx context.Context, addrParams *Parameters) error
+
+	// GetStaticAddressID retrieves the static address row ID for the
+	// address script.
+	GetStaticAddressID(ctx context.Context, pkScript []byte) (int32, error)
 
 	// GetAllStaticAddresses retrieves all static addresses from the store.
-	GetAllStaticAddresses(ctx context.Context) ([]*script.Parameters,
-		error)
+	GetAllStaticAddresses(ctx context.Context) ([]*Parameters, error)
+
+	// GetLegacyParameters retrieves the first static address created for the
+	// L402. This is the immutable legacy/root address that anchors existing
+	// single-address deposits.
+	GetLegacyParameters(ctx context.Context) (*Parameters, error)
 }
diff --git a/staticaddr/address/manager.go b/staticaddr/address/manager.go
index 322eed73..b9c5dc3b 100644
--- a/staticaddr/address/manager.go
+++ b/staticaddr/address/manager.go
@@ -1,9 +1,11 @@
 package address
 
 import (
-	"bytes"
 	"context"
+	"database/sql"
+	"errors"
 	"fmt"
+	"strings"
 	"sync"
 	"sync/atomic"
 
@@ -29,6 +31,12 @@ const (
 	maxStaticAddressCSVExpiry = uint32(200 * 144)
 )
 
+var (
+	// ErrNoStaticAddress is returned when no static address parameters are
+	// present in the store.
+	ErrNoStaticAddress = errors.New("no static address parameters found")
+)
+
 // ManagerConfig holds the configuration for the address manager.
 type ManagerConfig struct {
 	// AddressClient is the client that communicates with the loop server
@@ -62,6 +70,12 @@ type Manager struct {
 	cfg *ManagerConfig
 
 	currentHeight atomic.Int32
+
+	// activeStaticAddresses is the runtime index used to match wallet UTXOs
+	// to locally known static address parameters. The DB remains the
+	// durable source of truth; this map is rebuilt from the DB on startup
+	// and updated after successful address issuance.
+	activeStaticAddresses map[string]*Parameters
 }
 
 // NewManager creates a new address manager.
@@ -72,7 +86,8 @@ func NewManager(cfg *ManagerConfig, currentHeight int32) (*Manager, error) {
 	}
 
 	m := &Manager{
-		cfg: cfg,
+		cfg:                   cfg,
+		activeStaticAddresses: make(map[string]*Parameters),
 	}
 	m.currentHeight.Store(currentHeight)
 
@@ -88,6 +103,11 @@ func (m *Manager) Run(ctx context.Context, initChan chan struct{}) error {
 		return err
 	}
 
+	err = m.loadActiveAddresses(ctx)
+	if err != nil {
+		return err
+	}
+
 	// Communicate to the caller that the address manager has completed its
 	// initialization.
 	close(initChan)
@@ -107,54 +127,125 @@ func (m *Manager) Run(ctx context.Context, initChan chan struct{}) error {
 	}
 }
 
-// NewAddress creates a new static address with the server or returns an
-// existing one.
+// loadActiveAddresses rebuilds the runtime address map from the durable DB
+// state and re-imports all scripts into lnd. Importing is intentionally
+// idempotent so restart paths repair missing wallet watches before deposit
+// discovery starts.
+func (m *Manager) loadActiveAddresses(ctx context.Context) error {
+	params, err := m.cfg.Store.GetAllStaticAddresses(ctx)
+	if err != nil {
+		return err
+	}
+
+	active := make(map[string]*Parameters, len(params))
+	for _, param := range params {
+		staticAddress, err := staticAddressFromParams(param)
+		if err != nil {
+			return err
+		}
+
+		err = m.importAddressTapscript(ctx, staticAddress)
+		if err != nil {
+			return err
+		}
+
+		active[string(param.PkScript)] = param
+	}
+
+	m.Lock()
+	m.activeStaticAddresses = active
+	m.Unlock()
+
+	return nil
+}
+
+// NewAddress creates the next externally visible receive static address.
+//
+// The first call also makes sure the legacy/root static address seed exists,
+// because receive and change addresses are derived from the server pubkey and
+// expiry returned for that seed.
 func (m *Manager) NewAddress(ctx context.Context) (*btcutil.AddressTaproot,
 	int64, error) {
 
-	// If there's already a static address in the database, we can return
-	// it.
+	params, err := m.NewReceiveAddress(ctx)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	address, err := m.GetTaprootAddress(
+		params.ClientPubkey, params.ServerPubkey, int64(params.Expiry),
+	)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return address, int64(params.Expiry), nil
+}
+
+// EnsureStaticAddressSeed loads or creates the legacy/root static address
+// parameters. The root address is the only address that requires a Nautilus
+// ServerNewAddress call; all receive/change addresses derive client keys
+// locally and reuse this server pubkey/expiry seed.
+func (m *Manager) EnsureStaticAddressSeed(ctx context.Context) (*Parameters,
+	error) {
+
 	m.Lock()
+	seed := m.legacyParameters()
+	m.Unlock()
+	if seed != nil {
+		return seed, nil
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	// Another caller may have created the seed while we were waiting for the
+	// issuance lock.
+	seed = m.legacyParameters()
+	if seed != nil {
+		return seed, nil
+	}
+
 	addresses, err := m.cfg.Store.GetAllStaticAddresses(ctx)
 	if err != nil {
-		m.Unlock()
-
-		return nil, 0, err
+		return nil, err
 	}
 	if len(addresses) > 0 {
-		clientPubKey := addresses[0].ClientPubkey
-		serverPubKey := addresses[0].ServerPubkey
-		expiry := int64(addresses[0].Expiry)
+		for _, addr := range addresses {
+			// Re-import existing rows so startup can repair a DB-only
+			// address before deposit discovery depends on lnd's wallet
+			// view.
+			staticAddress, err := staticAddressFromParams(addr)
+			if err != nil {
+				return nil, err
+			}
 
-		defer m.Unlock()
+			err = m.importAddressTapscript(ctx, staticAddress)
+			if err != nil {
+				return nil, err
+			}
 
-		address, err := m.GetTaprootAddress(
-			clientPubKey, serverPubKey, expiry,
-		)
-		if err != nil {
-			return nil, 0, err
+			m.activeStaticAddresses[string(addr.PkScript)] = addr
 		}
 
-		return address, expiry, nil
+		return addresses[0], nil
 	}
-	m.Unlock()
 
-	// We are fetching a new L402 token from the server. There is one static
-	// address per L402 token allowed.
+	// We are fetching a new L402 token from the server. The returned server
+	// key/expiry is the static address seed for all future client-derived
+	// addresses for this L402.
 	err = m.cfg.FetchL402(ctx)
 	if err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
 	clientPubKey, err := m.cfg.WalletKit.DeriveNextKey(
 		ctx, swap.StaticAddressKeyFamily,
 	)
 	if err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
-	// Send our clientPubKey to the server and wait for the server to
-	// respond with he serverPubKey and the static address CSV expiry.
 	protocolVersion := version.CurrentRPCProtocolVersion()
 	resp, err := m.cfg.AddressClient.ServerNewAddress(
 		ctx, &staticaddressrpc.ServerNewAddressRequest{
@@ -163,78 +254,121 @@ func (m *Manager) NewAddress(ctx context.Context) (*btcutil.AddressTaproot,
 		},
 	)
 	if err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
 	if resp == nil {
-		return nil, 0, fmt.Errorf("missing server new address response")
+		return nil, fmt.Errorf("missing server new address response")
 	}
 
 	serverParams := resp.GetParams()
 	if err := validateServerAddressParams(serverParams); err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
 	serverPubKey, err := btcec.ParsePubKey(serverParams.GetServerKey())
 	if err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
+	return m.createAddressFromKey(
+		ctx, clientPubKey, serverPubKey, serverParams.Expiry,
+		version.AddressProtocolVersion(protocolVersion),
+	)
+}
+
+// NewReceiveAddress derives, stores, imports and activates the next receive
+// family static address. It is used by `loop static new`.
+func (m *Manager) NewReceiveAddress(ctx context.Context) (*Parameters, error) {
+	seed, err := m.EnsureStaticAddressSeed(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return m.newDerivedAddress(ctx, seed, swap.StaticMultiAddressKeyFamily)
+}
+
+// NewChangeAddress derives, stores, imports and activates the next change
+// family static address. Swap and withdrawal code calls this before submitting
+// requests that require change.
+func (m *Manager) NewChangeAddress(ctx context.Context) (*Parameters, error) {
+	seed, err := m.EnsureStaticAddressSeed(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return m.newDerivedAddress(ctx, seed, swap.StaticAddressChangeKeyFamily)
+}
+
+func (m *Manager) newDerivedAddress(ctx context.Context, seed *Parameters,
+	keyFamily int32) (*Parameters, error) {
+
+	m.Lock()
+	defer m.Unlock()
+
+	clientPubKey, err := m.cfg.WalletKit.DeriveNextKey(ctx, keyFamily)
+	if err != nil {
+		return nil, err
+	}
+
+	return m.createAddressFromKey(
+		ctx, clientPubKey, seed.ServerPubkey, seed.Expiry,
+		seed.ProtocolVersion,
+	)
+}
+
+func (m *Manager) createAddressFromKey(ctx context.Context,
+	clientPubKey *keychain.KeyDescriptor, serverPubKey *btcec.PublicKey,
+	expiry uint32, protocolVersion version.AddressProtocolVersion) (
+	*Parameters, error) {
+
 	staticAddress, err := script.NewStaticAddress(
-		input.MuSig2Version100RC2, int64(serverParams.Expiry),
-		clientPubKey.PubKey, serverPubKey,
+		input.MuSig2Version100RC2, int64(expiry), clientPubKey.PubKey,
+		serverPubKey,
 	)
 	if err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
 	pkScript, err := staticAddress.StaticAddressScript()
 	if err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
-	// Create the static address from the parameters the server provided and
-	// store all parameters in the database.
-	addrParams := &script.Parameters{
+	addrParams := &Parameters{
 		ClientPubkey: clientPubKey.PubKey,
 		ServerPubkey: serverPubKey,
 		PkScript:     pkScript,
-		Expiry:       serverParams.Expiry,
+		Expiry:       expiry,
 		KeyLocator: keychain.KeyLocator{
 			Family: clientPubKey.Family,
 			Index:  clientPubKey.Index,
 		},
-		ProtocolVersion: version.AddressProtocolVersion(
-			protocolVersion,
-		),
+		ProtocolVersion:  protocolVersion,
 		InitiationHeight: m.currentHeight.Load(),
 	}
+
+	// Import before persisting the address row. If lnd rejects the script
+	// import, a later startup retry should still see a clean missing-address
+	// state instead of a DB-only static address.
+	err = m.importAddressTapscript(ctx, staticAddress)
+	if err != nil {
+		return nil, err
+	}
+
 	err = m.cfg.Store.CreateStaticAddress(ctx, addrParams)
 	if err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
-	// Import the static address tapscript into our lnd wallet, so we can
-	// track unspent outputs of it.
-	tapScript := input.TapscriptFullTree(
-		staticAddress.InternalPubKey, *staticAddress.TimeoutLeaf,
-	)
-	addr, err := m.cfg.WalletKit.ImportTaprootScript(ctx, tapScript)
+	addrParams.ID, err = m.cfg.Store.GetStaticAddressID(ctx, pkScript)
 	if err != nil {
-		return nil, 0, err
+		return nil, err
 	}
 
-	log.Infof("Imported static address taproot script to lnd wallet: %v",
-		addr)
+	m.activeStaticAddresses[string(pkScript)] = addrParams
 
-	address, err := m.GetTaprootAddress(
-		clientPubKey.PubKey, serverPubKey, int64(serverParams.Expiry),
-	)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	return address, int64(serverParams.Expiry), nil
+	return addrParams, nil
 }
 
 // validateServerAddressParams validates the server-controlled static address
@@ -272,6 +406,60 @@ func validateServerAddressParams(
 	return nil
 }
 
+func (m *Manager) importAddressTapscript(ctx context.Context,
+	staticAddress *script.StaticAddress) error {
+
+	// Import the static address tapscript into our lnd wallet, so we can
+	// track unspent outputs of it.
+	tapScript := input.TapscriptFullTree(
+		staticAddress.InternalPubKey, *staticAddress.TimeoutLeaf,
+	)
+	addr, err := m.cfg.WalletKit.ImportTaprootScript(ctx, tapScript)
+	if err != nil {
+		// Importing into an lnd instance that already knows the script is
+		// expected on restart. Treat the duplicate import as success.
+		if strings.Contains(err.Error(), "already exists") {
+			log.Infof("Static address tapscript already imported")
+			return nil
+		}
+
+		return err
+	}
+
+	log.Infof("Imported static address taproot script to lnd wallet: %v",
+		addr)
+
+	return nil
+}
+
+func staticAddressFromParams(params *Parameters) (*script.StaticAddress,
+	error) {
+
+	if params == nil {
+		return nil, fmt.Errorf("missing static address parameters")
+	}
+
+	return script.NewStaticAddress(
+		input.MuSig2Version100RC2, int64(params.Expiry),
+		params.ClientPubkey, params.ServerPubkey,
+	)
+}
+
+func (m *Manager) legacyParameters() *Parameters {
+	var legacy *Parameters
+	for _, params := range m.activeStaticAddresses {
+		if params == nil {
+			continue
+		}
+
+		if legacy == nil || params.ID < legacy.ID {
+			legacy = params
+		}
+	}
+
+	return legacy
+}
+
 // GetTaprootAddress returns a taproot address for the given client and server
 // public keys and expiry.
 func (m *Manager) GetTaprootAddress(clientPubkey, serverPubkey *btcec.PublicKey,
@@ -292,21 +480,17 @@ func (m *Manager) GetTaprootAddress(clientPubkey, serverPubkey *btcec.PublicKey,
 
 // ListUnspentRaw returns a list of utxos at the static address.
 func (m *Manager) ListUnspentRaw(ctx context.Context, minConfs,
-	maxConfs int32) (*btcutil.AddressTaproot, []*lnwallet.Utxo, error) {
+	maxConfs int32) ([]*lnwallet.Utxo, error) {
 
-	addresses, err := m.cfg.Store.GetAllStaticAddresses(ctx)
-	switch {
-	case err != nil:
-		return nil, nil, err
-
-	case len(addresses) == 0:
-		return nil, nil, nil
-
-	case len(addresses) > 1:
-		return nil, nil, fmt.Errorf("more than one address found")
+	m.Lock()
+	active := make(map[string]struct{}, len(m.activeStaticAddresses))
+	for pkScript := range m.activeStaticAddresses {
+		active[pkScript] = struct{}{}
+	}
+	m.Unlock()
+	if len(active) == 0 {
+		return nil, nil
 	}
-
-	staticAddress := addresses[0]
 
 	// List all unspent utxos the wallet sees, regardless of the number of
 	// confirmations.
@@ -314,43 +498,36 @@ func (m *Manager) ListUnspentRaw(ctx context.Context, minConfs,
 		ctx, minConfs, maxConfs,
 	)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	// Filter the list of lnd's unspent utxos for the pkScript of our static
-	// address.
+	// Filter the list of lnd's unspent utxos for any locally active static
+	// address script.
 	var filteredUtxos []*lnwallet.Utxo
 	for _, utxo := range utxos {
-		if bytes.Equal(utxo.PkScript, staticAddress.PkScript) {
+		if _, ok := active[string(utxo.PkScript)]; ok {
 			filteredUtxos = append(filteredUtxos, utxo)
 		}
 	}
 
-	taprootAddress, err := m.GetTaprootAddress(
-		staticAddress.ClientPubkey, staticAddress.ServerPubkey,
-		int64(staticAddress.Expiry),
-	)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return taprootAddress, filteredUtxos, nil
+	return filteredUtxos, nil
 }
 
-// GetStaticAddressParameters returns the parameters of the static address.
+// GetStaticAddressParameters returns the legacy/root static-address
+// parameters.
 func (m *Manager) GetStaticAddressParameters(ctx context.Context) (
 	*script.Parameters, error) {
 
-	params, err := m.cfg.Store.GetAllStaticAddresses(ctx)
+	params, err := m.GetLegacyParameters(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	if len(params) == 0 {
-		return nil, fmt.Errorf("no static address parameters found")
+	if params == nil {
+		return nil, ErrNoStaticAddress
 	}
 
-	return params[0], nil
+	return params, nil
 }
 
 // GetStaticAddress returns a taproot address for the given client and server
@@ -363,25 +540,53 @@ func (m *Manager) GetStaticAddress(ctx context.Context) (*script.StaticAddress,
 		return nil, err
 	}
 
-	address, err := script.NewStaticAddress(
-		input.MuSig2Version100RC2, int64(params.Expiry),
-		params.ClientPubkey, params.ServerPubkey,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return address, nil
+	return staticAddressFromParams(params)
 }
 
 // ListUnspent returns a list of utxos at the static address.
 func (m *Manager) ListUnspent(ctx context.Context, minConfs,
 	maxConfs int32) ([]*lnwallet.Utxo, error) {
 
-	_, utxos, err := m.ListUnspentRaw(ctx, minConfs, maxConfs)
+	return m.ListUnspentRaw(ctx, minConfs, maxConfs)
+}
+
+// GetLegacyParameters returns the legacy/root static address parameters.
+func (m *Manager) GetLegacyParameters(ctx context.Context) (*Parameters,
+	error) {
+
+	params, err := m.cfg.Store.GetLegacyParameters(ctx)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
 	if err != nil {
 		return nil, err
 	}
 
-	return utxos, nil
+	return params, nil
+}
+
+// GetParameters returns active static address parameters for a pkScript.
+func (m *Manager) GetParameters(pkScript []byte) *Parameters {
+	m.Lock()
+	defer m.Unlock()
+
+	return m.activeStaticAddresses[string(pkScript)]
+}
+
+// GetStaticAddressID returns the database row ID for a static address script.
+func (m *Manager) GetStaticAddressID(ctx context.Context,
+	pkScript []byte) (int32, error) {
+
+	return m.cfg.Store.GetStaticAddressID(ctx, pkScript)
+}
+
+// IsOurPkScript returns true if the pkScript belongs to an active static
+// address.
+func (m *Manager) IsOurPkScript(pkScript []byte) bool {
+	return m.GetParameters(pkScript) != nil
+}
+
+// GetAllAddresses returns all persisted static address parameters.
+func (m *Manager) GetAllAddresses(ctx context.Context) ([]*Parameters, error) {
+	return m.cfg.Store.GetAllStaticAddresses(ctx)
 }
diff --git a/staticaddr/address/manager_test.go b/staticaddr/address/manager_test.go
index b7bbf79a..dc59f751 100644
--- a/staticaddr/address/manager_test.go
+++ b/staticaddr/address/manager_test.go
@@ -132,6 +132,20 @@ func TestManager(t *testing.T) {
 
 	// The expiry has to match.
 	require.EqualValues(t, defaultExpiry, expiry)
+
+	storedParams, err := testContext.manager.GetStaticAddressParameters(ctxb)
+	require.NoError(t, err)
+	require.EqualValues(
+		t, swap.StaticAddressKeyFamily, storedParams.KeyLocator.Family,
+	)
+
+	addresses, err := testContext.manager.GetAllAddresses(ctxb)
+	require.NoError(t, err)
+	require.Len(t, addresses, 2)
+	require.EqualValues(
+		t, swap.StaticMultiAddressKeyFamily,
+		addresses[1].KeyLocator.Family,
+	)
 }
 
 // TestNewAddressValidatesServerResponse tests that the untrusted
@@ -233,12 +247,12 @@ func TestNewAddressAcceptsMaxCSVExpiry(t *testing.T) {
 func GenerateExpectedTaprootAddress(t *ManagerTestContext) (
 	*btcutil.AddressTaproot, error) {
 
-	keyIndex := int32(0)
+	keyIndex := int32(1)
 	_, pubKey := test.CreateKey(keyIndex)
 
 	keyDescriptor := &keychain.KeyDescriptor{
 		KeyLocator: keychain.KeyLocator{
-			Family: keychain.KeyFamily(swap.StaticAddressKeyFamily),
+			Family: keychain.KeyFamily(swap.StaticMultiAddressKeyFamily),
 			Index:  uint32(keyIndex),
 		},
 		PubKey: pubKey,
diff --git a/staticaddr/address/sql_store.go b/staticaddr/address/sql_store.go
index 16f113c4..35298867 100644
--- a/staticaddr/address/sql_store.go
+++ b/staticaddr/address/sql_store.go
@@ -6,7 +6,6 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightninglabs/loop/loopdb"
 	"github.com/lightninglabs/loop/loopdb/sqlc"
-	"github.com/lightninglabs/loop/staticaddr/script"
 	"github.com/lightninglabs/loop/staticaddr/version"
 	"github.com/lightningnetwork/lnd/keychain"
 )
@@ -26,7 +25,7 @@ func NewSqlStore(db *loopdb.BaseDB) *SqlStore {
 
 // CreateStaticAddress creates a static address record in the database.
 func (s *SqlStore) CreateStaticAddress(ctx context.Context,
-	addrParams *script.Parameters) error {
+	addrParams *Parameters) error {
 
 	createArgs := sqlc.CreateStaticAddressParams{
 		ClientPubkey:     addrParams.ClientPubkey.SerializeCompressed(),
@@ -51,14 +50,14 @@ func (s *SqlStore) GetStaticAddressID(ctx context.Context,
 
 // GetAllStaticAddresses returns all addresses known to the client.
 func (s *SqlStore) GetAllStaticAddresses(ctx context.Context) (
-	[]*script.Parameters, error) {
+	[]*Parameters, error) {
 
 	staticAddresses, err := s.baseDB.Queries.AllStaticAddresses(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	var result []*script.Parameters
+	var result []*Parameters
 	for _, address := range staticAddresses {
 		res, err := s.toAddressParameters(address)
 		if err != nil {
@@ -72,8 +71,8 @@ func (s *SqlStore) GetAllStaticAddresses(ctx context.Context) (
 }
 
 // GetLegacyParameters returns the first static address created for this L402.
-func (s *SqlStore) GetLegacyParameters(ctx context.Context) (
-	*script.Parameters, error) {
+func (s *SqlStore) GetLegacyParameters(ctx context.Context) (*Parameters,
+	error) {
 
 	staticAddress, err := s.baseDB.Queries.GetLegacyAddress(ctx)
 	if err != nil {
@@ -86,7 +85,7 @@ func (s *SqlStore) GetLegacyParameters(ctx context.Context) (
 // toAddressParameters transforms a database representation of a static address
 // to an AddressParameters struct.
 func (s *SqlStore) toAddressParameters(row sqlc.StaticAddress) (
-	*script.Parameters, error) {
+	*Parameters, error) {
 
 	clientPubkey, err := btcec.ParsePubKey(row.ClientPubkey)
 	if err != nil {
@@ -98,7 +97,7 @@ func (s *SqlStore) toAddressParameters(row sqlc.StaticAddress) (
 		return nil, err
 	}
 
-	return &script.Parameters{
+	return &Parameters{
 		ID:           row.ID,
 		ClientPubkey: clientPubkey,
 		ServerPubkey: serverPubkey,