loopd: wire recovery service into daemon startup

Register a recovery gRPC endpoint, attach the new recovery package to the
swap client server, and have daemon startup write an encrypted backup file
whenever recoverable static-address or l402 state already exists locally.

Author: hieblmi

loopd/daemon.go

@@ -22,6 +22,7 @@ import (
 	"github.com/lightninglabs/loop/loopdb"
 	loop_looprpc "github.com/lightninglabs/loop/looprpc"
 	"github.com/lightninglabs/loop/notifications"
+	"github.com/lightninglabs/loop/recovery"
 	"github.com/lightninglabs/loop/staticaddr/address"
 	"github.com/lightninglabs/loop/staticaddr/deposit"
 	"github.com/lightninglabs/loop/staticaddr/loopin"
@@ -577,17 +578,47 @@ func (d *Daemon) initialize(withMacaroonService bool) error {
 		withdrawalManager    *withdraw.Manager
 		openChannelManager   *openchannel.Manager
 		staticLoopInManager  *loopin.Manager
+		recoveryService      *recovery.Service
 	)
 
+	writeRecoveryBackup := func(ctx context.Context, source string) error {
+		if recoveryService == nil {
+			return nil
+		}
+
+		backupFile, err := recoveryService.WriteBackup(ctx)
+		if err != nil {
+			return err
+		}
+		if backupFile != "" {
+			infof("Wrote encrypted recovery backup to %s after %s",
+				backupFile, source)
+		}
+
+		return nil
+	}
+
 	// Static address manager setup.
 	staticAddressStore := address.NewSqlStore(baseDb)
 	addrCfg := &address.ManagerConfig{
 		AddressClient: staticAddressClient,
-		FetchL402:     swapClient.Server.FetchL402,
+		FetchL402: func(ctx context.Context) error {
+			err := swapClient.Server.FetchL402(ctx)
+			if err != nil {
+				return err
+			}
+
+			return writeRecoveryBackup(ctx, "retrieving a paid L402")
+		},
 		Store:         staticAddressStore,
 		WalletKit:     d.lnd.WalletKit,
 		ChainParams:   d.lnd.ChainParams,
 		ChainNotifier: d.lnd.ChainNotifier,
+		OnStaticAddressCreated: func(ctx context.Context) error {
+			return writeRecoveryBackup(
+				ctx, "creating a static address",
+			)
+		},
 	}
 	staticAddressManager, err = address.NewManager(
 		addrCfg, int32(blockHeight),
@@ -689,6 +720,15 @@ func (d *Daemon) initialize(withMacaroonService bool) error {
 		return fmt.Errorf("unable to create loop-in manager: %w", err)
 	}
 
+	recoveryService = recovery.NewService(
+		d.cfg.DataDir, d.cfg.Network, d.lnd.Signer, d.lnd.WalletKit,
+		staticAddressManager, depositManager,
+	)
+	err = writeRecoveryBackup(d.mainCtx, "startup")
+	if err != nil {
+		return fmt.Errorf("unable to write backup file: %w", err)
+	}
+
 	var (
 		reservationManager *reservation.Manager
 		instantOutManager  *instantout.Manager
@@ -753,6 +793,7 @@ func (d *Daemon) initialize(withMacaroonService bool) error {
 		staticLoopInManager:  staticLoopInManager,
 		openChannelManager:   openChannelManager,
 		assetClient:          d.assetClient,
+		recoveryService:      recoveryService,
 		stopDaemon:           d.Stop,
 	}
 

loopd/swapclient_server.go

@@ -29,6 +29,7 @@ import (
 	"github.com/lightninglabs/loop/liquidity"
 	"github.com/lightninglabs/loop/loopdb"
 	"github.com/lightninglabs/loop/looprpc"
+	"github.com/lightninglabs/loop/recovery"
 	"github.com/lightninglabs/loop/staticaddr/address"
 	"github.com/lightninglabs/loop/staticaddr/deposit"
 	"github.com/lightninglabs/loop/staticaddr/loopin"
@@ -101,6 +102,7 @@ type swapClientServer struct {
 	staticLoopInManager  *loopin.Manager
 	openChannelManager   *openchannel.Manager
 	assetClient          *assets.TapdClient
+	recoveryService      *recovery.Service
 	swaps                map[lntypes.Hash]loop.SwapInfo
 	subscribers          map[int]chan<- any
 	statusChan           chan loop.SwapInfo
@@ -1265,9 +1267,59 @@ func (s *swapClientServer) FetchL402Token(ctx context.Context,
 		return nil, err
 	}
 
+	err = s.writeRecoveryBackup(ctx, "retrieving a paid L402")
+	if err != nil {
+		return nil, err
+	}
+
 	return &looprpc.FetchL402TokenResponse{}, nil
 }
 
+// Recover restores the local paid L402 token material and static-address state
+// from an encrypted backup file.
+func (s *swapClientServer) Recover(ctx context.Context,
+	req *looprpc.RecoverRequest) (*looprpc.RecoverResponse, error) {
+
+	if s.recoveryService == nil {
+		return nil, status.Error(
+			codes.Unavailable, "recovery service not configured",
+		)
+	}
+
+	result, err := s.recoveryService.Restore(ctx, req.GetBackupFile())
+	if err != nil {
+		return nil, err
+	}
+
+	return &looprpc.RecoverResponse{
+		BackupFile:                 result.BackupFile,
+		RestoredL402:               result.RestoredL402,
+		RestoredStaticAddress:      result.RestoredStaticAddress,
+		StaticAddress:              result.StaticAddress,
+		NumDepositsFound:           uint32(result.NumDepositsFound),
+		DepositReconciliationError: result.DepositReconciliationError,
+	}, nil
+}
+
+func (s *swapClientServer) writeRecoveryBackup(ctx context.Context,
+	source string) error {
+
+	if s.recoveryService == nil {
+		return nil
+	}
+
+	backupFile, err := s.recoveryService.WriteBackup(ctx)
+	if err != nil {
+		return err
+	}
+	if backupFile != "" {
+		infof("Wrote encrypted recovery backup to %s after %s",
+			backupFile, source)
+	}
+
+	return nil
+}
+
 // GetInfo returns basic information about the loop daemon and details to swaps
 // from the swap store.
 func (s *swapClientServer) GetInfo(ctx context.Context,