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"
@@ -255,6 +256,7 @@ func (d *Daemon) startWebServers() error {
 		grpc.StreamInterceptor(streamInterceptor),
 	)
 	loop_looprpc.RegisterSwapClientServer(d.grpcServer, d)
+	d.grpcServer.RegisterService(&recoveryServiceDesc, d)
 
 	// Register our debug server if it is compiled in.
 	d.registerDebugServer()
@@ -577,17 +579,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 +721,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 +794,7 @@ func (d *Daemon) initialize(withMacaroonService bool) error {
 		staticLoopInManager:  staticLoopInManager,
 		openChannelManager:   openChannelManager,
 		assetClient:          d.assetClient,
+		recoveryService:      recoveryService,
 		stopDaemon:           d.Stop,
 	}
 

loopd/recovery_service.go

@@ -0,0 +1,77 @@
+package loopd
+
+import (
+	"context"
+
+	"google.golang.org/grpc"
+	"google.golang.org/protobuf/types/known/structpb"
+	"google.golang.org/protobuf/types/known/wrapperspb"
+)
+
+type recoveryServer interface {
+	Recover(context.Context, *wrapperspb.StringValue) (*structpb.Struct,
+		error)
+}
+
+var recoveryServiceDesc = grpc.ServiceDesc{
+	ServiceName: "looprpc.Recovery",
+	HandlerType: (*recoveryServer)(nil),
+	Methods: []grpc.MethodDesc{{
+		MethodName: "Recover",
+		Handler:    recoveryHandler,
+	}},
+	Metadata: "loopd/recovery_service.go",
+}
+
+func recoveryHandler(srv interface{}, ctx context.Context,
+	dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (
+	interface{}, error) {
+
+	in := new(wrapperspb.StringValue)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+
+	if interceptor == nil {
+		return srv.(recoveryServer).Recover(ctx, in)
+	}
+
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/looprpc.Recovery/Recover",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(recoveryServer).Recover(
+			ctx, req.(*wrapperspb.StringValue),
+		)
+	}
+
+	return interceptor(ctx, in, info, handler)
+}
+
+// Recover restores the local L402 token material and static address state from
+// an encrypted backup file.
+func (s *swapClientServer) Recover(ctx context.Context,
+	req *wrapperspb.StringValue) (*structpb.Struct, error) {
+
+	result, err := s.recoveryService.Restore(ctx, req.GetValue())
+	if err != nil {
+		return nil, err
+	}
+
+	values := map[string]any{
+		"backup_file":             result.BackupFile,
+		"restored_l402":           result.RestoredL402,
+		"restored_static_address": result.RestoredStaticAddress,
+		"num_deposits_found":      result.NumDepositsFound,
+	}
+	if result.StaticAddress != "" {
+		values["static_address"] = result.StaticAddress
+	}
+	if result.DepositReconciliationError != "" {
+		values["deposit_reconciliation_error"] =
+			result.DepositReconciliationError
+	}
+
+	return structpb.NewStruct(values)
+}

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,33 @@ 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
 }
 
+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,